[OpenACC][CIR] Implement 'private' clause lowering. (#151360)
The private clause is the first with 'recipes', so a lot of infrastructure is included here, including some MLIR dialect changes that allow simple adding of a privatization. We'll likely get similar for firstprivate and reduction. Also, we have quite a bit of infrastructure in clause lowering to make sure we have most cases we could think of covered. At the moment, ONLY private is implemented, so all it requires is an 'init' segment (that doesn't call any copy operations), and potentially a 'destroy' segment. However, actually calling 'init' functions on each of the elements in them are not properly implemented, and will be in a followup patch. This patch implements all of that, and adds tests in a way that will be useful for firstprivate as well.
This commit is contained in:
Erich Keane
GitHub
parent
e7200c734d
commit
25c07763f7
@ -24,7 +24,8 @@ using namespace clang;
|
||||
using namespace clang::CIRGen;
|
||||
|
||||
CIRGenFunction::AutoVarEmission
|
||||
CIRGenFunction::emitAutoVarAlloca(const VarDecl &d) {
|
||||
CIRGenFunction::emitAutoVarAlloca(const VarDecl &d,
|
||||
mlir::OpBuilder::InsertPoint ip) {
|
||||
QualType ty = d.getType();
|
||||
if (ty.getAddressSpace() != LangAS::Default)
|
||||
cgm.errorNYI(d.getSourceRange(), "emitAutoVarAlloca: address space");
|
||||
@ -50,7 +51,8 @@ CIRGenFunction::emitAutoVarAlloca(const VarDecl &d) {
|
||||
// A normal fixed sized variable becomes an alloca in the entry block,
|
||||
mlir::Type allocaTy = convertTypeForMem(ty);
|
||||
// Create the temp alloca and declare variable using it.
|
||||
address = createTempAlloca(allocaTy, alignment, loc, d.getName());
|
||||
address = createTempAlloca(allocaTy, alignment, loc, d.getName(),
|
||||
/*arraySize=*/nullptr, /*alloca=*/nullptr, ip);
|
||||
declare(address.getPointer(), &d, ty, getLoc(d.getSourceRange()), alignment);
|
||||
|
||||
emission.Addr = address;
|
||||
|
||||
@ -858,7 +858,8 @@ public:
|
||||
|
||||
Address emitArrayToPointerDecay(const Expr *array);
|
||||
|
||||
AutoVarEmission emitAutoVarAlloca(const clang::VarDecl &d);
|
||||
AutoVarEmission emitAutoVarAlloca(const clang::VarDecl &d,
|
||||
mlir::OpBuilder::InsertPoint ip = {});
|
||||
|
||||
/// Emit code and set up symbol table for a variable declaration with auto,
|
||||
/// register, or no storage class specifier. These turn into simple stack
|
||||
@ -1377,6 +1378,7 @@ public:
|
||||
mlir::Location beginLoc;
|
||||
mlir::Value varValue;
|
||||
std::string name;
|
||||
QualType baseType;
|
||||
llvm::SmallVector<mlir::Value> bounds;
|
||||
};
|
||||
// Gets the collection of info required to lower and OpenACC clause or cache
|
||||
|
||||
@ -119,7 +119,7 @@ CIRGenFunction::getOpenACCDataOperandInfo(const Expr *e) {
|
||||
|
||||
if (const auto *memExpr = dyn_cast<MemberExpr>(curVarExpr))
|
||||
return {exprLoc, emitMemberExpr(memExpr).getPointer(), exprString,
|
||||
std::move(bounds)};
|
||||
curVarExpr->getType(), std::move(bounds)};
|
||||
|
||||
// Sema has made sure that only 4 types of things can get here, array
|
||||
// subscript, array section, member expr, or DRE to a var decl (or the
|
||||
@ -127,5 +127,5 @@ CIRGenFunction::getOpenACCDataOperandInfo(const Expr *e) {
|
||||
// right.
|
||||
const auto *dre = cast<DeclRefExpr>(curVarExpr);
|
||||
return {exprLoc, emitDeclRefLValue(dre).getPointer(), exprString,
|
||||
std::move(bounds)};
|
||||
curVarExpr->getType(), std::move(bounds)};
|
||||
}
|
||||
|
||||
@ -12,6 +12,7 @@
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
#include "CIRGenCXXABI.h"
|
||||
#include "CIRGenFunction.h"
|
||||
|
||||
#include "clang/AST/ExprCXX.h"
|
||||
@ -355,6 +356,110 @@ class OpenACCClauseCIREmitter final
|
||||
}
|
||||
}
|
||||
|
||||
template <typename RecipeTy>
|
||||
RecipeTy getOrCreateRecipe(ASTContext &astCtx, const Expr *varRef,
|
||||
DeclContext *dc, QualType baseType,
|
||||
mlir::Value mainOp) {
|
||||
mlir::ModuleOp mod =
|
||||
builder.getBlock()->getParent()->getParentOfType<mlir::ModuleOp>();
|
||||
|
||||
std::string recipeName;
|
||||
{
|
||||
llvm::raw_string_ostream stream(recipeName);
|
||||
if constexpr (std::is_same_v<RecipeTy, mlir::acc::PrivateRecipeOp>) {
|
||||
stream << "privatization_";
|
||||
} else if constexpr (std::is_same_v<RecipeTy,
|
||||
mlir::acc::FirstprivateRecipeOp>) {
|
||||
stream << "firstprivatization_";
|
||||
|
||||
} else if constexpr (std::is_same_v<RecipeTy,
|
||||
mlir::acc::ReductionRecipeOp>) {
|
||||
stream << "reduction_";
|
||||
// We don't have the reduction operation here well enough to know how to
|
||||
// spell this correctly (+ == 'add', etc), so when we implement
|
||||
// 'reduction' we have to do that here.
|
||||
cgf.cgm.errorNYI(varRef->getSourceRange(),
|
||||
"OpeNACC reduction recipe creation");
|
||||
} else {
|
||||
static_assert(!sizeof(RecipeTy), "Unknown Recipe op kind");
|
||||
}
|
||||
|
||||
MangleContext &mc = cgf.cgm.getCXXABI().getMangleContext();
|
||||
mc.mangleCanonicalTypeName(baseType, stream);
|
||||
}
|
||||
|
||||
if (auto recipe = mod.lookupSymbol<RecipeTy>(recipeName))
|
||||
return recipe;
|
||||
|
||||
mlir::Location loc = cgf.cgm.getLoc(varRef->getBeginLoc());
|
||||
mlir::Location locEnd = cgf.cgm.getLoc(varRef->getEndLoc());
|
||||
|
||||
mlir::OpBuilder modBuilder(mod.getBodyRegion());
|
||||
auto recipe =
|
||||
RecipeTy::create(modBuilder, loc, recipeName, mainOp.getType());
|
||||
|
||||
// Magic-up a var-decl so we can use normal init/destruction operations for
|
||||
// a variable declaration.
|
||||
VarDecl &tempDecl = *VarDecl::Create(
|
||||
astCtx, dc, varRef->getBeginLoc(), varRef->getBeginLoc(),
|
||||
&astCtx.Idents.get("openacc.private.init"), baseType,
|
||||
astCtx.getTrivialTypeSourceInfo(baseType), SC_Auto);
|
||||
CIRGenFunction::AutoVarEmission tempDeclEmission{
|
||||
CIRGenFunction::AutoVarEmission::invalid()};
|
||||
|
||||
// Init section.
|
||||
{
|
||||
llvm::SmallVector<mlir::Type> argsTys{mainOp.getType()};
|
||||
llvm::SmallVector<mlir::Location> argsLocs{loc};
|
||||
builder.createBlock(&recipe.getInitRegion(), recipe.getInitRegion().end(),
|
||||
argsTys, argsLocs);
|
||||
builder.setInsertionPointToEnd(&recipe.getInitRegion().back());
|
||||
|
||||
if constexpr (!std::is_same_v<RecipeTy, mlir::acc::PrivateRecipeOp>) {
|
||||
// We have only implemented 'init' for private, so make this NYI until
|
||||
// we have explicitly implemented everything.
|
||||
cgf.cgm.errorNYI(varRef->getSourceRange(),
|
||||
"OpenACC non-private recipe init");
|
||||
}
|
||||
|
||||
tempDeclEmission =
|
||||
cgf.emitAutoVarAlloca(tempDecl, builder.saveInsertionPoint());
|
||||
cgf.emitAutoVarInit(tempDeclEmission);
|
||||
|
||||
mlir::acc::YieldOp::create(builder, locEnd);
|
||||
}
|
||||
|
||||
// Copy section.
|
||||
if constexpr (std::is_same_v<RecipeTy, mlir::acc::FirstprivateRecipeOp> ||
|
||||
std::is_same_v<RecipeTy, mlir::acc::ReductionRecipeOp>) {
|
||||
// TODO: OpenACC: 'private' doesn't emit this, but for the other two we
|
||||
// have to figure out what 'copy' means here.
|
||||
cgf.cgm.errorNYI(varRef->getSourceRange(),
|
||||
"OpenACC record type privatization copy section");
|
||||
}
|
||||
|
||||
// Destroy section (doesn't currently exist).
|
||||
if (tempDecl.needsDestruction(cgf.getContext())) {
|
||||
llvm::SmallVector<mlir::Type> argsTys{mainOp.getType()};
|
||||
llvm::SmallVector<mlir::Location> argsLocs{loc};
|
||||
mlir::Block *block = builder.createBlock(&recipe.getDestroyRegion(),
|
||||
recipe.getDestroyRegion().end(),
|
||||
argsTys, argsLocs);
|
||||
builder.setInsertionPointToEnd(&recipe.getDestroyRegion().back());
|
||||
|
||||
mlir::Type elementTy =
|
||||
mlir::cast<cir::PointerType>(mainOp.getType()).getPointee();
|
||||
Address addr{block->getArgument(0), elementTy,
|
||||
cgf.getContext().getDeclAlign(&tempDecl)};
|
||||
cgf.emitDestroy(addr, baseType,
|
||||
cgf.getDestroyer(QualType::DK_cxx_destructor));
|
||||
|
||||
mlir::acc::YieldOp::create(builder, locEnd);
|
||||
}
|
||||
|
||||
return recipe;
|
||||
}
|
||||
|
||||
public:
|
||||
OpenACCClauseCIREmitter(OpTy &operation, CIRGen::CIRGenFunction &cgf,
|
||||
CIRGen::CIRGenBuilderTy &builder,
|
||||
@ -971,6 +1076,37 @@ public:
|
||||
llvm_unreachable("Unknown construct kind in VisitAttachClause");
|
||||
}
|
||||
}
|
||||
|
||||
void VisitPrivateClause(const OpenACCPrivateClause &clause) {
|
||||
if constexpr (isOneOfTypes<OpTy, mlir::acc::ParallelOp, mlir::acc::SerialOp,
|
||||
mlir::acc::LoopOp>) {
|
||||
for (const Expr *var : clause.getVarList()) {
|
||||
CIRGenFunction::OpenACCDataOperandInfo opInfo =
|
||||
cgf.getOpenACCDataOperandInfo(var);
|
||||
auto privateOp = mlir::acc::PrivateOp::create(
|
||||
builder, opInfo.beginLoc, opInfo.varValue, /*structured=*/true,
|
||||
/*implicit=*/false, opInfo.name, opInfo.bounds);
|
||||
privateOp.setDataClause(mlir::acc::DataClause::acc_private);
|
||||
|
||||
{
|
||||
mlir::OpBuilder::InsertionGuard guardCase(builder);
|
||||
auto recipe = getOrCreateRecipe<mlir::acc::PrivateRecipeOp>(
|
||||
cgf.getContext(), var, Decl::castToDeclContext(cgf.curFuncDecl),
|
||||
opInfo.baseType, privateOp.getResult());
|
||||
// TODO: OpenACC: The dialect is going to change in the near future to
|
||||
// have these be on a different operation, so when that changes, we
|
||||
// probably need to change these here.
|
||||
operation.addPrivatization(builder.getContext(), privateOp, recipe);
|
||||
}
|
||||
}
|
||||
} else if constexpr (isCombinedType<OpTy>) {
|
||||
// Despite this being valid on ParallelOp or SerialOp, combined type
|
||||
// applies to the 'loop'.
|
||||
applyToLoopOp(clause);
|
||||
} else {
|
||||
llvm_unreachable("Unknown construct kind in VisitPrivateClause");
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template <typename OpTy>
|
||||
|
||||
522
clang/test/CIR/CodeGenOpenACC/combined-private-clause.cpp
Normal file
522
clang/test/CIR/CodeGenOpenACC/combined-private-clause.cpp
Normal file
@ -0,0 +1,522 @@
|
||||
// RUN: %clang_cc1 -fopenacc -triple x86_64-linux-gnu -Wno-openacc-self-if-potential-conflict -emit-cir -fclangir -triple x86_64-linux-pc %s -o - | FileCheck %s
|
||||
|
||||
struct NoCopyConstruct {};
|
||||
|
||||
struct CopyConstruct {
|
||||
CopyConstruct() = default;
|
||||
CopyConstruct(const CopyConstruct&);
|
||||
};
|
||||
|
||||
struct NonDefaultCtor {
|
||||
NonDefaultCtor();
|
||||
};
|
||||
|
||||
struct HasDtor {
|
||||
~HasDtor();
|
||||
};
|
||||
|
||||
// CHECK: acc.private.recipe @privatization__ZTSA5_7HasDtor : !cir.ptr<!cir.array<!rec_HasDtor x 5>> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.array<!rec_HasDtor x 5>, !cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } destroy {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}):
|
||||
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<4> : !u64i
|
||||
// CHECK-NEXT: %[[ARRPTR:.*]] = cir.cast(array_to_ptrdecay, %[[ARG]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>), !cir.ptr<!rec_HasDtor>
|
||||
// CHECK-NEXT: %[[ELEM:.*]] = cir.ptr_stride(%[[ARRPTR]] : !cir.ptr<!rec_HasDtor>, %[[LAST_IDX]] : !u64i), !cir.ptr<!rec_HasDtor>
|
||||
// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !cir.ptr<!rec_HasDtor>, !cir.ptr<!cir.ptr<!rec_HasDtor>>, ["__array_idx"]
|
||||
// CHECK-NEXT: cir.store %[[ELEM]], %[[ITR]] : !cir.ptr<!rec_HasDtor>, !cir.ptr<!cir.ptr<!rec_HasDtor>>
|
||||
// CHECK-NEXT: cir.do {
|
||||
// CHECK-NEXT: %[[ELEM_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!cir.ptr<!rec_HasDtor>>, !cir.ptr<!rec_HasDtor>
|
||||
// CHECK-NEXT: cir.call @_ZN7HasDtorD1Ev(%[[ELEM_LOAD]]) nothrow : (!cir.ptr<!rec_HasDtor>) -> ()
|
||||
// CHECK-NEXT: %[[NEG_ONE:.*]] = cir.const #cir.int<-1> : !s64i
|
||||
// CHECK-NEXT: %[[PREVELEM:.*]] = cir.ptr_stride(%[[ELEM_LOAD]] : !cir.ptr<!rec_HasDtor>, %[[NEG_ONE]] : !s64i), !cir.ptr<!rec_HasDtor>
|
||||
// CHECK-NEXT: cir.store %[[PREVELEM]], %[[ITR]] : !cir.ptr<!rec_HasDtor>, !cir.ptr<!cir.ptr<!rec_HasDtor>>
|
||||
// CHECK-NEXT: cir.yield
|
||||
// CHECK-NEXT: } while {
|
||||
// CHECK-NEXT: %[[ELEM_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!cir.ptr<!rec_HasDtor>>, !cir.ptr<!rec_HasDtor>
|
||||
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[ELEM_LOAD]], %[[ARRPTR]]) : !cir.ptr<!rec_HasDtor>, !cir.bool
|
||||
// CHECK-NEXT: cir.condition(%[[CMP]])
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_14NonDefaultCtor : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.array<!rec_NonDefaultCtor x 5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_13CopyConstruct : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.array<!rec_CopyConstruct x 5>, !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_15NoCopyConstruct : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.array<!rec_NoCopyConstruct x 5>, !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTS7HasDtor : !cir.ptr<!rec_HasDtor> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !rec_HasDtor, !cir.ptr<!rec_HasDtor>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } destroy {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
|
||||
// CHECK-NEXT: cir.call @_ZN7HasDtorD1Ev(%[[ARG]]) nothrow : (!cir.ptr<!rec_HasDtor>) -> ()
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTS14NonDefaultCtor : !cir.ptr<!rec_NonDefaultCtor> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !rec_NonDefaultCtor, !cir.ptr<!rec_NonDefaultCtor>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTS13CopyConstruct : !cir.ptr<!rec_CopyConstruct> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !rec_CopyConstruct, !cir.ptr<!rec_CopyConstruct>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTS15NoCopyConstruct : !cir.ptr<!rec_NoCopyConstruct> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !rec_NoCopyConstruct, !cir.ptr<!rec_NoCopyConstruct>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSf : !cir.ptr<!cir.float> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSi : !cir.ptr<!s32i> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
|
||||
extern "C" void acc_combined() {
|
||||
// CHECK: cir.func{{.*}} @acc_combined() {
|
||||
|
||||
int someInt;
|
||||
// CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["someInt"]
|
||||
float someFloat;
|
||||
// CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["someFloat"]
|
||||
NoCopyConstruct noCopy;
|
||||
// CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca !rec_NoCopyConstruct, !cir.ptr<!rec_NoCopyConstruct>, ["noCopy"]
|
||||
CopyConstruct hasCopy;
|
||||
// CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca !rec_CopyConstruct, !cir.ptr<!rec_CopyConstruct>, ["hasCopy"]
|
||||
NonDefaultCtor notDefCtor;
|
||||
// CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca !rec_NonDefaultCtor, !cir.ptr<!rec_NonDefaultCtor>, ["notDefCtor", init]
|
||||
HasDtor dtor;
|
||||
// CHECK-NEXT: %[[DTOR:.*]] = cir.alloca !rec_HasDtor, !cir.ptr<!rec_HasDtor>, ["dtor"]
|
||||
int someIntArr[5];
|
||||
// CHECK-NEXT: %[[INTARR:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["someIntArr"]
|
||||
float someFloatArr[5];
|
||||
// CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["someFloatArr"]
|
||||
NoCopyConstruct noCopyArr[5];
|
||||
// CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca !cir.array<!rec_NoCopyConstruct x 5>, !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>, ["noCopyArr"]
|
||||
CopyConstruct hasCopyArr[5];
|
||||
// CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca !cir.array<!rec_CopyConstruct x 5>, !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>, ["hasCopyArr"]
|
||||
NonDefaultCtor notDefCtorArr[5];
|
||||
// CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca !cir.array<!rec_NonDefaultCtor x 5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["notDefCtorArr", init]
|
||||
HasDtor dtorArr[5];
|
||||
// CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca !cir.array<!rec_HasDtor x 5>, !cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["dtorArr"]
|
||||
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[NOTDEFCTOR]]) : (!cir.ptr<!rec_NonDefaultCtor>) -> ()
|
||||
|
||||
#pragma acc parallel loop private(someInt)
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK: acc.parallel combined(loop) {
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[SOMEINT]] : !cir.ptr<!s32i>) -> !cir.ptr<!s32i> {name = "someInt"}
|
||||
// CHECK-NEXT: acc.loop combined(parallel) private(@privatization__ZTSi -> %[[PRIVATE]] : !cir.ptr<!s32i>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc serial loop private(someFloat)
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: acc.serial combined(loop) {
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[SOMEFLOAT]] : !cir.ptr<!cir.float>) -> !cir.ptr<!cir.float> {name = "someFloat"}
|
||||
// CHECK-NEXT: acc.loop combined(serial) private(@privatization__ZTSf -> %[[PRIVATE]] : !cir.ptr<!cir.float>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
|
||||
#pragma acc parallel loop private(noCopy)
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: acc.parallel combined(loop) {
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[NOCOPY]] : !cir.ptr<!rec_NoCopyConstruct>) -> !cir.ptr<!rec_NoCopyConstruct> {name = "noCopy"}
|
||||
// CHECK-NEXT: acc.loop combined(parallel) private(@privatization__ZTS15NoCopyConstruct -> %[[PRIVATE]] : !cir.ptr<!rec_NoCopyConstruct>
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc serial loop private(hasCopy)
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: acc.serial combined(loop) {
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[HASCOPY]] : !cir.ptr<!rec_CopyConstruct>) -> !cir.ptr<!rec_CopyConstruct> {name = "hasCopy"}
|
||||
// CHECK-NEXT: acc.loop combined(serial) private(@privatization__ZTS13CopyConstruct -> %[[PRIVATE]] : !cir.ptr<!rec_CopyConstruct>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc serial loop private(notDefCtor)
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: acc.serial combined(loop) {
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[NOTDEFCTOR]] : !cir.ptr<!rec_NonDefaultCtor>) -> !cir.ptr<!rec_NonDefaultCtor> {name = "notDefCtor"}
|
||||
// CHECK-NEXT: acc.loop combined(serial) private(@privatization__ZTS14NonDefaultCtor -> %[[PRIVATE]] : !cir.ptr<!rec_NonDefaultCtor>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc serial loop private(dtor)
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: acc.serial combined(loop) {
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[DTOR]] : !cir.ptr<!rec_HasDtor>) -> !cir.ptr<!rec_HasDtor> {name = "dtor"}
|
||||
// CHECK-NEXT: acc.loop combined(serial) private(@privatization__ZTS7HasDtor -> %[[PRIVATE]] : !cir.ptr<!rec_HasDtor>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
|
||||
#pragma acc parallel loop private(someInt, someFloat, noCopy, hasCopy, notDefCtor, dtor)
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK: acc.parallel combined(loop) {
|
||||
// CHECK: %[[PRIVATE1:.*]] = acc.private varPtr(%[[SOMEINT]] : !cir.ptr<!s32i>) -> !cir.ptr<!s32i> {name = "someInt"}
|
||||
// CHECK-NEXT: %[[PRIVATE2:.*]] = acc.private varPtr(%[[SOMEFLOAT]] : !cir.ptr<!cir.float>) -> !cir.ptr<!cir.float> {name = "someFloat"}
|
||||
// CHECK-NEXT: %[[PRIVATE3:.*]] = acc.private varPtr(%[[NOCOPY]] : !cir.ptr<!rec_NoCopyConstruct>) -> !cir.ptr<!rec_NoCopyConstruct> {name = "noCopy"}
|
||||
// CHECK-NEXT: %[[PRIVATE4:.*]] = acc.private varPtr(%[[HASCOPY]] : !cir.ptr<!rec_CopyConstruct>) -> !cir.ptr<!rec_CopyConstruct> {name = "hasCopy"}
|
||||
// CHECK-NEXT: %[[PRIVATE5:.*]] = acc.private varPtr(%[[NOTDEFCTOR]] : !cir.ptr<!rec_NonDefaultCtor>) -> !cir.ptr<!rec_NonDefaultCtor> {name = "notDefCtor"}
|
||||
// CHECK-NEXT: %[[PRIVATE6:.*]] = acc.private varPtr(%[[DTOR]] : !cir.ptr<!rec_HasDtor>) -> !cir.ptr<!rec_HasDtor> {name = "dtor"}
|
||||
// CHECK-NEXT: acc.loop combined(parallel) private(@privatization__ZTSi -> %[[PRIVATE1]] : !cir.ptr<!s32i>,
|
||||
// CHECK-SAME: @privatization__ZTSf -> %[[PRIVATE2]] : !cir.ptr<!cir.float>,
|
||||
// CHECK-SAME: @privatization__ZTS15NoCopyConstruct -> %[[PRIVATE3]] : !cir.ptr<!rec_NoCopyConstruct>,
|
||||
// CHECK-SAME: @privatization__ZTS13CopyConstruct -> %[[PRIVATE4]] : !cir.ptr<!rec_CopyConstruct>,
|
||||
// CHECK-SAME: @privatization__ZTS14NonDefaultCtor -> %[[PRIVATE5]] : !cir.ptr<!rec_NonDefaultCtor>,
|
||||
// CHECK-SAME: @privatization__ZTS7HasDtor -> %[[PRIVATE6]] : !cir.ptr<!rec_HasDtor>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
|
||||
#pragma acc serial loop private(someIntArr[1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: acc.serial combined(loop) {
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[INTARR]] : !cir.ptr<!cir.array<!s32i x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!s32i x 5>> {name = "someIntArr[1]"}
|
||||
// CHECK-NEXT: acc.loop combined(serial) private(@privatization__ZTSA5_i -> %[[PRIVATE]] : !cir.ptr<!cir.array<!s32i x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc parallel loop private(someFloatArr[1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: acc.parallel combined(loop) {
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[FLOATARR]] : !cir.ptr<!cir.array<!cir.float x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!cir.float x 5>> {name = "someFloatArr[1]"}
|
||||
// CHECK-NEXT: acc.loop combined(parallel) private(@privatization__ZTSA5_f -> %[[PRIVATE]] : !cir.ptr<!cir.array<!cir.float x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc serial loop private(noCopyArr[1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: acc.serial combined(loop) {
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[NOCOPYARR]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {name = "noCopyArr[1]"}
|
||||
// CHECK-NEXT: acc.loop combined(serial) private(@privatization__ZTSA5_15NoCopyConstruct -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc parallel loop private(hasCopyArr[1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: acc.parallel combined(loop) {
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[HASCOPYARR]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {name = "hasCopyArr[1]"}
|
||||
// CHECK-NEXT: acc.loop combined(parallel) private(@privatization__ZTSA5_13CopyConstruct -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc parallel loop private(notDefCtorArr[1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: acc.parallel combined(loop) {
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[NOTDEFCTORARR]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {name = "notDefCtorArr[1]"}
|
||||
// CHECK-NEXT: acc.loop combined(parallel) private(@privatization__ZTSA5_14NonDefaultCtor -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc parallel loop private(dtorArr[1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: acc.parallel combined(loop) {
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[DTORARR]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_HasDtor x 5>> {name = "dtorArr[1]"}
|
||||
// CHECK-NEXT: acc.loop combined(parallel) private(@privatization__ZTSA5_7HasDtor -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc serial loop private(someIntArr[1], someFloatArr[1], noCopyArr[1], hasCopyArr[1], notDefCtorArr[1], dtorArr[1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: acc.serial combined(loop) {
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE1:.*]] = acc.private varPtr(%[[INTARR]] : !cir.ptr<!cir.array<!s32i x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!s32i x 5>> {name = "someIntArr[1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE2:.*]] = acc.private varPtr(%[[FLOATARR]] : !cir.ptr<!cir.array<!cir.float x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!cir.float x 5>> {name = "someFloatArr[1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE3:.*]] = acc.private varPtr(%[[NOCOPYARR]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {name = "noCopyArr[1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE4:.*]] = acc.private varPtr(%[[HASCOPYARR]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {name = "hasCopyArr[1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE5:.*]] = acc.private varPtr(%[[NOTDEFCTORARR]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {name = "notDefCtorArr[1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE6:.*]] = acc.private varPtr(%[[DTORARR]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_HasDtor x 5>> {name = "dtorArr[1]"}
|
||||
// CHECK-NEXT: acc.loop combined(serial) private(@privatization__ZTSA5_i -> %[[PRIVATE1]] : !cir.ptr<!cir.array<!s32i x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_f -> %[[PRIVATE2]] : !cir.ptr<!cir.array<!cir.float x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_15NoCopyConstruct -> %[[PRIVATE3]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_13CopyConstruct -> %[[PRIVATE4]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_14NonDefaultCtor -> %[[PRIVATE5]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_7HasDtor -> %[[PRIVATE6]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
|
||||
#pragma acc parallel loop private(someIntArr[1:1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: acc.parallel combined(loop) {
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[INTARR]] : !cir.ptr<!cir.array<!s32i x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!s32i x 5>> {name = "someIntArr[1:1]"}
|
||||
// CHECK-NEXT: acc.loop combined(parallel) private(@privatization__ZTSA5_i -> %[[PRIVATE]] : !cir.ptr<!cir.array<!s32i x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc serial loop private(someFloatArr[1:1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: acc.serial combined(loop) {
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[FLOATARR]] : !cir.ptr<!cir.array<!cir.float x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!cir.float x 5>> {name = "someFloatArr[1:1]"}
|
||||
// CHECK-NEXT: acc.loop combined(serial) private(@privatization__ZTSA5_f -> %[[PRIVATE]] : !cir.ptr<!cir.array<!cir.float x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc parallel loop private(noCopyArr[1:1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: acc.parallel combined(loop) {
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[NOCOPYARR]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {name = "noCopyArr[1:1]"}
|
||||
// CHECK-NEXT: acc.loop combined(parallel) private(@privatization__ZTSA5_15NoCopyConstruct -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc serial loop private(hasCopyArr[1:1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: acc.serial combined(loop) {
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[HASCOPYARR]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {name = "hasCopyArr[1:1]"}
|
||||
// CHECK-NEXT: acc.loop combined(serial) private(@privatization__ZTSA5_13CopyConstruct -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc parallel loop private(notDefCtorArr[1:1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: acc.parallel combined(loop) {
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[NOTDEFCTORARR]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {name = "notDefCtorArr[1:1]"}
|
||||
// CHECK-NEXT: acc.loop combined(parallel) private(@privatization__ZTSA5_14NonDefaultCtor -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc parallel loop private(dtorArr[1:1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: acc.parallel combined(loop) {
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[DTORARR]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_HasDtor x 5>> {name = "dtorArr[1:1]"}
|
||||
// CHECK-NEXT: acc.loop combined(parallel) private(@privatization__ZTSA5_7HasDtor -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc parallel loop private(someIntArr[1:1], someFloatArr[1:1], noCopyArr[1:1], hasCopyArr[1:1], notDefCtorArr[1:1], dtorArr[1:1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: acc.parallel combined(loop) {
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE1:.*]] = acc.private varPtr(%[[INTARR]] : !cir.ptr<!cir.array<!s32i x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!s32i x 5>> {name = "someIntArr[1:1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE2:.*]] = acc.private varPtr(%[[FLOATARR]] : !cir.ptr<!cir.array<!cir.float x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!cir.float x 5>> {name = "someFloatArr[1:1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE3:.*]] = acc.private varPtr(%[[NOCOPYARR]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {name = "noCopyArr[1:1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE4:.*]] = acc.private varPtr(%[[HASCOPYARR]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {name = "hasCopyArr[1:1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE5:.*]] = acc.private varPtr(%[[NOTDEFCTORARR]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {name = "notDefCtorArr[1:1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE6:.*]] = acc.private varPtr(%[[DTORARR]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_HasDtor x 5>> {name = "dtorArr[1:1]"}
|
||||
// CHECK-NEXT: acc.loop combined(parallel) private(@privatization__ZTSA5_i -> %[[PRIVATE1]] : !cir.ptr<!cir.array<!s32i x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_f -> %[[PRIVATE2]] : !cir.ptr<!cir.array<!cir.float x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_15NoCopyConstruct -> %[[PRIVATE3]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_13CopyConstruct -> %[[PRIVATE4]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_14NonDefaultCtor -> %[[PRIVATE5]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_7HasDtor -> %[[PRIVATE6]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
}
|
||||
459
clang/test/CIR/CodeGenOpenACC/compute-private-clause.cpp
Normal file
459
clang/test/CIR/CodeGenOpenACC/compute-private-clause.cpp
Normal file
@ -0,0 +1,459 @@
|
||||
// RUN: %clang_cc1 -fopenacc -triple x86_64-linux-gnu -Wno-openacc-self-if-potential-conflict -emit-cir -fclangir -triple x86_64-linux-pc %s -o - | FileCheck %s
|
||||
|
||||
struct NoCopyConstruct {};
|
||||
|
||||
struct CopyConstruct {
|
||||
CopyConstruct() = default;
|
||||
CopyConstruct(const CopyConstruct&);
|
||||
};
|
||||
|
||||
struct NonDefaultCtor {
|
||||
NonDefaultCtor();
|
||||
};
|
||||
|
||||
struct HasDtor {
|
||||
~HasDtor();
|
||||
};
|
||||
|
||||
// CHECK: acc.private.recipe @privatization__ZTSA5_7HasDtor : !cir.ptr<!cir.array<!rec_HasDtor x 5>> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.array<!rec_HasDtor x 5>, !cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } destroy {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}):
|
||||
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<4> : !u64i
|
||||
// CHECK-NEXT: %[[ARRPTR:.*]] = cir.cast(array_to_ptrdecay, %[[ARG]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>), !cir.ptr<!rec_HasDtor>
|
||||
// CHECK-NEXT: %[[ELEM:.*]] = cir.ptr_stride(%[[ARRPTR]] : !cir.ptr<!rec_HasDtor>, %[[LAST_IDX]] : !u64i), !cir.ptr<!rec_HasDtor>
|
||||
// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !cir.ptr<!rec_HasDtor>, !cir.ptr<!cir.ptr<!rec_HasDtor>>, ["__array_idx"]
|
||||
// CHECK-NEXT: cir.store %[[ELEM]], %[[ITR]] : !cir.ptr<!rec_HasDtor>, !cir.ptr<!cir.ptr<!rec_HasDtor>>
|
||||
// CHECK-NEXT: cir.do {
|
||||
// CHECK-NEXT: %[[ELEM_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!cir.ptr<!rec_HasDtor>>, !cir.ptr<!rec_HasDtor>
|
||||
// CHECK-NEXT: cir.call @_ZN7HasDtorD1Ev(%[[ELEM_LOAD]]) nothrow : (!cir.ptr<!rec_HasDtor>) -> ()
|
||||
// CHECK-NEXT: %[[NEG_ONE:.*]] = cir.const #cir.int<-1> : !s64i
|
||||
// CHECK-NEXT: %[[PREVELEM:.*]] = cir.ptr_stride(%[[ELEM_LOAD]] : !cir.ptr<!rec_HasDtor>, %[[NEG_ONE]] : !s64i), !cir.ptr<!rec_HasDtor>
|
||||
// CHECK-NEXT: cir.store %[[PREVELEM]], %[[ITR]] : !cir.ptr<!rec_HasDtor>, !cir.ptr<!cir.ptr<!rec_HasDtor>>
|
||||
// CHECK-NEXT: cir.yield
|
||||
// CHECK-NEXT: } while {
|
||||
// CHECK-NEXT: %[[ELEM_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!cir.ptr<!rec_HasDtor>>, !cir.ptr<!rec_HasDtor>
|
||||
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[ELEM_LOAD]], %[[ARRPTR]]) : !cir.ptr<!rec_HasDtor>, !cir.bool
|
||||
// CHECK-NEXT: cir.condition(%[[CMP]])
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_14NonDefaultCtor : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.array<!rec_NonDefaultCtor x 5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_13CopyConstruct : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.array<!rec_CopyConstruct x 5>, !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_15NoCopyConstruct : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.array<!rec_NoCopyConstruct x 5>, !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTS7HasDtor : !cir.ptr<!rec_HasDtor> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !rec_HasDtor, !cir.ptr<!rec_HasDtor>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } destroy {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
|
||||
// CHECK-NEXT: cir.call @_ZN7HasDtorD1Ev(%[[ARG]]) nothrow : (!cir.ptr<!rec_HasDtor>) -> ()
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTS14NonDefaultCtor : !cir.ptr<!rec_NonDefaultCtor> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !rec_NonDefaultCtor, !cir.ptr<!rec_NonDefaultCtor>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTS13CopyConstruct : !cir.ptr<!rec_CopyConstruct> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !rec_CopyConstruct, !cir.ptr<!rec_CopyConstruct>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTS15NoCopyConstruct : !cir.ptr<!rec_NoCopyConstruct> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !rec_NoCopyConstruct, !cir.ptr<!rec_NoCopyConstruct>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSf : !cir.ptr<!cir.float> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSi : !cir.ptr<!s32i> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
|
||||
extern "C" void acc_compute() {
|
||||
// CHECK: cir.func{{.*}} @acc_compute() {
|
||||
|
||||
int someInt;
|
||||
// CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["someInt"]
|
||||
float someFloat;
|
||||
// CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["someFloat"]
|
||||
NoCopyConstruct noCopy;
|
||||
// CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca !rec_NoCopyConstruct, !cir.ptr<!rec_NoCopyConstruct>, ["noCopy"]
|
||||
CopyConstruct hasCopy;
|
||||
// CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca !rec_CopyConstruct, !cir.ptr<!rec_CopyConstruct>, ["hasCopy"]
|
||||
NonDefaultCtor notDefCtor;
|
||||
// CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca !rec_NonDefaultCtor, !cir.ptr<!rec_NonDefaultCtor>, ["notDefCtor", init]
|
||||
HasDtor dtor;
|
||||
// CHECK-NEXT: %[[DTOR:.*]] = cir.alloca !rec_HasDtor, !cir.ptr<!rec_HasDtor>, ["dtor"]
|
||||
int someIntArr[5];
|
||||
// CHECK-NEXT: %[[INTARR:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["someIntArr"]
|
||||
float someFloatArr[5];
|
||||
// CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["someFloatArr"]
|
||||
NoCopyConstruct noCopyArr[5];
|
||||
// CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca !cir.array<!rec_NoCopyConstruct x 5>, !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>, ["noCopyArr"]
|
||||
CopyConstruct hasCopyArr[5];
|
||||
// CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca !cir.array<!rec_CopyConstruct x 5>, !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>, ["hasCopyArr"]
|
||||
NonDefaultCtor notDefCtorArr[5];
|
||||
// CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca !cir.array<!rec_NonDefaultCtor x 5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["notDefCtorArr", init]
|
||||
HasDtor dtorArr[5];
|
||||
// CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca !cir.array<!rec_HasDtor x 5>, !cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["dtorArr"]
|
||||
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[NOTDEFCTOR]]) : (!cir.ptr<!rec_NonDefaultCtor>) -> ()
|
||||
|
||||
#pragma acc parallel private(someInt)
|
||||
;
|
||||
// CHECK: %[[PRIVATE:.*]] = acc.private varPtr(%[[SOMEINT]] : !cir.ptr<!s32i>) -> !cir.ptr<!s32i> {name = "someInt"}
|
||||
// CHECK-NEXT: acc.parallel private(@privatization__ZTSi -> %[[PRIVATE]] : !cir.ptr<!s32i>)
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc serial private(someFloat)
|
||||
;
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[SOMEFLOAT]] : !cir.ptr<!cir.float>) -> !cir.ptr<!cir.float> {name = "someFloat"}
|
||||
// CHECK-NEXT: acc.serial private(@privatization__ZTSf -> %[[PRIVATE]] : !cir.ptr<!cir.float>)
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
|
||||
#pragma acc parallel private(noCopy)
|
||||
;
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[NOCOPY]] : !cir.ptr<!rec_NoCopyConstruct>) -> !cir.ptr<!rec_NoCopyConstruct> {name = "noCopy"}
|
||||
// CHECK-NEXT: acc.parallel private(@privatization__ZTS15NoCopyConstruct -> %[[PRIVATE]] : !cir.ptr<!rec_NoCopyConstruct>
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc serial private(hasCopy)
|
||||
;
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[HASCOPY]] : !cir.ptr<!rec_CopyConstruct>) -> !cir.ptr<!rec_CopyConstruct> {name = "hasCopy"}
|
||||
// CHECK-NEXT: acc.serial private(@privatization__ZTS13CopyConstruct -> %[[PRIVATE]] : !cir.ptr<!rec_CopyConstruct>)
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc serial private(notDefCtor)
|
||||
;
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[NOTDEFCTOR]] : !cir.ptr<!rec_NonDefaultCtor>) -> !cir.ptr<!rec_NonDefaultCtor> {name = "notDefCtor"}
|
||||
// CHECK-NEXT: acc.serial private(@privatization__ZTS14NonDefaultCtor -> %[[PRIVATE]] : !cir.ptr<!rec_NonDefaultCtor>)
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc serial private(dtor)
|
||||
;
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[DTOR]] : !cir.ptr<!rec_HasDtor>) -> !cir.ptr<!rec_HasDtor> {name = "dtor"}
|
||||
// CHECK-NEXT: acc.serial private(@privatization__ZTS7HasDtor -> %[[PRIVATE]] : !cir.ptr<!rec_HasDtor>)
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
|
||||
#pragma acc parallel private(someInt, someFloat, noCopy, hasCopy, notDefCtor, dtor)
|
||||
;
|
||||
// CHECK: %[[PRIVATE1:.*]] = acc.private varPtr(%[[SOMEINT]] : !cir.ptr<!s32i>) -> !cir.ptr<!s32i> {name = "someInt"}
|
||||
// CHECK-NEXT: %[[PRIVATE2:.*]] = acc.private varPtr(%[[SOMEFLOAT]] : !cir.ptr<!cir.float>) -> !cir.ptr<!cir.float> {name = "someFloat"}
|
||||
// CHECK-NEXT: %[[PRIVATE3:.*]] = acc.private varPtr(%[[NOCOPY]] : !cir.ptr<!rec_NoCopyConstruct>) -> !cir.ptr<!rec_NoCopyConstruct> {name = "noCopy"}
|
||||
// CHECK-NEXT: %[[PRIVATE4:.*]] = acc.private varPtr(%[[HASCOPY]] : !cir.ptr<!rec_CopyConstruct>) -> !cir.ptr<!rec_CopyConstruct> {name = "hasCopy"}
|
||||
// CHECK-NEXT: %[[PRIVATE5:.*]] = acc.private varPtr(%[[NOTDEFCTOR]] : !cir.ptr<!rec_NonDefaultCtor>) -> !cir.ptr<!rec_NonDefaultCtor> {name = "notDefCtor"}
|
||||
// CHECK-NEXT: %[[PRIVATE6:.*]] = acc.private varPtr(%[[DTOR]] : !cir.ptr<!rec_HasDtor>) -> !cir.ptr<!rec_HasDtor> {name = "dtor"}
|
||||
// CHECK-NEXT: acc.parallel private(@privatization__ZTSi -> %[[PRIVATE1]] : !cir.ptr<!s32i>,
|
||||
// CHECK-SAME: @privatization__ZTSf -> %[[PRIVATE2]] : !cir.ptr<!cir.float>,
|
||||
// CHECK-SAME: @privatization__ZTS15NoCopyConstruct -> %[[PRIVATE3]] : !cir.ptr<!rec_NoCopyConstruct>,
|
||||
// CHECK-SAME: @privatization__ZTS13CopyConstruct -> %[[PRIVATE4]] : !cir.ptr<!rec_CopyConstruct>,
|
||||
// CHECK-SAME: @privatization__ZTS14NonDefaultCtor -> %[[PRIVATE5]] : !cir.ptr<!rec_NonDefaultCtor>,
|
||||
// CHECK-SAME: @privatization__ZTS7HasDtor -> %[[PRIVATE6]] : !cir.ptr<!rec_HasDtor>)
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
|
||||
#pragma acc serial private(someIntArr[1])
|
||||
;
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[INTARR]] : !cir.ptr<!cir.array<!s32i x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!s32i x 5>> {name = "someIntArr[1]"}
|
||||
// CHECK-NEXT: acc.serial private(@privatization__ZTSA5_i -> %[[PRIVATE]] : !cir.ptr<!cir.array<!s32i x 5>>)
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc parallel private(someFloatArr[1])
|
||||
;
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[FLOATARR]] : !cir.ptr<!cir.array<!cir.float x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!cir.float x 5>> {name = "someFloatArr[1]"}
|
||||
// CHECK-NEXT: acc.parallel private(@privatization__ZTSA5_f -> %[[PRIVATE]] : !cir.ptr<!cir.array<!cir.float x 5>>)
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc serial private(noCopyArr[1])
|
||||
;
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[NOCOPYARR]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {name = "noCopyArr[1]"}
|
||||
// CHECK-NEXT: acc.serial private(@privatization__ZTSA5_15NoCopyConstruct -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>)
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc parallel private(hasCopyArr[1])
|
||||
;
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[HASCOPYARR]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {name = "hasCopyArr[1]"}
|
||||
// CHECK-NEXT: acc.parallel private(@privatization__ZTSA5_13CopyConstruct -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>)
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc parallel private(notDefCtorArr[1])
|
||||
;
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[NOTDEFCTORARR]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {name = "notDefCtorArr[1]"}
|
||||
// CHECK-NEXT: acc.parallel private(@privatization__ZTSA5_14NonDefaultCtor -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>)
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc parallel private(dtorArr[1])
|
||||
;
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[DTORARR]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_HasDtor x 5>> {name = "dtorArr[1]"}
|
||||
// CHECK-NEXT: acc.parallel private(@privatization__ZTSA5_7HasDtor -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>)
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc serial private(someIntArr[1], someFloatArr[1], noCopyArr[1], hasCopyArr[1], notDefCtorArr[1], dtorArr[1])
|
||||
;
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE1:.*]] = acc.private varPtr(%[[INTARR]] : !cir.ptr<!cir.array<!s32i x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!s32i x 5>> {name = "someIntArr[1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE2:.*]] = acc.private varPtr(%[[FLOATARR]] : !cir.ptr<!cir.array<!cir.float x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!cir.float x 5>> {name = "someFloatArr[1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE3:.*]] = acc.private varPtr(%[[NOCOPYARR]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {name = "noCopyArr[1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE4:.*]] = acc.private varPtr(%[[HASCOPYARR]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {name = "hasCopyArr[1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE5:.*]] = acc.private varPtr(%[[NOTDEFCTORARR]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {name = "notDefCtorArr[1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE6:.*]] = acc.private varPtr(%[[DTORARR]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_HasDtor x 5>> {name = "dtorArr[1]"}
|
||||
// CHECK-NEXT: acc.serial private(@privatization__ZTSA5_i -> %[[PRIVATE1]] : !cir.ptr<!cir.array<!s32i x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_f -> %[[PRIVATE2]] : !cir.ptr<!cir.array<!cir.float x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_15NoCopyConstruct -> %[[PRIVATE3]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_13CopyConstruct -> %[[PRIVATE4]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_14NonDefaultCtor -> %[[PRIVATE5]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_7HasDtor -> %[[PRIVATE6]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>)
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
|
||||
#pragma acc parallel private(someIntArr[1:1])
|
||||
;
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[INTARR]] : !cir.ptr<!cir.array<!s32i x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!s32i x 5>> {name = "someIntArr[1:1]"}
|
||||
// CHECK-NEXT: acc.parallel private(@privatization__ZTSA5_i -> %[[PRIVATE]] : !cir.ptr<!cir.array<!s32i x 5>>)
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc serial private(someFloatArr[1:1])
|
||||
;
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[FLOATARR]] : !cir.ptr<!cir.array<!cir.float x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!cir.float x 5>> {name = "someFloatArr[1:1]"}
|
||||
// CHECK-NEXT: acc.serial private(@privatization__ZTSA5_f -> %[[PRIVATE]] : !cir.ptr<!cir.array<!cir.float x 5>>)
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc parallel private(noCopyArr[1:1])
|
||||
;
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[NOCOPYARR]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {name = "noCopyArr[1:1]"}
|
||||
// CHECK-NEXT: acc.parallel private(@privatization__ZTSA5_15NoCopyConstruct -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>)
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc serial private(hasCopyArr[1:1])
|
||||
;
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[HASCOPYARR]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {name = "hasCopyArr[1:1]"}
|
||||
// CHECK-NEXT: acc.serial private(@privatization__ZTSA5_13CopyConstruct -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>)
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc parallel private(notDefCtorArr[1:1])
|
||||
;
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[NOTDEFCTORARR]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {name = "notDefCtorArr[1:1]"}
|
||||
// CHECK-NEXT: acc.parallel private(@privatization__ZTSA5_14NonDefaultCtor -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>)
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc parallel private(dtorArr[1:1])
|
||||
;
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[DTORARR]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_HasDtor x 5>> {name = "dtorArr[1:1]"}
|
||||
// CHECK-NEXT: acc.parallel private(@privatization__ZTSA5_7HasDtor -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>)
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc parallel private(someIntArr[1:1], someFloatArr[1:1], noCopyArr[1:1], hasCopyArr[1:1], notDefCtorArr[1:1], dtorArr[1:1])
|
||||
;
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE1:.*]] = acc.private varPtr(%[[INTARR]] : !cir.ptr<!cir.array<!s32i x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!s32i x 5>> {name = "someIntArr[1:1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE2:.*]] = acc.private varPtr(%[[FLOATARR]] : !cir.ptr<!cir.array<!cir.float x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!cir.float x 5>> {name = "someFloatArr[1:1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE3:.*]] = acc.private varPtr(%[[NOCOPYARR]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {name = "noCopyArr[1:1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE4:.*]] = acc.private varPtr(%[[HASCOPYARR]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {name = "hasCopyArr[1:1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE5:.*]] = acc.private varPtr(%[[NOTDEFCTORARR]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {name = "notDefCtorArr[1:1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE6:.*]] = acc.private varPtr(%[[DTORARR]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_HasDtor x 5>> {name = "dtorArr[1:1]"}
|
||||
// CHECK-NEXT: acc.parallel private(@privatization__ZTSA5_i -> %[[PRIVATE1]] : !cir.ptr<!cir.array<!s32i x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_f -> %[[PRIVATE2]] : !cir.ptr<!cir.array<!cir.float x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_15NoCopyConstruct -> %[[PRIVATE3]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_13CopyConstruct -> %[[PRIVATE4]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_14NonDefaultCtor -> %[[PRIVATE5]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_7HasDtor -> %[[PRIVATE6]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>)
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
}
|
||||
459
clang/test/CIR/CodeGenOpenACC/loop-private-clause.cpp
Normal file
459
clang/test/CIR/CodeGenOpenACC/loop-private-clause.cpp
Normal file
@ -0,0 +1,459 @@
|
||||
// RUN: %clang_cc1 -fopenacc -triple x86_64-linux-gnu -Wno-openacc-self-if-potential-conflict -emit-cir -fclangir -triple x86_64-linux-pc %s -o - | FileCheck %s
|
||||
|
||||
struct NoCopyConstruct {};
|
||||
|
||||
struct CopyConstruct {
|
||||
CopyConstruct() = default;
|
||||
CopyConstruct(const CopyConstruct&);
|
||||
};
|
||||
|
||||
struct NonDefaultCtor {
|
||||
NonDefaultCtor();
|
||||
};
|
||||
|
||||
struct HasDtor {
|
||||
~HasDtor();
|
||||
};
|
||||
|
||||
// CHECK: acc.private.recipe @privatization__ZTSA5_7HasDtor : !cir.ptr<!cir.array<!rec_HasDtor x 5>> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.array<!rec_HasDtor x 5>, !cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } destroy {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}):
|
||||
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<4> : !u64i
|
||||
// CHECK-NEXT: %[[ARRPTR:.*]] = cir.cast(array_to_ptrdecay, %[[ARG]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>), !cir.ptr<!rec_HasDtor>
|
||||
// CHECK-NEXT: %[[ELEM:.*]] = cir.ptr_stride(%[[ARRPTR]] : !cir.ptr<!rec_HasDtor>, %[[LAST_IDX]] : !u64i), !cir.ptr<!rec_HasDtor>
|
||||
// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !cir.ptr<!rec_HasDtor>, !cir.ptr<!cir.ptr<!rec_HasDtor>>, ["__array_idx"]
|
||||
// CHECK-NEXT: cir.store %[[ELEM]], %[[ITR]] : !cir.ptr<!rec_HasDtor>, !cir.ptr<!cir.ptr<!rec_HasDtor>>
|
||||
// CHECK-NEXT: cir.do {
|
||||
// CHECK-NEXT: %[[ELEM_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!cir.ptr<!rec_HasDtor>>, !cir.ptr<!rec_HasDtor>
|
||||
// CHECK-NEXT: cir.call @_ZN7HasDtorD1Ev(%[[ELEM_LOAD]]) nothrow : (!cir.ptr<!rec_HasDtor>) -> ()
|
||||
// CHECK-NEXT: %[[NEG_ONE:.*]] = cir.const #cir.int<-1> : !s64i
|
||||
// CHECK-NEXT: %[[PREVELEM:.*]] = cir.ptr_stride(%[[ELEM_LOAD]] : !cir.ptr<!rec_HasDtor>, %[[NEG_ONE]] : !s64i), !cir.ptr<!rec_HasDtor>
|
||||
// CHECK-NEXT: cir.store %[[PREVELEM]], %[[ITR]] : !cir.ptr<!rec_HasDtor>, !cir.ptr<!cir.ptr<!rec_HasDtor>>
|
||||
// CHECK-NEXT: cir.yield
|
||||
// CHECK-NEXT: } while {
|
||||
// CHECK-NEXT: %[[ELEM_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!cir.ptr<!rec_HasDtor>>, !cir.ptr<!rec_HasDtor>
|
||||
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[ELEM_LOAD]], %[[ARRPTR]]) : !cir.ptr<!rec_HasDtor>, !cir.bool
|
||||
// CHECK-NEXT: cir.condition(%[[CMP]])
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_14NonDefaultCtor : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.array<!rec_NonDefaultCtor x 5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_13CopyConstruct : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.array<!rec_CopyConstruct x 5>, !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_15NoCopyConstruct : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.array<!rec_NoCopyConstruct x 5>, !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTS7HasDtor : !cir.ptr<!rec_HasDtor> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !rec_HasDtor, !cir.ptr<!rec_HasDtor>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: } destroy {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
|
||||
// CHECK-NEXT: cir.call @_ZN7HasDtorD1Ev(%[[ARG]]) nothrow : (!cir.ptr<!rec_HasDtor>) -> ()
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTS14NonDefaultCtor : !cir.ptr<!rec_NonDefaultCtor> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !rec_NonDefaultCtor, !cir.ptr<!rec_NonDefaultCtor>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTS13CopyConstruct : !cir.ptr<!rec_CopyConstruct> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !rec_CopyConstruct, !cir.ptr<!rec_CopyConstruct>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTS15NoCopyConstruct : !cir.ptr<!rec_NoCopyConstruct> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !rec_NoCopyConstruct, !cir.ptr<!rec_NoCopyConstruct>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSf : !cir.ptr<!cir.float> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
//
|
||||
// CHECK-NEXT: acc.private.recipe @privatization__ZTSi : !cir.ptr<!s32i> init {
|
||||
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
|
||||
// CHECK-NEXT: cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.private.init"]
|
||||
// CHECK-NEXT: acc.yield
|
||||
// CHECK-NEXT: }
|
||||
|
||||
extern "C" void acc_loop() {
|
||||
// CHECK: cir.func{{.*}} @acc_loop() {
|
||||
|
||||
int someInt;
|
||||
// CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["someInt"]
|
||||
float someFloat;
|
||||
// CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["someFloat"]
|
||||
NoCopyConstruct noCopy;
|
||||
// CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca !rec_NoCopyConstruct, !cir.ptr<!rec_NoCopyConstruct>, ["noCopy"]
|
||||
CopyConstruct hasCopy;
|
||||
// CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca !rec_CopyConstruct, !cir.ptr<!rec_CopyConstruct>, ["hasCopy"]
|
||||
NonDefaultCtor notDefCtor;
|
||||
// CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca !rec_NonDefaultCtor, !cir.ptr<!rec_NonDefaultCtor>, ["notDefCtor", init]
|
||||
HasDtor dtor;
|
||||
// CHECK-NEXT: %[[DTOR:.*]] = cir.alloca !rec_HasDtor, !cir.ptr<!rec_HasDtor>, ["dtor"]
|
||||
int someIntArr[5];
|
||||
// CHECK-NEXT: %[[INTARR:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["someIntArr"]
|
||||
float someFloatArr[5];
|
||||
// CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["someFloatArr"]
|
||||
NoCopyConstruct noCopyArr[5];
|
||||
// CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca !cir.array<!rec_NoCopyConstruct x 5>, !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>, ["noCopyArr"]
|
||||
CopyConstruct hasCopyArr[5];
|
||||
// CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca !cir.array<!rec_CopyConstruct x 5>, !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>, ["hasCopyArr"]
|
||||
NonDefaultCtor notDefCtorArr[5];
|
||||
// CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca !cir.array<!rec_NonDefaultCtor x 5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["notDefCtorArr", init]
|
||||
HasDtor dtorArr[5];
|
||||
// CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca !cir.array<!rec_HasDtor x 5>, !cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["dtorArr"]
|
||||
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[NOTDEFCTOR]]) : (!cir.ptr<!rec_NonDefaultCtor>) -> ()
|
||||
|
||||
#pragma acc loop private(someInt)
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK: %[[PRIVATE:.*]] = acc.private varPtr(%[[SOMEINT]] : !cir.ptr<!s32i>) -> !cir.ptr<!s32i> {name = "someInt"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTSi -> %[[PRIVATE]] : !cir.ptr<!s32i>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc loop private(someFloat)
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[SOMEFLOAT]] : !cir.ptr<!cir.float>) -> !cir.ptr<!cir.float> {name = "someFloat"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTSf -> %[[PRIVATE]] : !cir.ptr<!cir.float>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
|
||||
#pragma acc loop private(noCopy)
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[NOCOPY]] : !cir.ptr<!rec_NoCopyConstruct>) -> !cir.ptr<!rec_NoCopyConstruct> {name = "noCopy"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTS15NoCopyConstruct -> %[[PRIVATE]] : !cir.ptr<!rec_NoCopyConstruct>
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc loop private(hasCopy)
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[HASCOPY]] : !cir.ptr<!rec_CopyConstruct>) -> !cir.ptr<!rec_CopyConstruct> {name = "hasCopy"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTS13CopyConstruct -> %[[PRIVATE]] : !cir.ptr<!rec_CopyConstruct>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc loop private(notDefCtor)
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[NOTDEFCTOR]] : !cir.ptr<!rec_NonDefaultCtor>) -> !cir.ptr<!rec_NonDefaultCtor> {name = "notDefCtor"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTS14NonDefaultCtor -> %[[PRIVATE]] : !cir.ptr<!rec_NonDefaultCtor>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc loop private(dtor)
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[DTOR]] : !cir.ptr<!rec_HasDtor>) -> !cir.ptr<!rec_HasDtor> {name = "dtor"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTS7HasDtor -> %[[PRIVATE]] : !cir.ptr<!rec_HasDtor>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
|
||||
#pragma acc loop private(someInt, someFloat, noCopy, hasCopy, notDefCtor, dtor)
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK: %[[PRIVATE1:.*]] = acc.private varPtr(%[[SOMEINT]] : !cir.ptr<!s32i>) -> !cir.ptr<!s32i> {name = "someInt"}
|
||||
// CHECK-NEXT: %[[PRIVATE2:.*]] = acc.private varPtr(%[[SOMEFLOAT]] : !cir.ptr<!cir.float>) -> !cir.ptr<!cir.float> {name = "someFloat"}
|
||||
// CHECK-NEXT: %[[PRIVATE3:.*]] = acc.private varPtr(%[[NOCOPY]] : !cir.ptr<!rec_NoCopyConstruct>) -> !cir.ptr<!rec_NoCopyConstruct> {name = "noCopy"}
|
||||
// CHECK-NEXT: %[[PRIVATE4:.*]] = acc.private varPtr(%[[HASCOPY]] : !cir.ptr<!rec_CopyConstruct>) -> !cir.ptr<!rec_CopyConstruct> {name = "hasCopy"}
|
||||
// CHECK-NEXT: %[[PRIVATE5:.*]] = acc.private varPtr(%[[NOTDEFCTOR]] : !cir.ptr<!rec_NonDefaultCtor>) -> !cir.ptr<!rec_NonDefaultCtor> {name = "notDefCtor"}
|
||||
// CHECK-NEXT: %[[PRIVATE6:.*]] = acc.private varPtr(%[[DTOR]] : !cir.ptr<!rec_HasDtor>) -> !cir.ptr<!rec_HasDtor> {name = "dtor"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTSi -> %[[PRIVATE1]] : !cir.ptr<!s32i>,
|
||||
// CHECK-SAME: @privatization__ZTSf -> %[[PRIVATE2]] : !cir.ptr<!cir.float>,
|
||||
// CHECK-SAME: @privatization__ZTS15NoCopyConstruct -> %[[PRIVATE3]] : !cir.ptr<!rec_NoCopyConstruct>,
|
||||
// CHECK-SAME: @privatization__ZTS13CopyConstruct -> %[[PRIVATE4]] : !cir.ptr<!rec_CopyConstruct>,
|
||||
// CHECK-SAME: @privatization__ZTS14NonDefaultCtor -> %[[PRIVATE5]] : !cir.ptr<!rec_NonDefaultCtor>,
|
||||
// CHECK-SAME: @privatization__ZTS7HasDtor -> %[[PRIVATE6]] : !cir.ptr<!rec_HasDtor>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
|
||||
#pragma acc loop private(someIntArr[1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[INTARR]] : !cir.ptr<!cir.array<!s32i x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!s32i x 5>> {name = "someIntArr[1]"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTSA5_i -> %[[PRIVATE]] : !cir.ptr<!cir.array<!s32i x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc loop private(someFloatArr[1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[FLOATARR]] : !cir.ptr<!cir.array<!cir.float x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!cir.float x 5>> {name = "someFloatArr[1]"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTSA5_f -> %[[PRIVATE]] : !cir.ptr<!cir.array<!cir.float x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc loop private(noCopyArr[1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[NOCOPYARR]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {name = "noCopyArr[1]"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTSA5_15NoCopyConstruct -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc loop private(hasCopyArr[1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[HASCOPYARR]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {name = "hasCopyArr[1]"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTSA5_13CopyConstruct -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc loop private(notDefCtorArr[1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[NOTDEFCTORARR]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {name = "notDefCtorArr[1]"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTSA5_14NonDefaultCtor -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc loop private(dtorArr[1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[DTORARR]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_HasDtor x 5>> {name = "dtorArr[1]"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTSA5_7HasDtor -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc loop private(someIntArr[1], someFloatArr[1], noCopyArr[1], hasCopyArr[1], notDefCtorArr[1], dtorArr[1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE1:.*]] = acc.private varPtr(%[[INTARR]] : !cir.ptr<!cir.array<!s32i x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!s32i x 5>> {name = "someIntArr[1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE2:.*]] = acc.private varPtr(%[[FLOATARR]] : !cir.ptr<!cir.array<!cir.float x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!cir.float x 5>> {name = "someFloatArr[1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE3:.*]] = acc.private varPtr(%[[NOCOPYARR]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {name = "noCopyArr[1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE4:.*]] = acc.private varPtr(%[[HASCOPYARR]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {name = "hasCopyArr[1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE5:.*]] = acc.private varPtr(%[[NOTDEFCTORARR]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {name = "notDefCtorArr[1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE_CONST:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CONST]] : i64) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE6:.*]] = acc.private varPtr(%[[DTORARR]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_HasDtor x 5>> {name = "dtorArr[1]"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTSA5_i -> %[[PRIVATE1]] : !cir.ptr<!cir.array<!s32i x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_f -> %[[PRIVATE2]] : !cir.ptr<!cir.array<!cir.float x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_15NoCopyConstruct -> %[[PRIVATE3]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_13CopyConstruct -> %[[PRIVATE4]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_14NonDefaultCtor -> %[[PRIVATE5]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_7HasDtor -> %[[PRIVATE6]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
|
||||
#pragma acc loop private(someIntArr[1:1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[INTARR]] : !cir.ptr<!cir.array<!s32i x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!s32i x 5>> {name = "someIntArr[1:1]"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTSA5_i -> %[[PRIVATE]] : !cir.ptr<!cir.array<!s32i x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc loop private(someFloatArr[1:1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[FLOATARR]] : !cir.ptr<!cir.array<!cir.float x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!cir.float x 5>> {name = "someFloatArr[1:1]"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTSA5_f -> %[[PRIVATE]] : !cir.ptr<!cir.array<!cir.float x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc loop private(noCopyArr[1:1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[NOCOPYARR]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {name = "noCopyArr[1:1]"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTSA5_15NoCopyConstruct -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc loop private(hasCopyArr[1:1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[HASCOPYARR]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {name = "hasCopyArr[1:1]"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTSA5_13CopyConstruct -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc loop private(notDefCtorArr[1:1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[NOTDEFCTORARR]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {name = "notDefCtorArr[1:1]"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTSA5_14NonDefaultCtor -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc loop private(dtorArr[1:1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE:.*]] = acc.private varPtr(%[[DTORARR]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_HasDtor x 5>> {name = "dtorArr[1:1]"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTSA5_7HasDtor -> %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
#pragma acc loop private(someIntArr[1:1], someFloatArr[1:1], noCopyArr[1:1], hasCopyArr[1:1], notDefCtorArr[1:1], dtorArr[1:1])
|
||||
for(int i = 0; i < 5; ++i);
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE1:.*]] = acc.private varPtr(%[[INTARR]] : !cir.ptr<!cir.array<!s32i x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!s32i x 5>> {name = "someIntArr[1:1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE2:.*]] = acc.private varPtr(%[[FLOATARR]] : !cir.ptr<!cir.array<!cir.float x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!cir.float x 5>> {name = "someFloatArr[1:1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE3:.*]] = acc.private varPtr(%[[NOCOPYARR]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {name = "noCopyArr[1:1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE4:.*]] = acc.private varPtr(%[[HASCOPYARR]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {name = "hasCopyArr[1:1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE5:.*]] = acc.private varPtr(%[[NOTDEFCTORARR]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {name = "notDefCtorArr[1:1]"}
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
|
||||
// CHECK-NEXT: %[[ONE_CAST2:.*]] = builtin.unrealized_conversion_cast %[[ONE]] : !s32i to si32
|
||||
// CHECK-NEXT: %[[ZERO_CONST:.*]] = arith.constant 0
|
||||
// CHECK-NEXT: %[[ONE_CONST2:.*]] = arith.constant 1
|
||||
// CHECK-NEXT: %[[BOUNDS:.*]] = acc.bounds lowerbound(%[[ONE_CAST]] : si32) extent(%[[ONE_CAST2]] : si32) stride(%[[ONE_CONST2]] : i64) startIdx(%[[ZERO_CONST]] : i64)
|
||||
// CHECK-NEXT: %[[PRIVATE6:.*]] = acc.private varPtr(%[[DTORARR]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>) bounds(%[[BOUNDS]]) -> !cir.ptr<!cir.array<!rec_HasDtor x 5>> {name = "dtorArr[1:1]"}
|
||||
// CHECK-NEXT: acc.loop private(@privatization__ZTSA5_i -> %[[PRIVATE1]] : !cir.ptr<!cir.array<!s32i x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_f -> %[[PRIVATE2]] : !cir.ptr<!cir.array<!cir.float x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_15NoCopyConstruct -> %[[PRIVATE3]] : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_13CopyConstruct -> %[[PRIVATE4]] : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_14NonDefaultCtor -> %[[PRIVATE5]] : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>,
|
||||
// CHECK-SAME: @privatization__ZTSA5_7HasDtor -> %[[PRIVATE6]] : !cir.ptr<!cir.array<!rec_HasDtor x 5>>)
|
||||
// CHECK: acc.yield
|
||||
// CHECK-NEXT: } loc
|
||||
}
|
||||
@ -10,8 +10,8 @@ void HelloWorld(int *A, int *B, int *C, int N) {
|
||||
// expected-error@+1{{ClangIR code gen Not Yet Implemented: OpenACC Declare Construct}}
|
||||
#pragma acc declare create(A)
|
||||
|
||||
// expected-error@+1{{ClangIR code gen Not Yet Implemented: OpenACC Clause: private}}
|
||||
#pragma acc parallel loop private(A)
|
||||
// expected-error@+1{{ClangIR code gen Not Yet Implemented: OpenACC Clause: firstprivate}}
|
||||
#pragma acc parallel loop firstprivate(A)
|
||||
for(int i = 0; i <5; ++i);
|
||||
// expected-error@+1{{ClangIR code gen Not Yet Implemented: OpenACC Clause: reduction}}
|
||||
#pragma acc parallel loop reduction(+:A)
|
||||
|
||||
@ -1532,6 +1532,10 @@ def OpenACC_ParallelOp : OpenACC_Op<"parallel",
|
||||
/// types.
|
||||
void addWaitOperands(MLIRContext *, bool hasDevnum, mlir::ValueRange,
|
||||
llvm::ArrayRef<DeviceType>);
|
||||
|
||||
/// Adds a private clause variable to this operation, including its recipe.
|
||||
void addPrivatization(MLIRContext *, mlir::acc::PrivateOp op,
|
||||
mlir::acc::PrivateRecipeOp recipe);
|
||||
}];
|
||||
|
||||
let assemblyFormat = [{
|
||||
@ -1674,6 +1678,9 @@ def OpenACC_SerialOp : OpenACC_Op<"serial",
|
||||
/// types.
|
||||
void addWaitOperands(MLIRContext *, bool hasDevnum, mlir::ValueRange,
|
||||
llvm::ArrayRef<DeviceType>);
|
||||
/// Adds a private clause variable to this operation, including its recipe.
|
||||
void addPrivatization(MLIRContext *, mlir::acc::PrivateOp op,
|
||||
mlir::acc::PrivateRecipeOp recipe);
|
||||
}];
|
||||
|
||||
let assemblyFormat = [{
|
||||
@ -2396,6 +2403,10 @@ def OpenACC_LoopOp : OpenACC_Op<"loop",
|
||||
// This first checks if the mode is set for the device_type requested.
|
||||
// And if not, it returns the non-device_type mode.
|
||||
LoopParMode getDefaultOrDeviceTypeParallelism(DeviceType);
|
||||
|
||||
/// Adds a private clause variable to this operation, including its recipe.
|
||||
void addPrivatization(MLIRContext *, mlir::acc::PrivateOp op,
|
||||
mlir::acc::PrivateRecipeOp recipe);
|
||||
}];
|
||||
|
||||
let hasCustomAssemblyFormat = 1;
|
||||
|
||||
@ -1375,6 +1375,21 @@ void acc::ParallelOp::addWaitOperands(
|
||||
setHasWaitDevnumAttr(mlir::ArrayAttr::get(context, hasDevnums));
|
||||
}
|
||||
|
||||
void acc::ParallelOp::addPrivatization(MLIRContext *context,
|
||||
mlir::acc::PrivateOp op,
|
||||
mlir::acc::PrivateRecipeOp recipe) {
|
||||
getPrivateOperandsMutable().append(op.getResult());
|
||||
|
||||
llvm::SmallVector<mlir::Attribute> recipes;
|
||||
|
||||
if (getPrivatizationRecipesAttr())
|
||||
llvm::copy(getPrivatizationRecipesAttr(), std::back_inserter(recipes));
|
||||
|
||||
recipes.push_back(
|
||||
mlir::SymbolRefAttr::get(context, recipe.getSymName().str()));
|
||||
setPrivatizationRecipesAttr(mlir::ArrayAttr::get(context, recipes));
|
||||
}
|
||||
|
||||
static ParseResult parseNumGangs(
|
||||
mlir::OpAsmParser &parser,
|
||||
llvm::SmallVectorImpl<mlir::OpAsmParser::UnresolvedOperand> &operands,
|
||||
@ -2011,6 +2026,21 @@ void acc::SerialOp::addWaitOperands(
|
||||
setHasWaitDevnumAttr(mlir::ArrayAttr::get(context, hasDevnums));
|
||||
}
|
||||
|
||||
void acc::SerialOp::addPrivatization(MLIRContext *context,
|
||||
mlir::acc::PrivateOp op,
|
||||
mlir::acc::PrivateRecipeOp recipe) {
|
||||
getPrivateOperandsMutable().append(op.getResult());
|
||||
|
||||
llvm::SmallVector<mlir::Attribute> recipes;
|
||||
|
||||
if (getPrivatizationRecipesAttr())
|
||||
llvm::copy(getPrivatizationRecipesAttr(), std::back_inserter(recipes));
|
||||
|
||||
recipes.push_back(
|
||||
mlir::SymbolRefAttr::get(context, recipe.getSymName().str()));
|
||||
setPrivatizationRecipesAttr(mlir::ArrayAttr::get(context, recipes));
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// KernelsOp
|
||||
//===----------------------------------------------------------------------===//
|
||||
@ -3014,6 +3044,21 @@ void acc::LoopOp::addGangOperands(
|
||||
}
|
||||
}
|
||||
|
||||
void acc::LoopOp::addPrivatization(MLIRContext *context,
|
||||
mlir::acc::PrivateOp op,
|
||||
mlir::acc::PrivateRecipeOp recipe) {
|
||||
getPrivateOperandsMutable().append(op.getResult());
|
||||
|
||||
llvm::SmallVector<mlir::Attribute> recipes;
|
||||
|
||||
if (getPrivatizationRecipesAttr())
|
||||
llvm::copy(getPrivatizationRecipesAttr(), std::back_inserter(recipes));
|
||||
|
||||
recipes.push_back(
|
||||
mlir::SymbolRefAttr::get(context, recipe.getSymName().str()));
|
||||
setPrivatizationRecipesAttr(mlir::ArrayAttr::get(context, recipes));
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// DataOp
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user