From d15c2f009e87fe7dfba2969eb0b979f9ecd025ab Mon Sep 17 00:00:00 2001 From: Kazuaki Matsumura Date: Tue, 13 May 2025 05:08:27 -0700 Subject: [PATCH 1/5] [flang][acc] Remove async and structured flag from data actions; Rename UpdateOp's async to asyncOnly; Print asyncOnly --- flang/lib/Lower/OpenACC.cpp | 354 +++++++----------- mlir/include/mlir/Dialect/OpenACC/OpenACC.h | 10 +- .../mlir/Dialect/OpenACC/OpenACCOps.td | 195 ++-------- mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp | 34 +- 4 files changed, 188 insertions(+), 405 deletions(-) diff --git a/flang/lib/Lower/OpenACC.cpp b/flang/lib/Lower/OpenACC.cpp index e1918288d6de3..c1a8dd0d5a478 100644 --- a/flang/lib/Lower/OpenACC.cpp +++ b/flang/lib/Lower/OpenACC.cpp @@ -104,15 +104,12 @@ static void addOperand(llvm::SmallVectorImpl &operands, } template -static Op -createDataEntryOp(fir::FirOpBuilder &builder, mlir::Location loc, - mlir::Value baseAddr, std::stringstream &name, - mlir::SmallVector bounds, bool structured, - bool implicit, mlir::acc::DataClause dataClause, - mlir::Type retTy, llvm::ArrayRef async, - llvm::ArrayRef asyncDeviceTypes, - llvm::ArrayRef asyncOnlyDeviceTypes, - bool unwrapBoxAddr = false, mlir::Value isPresent = {}) { +static Op createDataEntryOp(fir::FirOpBuilder &builder, mlir::Location loc, + mlir::Value baseAddr, std::stringstream &name, + mlir::SmallVector bounds, + bool implicit, mlir::acc::DataClause dataClause, + mlir::Type retTy, bool unwrapBoxAddr = false, + mlir::Value isPresent = {}) { mlir::Value varPtrPtr; // The data clause may apply to either the box reference itself or the // pointer to the data it holds. So use `unwrapBoxAddr` to decide. @@ -157,11 +154,9 @@ createDataEntryOp(fir::FirOpBuilder &builder, mlir::Location loc, addOperand(operands, operandSegments, baseAddr); addOperand(operands, operandSegments, varPtrPtr); addOperands(operands, operandSegments, bounds); - addOperands(operands, operandSegments, async); Op op = builder.create(loc, retTy, operands); op.setNameAttr(builder.getStringAttr(name.str())); - op.setStructured(structured); op.setImplicit(implicit); op.setDataClause(dataClause); if (auto mappableTy = @@ -176,10 +171,6 @@ createDataEntryOp(fir::FirOpBuilder &builder, mlir::Location loc, op->setAttr(Op::getOperandSegmentSizeAttr(), builder.getDenseI32ArrayAttr(operandSegments)); - if (!asyncDeviceTypes.empty()) - op.setAsyncOperandsDeviceTypeAttr(builder.getArrayAttr(asyncDeviceTypes)); - if (!asyncOnlyDeviceTypes.empty()) - op.setAsyncOnlyAttr(builder.getArrayAttr(asyncOnlyDeviceTypes)); return op; } @@ -249,9 +240,7 @@ static void createDeclareAllocFuncWithArg(mlir::OpBuilder &modBuilder, mlir::acc::UpdateDeviceOp updateDeviceOp = createDataEntryOp( builder, loc, registerFuncOp.getArgument(0), asFortranDesc, bounds, - /*structured=*/false, /*implicit=*/true, - mlir::acc::DataClause::acc_update_device, descTy, - /*async=*/{}, /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{}); + /*implicit=*/true, mlir::acc::DataClause::acc_update_device, descTy); llvm::SmallVector operandSegments{0, 0, 0, 1}; llvm::SmallVector operands{updateDeviceOp.getResult()}; createSimpleOp(builder, loc, operands, operandSegments); @@ -263,8 +252,7 @@ static void createDeclareAllocFuncWithArg(mlir::OpBuilder &modBuilder, addDeclareAttr(builder, boxAddrOp.getOperation(), clause); EntryOp entryOp = createDataEntryOp( builder, loc, boxAddrOp.getResult(), asFortran, bounds, - /*structured=*/false, /*implicit=*/false, clause, boxAddrOp.getType(), - /*async=*/{}, /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{}); + /*implicit=*/false, clause, boxAddrOp.getType()); builder.create( loc, mlir::acc::DeclareTokenType::get(entryOp.getContext()), mlir::ValueRange(entryOp.getAccVar())); @@ -302,26 +290,20 @@ static void createDeclareDeallocFuncWithArg( mlir::acc::GetDevicePtrOp entryOp = createDataEntryOp( builder, loc, var, asFortran, bounds, - /*structured=*/false, /*implicit=*/false, clause, var.getType(), - /*async=*/{}, /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{}); + /*implicit=*/false, clause, var.getType()); builder.create( loc, mlir::Value{}, mlir::ValueRange(entryOp.getAccVar())); if constexpr (std::is_same_v || std::is_same_v) - builder.create(entryOp.getLoc(), entryOp.getAccVar(), - entryOp.getVar(), entryOp.getVarType(), - entryOp.getBounds(), entryOp.getAsyncOperands(), - entryOp.getAsyncOperandsDeviceTypeAttr(), - entryOp.getAsyncOnlyAttr(), entryOp.getDataClause(), - /*structured=*/false, /*implicit=*/false, - builder.getStringAttr(*entryOp.getName())); + builder.create( + entryOp.getLoc(), entryOp.getAccVar(), entryOp.getVar(), + entryOp.getVarType(), entryOp.getBounds(), entryOp.getDataClause(), + /*implicit=*/false, builder.getStringAttr(*entryOp.getName())); else builder.create(entryOp.getLoc(), entryOp.getAccVar(), - entryOp.getBounds(), entryOp.getAsyncOperands(), - entryOp.getAsyncOperandsDeviceTypeAttr(), - entryOp.getAsyncOnlyAttr(), entryOp.getDataClause(), - /*structured=*/false, /*implicit=*/false, + entryOp.getBounds(), entryOp.getDataClause(), + /*implicit=*/false, builder.getStringAttr(*entryOp.getName())); // Generate the post dealloc function. @@ -341,9 +323,8 @@ static void createDeclareDeallocFuncWithArg( mlir::acc::UpdateDeviceOp updateDeviceOp = createDataEntryOp( builder, loc, var, asFortran, bounds, - /*structured=*/false, /*implicit=*/true, - mlir::acc::DataClause::acc_update_device, var.getType(), - /*async=*/{}, /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{}); + /*implicit=*/true, mlir::acc::DataClause::acc_update_device, + var.getType()); llvm::SmallVector operandSegments{0, 0, 0, 1}; llvm::SmallVector operands{updateDeviceOp.getResult()}; createSimpleOp(builder, loc, operands, operandSegments); @@ -700,10 +681,7 @@ genDataOperandOperations(const Fortran::parser::AccObjectList &objectList, Fortran::semantics::SemanticsContext &semanticsContext, Fortran::lower::StatementContext &stmtCtx, llvm::SmallVectorImpl &dataOperands, - mlir::acc::DataClause dataClause, bool structured, - bool implicit, llvm::ArrayRef async, - llvm::ArrayRef asyncDeviceTypes, - llvm::ArrayRef asyncOnlyDeviceTypes, + mlir::acc::DataClause dataClause, bool implicit, bool setDeclareAttr = false) { fir::FirOpBuilder &builder = converter.getFirOpBuilder(); Fortran::evaluate::ExpressionAnalyzer ea{semanticsContext}; @@ -732,9 +710,8 @@ genDataOperandOperations(const Fortran::parser::AccObjectList &objectList, ? info.rawInput : info.addr; Op op = createDataEntryOp( - builder, operandLocation, baseAddr, asFortran, bounds, structured, - implicit, dataClause, baseAddr.getType(), async, asyncDeviceTypes, - asyncOnlyDeviceTypes, /*unwrapBoxAddr=*/true, info.isPresent); + builder, operandLocation, baseAddr, asFortran, bounds, implicit, + dataClause, baseAddr.getType(), /*unwrapBoxAddr=*/true, info.isPresent); dataOperands.push_back(op.getAccVar()); } } @@ -746,7 +723,7 @@ static void genDeclareDataOperandOperations( Fortran::semantics::SemanticsContext &semanticsContext, Fortran::lower::StatementContext &stmtCtx, llvm::SmallVectorImpl &dataOperands, - mlir::acc::DataClause dataClause, bool structured, bool implicit) { + mlir::acc::DataClause dataClause, bool implicit) { fir::FirOpBuilder &builder = converter.getFirOpBuilder(); Fortran::evaluate::ExpressionAnalyzer ea{semanticsContext}; for (const auto &accObject : objectList.v) { @@ -765,10 +742,9 @@ static void genDeclareDataOperandOperations( /*genDefaultBounds=*/generateDefaultBounds, /*strideIncludeLowerExtent=*/strideIncludeLowerExtent); LLVM_DEBUG(llvm::dbgs() << __func__ << "\n"; info.dump(llvm::dbgs())); - EntryOp op = createDataEntryOp( - builder, operandLocation, info.addr, asFortran, bounds, structured, - implicit, dataClause, info.addr.getType(), - /*async=*/{}, /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{}); + EntryOp op = createDataEntryOp(builder, operandLocation, info.addr, + asFortran, bounds, implicit, + dataClause, info.addr.getType()); dataOperands.push_back(op.getAccVar()); addDeclareAttr(builder, op.getVar().getDefiningOp(), dataClause); if (mlir::isa(fir::unwrapRefType(info.addr.getType()))) { @@ -805,14 +781,12 @@ static void genDeclareDataOperandOperationsWithModifier( (modifier && (*modifier).v == mod) ? clauseWithModifier : clause; genDeclareDataOperandOperations( accObjectList, converter, semanticsContext, stmtCtx, dataClauseOperands, - dataClause, - /*structured=*/true, /*implicit=*/false); + dataClause, /*implicit=*/false); } template static void genDataExitOperations(fir::FirOpBuilder &builder, - llvm::SmallVector operands, - bool structured) { + llvm::SmallVector operands) { for (mlir::Value operand : operands) { auto entryOp = mlir::dyn_cast_or_null(operand.getDefiningOp()); assert(entryOp && "data entry op expected"); @@ -820,16 +794,13 @@ static void genDataExitOperations(fir::FirOpBuilder &builder, std::is_same_v) builder.create( entryOp.getLoc(), entryOp.getAccVar(), entryOp.getVar(), - entryOp.getVarType(), entryOp.getBounds(), entryOp.getAsyncOperands(), - entryOp.getAsyncOperandsDeviceTypeAttr(), entryOp.getAsyncOnlyAttr(), - entryOp.getDataClause(), structured, entryOp.getImplicit(), - builder.getStringAttr(*entryOp.getName())); - else - builder.create( - entryOp.getLoc(), entryOp.getAccVar(), entryOp.getBounds(), - entryOp.getAsyncOperands(), entryOp.getAsyncOperandsDeviceTypeAttr(), - entryOp.getAsyncOnlyAttr(), entryOp.getDataClause(), structured, + entryOp.getVarType(), entryOp.getBounds(), entryOp.getDataClause(), entryOp.getImplicit(), builder.getStringAttr(*entryOp.getName())); + else + builder.create(entryOp.getLoc(), entryOp.getAccVar(), + entryOp.getBounds(), entryOp.getDataClause(), + entryOp.getImplicit(), + builder.getStringAttr(*entryOp.getName())); } } @@ -1240,10 +1211,7 @@ genPrivatizations(const Fortran::parser::AccObjectList &objectList, Fortran::semantics::SemanticsContext &semanticsContext, Fortran::lower::StatementContext &stmtCtx, llvm::SmallVectorImpl &dataOperands, - llvm::SmallVector &privatizations, - llvm::ArrayRef async, - llvm::ArrayRef asyncDeviceTypes, - llvm::ArrayRef asyncOnlyDeviceTypes) { + llvm::SmallVector &privatizations) { fir::FirOpBuilder &builder = converter.getFirOpBuilder(); Fortran::evaluate::ExpressionAnalyzer ea{semanticsContext}; for (const auto &accObject : objectList.v) { @@ -1272,9 +1240,9 @@ genPrivatizations(const Fortran::parser::AccObjectList &objectList, recipe = Fortran::lower::createOrGetPrivateRecipe(builder, recipeName, operandLocation, retTy); auto op = createDataEntryOp( - builder, operandLocation, info.addr, asFortran, bounds, true, - /*implicit=*/false, mlir::acc::DataClause::acc_private, retTy, async, - asyncDeviceTypes, asyncOnlyDeviceTypes, /*unwrapBoxAddr=*/true); + builder, operandLocation, info.addr, asFortran, bounds, + /*implicit=*/false, mlir::acc::DataClause::acc_private, retTy, + /*unwrapBoxAddr=*/true); dataOperands.push_back(op.getAccVar()); } else { std::string suffix = @@ -1284,9 +1252,8 @@ genPrivatizations(const Fortran::parser::AccObjectList &objectList, recipe = Fortran::lower::createOrGetFirstprivateRecipe( builder, recipeName, operandLocation, retTy, bounds); auto op = createDataEntryOp( - builder, operandLocation, info.addr, asFortran, bounds, true, + builder, operandLocation, info.addr, asFortran, bounds, /*implicit=*/false, mlir::acc::DataClause::acc_firstprivate, retTy, - async, asyncDeviceTypes, asyncOnlyDeviceTypes, /*unwrapBoxAddr=*/true); dataOperands.push_back(op.getAccVar()); } @@ -1869,10 +1836,7 @@ genReductions(const Fortran::parser::AccObjectListWithReduction &objectList, Fortran::semantics::SemanticsContext &semanticsContext, Fortran::lower::StatementContext &stmtCtx, llvm::SmallVectorImpl &reductionOperands, - llvm::SmallVector &reductionRecipes, - llvm::ArrayRef async, - llvm::ArrayRef asyncDeviceTypes, - llvm::ArrayRef asyncOnlyDeviceTypes) { + llvm::SmallVector &reductionRecipes) { fir::FirOpBuilder &builder = converter.getFirOpBuilder(); const auto &objects = std::get(objectList.t); const auto &op = std::get(objectList.t); @@ -1904,9 +1868,8 @@ genReductions(const Fortran::parser::AccObjectListWithReduction &objectList, auto op = createDataEntryOp( builder, operandLocation, info.addr, asFortran, bounds, - /*structured=*/true, /*implicit=*/false, - mlir::acc::DataClause::acc_reduction, info.addr.getType(), async, - asyncDeviceTypes, asyncOnlyDeviceTypes, /*unwrapBoxAddr=*/true); + /*implicit=*/false, mlir::acc::DataClause::acc_reduction, + info.addr.getType(), /*unwrapBoxAddr=*/true); mlir::Type ty = op.getAccVar().getType(); if (!areAllBoundConstant(bounds) || fir::isAssumedShape(info.addr.getType()) || @@ -2169,9 +2132,8 @@ static void privatizeIv(Fortran::lower::AbstractConverter &converter, std::stringstream asFortran; asFortran << Fortran::lower::mangle::demangleName(toStringRef(sym.name())); auto op = createDataEntryOp( - builder, loc, ivValue, asFortran, {}, true, /*implicit=*/true, - mlir::acc::DataClause::acc_private, ivValue.getType(), - /*async=*/{}, /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{}); + builder, loc, ivValue, asFortran, {}, /*implicit=*/true, + mlir::acc::DataClause::acc_private, ivValue.getType()); privateOp = op.getOperation(); privateOperands.push_back(op.getAccVar()); @@ -2328,14 +2290,12 @@ static mlir::acc::LoopOp createLoopOp( &clause.u)) { genPrivatizations( privateClause->v, converter, semanticsContext, stmtCtx, - privateOperands, privatizations, /*async=*/{}, - /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{}); + privateOperands, privatizations); } else if (const auto *reductionClause = std::get_if( &clause.u)) { genReductions(reductionClause->v, converter, semanticsContext, stmtCtx, - reductionOperands, reductionRecipes, /*async=*/{}, - /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{}); + reductionOperands, reductionRecipes); } else if (std::get_if(&clause.u)) { for (auto crtDeviceTypeAttr : crtDeviceTypes) seqDeviceTypes.push_back(crtDeviceTypeAttr); @@ -2613,9 +2573,6 @@ static void genDataOperandOperationsWithModifier( llvm::SmallVectorImpl &dataClauseOperands, const mlir::acc::DataClause clause, const mlir::acc::DataClause clauseWithModifier, - llvm::ArrayRef async, - llvm::ArrayRef asyncDeviceTypes, - llvm::ArrayRef asyncOnlyDeviceTypes, bool setDeclareAttr = false) { const Fortran::parser::AccObjectListWithModifier &listWithModifier = x->v; const auto &accObjectList = @@ -2627,9 +2584,7 @@ static void genDataOperandOperationsWithModifier( (modifier && (*modifier).v == mod) ? clauseWithModifier : clause; genDataOperandOperations(accObjectList, converter, semanticsContext, stmtCtx, dataClauseOperands, dataClause, - /*structured=*/true, /*implicit=*/false, async, - asyncDeviceTypes, asyncOnlyDeviceTypes, - setDeclareAttr); + /*implicit=*/false, setDeclareAttr); } template @@ -2779,8 +2734,7 @@ static Op createComputeOp( genDataOperandOperations( copyClause->v, converter, semanticsContext, stmtCtx, dataClauseOperands, mlir::acc::DataClause::acc_copy, - /*structured=*/true, /*implicit=*/false, async, asyncDeviceTypes, - asyncOnlyDeviceTypes); + /*implicit=*/false); copyEntryOperands.append(dataClauseOperands.begin() + crtDataStart, dataClauseOperands.end()); } else if (const auto *copyinClause = @@ -2791,8 +2745,7 @@ static Op createComputeOp( copyinClause, converter, semanticsContext, stmtCtx, Fortran::parser::AccDataModifier::Modifier::ReadOnly, dataClauseOperands, mlir::acc::DataClause::acc_copyin, - mlir::acc::DataClause::acc_copyin_readonly, async, asyncDeviceTypes, - asyncOnlyDeviceTypes); + mlir::acc::DataClause::acc_copyin_readonly); copyinEntryOperands.append(dataClauseOperands.begin() + crtDataStart, dataClauseOperands.end()); } else if (const auto *copyoutClause = @@ -2804,8 +2757,7 @@ static Op createComputeOp( copyoutClause, converter, semanticsContext, stmtCtx, Fortran::parser::AccDataModifier::Modifier::ReadOnly, dataClauseOperands, mlir::acc::DataClause::acc_copyout, - mlir::acc::DataClause::acc_copyout_zero, async, asyncDeviceTypes, - asyncOnlyDeviceTypes); + mlir::acc::DataClause::acc_copyout_zero); copyoutEntryOperands.append(dataClauseOperands.begin() + crtDataStart, dataClauseOperands.end()); } else if (const auto *createClause = @@ -2816,8 +2768,7 @@ static Op createComputeOp( createClause, converter, semanticsContext, stmtCtx, Fortran::parser::AccDataModifier::Modifier::Zero, dataClauseOperands, mlir::acc::DataClause::acc_create, - mlir::acc::DataClause::acc_create_zero, async, asyncDeviceTypes, - asyncOnlyDeviceTypes); + mlir::acc::DataClause::acc_create_zero); createEntryOperands.append(dataClauseOperands.begin() + crtDataStart, dataClauseOperands.end()); } else if (const auto *noCreateClause = @@ -2827,8 +2778,7 @@ static Op createComputeOp( genDataOperandOperations( noCreateClause->v, converter, semanticsContext, stmtCtx, dataClauseOperands, mlir::acc::DataClause::acc_no_create, - /*structured=*/true, /*implicit=*/false, async, asyncDeviceTypes, - asyncOnlyDeviceTypes); + /*implicit=*/false); nocreateEntryOperands.append(dataClauseOperands.begin() + crtDataStart, dataClauseOperands.end()); } else if (const auto *presentClause = @@ -2838,8 +2788,7 @@ static Op createComputeOp( genDataOperandOperations( presentClause->v, converter, semanticsContext, stmtCtx, dataClauseOperands, mlir::acc::DataClause::acc_present, - /*structured=*/true, /*implicit=*/false, async, asyncDeviceTypes, - asyncOnlyDeviceTypes); + /*implicit=*/false); presentEntryOperands.append(dataClauseOperands.begin() + crtDataStart, dataClauseOperands.end()); } else if (const auto *devicePtrClause = @@ -2848,16 +2797,14 @@ static Op createComputeOp( genDataOperandOperations( devicePtrClause->v, converter, semanticsContext, stmtCtx, dataClauseOperands, mlir::acc::DataClause::acc_deviceptr, - /*structured=*/true, /*implicit=*/false, async, asyncDeviceTypes, - asyncOnlyDeviceTypes); + /*implicit=*/false); } else if (const auto *attachClause = std::get_if(&clause.u)) { auto crtDataStart = dataClauseOperands.size(); genDataOperandOperations( attachClause->v, converter, semanticsContext, stmtCtx, dataClauseOperands, mlir::acc::DataClause::acc_attach, - /*structured=*/true, /*implicit=*/false, async, asyncDeviceTypes, - asyncOnlyDeviceTypes); + /*implicit=*/false); attachEntryOperands.append(dataClauseOperands.begin() + crtDataStart, dataClauseOperands.end()); } else if (const auto *privateClause = @@ -2866,15 +2813,13 @@ static Op createComputeOp( if (!combinedConstructs) genPrivatizations( privateClause->v, converter, semanticsContext, stmtCtx, - privateOperands, privatizations, async, asyncDeviceTypes, - asyncOnlyDeviceTypes); + privateOperands, privatizations); } else if (const auto *firstprivateClause = std::get_if( &clause.u)) { genPrivatizations( firstprivateClause->v, converter, semanticsContext, stmtCtx, - firstprivateOperands, firstPrivatizations, async, asyncDeviceTypes, - asyncOnlyDeviceTypes); + firstprivateOperands, firstPrivatizations); } else if (const auto *reductionClause = std::get_if( &clause.u)) { @@ -2885,16 +2830,14 @@ static Op createComputeOp( // instead. if (!combinedConstructs) { genReductions(reductionClause->v, converter, semanticsContext, stmtCtx, - reductionOperands, reductionRecipes, async, - asyncDeviceTypes, asyncOnlyDeviceTypes); + reductionOperands, reductionRecipes); } else { auto crtDataStart = dataClauseOperands.size(); genDataOperandOperations( std::get(reductionClause->v.t), converter, semanticsContext, stmtCtx, dataClauseOperands, mlir::acc::DataClause::acc_reduction, - /*structured=*/true, /*implicit=*/true, async, asyncDeviceTypes, - asyncOnlyDeviceTypes); + /*implicit=*/true); copyEntryOperands.append(dataClauseOperands.begin() + crtDataStart, dataClauseOperands.end()); } @@ -2997,19 +2940,19 @@ static Op createComputeOp( // Create the exit operations after the region. genDataExitOperations( - builder, copyEntryOperands, /*structured=*/true); + builder, copyEntryOperands); genDataExitOperations( - builder, copyinEntryOperands, /*structured=*/true); + builder, copyinEntryOperands); genDataExitOperations( - builder, copyoutEntryOperands, /*structured=*/true); + builder, copyoutEntryOperands); genDataExitOperations( - builder, attachEntryOperands, /*structured=*/true); + builder, attachEntryOperands); genDataExitOperations( - builder, createEntryOperands, /*structured=*/true); + builder, createEntryOperands); genDataExitOperations( - builder, nocreateEntryOperands, /*structured=*/true); + builder, nocreateEntryOperands); genDataExitOperations( - builder, presentEntryOperands, /*structured=*/true); + builder, presentEntryOperands); builder.restoreInsertionPoint(insPt); return computeOp; @@ -3078,8 +3021,7 @@ static void genACCDataOp(Fortran::lower::AbstractConverter &converter, genDataOperandOperations( copyClause->v, converter, semanticsContext, stmtCtx, dataClauseOperands, mlir::acc::DataClause::acc_copy, - /*structured=*/true, /*implicit=*/false, async, asyncDeviceTypes, - asyncOnlyDeviceTypes); + /*implicit=*/false); copyEntryOperands.append(dataClauseOperands.begin() + crtDataStart, dataClauseOperands.end()); } else if (const auto *copyinClause = @@ -3090,8 +3032,7 @@ static void genACCDataOp(Fortran::lower::AbstractConverter &converter, copyinClause, converter, semanticsContext, stmtCtx, Fortran::parser::AccDataModifier::Modifier::ReadOnly, dataClauseOperands, mlir::acc::DataClause::acc_copyin, - mlir::acc::DataClause::acc_copyin_readonly, async, asyncDeviceTypes, - asyncOnlyDeviceTypes); + mlir::acc::DataClause::acc_copyin_readonly); copyinEntryOperands.append(dataClauseOperands.begin() + crtDataStart, dataClauseOperands.end()); } else if (const auto *copyoutClause = @@ -3103,8 +3044,7 @@ static void genACCDataOp(Fortran::lower::AbstractConverter &converter, copyoutClause, converter, semanticsContext, stmtCtx, Fortran::parser::AccDataModifier::Modifier::Zero, dataClauseOperands, mlir::acc::DataClause::acc_copyout, - mlir::acc::DataClause::acc_copyout_zero, async, asyncDeviceTypes, - asyncOnlyDeviceTypes); + mlir::acc::DataClause::acc_copyout_zero); copyoutEntryOperands.append(dataClauseOperands.begin() + crtDataStart, dataClauseOperands.end()); } else if (const auto *createClause = @@ -3115,8 +3055,7 @@ static void genACCDataOp(Fortran::lower::AbstractConverter &converter, createClause, converter, semanticsContext, stmtCtx, Fortran::parser::AccDataModifier::Modifier::Zero, dataClauseOperands, mlir::acc::DataClause::acc_create, - mlir::acc::DataClause::acc_create_zero, async, asyncDeviceTypes, - asyncOnlyDeviceTypes); + mlir::acc::DataClause::acc_create_zero); createEntryOperands.append(dataClauseOperands.begin() + crtDataStart, dataClauseOperands.end()); } else if (const auto *noCreateClause = @@ -3126,8 +3065,7 @@ static void genACCDataOp(Fortran::lower::AbstractConverter &converter, genDataOperandOperations( noCreateClause->v, converter, semanticsContext, stmtCtx, dataClauseOperands, mlir::acc::DataClause::acc_no_create, - /*structured=*/true, /*implicit=*/false, async, asyncDeviceTypes, - asyncOnlyDeviceTypes); + /*implicit=*/false); nocreateEntryOperands.append(dataClauseOperands.begin() + crtDataStart, dataClauseOperands.end()); } else if (const auto *presentClause = @@ -3137,8 +3075,7 @@ static void genACCDataOp(Fortran::lower::AbstractConverter &converter, genDataOperandOperations( presentClause->v, converter, semanticsContext, stmtCtx, dataClauseOperands, mlir::acc::DataClause::acc_present, - /*structured=*/true, /*implicit=*/false, async, asyncDeviceTypes, - asyncOnlyDeviceTypes); + /*implicit=*/false); presentEntryOperands.append(dataClauseOperands.begin() + crtDataStart, dataClauseOperands.end()); } else if (const auto *deviceptrClause = @@ -3147,16 +3084,14 @@ static void genACCDataOp(Fortran::lower::AbstractConverter &converter, genDataOperandOperations( deviceptrClause->v, converter, semanticsContext, stmtCtx, dataClauseOperands, mlir::acc::DataClause::acc_deviceptr, - /*structured=*/true, /*implicit=*/false, async, asyncDeviceTypes, - asyncOnlyDeviceTypes); + /*implicit=*/false); } else if (const auto *attachClause = std::get_if(&clause.u)) { auto crtDataStart = dataClauseOperands.size(); genDataOperandOperations( attachClause->v, converter, semanticsContext, stmtCtx, dataClauseOperands, mlir::acc::DataClause::acc_attach, - /*structured=*/true, /*implicit=*/false, async, asyncDeviceTypes, - asyncOnlyDeviceTypes); + /*implicit=*/false); attachEntryOperands.append(dataClauseOperands.begin() + crtDataStart, dataClauseOperands.end()); } else if (const auto *defaultClause = @@ -3211,19 +3146,19 @@ static void genACCDataOp(Fortran::lower::AbstractConverter &converter, // Create the exit operations after the region. genDataExitOperations( - builder, copyEntryOperands, /*structured=*/true); + builder, copyEntryOperands); genDataExitOperations( - builder, copyinEntryOperands, /*structured=*/true); + builder, copyinEntryOperands); genDataExitOperations( - builder, copyoutEntryOperands, /*structured=*/true); + builder, copyoutEntryOperands); genDataExitOperations( - builder, attachEntryOperands, /*structured=*/true); + builder, attachEntryOperands); genDataExitOperations( - builder, createEntryOperands, /*structured=*/true); + builder, createEntryOperands); genDataExitOperations( - builder, nocreateEntryOperands, /*structured=*/true); + builder, nocreateEntryOperands); genDataExitOperations( - builder, presentEntryOperands, /*structured=*/true); + builder, presentEntryOperands); builder.restoreInsertionPoint(insPt); } @@ -3252,8 +3187,7 @@ genACCHostDataOp(Fortran::lower::AbstractConverter &converter, genDataOperandOperations( useDevice->v, converter, semanticsContext, stmtCtx, dataOperands, mlir::acc::DataClause::acc_use_device, - /*structured=*/true, /*implicit=*/false, /*async=*/{}, - /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{}); + /*implicit=*/false); } else if (std::get_if(&clause.u)) { addIfPresentAttr = true; } @@ -3430,9 +3364,8 @@ genACCEnterDataOp(Fortran::lower::AbstractConverter &converter, std::get(listWithModifier.t); genDataOperandOperations( accObjectList, converter, semanticsContext, stmtCtx, - dataClauseOperands, mlir::acc::DataClause::acc_copyin, false, - /*implicit=*/false, asyncValues, asyncDeviceTypes, - asyncOnlyDeviceTypes); + dataClauseOperands, mlir::acc::DataClause::acc_copyin, + /*implicit=*/false); } else if (const auto *createClause = std::get_if(&clause.u)) { const Fortran::parser::AccObjectListWithModifier &listWithModifier = @@ -3448,15 +3381,13 @@ genACCEnterDataOp(Fortran::lower::AbstractConverter &converter, clause = mlir::acc::DataClause::acc_create_zero; genDataOperandOperations( accObjectList, converter, semanticsContext, stmtCtx, - dataClauseOperands, clause, false, /*implicit=*/false, asyncValues, - asyncDeviceTypes, asyncOnlyDeviceTypes); + dataClauseOperands, clause, /*implicit=*/false); } else if (const auto *attachClause = std::get_if(&clause.u)) { genDataOperandOperations( attachClause->v, converter, semanticsContext, stmtCtx, - dataClauseOperands, mlir::acc::DataClause::acc_attach, false, - /*implicit=*/false, asyncValues, asyncDeviceTypes, - asyncOnlyDeviceTypes); + dataClauseOperands, mlir::acc::DataClause::acc_attach, + /*implicit=*/false); } else if (!std::get_if(&clause.u)) { llvm::report_fatal_error( "Unknown clause in ENTER DATA directive lowering"); @@ -3544,20 +3475,17 @@ genACCExitDataOp(Fortran::lower::AbstractConverter &converter, std::get(listWithModifier.t); genDataOperandOperations( accObjectList, converter, semanticsContext, stmtCtx, copyoutOperands, - mlir::acc::DataClause::acc_copyout, false, /*implicit=*/false, - asyncValues, asyncDeviceTypes, asyncOnlyDeviceTypes); + mlir::acc::DataClause::acc_copyout, /*implicit=*/false); } else if (const auto *deleteClause = std::get_if(&clause.u)) { genDataOperandOperations( deleteClause->v, converter, semanticsContext, stmtCtx, deleteOperands, - mlir::acc::DataClause::acc_delete, false, /*implicit=*/false, - asyncValues, asyncDeviceTypes, asyncOnlyDeviceTypes); + mlir::acc::DataClause::acc_delete, /*implicit=*/false); } else if (const auto *detachClause = std::get_if(&clause.u)) { genDataOperandOperations( detachClause->v, converter, semanticsContext, stmtCtx, detachOperands, - mlir::acc::DataClause::acc_detach, false, /*implicit=*/false, - asyncValues, asyncDeviceTypes, asyncOnlyDeviceTypes); + mlir::acc::DataClause::acc_detach, /*implicit=*/false); } else if (std::get_if(&clause.u)) { addFinalizeAttr = true; } @@ -3587,11 +3515,11 @@ genACCExitDataOp(Fortran::lower::AbstractConverter &converter, exitDataOp.setFinalizeAttr(builder.getUnitAttr()); genDataExitOperations( - builder, copyoutOperands, /*structured=*/false); + builder, copyoutOperands); genDataExitOperations( - builder, deleteOperands, /*structured=*/false); + builder, deleteOperands); genDataExitOperations( - builder, detachOperands, /*structured=*/false); + builder, detachOperands); } template @@ -3765,16 +3693,14 @@ genACCUpdateOp(Fortran::lower::AbstractConverter &converter, std::get_if(&clause.u)) { genDataOperandOperations( hostClause->v, converter, semanticsContext, stmtCtx, - updateHostOperands, mlir::acc::DataClause::acc_update_host, false, - /*implicit=*/false, asyncOperands, asyncOperandsDeviceTypes, - asyncOnlyDeviceTypes); + updateHostOperands, mlir::acc::DataClause::acc_update_host, + /*implicit=*/false); } else if (const auto *deviceClause = std::get_if(&clause.u)) { genDataOperandOperations( deviceClause->v, converter, semanticsContext, stmtCtx, - dataClauseOperands, mlir::acc::DataClause::acc_update_device, false, - /*implicit=*/false, asyncOperands, asyncOperandsDeviceTypes, - asyncOnlyDeviceTypes); + dataClauseOperands, mlir::acc::DataClause::acc_update_device, + /*implicit=*/false); } else if (std::get_if(&clause.u)) { ifPresent = true; } else if (const auto *selfClause = @@ -3786,9 +3712,8 @@ genACCUpdateOp(Fortran::lower::AbstractConverter &converter, assert(accObjectList && "expect AccObjectList"); genDataOperandOperations( *accObjectList, converter, semanticsContext, stmtCtx, - updateHostOperands, mlir::acc::DataClause::acc_update_self, false, - /*implicit=*/false, asyncOperands, asyncOperandsDeviceTypes, - asyncOnlyDeviceTypes); + updateHostOperands, mlir::acc::DataClause::acc_update_self, + /*implicit=*/false); } } @@ -3805,7 +3730,7 @@ genACCUpdateOp(Fortran::lower::AbstractConverter &converter, ifPresent); genDataExitOperations( - builder, updateHostOperands, /*structured=*/false); + builder, updateHostOperands); } static void @@ -3928,9 +3853,8 @@ static void createDeclareGlobalOp(mlir::OpBuilder &modBuilder, llvm::SmallVector bounds; EntryOp entryOp = createDataEntryOp( - builder, loc, addrOp.getResTy(), asFortran, bounds, - /*structured=*/false, implicit, clause, addrOp.getResTy().getType(), - /*async=*/{}, /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{}); + builder, loc, addrOp.getResTy(), asFortran, bounds, implicit, clause, + addrOp.getResTy().getType()); if constexpr (std::is_same_v) builder.create( loc, mlir::acc::DeclareTokenType::get(entryOp.getContext()), @@ -3940,10 +3864,8 @@ static void createDeclareGlobalOp(mlir::OpBuilder &modBuilder, mlir::ValueRange(entryOp.getAccVar())); if constexpr (std::is_same_v) { builder.create(entryOp.getLoc(), entryOp.getAccVar(), - entryOp.getBounds(), entryOp.getAsyncOperands(), - entryOp.getAsyncOperandsDeviceTypeAttr(), - entryOp.getAsyncOnlyAttr(), entryOp.getDataClause(), - /*structured=*/false, /*implicit=*/false, + entryOp.getBounds(), entryOp.getDataClause(), + /*implicit=*/false, builder.getStringAttr(*entryOp.getName())); } builder.create(loc); @@ -3977,9 +3899,8 @@ static void createDeclareAllocFunc(mlir::OpBuilder &modBuilder, mlir::acc::UpdateDeviceOp updateDeviceOp = createDataEntryOp( builder, loc, addrOp, asFortranDesc, bounds, - /*structured=*/false, /*implicit=*/true, - mlir::acc::DataClause::acc_update_device, addrOp.getType(), - /*async=*/{}, /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{}); + /*implicit=*/true, mlir::acc::DataClause::acc_update_device, + addrOp.getType()); llvm::SmallVector operandSegments{0, 0, 0, 1}; llvm::SmallVector operands{updateDeviceOp.getResult()}; createSimpleOp(builder, loc, operands, operandSegments); @@ -3990,8 +3911,7 @@ static void createDeclareAllocFunc(mlir::OpBuilder &modBuilder, addDeclareAttr(builder, boxAddrOp.getOperation(), clause); EntryOp entryOp = createDataEntryOp( builder, loc, boxAddrOp.getResult(), asFortran, bounds, - /*structured=*/false, /*implicit=*/false, clause, boxAddrOp.getType(), - /*async=*/{}, /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{}); + /*implicit=*/false, clause, boxAddrOp.getType()); builder.create( loc, mlir::acc::DeclareTokenType::get(entryOp.getContext()), mlir::ValueRange(entryOp.getAccVar())); @@ -4035,8 +3955,7 @@ static void createDeclareDeallocFunc(mlir::OpBuilder &modBuilder, mlir::acc::GetDevicePtrOp entryOp = createDataEntryOp( builder, loc, var, asFortran, bounds, - /*structured=*/false, /*implicit=*/false, clause, var.getType(), - /*async=*/{}, /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{}); + /*implicit=*/false, clause, var.getType()); builder.create( loc, mlir::Value{}, mlir::ValueRange(entryOp.getAccVar())); @@ -4045,18 +3964,13 @@ static void createDeclareDeallocFunc(mlir::OpBuilder &modBuilder, std::is_same_v) builder.create( entryOp.getLoc(), entryOp.getAccVar(), entryOp.getVar(), - entryOp.getBounds(), entryOp.getAsyncOperands(), - entryOp.getAsyncOperandsDeviceTypeAttr(), entryOp.getAsyncOnlyAttr(), - entryOp.getDataClause(), - /*structured=*/false, /*implicit=*/false, - builder.getStringAttr(*entryOp.getName())); + entryOp.getBounds(), entryOp.getDataClause(), + /*implicit=*/false, builder.getStringAttr(*entryOp.getName())); else - builder.create( - entryOp.getLoc(), entryOp.getAccVar(), entryOp.getBounds(), - entryOp.getAsyncOperands(), entryOp.getAsyncOperandsDeviceTypeAttr(), - entryOp.getAsyncOnlyAttr(), entryOp.getDataClause(), - /*structured=*/false, /*implicit=*/false, - builder.getStringAttr(*entryOp.getName())); + builder.create(entryOp.getLoc(), entryOp.getAccVar(), + entryOp.getBounds(), entryOp.getDataClause(), + /*implicit=*/false, + builder.getStringAttr(*entryOp.getName())); // Generate the post dealloc function. modBuilder.setInsertionPointAfter(preDeallocOp); @@ -4076,9 +3990,8 @@ static void createDeclareDeallocFunc(mlir::OpBuilder &modBuilder, mlir::acc::UpdateDeviceOp updateDeviceOp = createDataEntryOp( builder, loc, addrOp, asFortran, bounds, - /*structured=*/false, /*implicit=*/true, - mlir::acc::DataClause::acc_update_device, addrOp.getType(), - /*async=*/{}, /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{}); + /*implicit=*/true, mlir::acc::DataClause::acc_update_device, + addrOp.getType()); llvm::SmallVector operandSegments{0, 0, 0, 1}; llvm::SmallVector operands{updateDeviceOp.getResult()}; createSimpleOp(builder, loc, operands, operandSegments); @@ -4216,7 +4129,7 @@ genDeclareInFunction(Fortran::lower::AbstractConverter &converter, mlir::acc::CopyoutOp>( copyClause->v, converter, semanticsContext, stmtCtx, dataClauseOperands, mlir::acc::DataClause::acc_copy, - /*structured=*/true, /*implicit=*/false); + /*implicit=*/false); copyEntryOperands.append(dataClauseOperands.begin() + crtDataStart, dataClauseOperands.end()); } else if (const auto *createClause = @@ -4229,7 +4142,7 @@ genDeclareInFunction(Fortran::lower::AbstractConverter &converter, genDeclareDataOperandOperations( accObjectList, converter, semanticsContext, stmtCtx, dataClauseOperands, mlir::acc::DataClause::acc_create, - /*structured=*/true, /*implicit=*/false); + /*implicit=*/false); createEntryOperands.append(dataClauseOperands.begin() + crtDataStart, dataClauseOperands.end()); } else if (const auto *presentClause = @@ -4240,7 +4153,7 @@ genDeclareInFunction(Fortran::lower::AbstractConverter &converter, mlir::acc::DeleteOp>( presentClause->v, converter, semanticsContext, stmtCtx, dataClauseOperands, mlir::acc::DataClause::acc_present, - /*structured=*/true, /*implicit=*/false); + /*implicit=*/false); presentEntryOperands.append(dataClauseOperands.begin() + crtDataStart, dataClauseOperands.end()); } else if (const auto *copyinClause = @@ -4266,7 +4179,7 @@ genDeclareInFunction(Fortran::lower::AbstractConverter &converter, mlir::acc::CopyoutOp>( accObjectList, converter, semanticsContext, stmtCtx, dataClauseOperands, mlir::acc::DataClause::acc_copyout, - /*structured=*/true, /*implicit=*/false); + /*implicit=*/false); copyoutEntryOperands.append(dataClauseOperands.begin() + crtDataStart, dataClauseOperands.end()); } else if (const auto *devicePtrClause = @@ -4276,14 +4189,14 @@ genDeclareInFunction(Fortran::lower::AbstractConverter &converter, mlir::acc::DevicePtrOp>( devicePtrClause->v, converter, semanticsContext, stmtCtx, dataClauseOperands, mlir::acc::DataClause::acc_deviceptr, - /*structured=*/true, /*implicit=*/false); + /*implicit=*/false); } else if (const auto *linkClause = std::get_if(&clause.u)) { genDeclareDataOperandOperations( linkClause->v, converter, semanticsContext, stmtCtx, dataClauseOperands, mlir::acc::DataClause::acc_declare_link, - /*structured=*/true, /*implicit=*/false); + /*implicit=*/false); } else if (const auto *deviceResidentClause = std::get_if( &clause.u)) { @@ -4293,7 +4206,7 @@ genDeclareInFunction(Fortran::lower::AbstractConverter &converter, deviceResidentClause->v, converter, semanticsContext, stmtCtx, dataClauseOperands, mlir::acc::DataClause::acc_declare_device_resident, - /*structured=*/true, /*implicit=*/false); + /*implicit=*/false); deviceResidentEntryOperands.append( dataClauseOperands.begin() + crtDataStart, dataClauseOperands.end()); } else { @@ -4341,18 +4254,18 @@ genDeclareInFunction(Fortran::lower::AbstractConverter &converter, } genDataExitOperations( - builder, createEntryOperands, /*structured=*/true); + builder, createEntryOperands); genDataExitOperations( - builder, deviceResidentEntryOperands, /*structured=*/true); + mlir::acc::DeleteOp>(builder, + deviceResidentEntryOperands); genDataExitOperations( - builder, copyEntryOperands, /*structured=*/true); + builder, copyEntryOperands); genDataExitOperations( - builder, copyinEntryOperands, /*structured=*/true); + builder, copyinEntryOperands); genDataExitOperations( - builder, copyoutEntryOperands, /*structured=*/true); + builder, copyoutEntryOperands); genDataExitOperations( - builder, presentEntryOperands, /*structured=*/true); + builder, presentEntryOperands); }); } @@ -4702,12 +4615,11 @@ genACC(Fortran::lower::AbstractConverter &converter, if (modifier && (*modifier).v == Fortran::parser::AccDataModifier::Modifier::ReadOnly) dataClause = mlir::acc::DataClause::acc_cache_readonly; - genDataOperandOperations( - accObjectList, converter, semanticsContext, stmtCtx, cacheOperands, - dataClause, - /*structured=*/true, /*implicit=*/false, - /*async=*/{}, /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{}, - /*setDeclareAttr*/ false); + genDataOperandOperations(accObjectList, converter, + semanticsContext, stmtCtx, + cacheOperands, dataClause, + /*implicit=*/false, + /*setDeclareAttr*/ false); loopOp.getCacheOperandsMutable().append(cacheOperands); } else { llvm::report_fatal_error( diff --git a/mlir/include/mlir/Dialect/OpenACC/OpenACC.h b/mlir/include/mlir/Dialect/OpenACC/OpenACC.h index ff5845343313c..e053e3d2bbcfc 100644 --- a/mlir/include/mlir/Dialect/OpenACC/OpenACC.h +++ b/mlir/include/mlir/Dialect/OpenACC/OpenACC.h @@ -117,19 +117,19 @@ mlir::Value getVarPtrPtr(mlir::Operation *accDataClauseOp); /// Returns an empty vector if there are no bounds. mlir::SmallVector getBounds(mlir::Operation *accDataClauseOp); -/// Used to obtain `async` operands from an acc data clause operation. +/// Used to obtain `async` operands from an acc operation. /// Returns an empty vector if there are no such operands. mlir::SmallVector getAsyncOperands(mlir::Operation *accDataClauseOp); /// Returns an array of acc:DeviceTypeAttr attributes attached to -/// an acc data clause operation, that correspond to the device types -/// associated with the async clauses with an async-value. +/// an acc operation, that correspond to the device types associated with the +/// async clauses with an async-value. mlir::ArrayAttr getAsyncOperandsDeviceType(mlir::Operation *accDataClauseOp); /// Returns an array of acc:DeviceTypeAttr attributes attached to -/// an acc data clause operation, that correspond to the device types -/// associated with the async clauses without an async-value. +/// an acc operation, that correspond to the device types associated with the +/// async clauses without an async-value. mlir::ArrayAttr getAsyncOnly(mlir::Operation *accDataClauseOp); /// Used to obtain the `name` from an acc operation. diff --git a/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td b/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td index 5d5add6318e06..59b9a50144a1e 100644 --- a/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td +++ b/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td @@ -470,11 +470,7 @@ class OpenACC_DataEntryOp:$varPtrPtr, Variadic:$bounds, /* rank-0 to rank-{n-1} */ - Variadic:$asyncOperands, - OptionalAttr:$asyncOperandsDeviceType, - OptionalAttr:$asyncOnly, DefaultValuedAttr:$dataClause, - DefaultValuedAttr:$structured, DefaultValuedAttr:$implicit, OptionalAttr:$name)); @@ -491,63 +487,16 @@ class OpenACC_DataEntryOp(attr); - if (deviceTypeAttr.getValue() == deviceType) - return true; - } - return false; - } - /// Return the value of the async clause if present. - mlir::Value getAsyncValue() { - return getAsyncValue(mlir::acc::DeviceType::None); - } - /// Return the value of the async clause for the given device_type if - /// present. - mlir::Value getAsyncValue(mlir::acc::DeviceType deviceType) { - mlir::ArrayAttr deviceTypes = getAsyncOperandsDeviceTypeAttr(); - if (!deviceTypes) - return nullptr; - for (auto [attr, asyncValue] : - llvm::zip(deviceTypes, getAsyncOperands())) { - auto deviceTypeAttr = mlir::dyn_cast(attr); - if (deviceTypeAttr.getValue() == deviceType) - return asyncValue; - } - return nullptr; - } mlir::TypedValue getVarPtr() { return mlir::dyn_cast>(getVar()); } @@ -561,16 +510,13 @@ class OpenACC_DataEntryOp($asyncOperands, - type($asyncOperands), $asyncOperandsDeviceType) `)` ) `->` type($accVar) attr-dict }]; let hasVerifier = 1; let builders = [ - OpBuilder<(ins "::mlir::Value":$var, - "bool":$structured, "bool":$implicit, + OpBuilder<(ins "::mlir::Value":$var, "bool":$implicit, CArg<"::mlir::ValueRange", "{}">:$bounds), [{ auto ptrLikeTy = ::mlir::dyn_cast<::mlir::acc::PointerLikeType>( @@ -579,14 +525,10 @@ class OpenACC_DataEntryOp, - OpBuilder<(ins "::mlir::Value":$var, - "bool":$structured, "bool":$implicit, + OpBuilder<(ins "::mlir::Value":$var, "bool":$implicit, "const ::llvm::Twine &":$name, CArg<"::mlir::ValueRange", "{}">:$bounds), [{ @@ -596,10 +538,7 @@ class OpenACC_DataEntryOp]; @@ -829,15 +768,10 @@ def OpenACC_CacheOp : OpenACC_DataEntryOp<"cache", class OpenACC_DataExitOp traits = [], dag additionalArgs = (ins)> : OpenACC_Op]>])> { + [MemoryEffects<[MemRead]>])> { let arguments = !con(additionalArgs, (ins Variadic:$bounds, - Variadic:$asyncOperands, - OptionalAttr:$asyncOperandsDeviceType, - OptionalAttr:$asyncOnly, DefaultValuedAttr:$dataClause, - DefaultValuedAttr:$structured, DefaultValuedAttr:$implicit, OptionalAttr:$name)); @@ -846,65 +780,15 @@ class OpenACC_DataExitOp(attr); - if (deviceTypeAttr.getValue() == deviceType) - return true; - } - return false; - } - /// Return the value of the async clause if present. - mlir::Value getAsyncValue() { - return getAsyncValue(mlir::acc::DeviceType::None); - } - /// Return the value of the async clause for the given device_type if - /// present. - mlir::Value getAsyncValue(mlir::acc::DeviceType deviceType) { - mlir::ArrayAttr deviceTypes = getAsyncOperandsDeviceTypeAttr(); - if (!deviceTypes) - return nullptr; - for (auto [attr, asyncValue] : - llvm::zip(deviceTypes, getAsyncOperands())) { - auto deviceTypeAttr = mlir::dyn_cast(attr); - if (deviceTypeAttr.getValue() == deviceType) - return asyncValue; - } - return nullptr; - } - }]; - let hasVerifier = 1; } @@ -922,16 +806,13 @@ class OpenACC_DataExitOpWithVarPtr let assemblyFormat = [{ custom($accVar, type($accVar)) (`bounds` `(` $bounds^ `)` )? - (`async` `(` custom($asyncOperands, - type($asyncOperands), $asyncOperandsDeviceType)^ `)`)? `to` custom($var) `:` custom(type($var), $varType) attr-dict }]; let builders = [ OpBuilder<(ins "::mlir::Value":$accVar, - "::mlir::Value":$var, - "bool":$structured, "bool":$implicit, + "::mlir::Value":$var, "bool":$implicit, CArg<"::mlir::ValueRange", "{}">:$bounds), [{ auto ptrLikeTy = ::mlir::dyn_cast<::mlir::acc::PointerLikeType>( @@ -940,14 +821,11 @@ class OpenACC_DataExitOpWithVarPtr /*varType=*/ptrLikeTy ? ::mlir::TypeAttr::get(ptrLikeTy.getElementType()) : ::mlir::TypeAttr::get(var.getType()), - bounds, /*asyncOperands=*/{}, /*asyncOperandsDeviceType=*/nullptr, - /*asyncOnly=*/nullptr, /*dataClause=*/nullptr, - /*structured=*/$_builder.getBoolAttr(structured), + bounds, /*dataClause=*/nullptr, /*implicit=*/$_builder.getBoolAttr(implicit), /*name=*/nullptr); }]>, OpBuilder<(ins "::mlir::Value":$accVar, - "::mlir::Value":$var, - "bool":$structured, "bool":$implicit, + "::mlir::Value":$var, "bool":$implicit, "const ::llvm::Twine &":$name, CArg<"::mlir::ValueRange", "{}">:$bounds), [{ @@ -957,9 +835,7 @@ class OpenACC_DataExitOpWithVarPtr /*varType=*/ptrLikeTy ? ::mlir::TypeAttr::get(ptrLikeTy.getElementType()) : ::mlir::TypeAttr::get(var.getType()), - bounds, /*asyncOperands=*/{}, /*asyncOperandsDeviceType=*/nullptr, - /*asyncOnly=*/nullptr, /*dataClause=*/nullptr, - /*structured=*/$_builder.getBoolAttr(structured), + bounds, /*dataClause=*/nullptr, /*implicit=*/$_builder.getBoolAttr(implicit), /*name=*/$_builder.getStringAttr(name)); }]>]; @@ -983,31 +859,23 @@ class OpenACC_DataExitOpNoVarPtr : let assemblyFormat = [{ custom($accVar, type($accVar)) (`bounds` `(` $bounds^ `)` )? - (`async` `(` custom($asyncOperands, - type($asyncOperands), $asyncOperandsDeviceType)^ `)`)? attr-dict }]; let builders = [ - OpBuilder<(ins "::mlir::Value":$accVar, - "bool":$structured, "bool":$implicit, + OpBuilder<(ins "::mlir::Value":$accVar, "bool":$implicit, CArg<"::mlir::ValueRange", "{}">:$bounds), [{ build($_builder, $_state, accVar, - bounds, /*asyncOperands=*/{}, /*asyncOperandsDeviceType=*/nullptr, - /*asyncOnly=*/nullptr, /*dataClause=*/nullptr, - /*structured=*/$_builder.getBoolAttr(structured), + bounds, /*dataClause=*/nullptr, /*implicit=*/$_builder.getBoolAttr(implicit), /*name=*/nullptr); }]>, - OpBuilder<(ins "::mlir::Value":$accVar, - "bool":$structured, "bool":$implicit, + OpBuilder<(ins "::mlir::Value":$accVar, "bool":$implicit, "const ::llvm::Twine &":$name, CArg<"::mlir::ValueRange", "{}">:$bounds), [{ build($_builder, $_state, accVar, - bounds, /*asyncOperands=*/{}, /*asyncOperandsDeviceType=*/nullptr, - /*asyncOnly=*/nullptr, /*dataClause=*/nullptr, - /*structured=*/$_builder.getBoolAttr(structured), + bounds, /*dataClause=*/nullptr, /*implicit=*/$_builder.getBoolAttr(implicit), /*name=*/$_builder.getStringAttr(name)); }]> @@ -1027,7 +895,7 @@ def OpenACC_CopyoutOp : OpenACC_DataExitOpWithVarPtr<"copyout", "mlir::acc::DataClause::acc_copyout"> { let summary = "Represents acc copyout semantics - reverse of copyin."; - let extraClassDeclaration = extraClassDeclarationBase # extraClassDeclarationDataExit # [{ + let extraClassDeclaration = extraClassDeclarationDataExit # [{ /// Check if this is a copyout with zero modifier. bool isCopyoutZero(); }]; @@ -1039,7 +907,7 @@ def OpenACC_CopyoutOp : OpenACC_DataExitOpWithVarPtr<"copyout", def OpenACC_DeleteOp : OpenACC_DataExitOpNoVarPtr<"delete", "mlir::acc::DataClause::acc_delete"> { let summary = "Represents acc delete semantics - reverse of create."; - let extraClassDeclaration = extraClassDeclarationBase # extraClassDeclarationDataExit; + let extraClassDeclaration = extraClassDeclarationDataExit; } //===----------------------------------------------------------------------===// @@ -1048,7 +916,7 @@ def OpenACC_DeleteOp : OpenACC_DataExitOpNoVarPtr<"delete", def OpenACC_DetachOp : OpenACC_DataExitOpNoVarPtr<"detach", "mlir::acc::DataClause::acc_detach"> { let summary = "Represents acc detach semantics - reverse of attach."; - let extraClassDeclaration = extraClassDeclarationBase # extraClassDeclarationDataExit; + let extraClassDeclaration = extraClassDeclarationDataExit; } //===----------------------------------------------------------------------===// @@ -1057,7 +925,7 @@ def OpenACC_DetachOp : OpenACC_DataExitOpNoVarPtr<"detach", def OpenACC_UpdateHostOp : OpenACC_DataExitOpWithVarPtr<"update_host", "mlir::acc::DataClause::acc_update_host"> { let summary = "Represents acc update host semantics."; - let extraClassDeclaration = extraClassDeclarationBase # extraClassDeclarationDataExit # [{ + let extraClassDeclaration = extraClassDeclarationDataExit # [{ /// Check if this is an acc update self. bool isSelf() { return getDataClause() == acc::DataClause::acc_update_self; @@ -1439,8 +1307,8 @@ def OpenACC_ParallelOp : OpenACC_Op<"parallel", ( `combined` `(` `loop` `)` $combined^)? oilist( `dataOperands` `(` $dataClauseOperands `:` type($dataClauseOperands) `)` - | `async` `(` custom($asyncOperands, - type($asyncOperands), $asyncOperandsDeviceType) `)` + | `async` `(` custom($asyncOperands, + type($asyncOperands), $asyncOperandsDeviceType, $asyncOnly) `)` | `firstprivate` `(` custom($firstprivateOperands, type($firstprivateOperands), $firstprivatizations) `)` @@ -1581,8 +1449,8 @@ def OpenACC_SerialOp : OpenACC_Op<"serial", ( `combined` `(` `loop` `)` $combined^)? oilist( `dataOperands` `(` $dataClauseOperands `:` type($dataClauseOperands) `)` - | `async` `(` custom($asyncOperands, - type($asyncOperands), $asyncOperandsDeviceType) `)` + | `async` `(` custom($asyncOperands, + type($asyncOperands), $asyncOperandsDeviceType, $asyncOnly) `)` | `firstprivate` `(` custom($firstprivateOperands, type($firstprivateOperands), $firstprivatizations) `)` @@ -1750,8 +1618,8 @@ def OpenACC_KernelsOp : OpenACC_Op<"kernels", ( `combined` `(` `loop` `)` $combined^)? oilist( `dataOperands` `(` $dataClauseOperands `:` type($dataClauseOperands) `)` - | `async` `(` custom($asyncOperands, - type($asyncOperands), $asyncOperandsDeviceType) `)` + | `async` `(` custom($asyncOperands, + type($asyncOperands), $asyncOperandsDeviceType, $asyncOnly) `)` | `num_gangs` `(` custom($numGangs, type($numGangs), $numGangsDeviceType, $numGangsSegments) `)` | `num_workers` `(` custom($numWorkers, @@ -1799,6 +1667,9 @@ def OpenACC_DataOp : OpenACC_Op<"data", `async` and `wait` operands are supported with `device_type` information. They should only be accessed by the extra provided getters. If modified, the corresponding `device_type` attributes must be modified as well. + + The `asyncOnly` operand is a list of device_type's for which async clause + does not specify a value (default is acc_async_noval - OpenACC 3.3 2.16.1). }]; @@ -1870,8 +1741,8 @@ def OpenACC_DataOp : OpenACC_Op<"data", let assemblyFormat = [{ oilist( `if` `(` $ifCond `)` - | `async` `(` custom($asyncOperands, - type($asyncOperands), $asyncOperandsDeviceType) `)` + | `async` `(` custom($asyncOperands, + type($asyncOperands), $asyncOperandsDeviceType, $asyncOnly) `)` | `dataOperands` `(` $dataClauseOperands `:` type($dataClauseOperands) `)` | `wait` `` custom($waitOperands, type($waitOperands), $waitOperandsDeviceType, $waitOperandsSegments, $hasWaitDevnum, @@ -1931,6 +1802,7 @@ def OpenACC_EnterDataOp : OpenACC_Op<"enter_data", Value getDataOperand(unsigned i); }]; + // TODO: Show $async and $wait. let assemblyFormat = [{ oilist( `if` `(` $ifCond `)` @@ -1983,6 +1855,7 @@ def OpenACC_ExitDataOp : OpenACC_Op<"exit_data", Value getDataOperand(unsigned i); }]; + // TODO: Show $async and $wait. let assemblyFormat = [{ oilist( `if` `(` $ifCond `)` @@ -2853,7 +2726,7 @@ def OpenACC_UpdateOp : OpenACC_Op<"update", let arguments = (ins Optional:$ifCond, Variadic:$asyncOperands, OptionalAttr:$asyncOperandsDeviceType, - OptionalAttr:$async, + OptionalAttr:$asyncOnly, Variadic:$waitOperands, OptionalAttr:$waitOperandsSegments, OptionalAttr:$waitOperandsDeviceType, @@ -2901,9 +2774,8 @@ def OpenACC_UpdateOp : OpenACC_Op<"update", let assemblyFormat = [{ oilist( `if` `(` $ifCond `)` - | `async` `` custom( - $asyncOperands, type($asyncOperands), - $asyncOperandsDeviceType, $async) + | `async` `(` custom($asyncOperands, + type($asyncOperands), $asyncOperandsDeviceType, $asyncOnly) `)` | `wait` `` custom($waitOperands, type($waitOperands), $waitOperandsDeviceType, $waitOperandsSegments, $hasWaitDevnum, $waitOnly) @@ -2946,6 +2818,7 @@ def OpenACC_WaitOp : OpenACC_Op<"wait", [AttrSizedOperandSegments]> { UnitAttr:$async, Optional:$ifCond); + // TODO: Show $async. let assemblyFormat = [{ ( `(` $waitOperands^ `:` type($waitOperands) `)` )? oilist(`async` `(` $asyncOperand `:` type($asyncOperand) `)` diff --git a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp index 7eb72d433c972..ee00acecb17b9 100644 --- a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp +++ b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp @@ -3505,7 +3505,7 @@ bool UpdateOp::hasAsyncOnly() { } bool UpdateOp::hasAsyncOnly(mlir::acc::DeviceType deviceType) { - return hasDeviceType(getAsync(), deviceType); + return hasDeviceType(getAsyncOnly(), deviceType); } mlir::Value UpdateOp::getAsyncValue() { @@ -3659,32 +3659,30 @@ mlir::acc::getBounds(mlir::Operation *accDataClauseOp) { } mlir::SmallVector -mlir::acc::getAsyncOperands(mlir::Operation *accDataClauseOp) { +mlir::acc::getAsyncOperands(mlir::Operation *accOp) { return llvm::TypeSwitch>( - accDataClauseOp) - .Case([&](auto dataClause) { - return mlir::SmallVector( - dataClause.getAsyncOperands().begin(), - dataClause.getAsyncOperands().end()); - }) + accOp) + .Case( + [&](auto op) { + return mlir::SmallVector(op.getAsyncOperands().begin(), + op.getAsyncOperands().end()); + }) .Default([&](mlir::Operation *) { return mlir::SmallVector(); }); } -mlir::ArrayAttr -mlir::acc::getAsyncOperandsDeviceType(mlir::Operation *accDataClauseOp) { - return llvm::TypeSwitch(accDataClauseOp) - .Case([&](auto dataClause) { - return dataClause.getAsyncOperandsDeviceTypeAttr(); - }) +mlir::ArrayAttr mlir::acc::getAsyncOperandsDeviceType(mlir::Operation *accOp) { + return llvm::TypeSwitch(accOp) + .Case( + [&](auto op) { return op.getAsyncOperandsDeviceTypeAttr(); }) .Default([&](mlir::Operation *) { return mlir::ArrayAttr{}; }); } -mlir::ArrayAttr mlir::acc::getAsyncOnly(mlir::Operation *accDataClauseOp) { - return llvm::TypeSwitch(accDataClauseOp) - .Case( - [&](auto dataClause) { return dataClause.getAsyncOnlyAttr(); }) +mlir::ArrayAttr mlir::acc::getAsyncOnly(mlir::Operation *accOp) { + return llvm::TypeSwitch(accOp) + .Case( + [&](auto op) { return op.getAsyncOnlyAttr(); }) .Default([&](mlir::Operation *) { return mlir::ArrayAttr{}; }); } From 38e6b58dc6bc4fed2db23dd348c1a0cfe91d4fbe Mon Sep 17 00:00:00 2001 From: Kazuaki Matsumura Date: Tue, 13 May 2025 05:21:48 -0700 Subject: [PATCH 2/5] [acc] accDataClauseOp -> accOp --- mlir/include/mlir/Dialect/OpenACC/OpenACC.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/mlir/include/mlir/Dialect/OpenACC/OpenACC.h b/mlir/include/mlir/Dialect/OpenACC/OpenACC.h index e053e3d2bbcfc..f667a6786189b 100644 --- a/mlir/include/mlir/Dialect/OpenACC/OpenACC.h +++ b/mlir/include/mlir/Dialect/OpenACC/OpenACC.h @@ -120,17 +120,17 @@ mlir::SmallVector getBounds(mlir::Operation *accDataClauseOp); /// Used to obtain `async` operands from an acc operation. /// Returns an empty vector if there are no such operands. mlir::SmallVector -getAsyncOperands(mlir::Operation *accDataClauseOp); +getAsyncOperands(mlir::Operation *accOp); /// Returns an array of acc:DeviceTypeAttr attributes attached to /// an acc operation, that correspond to the device types associated with the /// async clauses with an async-value. -mlir::ArrayAttr getAsyncOperandsDeviceType(mlir::Operation *accDataClauseOp); +mlir::ArrayAttr getAsyncOperandsDeviceType(mlir::Operation *accOp); /// Returns an array of acc:DeviceTypeAttr attributes attached to /// an acc operation, that correspond to the device types associated with the /// async clauses without an async-value. -mlir::ArrayAttr getAsyncOnly(mlir::Operation *accDataClauseOp); +mlir::ArrayAttr getAsyncOnly(mlir::Operation *accOp); /// Used to obtain the `name` from an acc operation. std::optional getVarName(mlir::Operation *accOp); From 1a0bac6b11d3c882b3ac7e6e0d28b97806048bec Mon Sep 17 00:00:00 2001 From: Kazuaki Matsumura Date: Tue, 13 May 2025 05:49:39 -0700 Subject: [PATCH 3/5] [acc] clang-format --- mlir/include/mlir/Dialect/OpenACC/OpenACC.h | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/mlir/include/mlir/Dialect/OpenACC/OpenACC.h b/mlir/include/mlir/Dialect/OpenACC/OpenACC.h index f667a6786189b..30271d0599236 100644 --- a/mlir/include/mlir/Dialect/OpenACC/OpenACC.h +++ b/mlir/include/mlir/Dialect/OpenACC/OpenACC.h @@ -119,8 +119,7 @@ mlir::SmallVector getBounds(mlir::Operation *accDataClauseOp); /// Used to obtain `async` operands from an acc operation. /// Returns an empty vector if there are no such operands. -mlir::SmallVector -getAsyncOperands(mlir::Operation *accOp); +mlir::SmallVector getAsyncOperands(mlir::Operation *accOp); /// Returns an array of acc:DeviceTypeAttr attributes attached to /// an acc operation, that correspond to the device types associated with the From 5ee42b2c7a2db13eeb587fc4586ee3dedb3a9614 Mon Sep 17 00:00:00 2001 From: Kazuaki Matsumura Date: Tue, 13 May 2025 09:05:08 -0700 Subject: [PATCH 4/5] [flang][acc] Revert assemblyFormat changes; asyncOnly is an attribute, no need to handle it --- .../mlir/Dialect/OpenACC/OpenACCOps.td | 23 ++++++++----------- 1 file changed, 10 insertions(+), 13 deletions(-) diff --git a/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td b/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td index 59b9a50144a1e..ead7e95a694db 100644 --- a/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td +++ b/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td @@ -1307,8 +1307,8 @@ def OpenACC_ParallelOp : OpenACC_Op<"parallel", ( `combined` `(` `loop` `)` $combined^)? oilist( `dataOperands` `(` $dataClauseOperands `:` type($dataClauseOperands) `)` - | `async` `(` custom($asyncOperands, - type($asyncOperands), $asyncOperandsDeviceType, $asyncOnly) `)` + | `async` `(` custom($asyncOperands, + type($asyncOperands), $asyncOperandsDeviceType) `)` | `firstprivate` `(` custom($firstprivateOperands, type($firstprivateOperands), $firstprivatizations) `)` @@ -1449,8 +1449,8 @@ def OpenACC_SerialOp : OpenACC_Op<"serial", ( `combined` `(` `loop` `)` $combined^)? oilist( `dataOperands` `(` $dataClauseOperands `:` type($dataClauseOperands) `)` - | `async` `(` custom($asyncOperands, - type($asyncOperands), $asyncOperandsDeviceType, $asyncOnly) `)` + | `async` `(` custom($asyncOperands, + type($asyncOperands), $asyncOperandsDeviceType) `)` | `firstprivate` `(` custom($firstprivateOperands, type($firstprivateOperands), $firstprivatizations) `)` @@ -1618,8 +1618,8 @@ def OpenACC_KernelsOp : OpenACC_Op<"kernels", ( `combined` `(` `loop` `)` $combined^)? oilist( `dataOperands` `(` $dataClauseOperands `:` type($dataClauseOperands) `)` - | `async` `(` custom($asyncOperands, - type($asyncOperands), $asyncOperandsDeviceType, $asyncOnly) `)` + | `async` `(` custom($asyncOperands, + type($asyncOperands), $asyncOperandsDeviceType) `)` | `num_gangs` `(` custom($numGangs, type($numGangs), $numGangsDeviceType, $numGangsSegments) `)` | `num_workers` `(` custom($numWorkers, @@ -1741,8 +1741,8 @@ def OpenACC_DataOp : OpenACC_Op<"data", let assemblyFormat = [{ oilist( `if` `(` $ifCond `)` - | `async` `(` custom($asyncOperands, - type($asyncOperands), $asyncOperandsDeviceType, $asyncOnly) `)` + | `async` `(` custom($asyncOperands, + type($asyncOperands), $asyncOperandsDeviceType) `)` | `dataOperands` `(` $dataClauseOperands `:` type($dataClauseOperands) `)` | `wait` `` custom($waitOperands, type($waitOperands), $waitOperandsDeviceType, $waitOperandsSegments, $hasWaitDevnum, @@ -1802,7 +1802,6 @@ def OpenACC_EnterDataOp : OpenACC_Op<"enter_data", Value getDataOperand(unsigned i); }]; - // TODO: Show $async and $wait. let assemblyFormat = [{ oilist( `if` `(` $ifCond `)` @@ -1855,7 +1854,6 @@ def OpenACC_ExitDataOp : OpenACC_Op<"exit_data", Value getDataOperand(unsigned i); }]; - // TODO: Show $async and $wait. let assemblyFormat = [{ oilist( `if` `(` $ifCond `)` @@ -2774,8 +2772,8 @@ def OpenACC_UpdateOp : OpenACC_Op<"update", let assemblyFormat = [{ oilist( `if` `(` $ifCond `)` - | `async` `(` custom($asyncOperands, - type($asyncOperands), $asyncOperandsDeviceType, $asyncOnly) `)` + | `async` `(` custom($asyncOperands, + type($asyncOperands), $asyncOperandsDeviceType) `)` | `wait` `` custom($waitOperands, type($waitOperands), $waitOperandsDeviceType, $waitOperandsSegments, $hasWaitDevnum, $waitOnly) @@ -2818,7 +2816,6 @@ def OpenACC_WaitOp : OpenACC_Op<"wait", [AttrSizedOperandSegments]> { UnitAttr:$async, Optional:$ifCond); - // TODO: Show $async. let assemblyFormat = [{ ( `(` $waitOperands^ `:` type($waitOperands) `)` )? oilist(`async` `(` $asyncOperand `:` type($asyncOperand) `)` From 18522fdb0c59b1d06d35cf6b9860e79795968e60 Mon Sep 17 00:00:00 2001 From: Kazuaki Matsumura Date: Tue, 13 May 2025 12:01:23 -0700 Subject: [PATCH 5/5] [flang][acc] Update lit tests --- .../Fir/OpenACC/openacc-type-categories.f90 | 20 +-- flang/test/Lower/OpenACC/acc-bounds.f90 | 6 +- .../OpenACC/acc-data-unwrap-defaultbounds.f90 | 7 +- flang/test/Lower/OpenACC/acc-data.f90 | 7 +- .../Lower/OpenACC/acc-declare-globals.f90 | 20 +-- .../acc-declare-unwrap-defaultbounds.f90 | 38 +++--- flang/test/Lower/OpenACC/acc-declare.f90 | 26 ++-- .../acc-enter-data-unwrap-defaultbounds.f90 | 124 +++++++++--------- flang/test/Lower/OpenACC/acc-enter-data.f90 | 124 +++++++++--------- .../acc-exit-data-unwrap-defaultbounds.f90 | 68 +++++----- flang/test/Lower/OpenACC/acc-exit-data.f90 | 68 +++++----- flang/test/Lower/OpenACC/acc-parallel.f90 | 9 +- flang/test/Lower/OpenACC/acc-update.f90 | 84 ++++++------ mlir/test/Dialect/OpenACC/invalid.mlir | 2 +- mlir/test/Dialect/OpenACC/ops.mlir | 16 +-- 15 files changed, 311 insertions(+), 308 deletions(-) diff --git a/flang/test/Fir/OpenACC/openacc-type-categories.f90 b/flang/test/Fir/OpenACC/openacc-type-categories.f90 index c25c38422b755..64c5e897e960e 100644 --- a/flang/test/Fir/OpenACC/openacc-type-categories.f90 +++ b/flang/test/Fir/OpenACC/openacc-type-categories.f90 @@ -17,33 +17,33 @@ program main !$acc enter data copyin(complexvar, charvar, ttvar%field, ttvar%fieldarray, arrayconstsize(1)) end program -! CHECK: Visiting: {{.*}} acc.copyin {{.*}} {name = "scalar", structured = false} +! CHECK: Visiting: {{.*}} acc.copyin {{.*}} {name = "scalar"} ! CHECK: Pointer-like: !fir.ref ! CHECK: Type category: scalar -! CHECK: Visiting: {{.*}} acc.copyin {{.*}} {name = "scalaralloc", structured = false} +! CHECK: Visiting: {{.*}} acc.copyin {{.*}} {name = "scalaralloc"} ! CHECK: Pointer-like: !fir.ref>> ! CHECK: Type category: nonscalar -! CHECK: Visiting: {{.*}} acc.copyin {{.*}} {name = "ttvar", structured = false} +! CHECK: Visiting: {{.*}} acc.copyin {{.*}} {name = "ttvar"} ! CHECK: Pointer-like: !fir.ref}>> ! CHECK: Type category: composite -! CHECK: Visiting: {{.*}} acc.copyin {{.*}} {name = "arrayconstsize", structured = false} +! CHECK: Visiting: {{.*}} acc.copyin {{.*}} {name = "arrayconstsize"} ! CHECK: Pointer-like: !fir.ref> ! CHECK: Type category: array -! CHECK: Visiting: {{.*}} acc.copyin {{.*}} {name = "arrayalloc", structured = false} +! CHECK: Visiting: {{.*}} acc.copyin {{.*}} {name = "arrayalloc"} ! CHECK: Pointer-like: !fir.ref>>> ! CHECK: Type category: array -! CHECK: Visiting: {{.*}} acc.copyin {{.*}} {name = "complexvar", structured = false} +! CHECK: Visiting: {{.*}} acc.copyin {{.*}} {name = "complexvar"} ! CHECK: Pointer-like: !fir.ref> ! CHECK: Type category: scalar -! CHECK: Visiting: {{.*}} acc.copyin {{.*}} {name = "charvar", structured = false} +! CHECK: Visiting: {{.*}} acc.copyin {{.*}} {name = "charvar"} ! CHECK: Pointer-like: !fir.ref> ! CHECK: Type category: nonscalar -! CHECK: Visiting: {{.*}} acc.copyin {{.*}} {name = "ttvar%field", structured = false} +! CHECK: Visiting: {{.*}} acc.copyin {{.*}} {name = "ttvar%field"} ! CHECK: Pointer-like: !fir.ref ! CHECK: Type category: composite -! CHECK: Visiting: {{.*}} acc.copyin {{.*}} {name = "ttvar%fieldarray", structured = false} +! CHECK: Visiting: {{.*}} acc.copyin {{.*}} {name = "ttvar%fieldarray"} ! CHECK: Pointer-like: !fir.ref> ! CHECK: Type category: array -! CHECK: Visiting: {{.*}} acc.copyin {{.*}} {name = "arrayconstsize(1)", structured = false} +! CHECK: Visiting: {{.*}} acc.copyin {{.*}} {name = "arrayconstsize(1)"} ! CHECK: Pointer-like: !fir.ref> ! CHECK: Type category: array diff --git a/flang/test/Lower/OpenACC/acc-bounds.f90 b/flang/test/Lower/OpenACC/acc-bounds.f90 index cff53a2bfd122..5b3396b54ace7 100644 --- a/flang/test/Lower/OpenACC/acc-bounds.f90 +++ b/flang/test/Lower/OpenACC/acc-bounds.f90 @@ -33,7 +33,7 @@ subroutine acc_derived_type_component_pointer_array() ! CHECK: %[[UB:.*]] = arith.subi %[[BOX_DIMS1]]#1, %[[C1]] : index ! CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%c0{{.*}} : index) upperbound(%[[UB]] : index) extent(%[[BOX_DIMS1]]#1 : index) stride(%[[BOX_DIMS1]]#2 : index) startIdx(%[[BOX_DIMS0]]#0 : index) {strideInBytes = true} ! CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[LOAD]] : (!fir.box>>) -> !fir.ptr> -! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ptr>) bounds(%[[BOUND]]) -> !fir.ptr> {name = "d%array_comp", structured = false} +! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ptr>) bounds(%[[BOUND]]) -> !fir.ptr> {name = "d%array_comp"} ! CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ptr>) ! CHECK: return ! CHECK: } @@ -53,7 +53,7 @@ subroutine acc_derived_type_component_array() ! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.subi %[[C10]], %[[C1]] : index ! CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[C0]] : index) upperbound(%[[UB]] : index) extent(%[[C10]] : index) stride(%[[C1]] : index) startIdx(%[[C1]] : index) -! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "d%array_comp", structured = false} +! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "d%array_comp"} ! CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) ! CHECK: return ! CHECK: } @@ -74,7 +74,7 @@ subroutine acc_derived_type_component_allocatable_array() ! CHECK: %[[UB:.*]] = arith.subi %[[BOX_DIMS1]]#1, %[[C1]] : index ! CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%c0{{.*}} : index) upperbound(%[[UB]] : index) extent(%[[BOX_DIMS1]]#1 : index) stride(%[[BOX_DIMS1]]#2 : index) startIdx(%[[BOX_DIMS0]]#0 : index) {strideInBytes = true} ! CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[LOAD]] : (!fir.box>>) -> !fir.heap> -! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.heap>) bounds(%[[BOUND]]) -> !fir.heap> {name = "d%array_comp", structured = false} +! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.heap>) bounds(%[[BOUND]]) -> !fir.heap> {name = "d%array_comp"} ! CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.heap>) ! CHECK: return ! CHECK: } diff --git a/flang/test/Lower/OpenACC/acc-data-unwrap-defaultbounds.f90 b/flang/test/Lower/OpenACC/acc-data-unwrap-defaultbounds.f90 index d010d39cef4eb..d0b2396500b3a 100644 --- a/flang/test/Lower/OpenACC/acc-data-unwrap-defaultbounds.f90 +++ b/flang/test/Lower/OpenACC/acc-data-unwrap-defaultbounds.f90 @@ -161,10 +161,11 @@ subroutine acc_data !$acc data copy(a) async(1) !$acc end data -! CHECK: %[[COPYIN:.*]] = acc.copyin varPtr(%{{.*}} : !fir.ref>) bounds(%{{.*}}, %{{.*}}) async(%[[ASYNC:.*]] : i32) -> !fir.ref> {dataClause = #acc, name = "a"} -! CHECK: acc.data async(%[[ASYNC]] : i32) dataOperands(%[[COPYIN]] : !fir.ref>) { +! CHECK-DAG: %[[COPYIN:.*]] = acc.copyin varPtr(%{{.*}} : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a"} +! CHECK-DAG: acc.data async(%[[ASYNC:.*]] : i32) dataOperands(%[[COPYIN]] : !fir.ref>) { +! CHECK-DAG: %[[ASYNC]] = arith.constant 1 : i32 ! CHECK: }{{$}} -! CHECK: acc.copyout accPtr(%[[COPYIN]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) async(%[[ASYNC]] : i32) to varPtr(%{{.*}} : !fir.ref>) {dataClause = #acc, name = "a"} +! CHECK: acc.copyout accPtr(%[[COPYIN]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) to varPtr(%{{.*}} : !fir.ref>) {dataClause = #acc, name = "a"} !$acc data present(a) wait !$acc end data diff --git a/flang/test/Lower/OpenACC/acc-data.f90 b/flang/test/Lower/OpenACC/acc-data.f90 index 7965fdc0ac707..46687876925e6 100644 --- a/flang/test/Lower/OpenACC/acc-data.f90 +++ b/flang/test/Lower/OpenACC/acc-data.f90 @@ -161,10 +161,11 @@ subroutine acc_data !$acc data copy(a) async(1) !$acc end data -! CHECK: %[[COPYIN:.*]] = acc.copyin varPtr(%{{.*}} : !fir.ref>) async(%[[ASYNC:.*]] : i32) -> !fir.ref> {dataClause = #acc, name = "a"} -! CHECK: acc.data async(%[[ASYNC]] : i32) dataOperands(%[[COPYIN]] : !fir.ref>) { +! CHECK-DAG: %[[COPYIN:.*]] = acc.copyin varPtr(%{{.*}} : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} +! CHECK-DAG: acc.data async(%[[ASYNC:.*]] : i32) dataOperands(%[[COPYIN]] : !fir.ref>) { +! CHECK-DAG: %[[ASYNC]] = arith.constant 1 : i32 ! CHECK: }{{$}} -! CHECK: acc.copyout accPtr(%[[COPYIN]] : !fir.ref>) async(%[[ASYNC]] : i32) to varPtr(%{{.*}} : !fir.ref>) {dataClause = #acc, name = "a"} +! CHECK: acc.copyout accPtr(%[[COPYIN]] : !fir.ref>) to varPtr(%{{.*}} : !fir.ref>) {dataClause = #acc, name = "a"} !$acc data present(a) wait !$acc end data diff --git a/flang/test/Lower/OpenACC/acc-declare-globals.f90 b/flang/test/Lower/OpenACC/acc-declare-globals.f90 index 4556c5f4ddb1c..b79a92afea7bc 100644 --- a/flang/test/Lower/OpenACC/acc-declare-globals.f90 +++ b/flang/test/Lower/OpenACC/acc-declare-globals.f90 @@ -46,16 +46,16 @@ module acc_declare_test ! CHECK-LABEL: acc.global_ctor @_QMacc_declare_testEdata1_acc_ctor { ! CHECK: %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_testEdata1) {acc.declare = #acc.declare} : !fir.ref> -! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[GLOBAL_ADDR]] : !fir.ref>) -> !fir.ref> {name = "data1", structured = false} +! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[GLOBAL_ADDR]] : !fir.ref>) -> !fir.ref> {name = "data1"} ! CHECK: acc.declare_enter dataOperands(%[[CREATE]] : !fir.ref>) ! CHECK: acc.terminator ! CHECK: } ! CHECK-LABEL: acc.global_dtor @_QMacc_declare_testEdata1_acc_dtor { ! CHECK: %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_testEdata1) {acc.declare = #acc.declare} : !fir.ref> -! CHECK: %[[DEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[GLOBAL_ADDR]] : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "data1", structured = false} +! CHECK: %[[DEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[GLOBAL_ADDR]] : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "data1"} ! CHECK: acc.declare_exit dataOperands(%[[DEVICEPTR]] : !fir.ref>) -! CHECK: acc.delete accPtr(%[[DEVICEPTR]] : !fir.ref>) {dataClause = #acc, name = "data1", structured = false} +! CHECK: acc.delete accPtr(%[[DEVICEPTR]] : !fir.ref>) {dataClause = #acc, name = "data1"} ! CHECK: acc.terminator ! CHECK: } @@ -67,16 +67,16 @@ module acc_declare_copyin_test ! CHECK-LABEL: acc.global_ctor @_QMacc_declare_copyin_testEdata1_acc_ctor { ! CHECK: %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_copyin_testEdata1) {acc.declare = #acc.declare} : !fir.ref> -! CHECK: %[[COPYIN:.*]] = acc.copyin varPtr(%[[GLOBAL_ADDR]] : !fir.ref>) -> !fir.ref> {name = "data1", structured = false} +! CHECK: %[[COPYIN:.*]] = acc.copyin varPtr(%[[GLOBAL_ADDR]] : !fir.ref>) -> !fir.ref> {name = "data1"} ! CHECK: acc.declare_enter dataOperands(%[[COPYIN]] : !fir.ref>) ! CHECK: acc.terminator ! CHECK: } ! CHECK-LABEL: acc.global_dtor @_QMacc_declare_copyin_testEdata1_acc_dtor { ! CHECK: %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_copyin_testEdata1) {acc.declare = #acc.declare} : !fir.ref> -! CHECK: %[[DEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[GLOBAL_ADDR]] : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "data1", structured = false} +! CHECK: %[[DEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[GLOBAL_ADDR]] : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "data1"} ! CHECK: acc.declare_exit dataOperands(%[[DEVICEPTR]] : !fir.ref>) -! CHECK: acc.delete accPtr(%[[DEVICEPTR]] : !fir.ref>) {dataClause = #acc, name = "data1", structured = false} +! CHECK: acc.delete accPtr(%[[DEVICEPTR]] : !fir.ref>) {dataClause = #acc, name = "data1"} ! CHECK: acc.terminator ! CHECK: } @@ -90,16 +90,16 @@ module acc_declare_device_resident_test ! CHECK-LABEL: acc.global_ctor @_QMacc_declare_device_resident_testEdata1_acc_ctor { ! CHECK: %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_device_resident_testEdata1) {acc.declare = #acc.declare} : !fir.ref> -! CHECK: %[[DEVICERESIDENT:.*]] = acc.declare_device_resident varPtr(%0 : !fir.ref>) -> !fir.ref> {name = "data1", structured = false} +! CHECK: %[[DEVICERESIDENT:.*]] = acc.declare_device_resident varPtr(%0 : !fir.ref>) -> !fir.ref> {name = "data1"} ! CHECK: acc.declare_enter dataOperands(%[[DEVICERESIDENT]] : !fir.ref>) ! CHECK: acc.terminator ! CHECK: } ! CHECK-LABEL: acc.global_dtor @_QMacc_declare_device_resident_testEdata1_acc_dtor { ! CHECK: %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_device_resident_testEdata1) {acc.declare = #acc.declare} : !fir.ref> -! CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[GLOBAL_ADDR]] : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "data1", structured = false} +! CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[GLOBAL_ADDR]] : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "data1"} ! CHECK: acc.declare_exit dataOperands(%[[DEVICEPTR]] : !fir.ref>) -! CHECK: acc.delete accPtr(%[[DEVICEPTR]] : !fir.ref>) {dataClause = #acc, name = "data1", structured = false} +! CHECK: acc.delete accPtr(%[[DEVICEPTR]] : !fir.ref>) {dataClause = #acc, name = "data1"} ! CHECK: acc.terminator ! CHECK: } @@ -113,7 +113,7 @@ module acc_declare_device_link_test ! CHECK-LABEL: acc.global_ctor @_QMacc_declare_device_link_testEdata1_acc_ctor { ! CHECK: %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_device_link_testEdata1) {acc.declare = #acc.declare} : !fir.ref> -! CHECK: %[[LINK:.*]] = acc.declare_link varPtr(%[[GLOBAL_ADDR]] : !fir.ref>) -> !fir.ref> {name = "data1", structured = false} +! CHECK: %[[LINK:.*]] = acc.declare_link varPtr(%[[GLOBAL_ADDR]] : !fir.ref>) -> !fir.ref> {name = "data1"} ! CHECK: acc.declare_enter dataOperands(%[[LINK]] : !fir.ref>) ! CHECK: acc.terminator ! CHECK: } diff --git a/flang/test/Lower/OpenACC/acc-declare-unwrap-defaultbounds.f90 b/flang/test/Lower/OpenACC/acc-declare-unwrap-defaultbounds.f90 index 5bb1ae3797346..7dbfd2de90176 100644 --- a/flang/test/Lower/OpenACC/acc-declare-unwrap-defaultbounds.f90 +++ b/flang/test/Lower/OpenACC/acc-declare-unwrap-defaultbounds.f90 @@ -258,11 +258,11 @@ subroutine acc_declare_allocate() ! CHECK-LABEL: func.func private @_QMacc_declareFacc_declare_allocateEa_acc_declare_update_desc_post_alloc( ! CHECK-SAME: %[[ARG0:.*]]: !fir.ref>>>) { -! CHECK: %[[UPDATE:.*]] = acc.update_device varPtr(%[[ARG0]] : !fir.ref>>>) -> !fir.ref>>> {implicit = true, name = "a_desc", structured = false} +! CHECK: %[[UPDATE:.*]] = acc.update_device varPtr(%[[ARG0]] : !fir.ref>>>) -> !fir.ref>>> {implicit = true, name = "a_desc"} ! CHECK: acc.update dataOperands(%[[UPDATE]] : !fir.ref>>>) ! CHECK: %[[LOAD:.*]] = fir.load %[[ARG0]] : !fir.ref>>> ! CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[LOAD]] {acc.declare = #acc.declare} : (!fir.box>>) -> !fir.heap> -! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.heap>) -> !fir.heap> {name = "a", structured = false} +! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.heap>) -> !fir.heap> {name = "a"} ! CHECK: acc.declare_enter dataOperands(%[[CREATE]] : !fir.heap>) ! CHECK: return ! CHECK: } @@ -271,9 +271,9 @@ subroutine acc_declare_allocate() ! CHECK-SAME: %[[ARG0:.*]]: !fir.ref>>>) { ! CHECK: %[[LOAD:.*]] = fir.load %[[ARG0]] : !fir.ref>>> ! CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[LOAD]] {acc.declare = #acc.declare} : (!fir.box>>) -> !fir.heap> -! CHECK: %[[GETDEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[BOX_ADDR]] : !fir.heap>) -> !fir.heap> {dataClause = #acc, name = "a", structured = false} +! CHECK: %[[GETDEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[BOX_ADDR]] : !fir.heap>) -> !fir.heap> {dataClause = #acc, name = "a"} ! CHECK: acc.declare_exit dataOperands(%[[GETDEVICEPTR]] : !fir.heap>) -! CHECK: acc.delete accPtr(%[[GETDEVICEPTR]] : !fir.heap>) {dataClause = #acc, name = "a", structured = false} +! CHECK: acc.delete accPtr(%[[GETDEVICEPTR]] : !fir.heap>) {dataClause = #acc, name = "a"} ! CHECK: return ! CHECK: } @@ -281,7 +281,7 @@ subroutine acc_declare_allocate() ! CHECK-SAME: %[[ARG0:.*]]: !fir.ref>>>) { ! CHECK: %[[LOAD:.*]] = fir.load %[[ARG0]] : !fir.ref>>> ! CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[LOAD]] : (!fir.box>>) -> !fir.heap> -! CHECK: %[[UPDATE:.*]] = acc.update_device varPtr(%[[BOX_ADDR]] : !fir.heap>) -> !fir.heap> {implicit = true, name = "a_desc", structured = false} +! CHECK: %[[UPDATE:.*]] = acc.update_device varPtr(%[[BOX_ADDR]] : !fir.heap>) -> !fir.heap> {implicit = true, name = "a_desc"} ! CHECK: acc.update dataOperands(%[[UPDATE]] : !fir.heap>) ! CHECK: return ! CHECK: } @@ -348,18 +348,18 @@ module acc_declare_allocatable_test ! CHECK-LABEL: acc.global_ctor @_QMacc_declare_allocatable_testEdata1_acc_ctor { ! CHECK: %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_allocatable_testEdata1) {acc.declare = #acc.declare} : !fir.ref>>> -! CHECK: %[[COPYIN:.*]] = acc.copyin varPtr(%[[GLOBAL_ADDR]] : !fir.ref>>>) -> !fir.ref>>> {dataClause = #acc, implicit = true, name = "data1", structured = false} +! CHECK: %[[COPYIN:.*]] = acc.copyin varPtr(%[[GLOBAL_ADDR]] : !fir.ref>>>) -> !fir.ref>>> {dataClause = #acc, implicit = true, name = "data1"} ! CHECK: acc.declare_enter dataOperands(%[[COPYIN]] : !fir.ref>>>) ! CHECK: acc.terminator ! CHECK: } ! CHECK-LABEL: func.func private @_QMacc_declare_allocatable_testEdata1_acc_declare_update_desc_post_alloc() { ! CHECK: %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_allocatable_testEdata1) : !fir.ref>>> -! CHECK: %[[UPDATE:.*]] = acc.update_device varPtr(%[[GLOBAL_ADDR]] : !fir.ref>>>) -> !fir.ref>>> {implicit = true, name = "data1_desc", structured = false} +! CHECK: %[[UPDATE:.*]] = acc.update_device varPtr(%[[GLOBAL_ADDR]] : !fir.ref>>>) -> !fir.ref>>> {implicit = true, name = "data1_desc"} ! CHECK: acc.update dataOperands(%[[UPDATE]] : !fir.ref>>>) ! CHECK: %[[LOAD:.*]] = fir.load %[[GLOBAL_ADDR]] : !fir.ref>>> ! CHECK: %[[BOXADDR:.*]] = fir.box_addr %[[LOAD]] {acc.declare = #acc.declare} : (!fir.box>>) -> !fir.heap> -! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOXADDR]] : !fir.heap>) -> !fir.heap> {name = "data1", structured = false} +! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOXADDR]] : !fir.heap>) -> !fir.heap> {name = "data1"} ! CHECK: acc.declare_enter dataOperands(%[[CREATE]] : !fir.heap>) ! CHECK: return ! CHECK: } @@ -368,24 +368,24 @@ module acc_declare_allocatable_test ! CHECK: %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_allocatable_testEdata1) : !fir.ref>>> ! CHECK: %[[LOAD:.*]] = fir.load %[[GLOBAL_ADDR]] : !fir.ref>>> ! CHECK: %[[BOXADDR:.*]] = fir.box_addr %[[LOAD]] {acc.declare = #acc.declare} : (!fir.box>>) -> !fir.heap> -! CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[BOXADDR]] : !fir.heap>) -> !fir.heap> {dataClause = #acc, name = "data1", structured = false} +! CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[BOXADDR]] : !fir.heap>) -> !fir.heap> {dataClause = #acc, name = "data1"} ! CHECK: acc.declare_exit dataOperands(%[[DEVPTR]] : !fir.heap>) -! CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.heap>) {dataClause = #acc, name = "data1", structured = false} +! CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.heap>) {dataClause = #acc, name = "data1"} ! CHECK: return ! CHECK: } ! CHECK-LABEL: func.func private @_QMacc_declare_allocatable_testEdata1_acc_declare_update_desc_post_dealloc() { ! CHECK: %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_allocatable_testEdata1) : !fir.ref>>> -! CHECK: %[[UPDATE:.*]] = acc.update_device varPtr(%[[GLOBAL_ADDR]] : !fir.ref>>>) -> !fir.ref>>> {implicit = true, name = "data1_desc", structured = false} +! CHECK: %[[UPDATE:.*]] = acc.update_device varPtr(%[[GLOBAL_ADDR]] : !fir.ref>>>) -> !fir.ref>>> {implicit = true, name = "data1_desc"} ! CHECK: acc.update dataOperands(%[[UPDATE]] : !fir.ref>>>) ! CHECK: return ! CHECK: } ! CHECK-LABEL: acc.global_dtor @_QMacc_declare_allocatable_testEdata1_acc_dtor { ! CHECK: %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_allocatable_testEdata1) {acc.declare = #acc.declare} : !fir.ref>>> -! CHECK: %[[DEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[GLOBAL_ADDR]] : !fir.ref>>>) -> !fir.ref>>> {dataClause = #acc, name = "data1", structured = false} +! CHECK: %[[DEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[GLOBAL_ADDR]] : !fir.ref>>>) -> !fir.ref>>> {dataClause = #acc, name = "data1"} ! CHECK: acc.declare_exit dataOperands(%[[DEVICEPTR]] : !fir.ref>>>) -! CHECK: acc.delete accPtr(%[[DEVICEPTR]] : !fir.ref>>>) {dataClause = #acc, name = "data1", structured = false} +! CHECK: acc.delete accPtr(%[[DEVICEPTR]] : !fir.ref>>>) {dataClause = #acc, name = "data1"} ! CHECK: acc.terminator ! CHECK: } @@ -400,15 +400,15 @@ module acc_declare_equivalent ! CHECK-LABEL: acc.global_ctor @_QMacc_declare_equivalentEv2_acc_ctor { ! CHECK: %[[ADDR:.*]] = fir.address_of(@_QMacc_declare_equivalentEv1) {acc.declare = #acc.declare} : !fir.ref> -! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) -> !fir.ref> {name = "v2", structured = false} +! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) -> !fir.ref> {name = "v2"} ! CHECK: acc.declare_enter dataOperands(%[[CREATE]] : !fir.ref>) ! CHECK: acc.terminator ! CHECK: } ! CHECK-LABEL: acc.global_dtor @_QMacc_declare_equivalentEv2_acc_dtor { ! CHECK: %[[ADDR:.*]] = fir.address_of(@_QMacc_declare_equivalentEv1) {acc.declare = #acc.declare} : !fir.ref> -! CHECK: %[[DEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[ADDR]] : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "v2", structured = false} +! CHECK: %[[DEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[ADDR]] : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "v2"} ! CHECK: acc.declare_exit dataOperands(%[[DEVICEPTR]] : !fir.ref>) -! CHECK: acc.delete accPtr(%[[DEVICEPTR]] : !fir.ref>) {dataClause = #acc, name = "v2", structured = false} +! CHECK: acc.delete accPtr(%[[DEVICEPTR]] : !fir.ref>) {dataClause = #acc, name = "v2"} ! CHECK: acc.terminator ! CHECK: } @@ -421,15 +421,15 @@ module acc_declare_equivalent2 ! CHECK-LABEL: acc.global_ctor @_QMacc_declare_equivalent2Ev2_acc_ctor { ! CHECK: %[[ADDR:.*]] = fir.address_of(@_QMacc_declare_equivalent2Ev1) {acc.declare = #acc.declare} : !fir.ref> -! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) -> !fir.ref> {name = "v2", structured = false} +! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) -> !fir.ref> {name = "v2"} ! CHECK: acc.declare_enter dataOperands(%[[CREATE]] : !fir.ref>) ! CHECK: acc.terminator ! CHECK: } ! CHECK-LABEL: acc.global_dtor @_QMacc_declare_equivalent2Ev2_acc_dtor { ! CHECK: %[[ADDR:.*]] = fir.address_of(@_QMacc_declare_equivalent2Ev1) {acc.declare = #acc.declare} : !fir.ref> -! CHECK: %[[DEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[ADDR]] : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "v2", structured = false} +! CHECK: %[[DEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[ADDR]] : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "v2"} ! CHECK: acc.declare_exit dataOperands(%[[DEVICEPTR]] : !fir.ref>) -! CHECK: acc.delete accPtr(%[[DEVICEPTR]] : !fir.ref>) {dataClause = #acc, name = "v2", structured = false} +! CHECK: acc.delete accPtr(%[[DEVICEPTR]] : !fir.ref>) {dataClause = #acc, name = "v2"} ! CHECK: acc.terminator ! CHECK: } diff --git a/flang/test/Lower/OpenACC/acc-declare.f90 b/flang/test/Lower/OpenACC/acc-declare.f90 index 889cdef51f4ce..534df44782c0f 100644 --- a/flang/test/Lower/OpenACC/acc-declare.f90 +++ b/flang/test/Lower/OpenACC/acc-declare.f90 @@ -250,14 +250,14 @@ subroutine acc_declare_allocate() ! CHECK-LABEL: func.func private @_QMacc_declareFacc_declare_allocateEa_acc_declare_update_desc_post_alloc( ! CHECK-SAME: %[[ARG0:.*]]: !fir.ref>>>) { -! CHECK: %[[UPDATE:.*]] = acc.update_device varPtr(%[[ARG0]] : !fir.ref>>>) -> !fir.ref>>> {implicit = true, name = "a", structured = false} +! CHECK: %[[UPDATE:.*]] = acc.update_device varPtr(%[[ARG0]] : !fir.ref>>>) -> !fir.ref>>> {implicit = true, name = "a"} ! CHECK: acc.update dataOperands(%[[UPDATE]] : !fir.ref>>>) ! CHECK: return ! CHECK: } ! CHECK-LABEL: func.func private @_QMacc_declareFacc_declare_allocateEa_acc_declare_update_desc_post_dealloc( ! CHECK-SAME: %[[ARG0:.*]]: !fir.ref>>>) { -! CHECK: %[[UPDATE:.*]] = acc.update_device varPtr(%[[ARG0]] : !fir.ref>>>) -> !fir.ref>>> {implicit = true, name = "a", structured = false} +! CHECK: %[[UPDATE:.*]] = acc.update_device varPtr(%[[ARG0]] : !fir.ref>>>) -> !fir.ref>>> {implicit = true, name = "a"} ! CHECK: acc.update dataOperands(%[[UPDATE]] : !fir.ref>>>) ! CHECK: return ! CHECK: } @@ -323,30 +323,30 @@ module acc_declare_allocatable_test ! CHECK-LABEL: acc.global_ctor @_QMacc_declare_allocatable_testEdata1_acc_ctor { ! CHECK: %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_allocatable_testEdata1) {acc.declare = #acc.declare} : !fir.ref>>> -! CHECK: %[[COPYIN:.*]] = acc.copyin varPtr(%[[GLOBAL_ADDR]] : !fir.ref>>>) -> !fir.ref>>> {dataClause = #acc, implicit = true, name = "data1", structured = false} +! CHECK: %[[COPYIN:.*]] = acc.copyin varPtr(%[[GLOBAL_ADDR]] : !fir.ref>>>) -> !fir.ref>>> {dataClause = #acc, implicit = true, name = "data1"} ! CHECK: acc.declare_enter dataOperands(%[[COPYIN]] : !fir.ref>>>) ! CHECK: acc.terminator ! CHECK: } ! CHECK-LABEL: func.func private @_QMacc_declare_allocatable_testEdata1_acc_declare_update_desc_post_alloc() { ! CHECK: %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_allocatable_testEdata1) : !fir.ref>>> -! CHECK: %[[UPDATE:.*]] = acc.update_device varPtr(%[[GLOBAL_ADDR]] : !fir.ref>>>) -> !fir.ref>>> {implicit = true, name = "data1", structured = false} +! CHECK: %[[UPDATE:.*]] = acc.update_device varPtr(%[[GLOBAL_ADDR]] : !fir.ref>>>) -> !fir.ref>>> {implicit = true, name = "data1"} ! CHECK: acc.update dataOperands(%[[UPDATE]] : !fir.ref>>>) ! CHECK: return ! CHECK: } ! CHECK-LABEL: func.func private @_QMacc_declare_allocatable_testEdata1_acc_declare_update_desc_post_dealloc() { ! CHECK: %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_allocatable_testEdata1) : !fir.ref>>> -! CHECK: %[[UPDATE:.*]] = acc.update_device varPtr(%[[GLOBAL_ADDR]] : !fir.ref>>>) -> !fir.ref>>> {implicit = true, name = "data1", structured = false} +! CHECK: %[[UPDATE:.*]] = acc.update_device varPtr(%[[GLOBAL_ADDR]] : !fir.ref>>>) -> !fir.ref>>> {implicit = true, name = "data1"} ! CHECK: acc.update dataOperands(%[[UPDATE]] : !fir.ref>>>) ! CHECK: return ! CHECK: } ! CHECK-LABEL: acc.global_dtor @_QMacc_declare_allocatable_testEdata1_acc_dtor { ! CHECK: %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_allocatable_testEdata1) {acc.declare = #acc.declare} : !fir.ref>>> -! CHECK: %[[DEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[GLOBAL_ADDR]] : !fir.ref>>>) -> !fir.ref>>> {dataClause = #acc, name = "data1", structured = false} +! CHECK: %[[DEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[GLOBAL_ADDR]] : !fir.ref>>>) -> !fir.ref>>> {dataClause = #acc, name = "data1"} ! CHECK: acc.declare_exit dataOperands(%[[DEVICEPTR]] : !fir.ref>>>) -! CHECK: acc.delete accPtr(%[[DEVICEPTR]] : !fir.ref>>>) {dataClause = #acc, name = "data1", structured = false} +! CHECK: acc.delete accPtr(%[[DEVICEPTR]] : !fir.ref>>>) {dataClause = #acc, name = "data1"} ! CHECK: acc.terminator ! CHECK: } @@ -361,15 +361,15 @@ module acc_declare_equivalent ! CHECK-LABEL: acc.global_ctor @_QMacc_declare_equivalentEv2_acc_ctor { ! CHECK: %[[ADDR:.*]] = fir.address_of(@_QMacc_declare_equivalentEv1) {acc.declare = #acc.declare} : !fir.ref> -! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) -> !fir.ref> {name = "v2", structured = false} +! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) -> !fir.ref> {name = "v2"} ! CHECK: acc.declare_enter dataOperands(%[[CREATE]] : !fir.ref>) ! CHECK: acc.terminator ! CHECK: } ! CHECK-LABEL: acc.global_dtor @_QMacc_declare_equivalentEv2_acc_dtor { ! CHECK: %[[ADDR:.*]] = fir.address_of(@_QMacc_declare_equivalentEv1) {acc.declare = #acc.declare} : !fir.ref> -! CHECK: %[[DEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[ADDR]] : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "v2", structured = false} +! CHECK: %[[DEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[ADDR]] : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "v2"} ! CHECK: acc.declare_exit dataOperands(%[[DEVICEPTR]] : !fir.ref>) -! CHECK: acc.delete accPtr(%[[DEVICEPTR]] : !fir.ref>) {dataClause = #acc, name = "v2", structured = false} +! CHECK: acc.delete accPtr(%[[DEVICEPTR]] : !fir.ref>) {dataClause = #acc, name = "v2"} ! CHECK: acc.terminator ! CHECK: } @@ -382,15 +382,15 @@ module acc_declare_equivalent2 ! CHECK-LABEL: acc.global_ctor @_QMacc_declare_equivalent2Ev2_acc_ctor { ! CHECK: %[[ADDR:.*]] = fir.address_of(@_QMacc_declare_equivalent2Ev1) {acc.declare = #acc.declare} : !fir.ref> -! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) -> !fir.ref> {name = "v2", structured = false} +! CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) -> !fir.ref> {name = "v2"} ! CHECK: acc.declare_enter dataOperands(%[[CREATE]] : !fir.ref>) ! CHECK: acc.terminator ! CHECK: } ! CHECK-LABEL: acc.global_dtor @_QMacc_declare_equivalent2Ev2_acc_dtor { ! CHECK: %[[ADDR:.*]] = fir.address_of(@_QMacc_declare_equivalent2Ev1) {acc.declare = #acc.declare} : !fir.ref> -! CHECK: %[[DEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[ADDR]] : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "v2", structured = false} +! CHECK: %[[DEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[ADDR]] : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "v2"} ! CHECK: acc.declare_exit dataOperands(%[[DEVICEPTR]] : !fir.ref>) -! CHECK: acc.delete accPtr(%[[DEVICEPTR]] : !fir.ref>) {dataClause = #acc, name = "v2", structured = false} +! CHECK: acc.delete accPtr(%[[DEVICEPTR]] : !fir.ref>) {dataClause = #acc, name = "v2"} ! CHECK: acc.terminator ! CHECK: } diff --git a/flang/test/Lower/OpenACC/acc-enter-data-unwrap-defaultbounds.f90 b/flang/test/Lower/OpenACC/acc-enter-data-unwrap-defaultbounds.f90 index c42350a07c498..925d4b93b754e 100644 --- a/flang/test/Lower/OpenACC/acc-enter-data-unwrap-defaultbounds.f90 +++ b/flang/test/Lower/OpenACC/acc-enter-data-unwrap-defaultbounds.f90 @@ -27,7 +27,7 @@ subroutine acc_enter_data !CHECK: %[[LB:.*]] = arith.constant 0 : index !CHECK: %[[UB:.*]] = arith.subi %[[EXTENT_C10]], %[[ONE]] : index !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[EXTENT_C10]] : index) stride(%c1{{.*}} : index) startIdx(%[[ONE]] : index) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a"} !CHECK: acc.enter_data dataOperands(%[[CREATE_A]] : !fir.ref>){{$}} !$acc enter data create(a) if(.true.) @@ -38,7 +38,7 @@ subroutine acc_enter_data !CHECK: %[[LB:.*]] = arith.constant 0 : index !CHECK: %[[UB:.*]] = arith.subi %[[EXTENT_C10]], %[[ONE]] : index !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[EXTENT_C10]] : index) stride(%c1{{.*}} : index) startIdx(%[[ONE]] : index) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a"} !CHECK: [[IF1:%.*]] = arith.constant true !CHECK: acc.enter_data if([[IF1]]) dataOperands(%[[CREATE_A]] : !fir.ref>){{$}} @@ -50,7 +50,7 @@ subroutine acc_enter_data !CHECK: %[[LB:.*]] = arith.constant 0 : index !CHECK: %[[UB:.*]] = arith.subi %[[EXTENT_C10]], %[[ONE]] : index !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[EXTENT_C10]] : index) stride(%c1{{.*}} : index) startIdx(%[[ONE]] : index) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a"} !CHECK: [[IFCOND:%.*]] = fir.load %{{.*}} : !fir.ref> !CHECK: [[IF2:%.*]] = fir.convert [[IFCOND]] : (!fir.logical<4>) -> i1 !CHECK: acc.enter_data if([[IF2]]) dataOperands(%[[CREATE_A]] : !fir.ref>){{$}} @@ -58,62 +58,62 @@ subroutine acc_enter_data !$acc enter data create(a) create(b) create(c) !CHECK: %[[BOUND0:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[EXTENT_C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a"} !CHECK: %[[BOUND0:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%c10_{{.*}} : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%c10_{{.*}} : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) -!CHECK: %[[CREATE_B:.*]] = acc.create varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "b", structured = false} +!CHECK: %[[CREATE_B:.*]] = acc.create varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "b"} !CHECK: %[[BOUND0:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%c10_{{.*}} : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%c10_{{.*}} : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) -!CHECK: %[[CREATE_C:.*]] = acc.create varPtr(%[[DECLC]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "c", structured = false} +!CHECK: %[[CREATE_C:.*]] = acc.create varPtr(%[[DECLC]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "c"} !CHECK: acc.enter_data dataOperands(%[[CREATE_A]], %[[CREATE_B]], %[[CREATE_C]] : !fir.ref>, !fir.ref>, !fir.ref>){{$}} !$acc enter data create(a) create(b) create(zero: c) !CHECK: %[[BOUND0:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[EXTENT_C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a"} !CHECK: %[[BOUND0:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%c10_{{.*}} : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%c10_{{.*}} : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) -!CHECK: %[[CREATE_B:.*]] = acc.create varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "b", structured = false} +!CHECK: %[[CREATE_B:.*]] = acc.create varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "b"} !CHECK: %[[BOUND0:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%c10_{{.*}} : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%c10_{{.*}} : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) -!CHECK: %[[CREATE_C:.*]] = acc.create varPtr(%[[DECLC]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {dataClause = #acc, name = "c", structured = false} +!CHECK: %[[CREATE_C:.*]] = acc.create varPtr(%[[DECLC]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {dataClause = #acc, name = "c"} !CHECK: acc.enter_data dataOperands(%[[CREATE_A]], %[[CREATE_B]], %[[CREATE_C]] : !fir.ref>, !fir.ref>, !fir.ref>){{$}} !$acc enter data copyin(a) create(b) attach(d) !CHECK: %[[BOUND0:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[EXTENT_C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) -!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a"} !CHECK: %[[BOUND0:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%c10_{{.*}} : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%c10_{{.*}} : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) -!CHECK: %[[CREATE_B:.*]] = acc.create varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "b", structured = false} +!CHECK: %[[CREATE_B:.*]] = acc.create varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "b"} !CHECK: %[[BOX_D:.*]] = fir.load %[[DECLD]]#0 : !fir.ref>> !CHECK: %[[BOX_ADDR_D:.*]] = fir.box_addr %[[BOX_D]] : (!fir.box>) -> !fir.ptr -!CHECK: %[[ATTACH_D:.*]] = acc.attach varPtr(%[[BOX_ADDR_D]] : !fir.ptr) -> !fir.ptr {name = "d", structured = false} +!CHECK: %[[ATTACH_D:.*]] = acc.attach varPtr(%[[BOX_ADDR_D]] : !fir.ptr) -> !fir.ptr {name = "d"} !CHECK: acc.enter_data dataOperands(%[[COPYIN_A]], %[[CREATE_B]], %[[ATTACH_D]] : !fir.ref>, !fir.ref>, !fir.ptr){{$}} !$acc enter data create(a) async !CHECK: %[[BOUND0:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[EXTENT_C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {asyncOnly = [#acc.device_type], name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a"} !CHECK: acc.enter_data dataOperands(%[[CREATE_A]] : !fir.ref>) attributes {async} !$acc enter data create(a) wait !CHECK: %[[BOUND0:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[EXTENT_C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a"} !CHECK: acc.enter_data dataOperands(%[[CREATE_A]] : !fir.ref>) attributes {wait} !$acc enter data create(a) async wait !CHECK: %[[BOUND0:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[EXTENT_C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {asyncOnly = [#acc.device_type], name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a"} !CHECK: acc.enter_data dataOperands(%[[CREATE_A]] : !fir.ref>) attributes {async, wait} !$acc enter data create(a) async(1) !CHECK: %[[ASYNC1:.*]] = arith.constant 1 : i32 !CHECK: %[[BOUND0:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[EXTENT_C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) async(%[[ASYNC1]] : i32) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a"} !CHECK: acc.enter_data async(%[[ASYNC1]] : i32) dataOperands(%[[CREATE_A]] : !fir.ref>) !$acc enter data create(a) async(async) @@ -121,20 +121,20 @@ subroutine acc_enter_data !CHECK: %[[BOUND0:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[EXTENT_C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) async(%[[ASYNC2]] : i32) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a"} !CHECK: acc.enter_data async(%[[ASYNC2]] : i32) dataOperands(%[[CREATE_A]] : !fir.ref>) !$acc enter data create(a) wait(1) !CHECK: %[[BOUND0:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[EXTENT_C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a"} !CHECK: %[[WAIT1:.*]] = arith.constant 1 : i32 !CHECK: acc.enter_data wait(%[[WAIT1]] : i32) dataOperands(%[[CREATE_A]] : !fir.ref>) !$acc enter data create(a) wait(queues: 1, 2) !CHECK: %[[BOUND0:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[EXTENT_C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a"} !CHECK: %[[WAIT2:.*]] = arith.constant 1 : i32 !CHECK: %[[WAIT3:.*]] = arith.constant 2 : i32 !CHECK: acc.enter_data wait(%[[WAIT2]], %[[WAIT3]] : i32, i32) dataOperands(%[[CREATE_A]] : !fir.ref>) @@ -142,7 +142,7 @@ subroutine acc_enter_data !$acc enter data create(a) wait(devnum: 1: queues: 1, 2) !CHECK: %[[BOUND0:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[EXTENT_C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a"} !CHECK: %[[WAIT4:.*]] = arith.constant 1 : i32 !CHECK: %[[WAIT5:.*]] = arith.constant 2 : i32 !CHECK: %[[WAIT6:.*]] = arith.constant 1 : i32 @@ -151,7 +151,7 @@ subroutine acc_enter_data !$acc enter data copyin(a(1:10,1:5)) !CHECK: %[[BOUND0:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[EXTENT_C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) -!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a(1:10,1:5)", structured = false} +!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a(1:10,1:5)"} !CHECK: acc.enter_data dataOperands(%[[COPYIN_A]] : !fir.ref>) !$acc enter data copyin(a(1:,1:5)) @@ -162,7 +162,7 @@ subroutine acc_enter_data !CHECK: %[[LB2:.*]] = arith.constant 0 : index !CHECK: %[[UB2:.*]] = arith.constant 4 : index !CHECK: %[[BOUND2:.*]] = acc.bounds lowerbound(%[[LB2]] : index) upperbound(%[[UB2]] : index) extent(%[[EXTENT_C10]] : index) stride(%c1{{.*}} : index) startIdx(%c1{{.*}} : index) -!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND1]], %[[BOUND2]]) -> !fir.ref> {name = "a(1:,1:5)", structured = false} +!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND1]], %[[BOUND2]]) -> !fir.ref> {name = "a(1:,1:5)"} !CHECK: acc.enter_data dataOperands(%[[COPYIN_A]] : !fir.ref>) !$acc enter data copyin(a(:10,1:5)) @@ -173,7 +173,7 @@ subroutine acc_enter_data !CHECK: %[[LB:.*]] = arith.constant 0 : index !CHECK: %[[UB2:.*]] = arith.constant 4 : index !CHECK: %[[BOUND2:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB2]] : index) extent(%[[EXTENT_C10]] : index) stride(%c1{{.*}} : index) startIdx(%[[ONE]] : index) -!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND1]], %[[BOUND2]]) -> !fir.ref> {name = "a(:10,1:5)", structured = false} +!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND1]], %[[BOUND2]]) -> !fir.ref> {name = "a(:10,1:5)"} !CHECK: acc.enter_data dataOperands(%[[COPYIN_A]] : !fir.ref>) !$acc enter data copyin(a(:,:)) @@ -183,7 +183,7 @@ subroutine acc_enter_data !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%c10{{.*}} : index) stride(%[[ONE]] : index) startIdx(%[[ONE]] : index) !CHECK: %[[UB:.*]] = arith.subi %c10{{.*}}, %[[ONE]] : index !CHECK: %[[BOUND2:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%c10{{.*}} : index) stride(%c1{{.*}} : index) startIdx(%[[ONE]] : index) -!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND1]], %[[BOUND2]]) -> !fir.ref> {name = "a(:,:)", structured = false} +!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND1]], %[[BOUND2]]) -> !fir.ref> {name = "a(:,:)"} end subroutine acc_enter_data subroutine acc_enter_data_dummy(a, b, n, m) @@ -213,14 +213,14 @@ subroutine acc_enter_data_dummy(a, b, n, m) !$acc enter data create(a) !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%c10{{.*}} : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(b) !CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[DECLB]]#0, %c0{{.*}} : (!fir.box>, index) -> (index, index, index) !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[DIMS]]#1 : index) stride(%[[DIMS]]#2 : index) startIdx(%{{.*}} : index) {strideInBytes = true} !CHECK: %[[ADDR:.*]] = fir.box_addr %[[DECLB]]#0 : (!fir.box>) -> !fir.ref> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "b", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "b"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(a(5:10)) @@ -228,7 +228,7 @@ subroutine acc_enter_data_dummy(a, b, n, m) !CHECK: %[[LB1:.*]] = arith.constant 4 : index !CHECK: %[[UB1:.*]] = arith.constant 9 : index !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%[[LB1]] : index) upperbound(%[[UB1]] : index) extent(%c10{{.*}} : index) stride(%[[ONE]] : index) startIdx(%c1{{.*}} : index) -!CHECK: %[[CREATE1:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND1]]) -> !fir.ref> {name = "a(5:10)", structured = false} +!CHECK: %[[CREATE1:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND1]]) -> !fir.ref> {name = "a(5:10)"} !CHECK: acc.enter_data dataOperands(%[[CREATE1]] : !fir.ref>) !$acc enter data create(b(n:m)) @@ -243,7 +243,7 @@ subroutine acc_enter_data_dummy(a, b, n, m) !CHECK: %[[UB:.*]] = arith.subi %[[M_CONV2]], %[[N_IDX]] : index !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[EXT_B]] : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[N_IDX]] : index) {strideInBytes = true} !CHECK: %[[ADDR:.*]] = fir.box_addr %[[DECLB]]#0 : (!fir.box>) -> !fir.ref> -!CHECK: %[[CREATE1:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) bounds(%[[BOUND1]]) -> !fir.ref> {name = "b(n:m)", structured = false} +!CHECK: %[[CREATE1:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) bounds(%[[BOUND1]]) -> !fir.ref> {name = "b(n:m)"} !CHECK: acc.enter_data dataOperands(%[[CREATE1]] : !fir.ref>) !$acc enter data create(b(n:)) @@ -256,7 +256,7 @@ subroutine acc_enter_data_dummy(a, b, n, m) !CHECK: %[[UB:.*]] = arith.subi %[[EXT_B]], %c1{{.*}} : index !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[EXT_B]] : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[N_IDX]] : index) {strideInBytes = true} !CHECK: %[[ADDR:.*]] = fir.box_addr %[[DECLB]]#0 : (!fir.box>) -> !fir.ref> -!CHECK: %[[CREATE1:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) bounds(%[[BOUND1]]) -> !fir.ref> {name = "b(n:)", structured = false} +!CHECK: %[[CREATE1:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) bounds(%[[BOUND1]]) -> !fir.ref> {name = "b(n:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE1]] : !fir.ref>) !$acc enter data create(b(:)) @@ -266,7 +266,7 @@ subroutine acc_enter_data_dummy(a, b, n, m) !CHECK: %[[UB:.*]] = arith.subi %[[EXT_B]], %[[ONE]] : index !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%[[ZERO]] : index) upperbound(%[[UB]] : index) extent(%[[EXT_B]] : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[N_IDX]] : index) {strideInBytes = true} !CHECK: %[[ADDR:.*]] = fir.box_addr %[[DECLB]]#0 : (!fir.box>) -> !fir.ref> -!CHECK: %[[CREATE1:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) bounds(%[[BOUND1]]) -> !fir.ref> {name = "b(:)", structured = false} +!CHECK: %[[CREATE1:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) bounds(%[[BOUND1]]) -> !fir.ref> {name = "b(:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE1]] : !fir.ref>) end subroutine @@ -291,7 +291,7 @@ subroutine acc_enter_data_non_default_lb() !CHECK: %[[UB:.*]] = arith.subi %[[SECTIONUB]], %[[BASELB]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%c10{{.*}} : index) stride(%{{.*}} : index) startIdx(%[[BASELB]] : index) !CHECK: %[[ADDR:.*]] = fir.box_addr %[[DECLA]]#0 : (!fir.box>) -> !fir.ref> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(5:9)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(5:9)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(a(:)) @@ -300,7 +300,7 @@ subroutine acc_enter_data_non_default_lb() !CHECK: %[[UB:.*]] = arith.subi %[[EXTENT_C10]], %[[ONE]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[ZERO]] : index) upperbound(%[[UB]] : index) extent(%[[EXTENT_C10]] : index) stride(%{{.*}} : index) startIdx(%[[BASELB]] : index) !CHECK: %[[ADDR:.*]] = fir.box_addr %[[DECLA]]#0 : (!fir.box>) -> !fir.ref> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(:)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(a(:6)) @@ -309,7 +309,7 @@ subroutine acc_enter_data_non_default_lb() !CHECK: %[[UB:.*]] = arith.subi %[[SECTIONUB]], %[[BASELB]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[ZERO]] : index) upperbound(%[[UB]] : index) extent(%c10{{.*}} : index) stride(%{{.*}} : index) startIdx(%[[BASELB]] : index) !CHECK: %[[ADDR:.*]] = fir.box_addr %[[DECLA]]#0 : (!fir.box>) -> !fir.ref> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(:6)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(:6)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(a(4:)) @@ -319,7 +319,7 @@ subroutine acc_enter_data_non_default_lb() !CHECK: %[[UB:.*]] = arith.subi %[[EXTENT_C10]], %[[ONE]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[EXTENT_C10]] : index) stride(%{{.*}} : index) startIdx(%[[BASELB]] : index) !CHECK: %[[ADDR:.*]] = fir.box_addr %[[DECLA]]#0 : (!fir.box>) -> !fir.ref> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(4:)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(4:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(b) @@ -329,7 +329,7 @@ subroutine acc_enter_data_non_default_lb() !CHECK: %[[UB:.*]] = arith.subi %[[DIMS0]]#1, %[[ONE]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%c0{{.*}} : index) upperbound(%[[UB]] : index) extent(%[[DIMS0]]#1 : index) stride(%{{.*}} : index) startIdx(%c11{{.*}} : index) {strideInBytes = true} !CHECK: %[[ADDR:.*]] = fir.box_addr %[[DECLB]]#0 : (!fir.box>) -> !fir.ref> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "b", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "b"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) end subroutine @@ -357,7 +357,7 @@ subroutine acc_enter_data_assumed(a, b, n, m) !CHECK: %[[UB:.*]] = arith.subi %[[DIMS]]#1, %[[C1]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS]]#1 : index) stride(%[[DIMS]]#2 : index) startIdx(%[[C1]] : index) {strideInBytes = true} !CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[DECLA]]#0 : (!fir.box>) -> !fir.ref> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(a(:)) @@ -373,7 +373,7 @@ subroutine acc_enter_data_assumed(a, b, n, m) !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS1]]#1 : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[ONE]] : index) {strideInBytes = true} !CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[DECLA]]#0 : (!fir.box>) -> !fir.ref> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(:)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(a(2:)) @@ -389,7 +389,7 @@ subroutine acc_enter_data_assumed(a, b, n, m) !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS1]]#1 : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[ONE]] : index) {strideInBytes = true} !CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[DECLA]]#0 : (!fir.box>) -> !fir.ref> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(2:)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(2:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(a(:4)) @@ -403,7 +403,7 @@ subroutine acc_enter_data_assumed(a, b, n, m) !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS1]]#1 : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[ONE]] : index) {strideInBytes = true} !CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[DECLA]]#0 : (!fir.box>) -> !fir.ref> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(:4)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(:4)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(a(6:10)) @@ -417,7 +417,7 @@ subroutine acc_enter_data_assumed(a, b, n, m) !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS1]]#1 : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[ONE]] : index) {strideInBytes = true} !CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[DECLA]]#0 : (!fir.box>) -> !fir.ref> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(6:10)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(6:10)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(a(n:)) @@ -437,7 +437,7 @@ subroutine acc_enter_data_assumed(a, b, n, m) !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS]]#1 : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[ONE]] : index) {strideInBytes = true} !CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[DECLA]]#0 : (!fir.box>) -> !fir.ref> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(n:)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(n:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(a(:m)) @@ -455,7 +455,7 @@ subroutine acc_enter_data_assumed(a, b, n, m) !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[BASELB]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS1]]#1 : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[ONE]] : index) {strideInBytes = true} !CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[DECLA]]#0 : (!fir.box>) -> !fir.ref> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(:m)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(:m)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(a(n:m)) @@ -477,7 +477,7 @@ subroutine acc_enter_data_assumed(a, b, n, m) !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS1]]#1 : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[ONE]] : index) {strideInBytes = true} !CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[DECLA]]#0 : (!fir.box>) -> !fir.ref> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(n:m)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(n:m)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(b(:m)) @@ -494,7 +494,7 @@ subroutine acc_enter_data_assumed(a, b, n, m) !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[ZERO]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS1]]#1 : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[LB_C10_IDX]] : index) {strideInBytes = true} !CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[DECLB]]#0 : (!fir.box>) -> !fir.ref> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "b(:m)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "b(:m)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(b) @@ -507,7 +507,7 @@ subroutine acc_enter_data_assumed(a, b, n, m) !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[C0]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS0]]#1 : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[LB_C10_IDX]] : index) {strideInBytes = true} !CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[DECLB]]#0 : (!fir.box>) -> !fir.ref> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "b", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "b"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) end subroutine @@ -533,7 +533,7 @@ subroutine acc_enter_data_allocatable() !CHECK: %[[UB:.*]] = arith.subi %[[DIMS1]]#1, %c1{{.*}} : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%c0{{.*}} : index) upperbound(%[[UB]] : index) extent(%[[DIMS1]]#1 : index) stride(%[[DIMS1]]#2 : index) startIdx(%[[DIMS0]]#0 : index) {strideInBytes = true} !CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[BOX_A_0]] : (!fir.box>>) -> !fir.heap> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.heap>) bounds(%[[BOUND]]) -> !fir.heap> {name = "a", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.heap>) bounds(%[[BOUND]]) -> !fir.heap> {name = "a"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.heap>) !$acc enter data create(a(:)) @@ -554,7 +554,7 @@ subroutine acc_enter_data_allocatable() !CHECK: %[[UB:.*]] = arith.subi %[[DIMS2]]#1, %[[ONE]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[ZERO]] : index) upperbound(%[[UB:.*]] : index) extent(%[[DIMS2]]#1 : index) stride(%[[DIMS1]]#2 : index) startIdx(%[[DIMS0]]#0 : index) {strideInBytes = true} !CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[BOX_A_0]] : (!fir.box>>) -> !fir.heap> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.heap>) bounds(%[[BOUND]]) -> !fir.heap> {name = "a(:)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.heap>) bounds(%[[BOUND]]) -> !fir.heap> {name = "a(:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.heap>) !$acc enter data create(a(2:5)) @@ -575,7 +575,7 @@ subroutine acc_enter_data_allocatable() !CHECK: %[[DIMS2:.*]]:3 = fir.box_dims %[[BOX_A_2]], %[[C0]] : (!fir.box>>, index) -> (index, index, index) !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS2]]#1 : index) stride(%[[DIMS1]]#2 : index) startIdx(%[[DIMS0]]#0 : index) {strideInBytes = true} !CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[BOX_A_0]] : (!fir.box>>) -> !fir.heap> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.heap>) bounds(%[[BOUND]]) -> !fir.heap> {name = "a(2:5)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.heap>) bounds(%[[BOUND]]) -> !fir.heap> {name = "a(2:5)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.heap>) !$acc enter data create(a(3:)) @@ -597,7 +597,7 @@ subroutine acc_enter_data_allocatable() !CHECK: %[[UB:.*]] = arith.subi %[[DIMS2]]#1, %[[ONE]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS2]]#1 : index) stride(%[[DIMS1]]#2 : index) startIdx(%[[DIMS0]]#0 : index) {strideInBytes = true} !CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[BOX_A_0]] : (!fir.box>>) -> !fir.heap> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.heap>) bounds(%[[BOUND]]) -> !fir.heap> {name = "a(3:)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.heap>) bounds(%[[BOUND]]) -> !fir.heap> {name = "a(3:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.heap>) !$acc enter data create(a(:7)) @@ -617,14 +617,14 @@ subroutine acc_enter_data_allocatable() !CHECK: %[[DIMS2:.*]]:3 = fir.box_dims %[[BOX_A_2]], %[[C0]] : (!fir.box>>, index) -> (index, index, index) !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[ZERO]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS2]]#1 : index) stride(%[[DIMS1]]#2 : index) startIdx(%[[DIMS0]]#0 : index) {strideInBytes = true} !CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[BOX_A_0]] : (!fir.box>>) -> !fir.heap> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.heap>) bounds(%[[BOUND]]) -> !fir.heap> {name = "a(:7)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.heap>) bounds(%[[BOUND]]) -> !fir.heap> {name = "a(:7)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.heap>) !$acc enter data create(i) !CHECK: %[[BOX_I:.*]] = fir.load %[[DECLI]]#0 : !fir.ref>> !CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[BOX_I]] : (!fir.box>) -> !fir.heap -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.heap) -> !fir.heap {name = "i", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.heap) -> !fir.heap {name = "i"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.heap) end subroutine @@ -669,7 +669,7 @@ subroutine acc_enter_data_derived_type() !CHECK: %[[DATA_COORD:.*]] = hlfir.designate %[[DECLA]]#0{"data"} : (!fir.ref}>>) -> !fir.ref -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DATA_COORD]] : !fir.ref) -> !fir.ref {name = "a%data", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DATA_COORD]] : !fir.ref) -> !fir.ref {name = "a%data"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref) !$acc enter data create(b%d%data) @@ -678,7 +678,7 @@ subroutine acc_enter_data_derived_type() !CHECK: %[[D_COORD:.*]] = hlfir.designate %[[DECLB]]#0{"d"} : (!fir.ref}>}>>) -> !fir.ref}>> !CHECK: %[[DATA_COORD:.*]] = hlfir.designate %[[D_COORD]]{"data"} : (!fir.ref}>>) -> !fir.ref -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DATA_COORD]] : !fir.ref) -> !fir.ref {name = "b%d%data", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DATA_COORD]] : !fir.ref) -> !fir.ref {name = "b%d%data"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref) !$acc enter data create(a%array) @@ -690,7 +690,7 @@ subroutine acc_enter_data_derived_type() !CHECK: %[[LB:.*]] = arith.constant 0 : index !CHECK: %[[UB:.*]] = arith.subi %[[C10]], %[[C1]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[C10]] : index) stride(%[[C1]] : index) startIdx(%[[C1]] : index) -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a%array", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a%array"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(a%array(:)) @@ -702,7 +702,7 @@ subroutine acc_enter_data_derived_type() !CHECK: %[[C1:.*]] = arith.constant 1 : index !CHECK: %[[UB:.*]] = arith.subi %[[C10]], %[[C1]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[C10]] : index) stride(%[[C1]] : index) startIdx(%[[C1]] : index) -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a%array(:)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a%array(:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(a%array(1:5)) @@ -713,7 +713,7 @@ subroutine acc_enter_data_derived_type() !CHECK: %[[C0:.*]] = arith.constant 0 : index !CHECK: %[[C4:.*]] = arith.constant 4 : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[C0]] : index) upperbound(%[[C4]] : index) extent(%[[C10]] : index) stride(%[[C1]] : index) startIdx(%[[C1]] : index) -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a%array(1:5)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a%array(1:5)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(a%array(:5)) @@ -724,7 +724,7 @@ subroutine acc_enter_data_derived_type() !CHECK: %[[C1:.*]] = arith.constant 1 : index !CHECK: %[[C4:.*]] = arith.constant 4 : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[C4]] : index) extent(%[[C10]] : index) stride(%[[C1]] : index) startIdx(%[[C1]] : index) -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a%array(:5)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a%array(:5)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(a%array(2:)) @@ -736,7 +736,7 @@ subroutine acc_enter_data_derived_type() !CHECK: %[[LB:.*]] = arith.constant 1 : index !CHECK: %[[UB:.*]] = arith.subi %[[C10]], %[[ONE]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[C10]] : index) stride(%[[ONE]] : index) startIdx(%[[ONE]] : index) -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a%array(2:)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a%array(2:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(b%d%array) @@ -750,7 +750,7 @@ subroutine acc_enter_data_derived_type() !CHECK: %[[LB:.*]] = arith.constant 0 : index !CHECK: %[[UB:.*]] = arith.subi %[[C10]], %[[C1]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[C10]] : index) stride(%[[C1]] : index) startIdx(%[[C1]] : index) -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "b%d%array", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "b%d%array"} !$acc enter data create(c%data) @@ -765,7 +765,7 @@ subroutine acc_enter_data_derived_type() !CHECK: %[[UB:.*]] = arith.subi %[[DIMS0_1]]#1, %[[ONE]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%c0{{.*}} : index) upperbound(%[[UB]] : index) extent(%[[DIMS0_1]]#1 : index) stride(%[[DIMS0_1]]#2 : index) startIdx(%[[DIMS0]]#0 : index) {strideInBytes = true} !CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[DATA_BOX]] : (!fir.box>>) -> !fir.heap> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.heap>) bounds(%[[BOUND]]) -> !fir.heap> {name = "c%data", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[BOX_ADDR]] : !fir.heap>) bounds(%[[BOUND]]) -> !fir.heap> {name = "c%data"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.heap>) !$acc enter data create (d%d(1)%array) @@ -785,7 +785,7 @@ subroutine acc_enter_data_derived_type() !CHECK: %[[LB:.*]] = arith.constant 0 : index !CHECK: %[[UB:.*]] = arith.subi %[[C10]], %[[C1]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[C10]] : index) stride(%[[C1]] : index) startIdx(%[[C1]] : index) -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "d%d(1_8)%array", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "d%d(1_8)%array"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) end subroutine @@ -812,7 +812,7 @@ subroutine acc_enter_data_single_array_element() !CHECK: %[[VAL_46:.*]] = arith.constant 2 : index !CHECK: %[[VAL_47:.*]] = arith.subi %[[VAL_46]], %[[VAL_40]]#0 : index !CHECK: %[[VAL_48:.*]] = acc.bounds lowerbound(%[[VAL_47]] : index) upperbound(%[[VAL_47]] : index) extent(%[[VAL_42]] : index) stride(%[[VAL_42]] : index) startIdx(%[[VAL_40]]#0 : index) -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[VAL_41]] : !fir.heap>) bounds(%[[VAL_45]], %[[VAL_48]]) -> !fir.heap> {name = "e(2_8)%a(1,2)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[VAL_41]] : !fir.heap>) bounds(%[[VAL_45]], %[[VAL_48]]) -> !fir.heap> {name = "e(2_8)%a(1,2)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.heap>) end subroutine diff --git a/flang/test/Lower/OpenACC/acc-enter-data.f90 b/flang/test/Lower/OpenACC/acc-enter-data.f90 index 3e49259c360eb..71d8d8403806e 100644 --- a/flang/test/Lower/OpenACC/acc-enter-data.f90 +++ b/flang/test/Lower/OpenACC/acc-enter-data.f90 @@ -20,73 +20,73 @@ subroutine acc_enter_data !CHECK: %[[DECLD:.*]]:2 = hlfir.declare %[[D]] !$acc enter data create(a) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a"} !CHECK: acc.enter_data dataOperands(%[[CREATE_A]] : !fir.ref>){{$}} !$acc enter data create(a) if(.true.) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a"} !CHECK: [[IF1:%.*]] = arith.constant true !CHECK: acc.enter_data if([[IF1]]) dataOperands(%[[CREATE_A]] : !fir.ref>){{$}} !$acc enter data create(a) if(ifCondition) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a"} !CHECK: [[IFCOND:%.*]] = fir.load %{{.*}} : !fir.ref> !CHECK: [[IF2:%.*]] = fir.convert [[IFCOND]] : (!fir.logical<4>) -> i1 !CHECK: acc.enter_data if([[IF2]]) dataOperands(%[[CREATE_A]] : !fir.ref>){{$}} !$acc enter data create(a) create(b) create(c) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a", structured = false} -!CHECK: %[[CREATE_B:.*]] = acc.create varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {name = "b", structured = false} -!CHECK: %[[CREATE_C:.*]] = acc.create varPtr(%[[DECLC]]#0 : !fir.ref>) -> !fir.ref> {name = "c", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a"} +!CHECK: %[[CREATE_B:.*]] = acc.create varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {name = "b"} +!CHECK: %[[CREATE_C:.*]] = acc.create varPtr(%[[DECLC]]#0 : !fir.ref>) -> !fir.ref> {name = "c"} !CHECK: acc.enter_data dataOperands(%[[CREATE_A]], %[[CREATE_B]], %[[CREATE_C]] : !fir.ref>, !fir.ref>, !fir.ref>){{$}} !$acc enter data create(a) create(b) create(zero: c) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a", structured = false} -!CHECK: %[[CREATE_B:.*]] = acc.create varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {name = "b", structured = false} -!CHECK: %[[CREATE_C:.*]] = acc.create varPtr(%[[DECLC]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "c", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a"} +!CHECK: %[[CREATE_B:.*]] = acc.create varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {name = "b"} +!CHECK: %[[CREATE_C:.*]] = acc.create varPtr(%[[DECLC]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "c"} !CHECK: acc.enter_data dataOperands(%[[CREATE_A]], %[[CREATE_B]], %[[CREATE_C]] : !fir.ref>, !fir.ref>, !fir.ref>){{$}} !$acc enter data copyin(a) create(b) attach(d) -!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a", structured = false} -!CHECK: %[[CREATE_B:.*]] = acc.create varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {name = "b", structured = false} -!CHECK: %[[ATTACH_D:.*]] = acc.attach varPtr(%[[DECLD]]#0 : !fir.ref>>) -> !fir.ref>> {name = "d", structured = false} +!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a"} +!CHECK: %[[CREATE_B:.*]] = acc.create varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {name = "b"} +!CHECK: %[[ATTACH_D:.*]] = acc.attach varPtr(%[[DECLD]]#0 : !fir.ref>>) -> !fir.ref>> {name = "d"} !CHECK: acc.enter_data dataOperands(%[[COPYIN_A]], %[[CREATE_B]], %[[ATTACH_D]] : !fir.ref>, !fir.ref>, !fir.ref>>){{$}} !$acc enter data create(a) async -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {asyncOnly = [#acc.device_type], name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a"} !CHECK: acc.enter_data dataOperands(%[[CREATE_A]] : !fir.ref>) attributes {async} !$acc enter data create(a) wait -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a"} !CHECK: acc.enter_data dataOperands(%[[CREATE_A]] : !fir.ref>) attributes {wait} !$acc enter data create(a) async wait -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {asyncOnly = [#acc.device_type], name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a"} !CHECK: acc.enter_data dataOperands(%[[CREATE_A]] : !fir.ref>) attributes {async, wait} !$acc enter data create(a) async(1) !CHECK: %[[ASYNC1:.*]] = arith.constant 1 : i32 -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) async(%[[ASYNC1]] : i32) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a"} !CHECK: acc.enter_data async(%[[ASYNC1]] : i32) dataOperands(%[[CREATE_A]] : !fir.ref>) !$acc enter data create(a) async(async) !CHECK: %[[ASYNC2:.*]] = fir.load %{{.*}} : !fir.ref -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) async(%[[ASYNC2]] : i32) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a"} !CHECK: acc.enter_data async(%[[ASYNC2]] : i32) dataOperands(%[[CREATE_A]] : !fir.ref>) !$acc enter data create(a) wait(1) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a"} !CHECK: %[[WAIT1:.*]] = arith.constant 1 : i32 !CHECK: acc.enter_data wait(%[[WAIT1]] : i32) dataOperands(%[[CREATE_A]] : !fir.ref>) !$acc enter data create(a) wait(queues: 1, 2) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a"} !CHECK: %[[WAIT2:.*]] = arith.constant 1 : i32 !CHECK: %[[WAIT3:.*]] = arith.constant 2 : i32 !CHECK: acc.enter_data wait(%[[WAIT2]], %[[WAIT3]] : i32, i32) dataOperands(%[[CREATE_A]] : !fir.ref>) !$acc enter data create(a) wait(devnum: 1: queues: 1, 2) -!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a"} !CHECK: %[[WAIT4:.*]] = arith.constant 1 : i32 !CHECK: %[[WAIT5:.*]] = arith.constant 2 : i32 !CHECK: %[[WAIT6:.*]] = arith.constant 1 : i32 @@ -95,7 +95,7 @@ subroutine acc_enter_data !$acc enter data copyin(a(1:10,1:5)) !CHECK: %[[BOUND0:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%[[EXTENT_C10]] : index) stride(%c1{{.*}} : index) startIdx(%{{.*}} : index) -!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a(1:10,1:5)", structured = false} +!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND0]], %[[BOUND1]]) -> !fir.ref> {name = "a(1:10,1:5)"} !CHECK: acc.enter_data dataOperands(%[[COPYIN_A]] : !fir.ref>) !$acc enter data copyin(a(1:,1:5)) @@ -106,7 +106,7 @@ subroutine acc_enter_data !CHECK: %[[LB2:.*]] = arith.constant 0 : index !CHECK: %[[UB2:.*]] = arith.constant 4 : index !CHECK: %[[BOUND2:.*]] = acc.bounds lowerbound(%[[LB2]] : index) upperbound(%[[UB2]] : index) extent(%[[EXTENT_C10]] : index) stride(%c1{{.*}} : index) startIdx(%c1{{.*}} : index) -!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND1]], %[[BOUND2]]) -> !fir.ref> {name = "a(1:,1:5)", structured = false} +!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND1]], %[[BOUND2]]) -> !fir.ref> {name = "a(1:,1:5)"} !CHECK: acc.enter_data dataOperands(%[[COPYIN_A]] : !fir.ref>) !$acc enter data copyin(a(:10,1:5)) @@ -117,7 +117,7 @@ subroutine acc_enter_data !CHECK: %[[LB:.*]] = arith.constant 0 : index !CHECK: %[[UB2:.*]] = arith.constant 4 : index !CHECK: %[[BOUND2:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB2]] : index) extent(%[[EXTENT_C10]] : index) stride(%c1{{.*}} : index) startIdx(%[[ONE]] : index) -!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND1]], %[[BOUND2]]) -> !fir.ref> {name = "a(:10,1:5)", structured = false} +!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND1]], %[[BOUND2]]) -> !fir.ref> {name = "a(:10,1:5)"} !CHECK: acc.enter_data dataOperands(%[[COPYIN_A]] : !fir.ref>) !$acc enter data copyin(a(:,:)) @@ -127,7 +127,7 @@ subroutine acc_enter_data !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%c10{{.*}} : index) stride(%[[ONE]] : index) startIdx(%[[ONE]] : index) !CHECK: %[[UB:.*]] = arith.subi %c10{{.*}}, %[[ONE]] : index !CHECK: %[[BOUND2:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%c10{{.*}} : index) stride(%c1{{.*}} : index) startIdx(%c1{{.*}} : index) -!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND1]], %[[BOUND2]]) -> !fir.ref> {name = "a(:,:)", structured = false} +!CHECK: %[[COPYIN_A:.*]] = acc.copyin varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND1]], %[[BOUND2]]) -> !fir.ref> {name = "a(:,:)"} end subroutine acc_enter_data subroutine acc_enter_data_dummy(a, b, n, m) @@ -156,11 +156,11 @@ subroutine acc_enter_data_dummy(a, b, n, m) !CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] !$acc enter data create(a) -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(b) -!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLB]]#0 : !fir.box>) -> !fir.box> {name = "b", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLB]]#0 : !fir.box>) -> !fir.box> {name = "b"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.box>) !$acc enter data create(a(5:10)) @@ -168,7 +168,7 @@ subroutine acc_enter_data_dummy(a, b, n, m) !CHECK: %[[LB1:.*]] = arith.constant 4 : index !CHECK: %[[UB1:.*]] = arith.constant 9 : index !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%[[LB1]] : index) upperbound(%[[UB1]] : index) extent(%c10{{.*}} : index) stride(%[[ONE]] : index) startIdx(%c1{{.*}} : index) -!CHECK: %[[CREATE1:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND1]]) -> !fir.ref> {name = "a(5:10)", structured = false} +!CHECK: %[[CREATE1:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%[[BOUND1]]) -> !fir.ref> {name = "a(5:10)"} !CHECK: acc.enter_data dataOperands(%[[CREATE1]] : !fir.ref>) !$acc enter data create(b(n:m)) @@ -182,7 +182,7 @@ subroutine acc_enter_data_dummy(a, b, n, m) !CHECK: %[[M_CONV2:.*]] = fir.convert %[[M_CONV1]] : (i64) -> index !CHECK: %[[UB:.*]] = arith.subi %[[M_CONV2]], %[[N_IDX]] : index !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[EXT_B]] : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[N_IDX]] : index) {strideInBytes = true} -!CHECK: %[[CREATE1:.*]] = acc.create var(%[[DECLB]]#0 : !fir.box>) bounds(%[[BOUND1]]) -> !fir.box> {name = "b(n:m)", structured = false} +!CHECK: %[[CREATE1:.*]] = acc.create var(%[[DECLB]]#0 : !fir.box>) bounds(%[[BOUND1]]) -> !fir.box> {name = "b(n:m)"} !CHECK: acc.enter_data dataOperands(%[[CREATE1]] : !fir.box>) !$acc enter data create(b(n:)) @@ -194,7 +194,7 @@ subroutine acc_enter_data_dummy(a, b, n, m) !CHECK: %[[LB:.*]] = arith.subi %[[CONVERT2_N]], %[[N_IDX]] : index !CHECK: %[[UB:.*]] = arith.subi %[[EXT_B]], %c1{{.*}} : index !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[EXT_B]] : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[N_IDX]] : index) {strideInBytes = true} -!CHECK: %[[CREATE1:.*]] = acc.create var(%[[DECLB]]#0 : !fir.box>) bounds(%[[BOUND1]]) -> !fir.box> {name = "b(n:)", structured = false} +!CHECK: %[[CREATE1:.*]] = acc.create var(%[[DECLB]]#0 : !fir.box>) bounds(%[[BOUND1]]) -> !fir.box> {name = "b(n:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE1]] : !fir.box>) !$acc enter data create(b(:)) @@ -203,7 +203,7 @@ subroutine acc_enter_data_dummy(a, b, n, m) !CHECK: %[[DIMS0:.*]]:3 = fir.box_dims %[[DECLB]]#0, %c0{{.*}} : (!fir.box>, index) -> (index, index, index) !CHECK: %[[UB:.*]] = arith.subi %[[EXT_B]], %[[ONE]] : index !CHECK: %[[BOUND1:.*]] = acc.bounds lowerbound(%[[ZERO]] : index) upperbound(%[[UB]] : index) extent(%[[EXT_B]] : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[N_IDX]] : index) {strideInBytes = true} -!CHECK: %[[CREATE1:.*]] = acc.create var(%[[DECLB]]#0 : !fir.box>) bounds(%[[BOUND1]]) -> !fir.box> {name = "b(:)", structured = false} +!CHECK: %[[CREATE1:.*]] = acc.create var(%[[DECLB]]#0 : !fir.box>) bounds(%[[BOUND1]]) -> !fir.box> {name = "b(:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE1]] : !fir.box>) end subroutine @@ -227,7 +227,7 @@ subroutine acc_enter_data_non_default_lb() !CHECK: %[[SECTIONUB:.*]] = arith.constant 9 : index !CHECK: %[[UB:.*]] = arith.subi %[[SECTIONUB]], %[[BASELB]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%c10{{.*}} : index) stride(%{{.*}} : index) startIdx(%[[BASELB]] : index) -!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(5:9)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(5:9)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.box>) !$acc enter data create(a(:)) @@ -235,7 +235,7 @@ subroutine acc_enter_data_non_default_lb() !CHECK: %[[ONE:.*]] = arith.constant 1 : index !CHECK: %[[UB:.*]] = arith.subi %[[EXTENT_C10]], %[[ONE]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[ZERO]] : index) upperbound(%[[UB]] : index) extent(%[[EXTENT_C10]] : index) stride(%{{.*}} : index) startIdx(%[[BASELB]] : index) -!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(:)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.box>) !$acc enter data create(a(:6)) @@ -243,7 +243,7 @@ subroutine acc_enter_data_non_default_lb() !CHECK: %[[SECTIONUB:.*]] = arith.constant 6 : index !CHECK: %[[UB:.*]] = arith.subi %[[SECTIONUB]], %[[BASELB]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[ZERO]] : index) upperbound(%[[UB]] : index) extent(%c10{{.*}} : index) stride(%{{.*}} : index) startIdx(%[[BASELB]] : index) -!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(:6)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(:6)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.box>) !$acc enter data create(a(4:)) @@ -252,11 +252,11 @@ subroutine acc_enter_data_non_default_lb() !CHECK: %[[LB:.*]] = arith.subi %[[SECTIONLB]], %[[BASELB]] : index !CHECK: %[[UB:.*]] = arith.subi %[[EXTENT_C10]], %[[ONE]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[EXTENT_C10]] : index) stride(%{{.*}} : index) startIdx(%[[BASELB]] : index) -!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(4:)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(4:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.box>) !$acc enter data create(b) -!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLB]]#0 : !fir.box>) -> !fir.box> {name = "b", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLB]]#0 : !fir.box>) -> !fir.box> {name = "b"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.box>) end subroutine @@ -277,7 +277,7 @@ subroutine acc_enter_data_assumed(a, b, n, m) !CHECK: %[[DECLN:.*]]:2 = hlfir.declare %[[N]] !$acc enter data create(a) -!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) -> !fir.box> {name = "a", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) -> !fir.box> {name = "a"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.box>) !$acc enter data create(a(:)) @@ -292,7 +292,7 @@ subroutine acc_enter_data_assumed(a, b, n, m) !CHECK: %[[UB:.*]] = arith.subi %[[DIMS1]]#1, %[[ONE]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS1]]#1 : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[ONE]] : index) {strideInBytes = true} -!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(:)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.box>) !$acc enter data create(a(2:)) @@ -307,7 +307,7 @@ subroutine acc_enter_data_assumed(a, b, n, m) !CHECK: %[[UB:.*]] = arith.subi %[[DIMS1]]#1, %[[ONE]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS1]]#1 : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[ONE]] : index) {strideInBytes = true} -!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(2:)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(2:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.box>) !$acc enter data create(a(:4)) @@ -319,7 +319,7 @@ subroutine acc_enter_data_assumed(a, b, n, m) !CHECK: %[[UB:.*]] = arith.constant 3 : index !CHECK: %[[DIMS1:.*]]:3 = fir.box_dims %[[DECLA]]#1, %{{.*}} : (!fir.box>, index) -> (index, index, index) !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS1]]#1 : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[ONE]] : index) {strideInBytes = true} -!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(:4)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(:4)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.box>) !$acc enter data create(a(6:10)) @@ -330,7 +330,7 @@ subroutine acc_enter_data_assumed(a, b, n, m) !CHECK: %[[UB:.*]] = arith.constant 9 : index !CHECK: %[[DIMS1:.*]]:3 = fir.box_dims %[[DECLA]]#1, %{{.*}} : (!fir.box>, index) -> (index, index, index) !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS1]]#1 : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[ONE]] : index) {strideInBytes = true} -!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(6:10)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(6:10)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.box>) !$acc enter data create(a(n:)) @@ -345,7 +345,7 @@ subroutine acc_enter_data_assumed(a, b, n, m) !CHECK: %[[DIMS:.*]]:3 = fir.box_dims %[[DECLA]]#1, %[[C0]] : (!fir.box>, index) -> (index, index, index) !CHECK: %[[UB:.*]] = arith.subi %[[DIMS]]#1, %[[ONE]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS]]#1 : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[ONE]] : index) {strideInBytes = true} -!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(n:)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(n:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.box>) !$acc enter data create(a(:m)) @@ -359,7 +359,7 @@ subroutine acc_enter_data_assumed(a, b, n, m) !CHECK: %[[UB:.*]] = arith.subi %[[CONVERT2_M]], %[[ONE]] : index !CHECK: %[[DIMS1:.*]]:3 = fir.box_dims %[[DECLA]]#1, %{{.*}} : (!fir.box>, index) -> (index, index, index) !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[BASELB]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS1]]#1 : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[ONE]] : index) {strideInBytes = true} -!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(:m)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(:m)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.box>) !$acc enter data create(a(n:m)) @@ -376,7 +376,7 @@ subroutine acc_enter_data_assumed(a, b, n, m) !CHECK: %[[UB:.*]] = arith.subi %[[CONVERT2_M]], %[[ONE]] : index !CHECK: %[[DIMS1:.*]]:3 = fir.box_dims %[[DECLA]]#1, %{{.*}} : (!fir.box>, index) -> (index, index, index) !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS1]]#1 : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[ONE]] : index) {strideInBytes = true} -!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(n:m)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLA]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(n:m)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.box>) !$acc enter data create(b(:m)) @@ -389,11 +389,11 @@ subroutine acc_enter_data_assumed(a, b, n, m) !CHECK: %[[UB:.*]] = arith.subi %[[CONVERT2_M]], %[[LB_C10_IDX]] : index !CHECK: %[[DIMS1:.*]]:3 = fir.box_dims %[[DECLB]]#1, %{{.*}} : (!fir.box>, index) -> (index, index, index) !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[ZERO]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS1]]#1 : index) stride(%[[DIMS0]]#2 : index) startIdx(%[[LB_C10_IDX]] : index) {strideInBytes = true} -!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLB]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "b(:m)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLB]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "b(:m)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.box>) !$acc enter data create(b) -!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLB]]#0 : !fir.box>) -> !fir.box> {name = "b", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create var(%[[DECLB]]#0 : !fir.box>) -> !fir.box> {name = "b"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.box>) end subroutine @@ -410,7 +410,7 @@ subroutine acc_enter_data_allocatable() !$acc enter data create(a) -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>>>) -> !fir.ref>>> {name = "a", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>>>) -> !fir.ref>>> {name = "a"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>>>) !$acc enter data create(a(:)) @@ -428,7 +428,7 @@ subroutine acc_enter_data_allocatable() !CHECK: %[[DIMS2:.*]]:3 = fir.box_dims %[[BOX_A_2]], %[[C0]] : (!fir.box>>, index) -> (index, index, index) !CHECK: %[[UB:.*]] = arith.subi %[[DIMS2]]#1, %[[ONE]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[ZERO]] : index) upperbound(%[[UB:.*]] : index) extent(%[[DIMS2]]#1 : index) stride(%[[DIMS1]]#2 : index) startIdx(%[[DIMS0]]#0 : index) {strideInBytes = true} -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>>>) bounds(%[[BOUND]]) -> !fir.ref>>> {name = "a(:)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>>>) bounds(%[[BOUND]]) -> !fir.ref>>> {name = "a(:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>>>) !$acc enter data create(a(2:5)) @@ -447,7 +447,7 @@ subroutine acc_enter_data_allocatable() !CHECK: %[[C0:.*]] = arith.constant 0 : index !CHECK: %[[DIMS2:.*]]:3 = fir.box_dims %[[BOX_A_2]], %[[C0]] : (!fir.box>>, index) -> (index, index, index) !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS2]]#1 : index) stride(%[[DIMS1]]#2 : index) startIdx(%[[DIMS0]]#0 : index) {strideInBytes = true} -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>>>) bounds(%[[BOUND]]) -> !fir.ref>>> {name = "a(2:5)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>>>) bounds(%[[BOUND]]) -> !fir.ref>>> {name = "a(2:5)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>>>) !$acc enter data create(a(3:)) @@ -466,7 +466,7 @@ subroutine acc_enter_data_allocatable() !CHECK: %[[DIMS2:.*]]:3 = fir.box_dims %[[BOX_A_2]], %[[C0]] : (!fir.box>>, index) -> (index, index, index) !CHECK: %[[UB:.*]] = arith.subi %[[DIMS2]]#1, %[[ONE]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS2]]#1 : index) stride(%[[DIMS1]]#2 : index) startIdx(%[[DIMS0]]#0 : index) {strideInBytes = true} -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>>>) bounds(%[[BOUND]]) -> !fir.ref>>> {name = "a(3:)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>>>) bounds(%[[BOUND]]) -> !fir.ref>>> {name = "a(3:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>>>) !$acc enter data create(a(:7)) @@ -484,12 +484,12 @@ subroutine acc_enter_data_allocatable() !CHECK: %[[C0:.*]] = arith.constant 0 : index !CHECK: %[[DIMS2:.*]]:3 = fir.box_dims %[[BOX_A_2]], %[[C0]] : (!fir.box>>, index) -> (index, index, index) !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[ZERO]] : index) upperbound(%[[UB]] : index) extent(%[[DIMS2]]#1 : index) stride(%[[DIMS1]]#2 : index) startIdx(%[[DIMS0]]#0 : index) {strideInBytes = true} -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>>>) bounds(%[[BOUND]]) -> !fir.ref>>> {name = "a(:7)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DECLA]]#0 : !fir.ref>>>) bounds(%[[BOUND]]) -> !fir.ref>>> {name = "a(:7)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>>>) !$acc enter data create(i) -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DECLI]]#0 : !fir.ref>>) -> !fir.ref>> {name = "i", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DECLI]]#0 : !fir.ref>>) -> !fir.ref>> {name = "i"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>>) end subroutine @@ -534,7 +534,7 @@ subroutine acc_enter_data_derived_type() !CHECK: %[[DATA_COORD:.*]] = hlfir.designate %[[DECLA]]#0{"data"} : (!fir.ref}>>) -> !fir.ref -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DATA_COORD]] : !fir.ref) -> !fir.ref {name = "a%data", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DATA_COORD]] : !fir.ref) -> !fir.ref {name = "a%data"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref) !$acc enter data create(b%d%data) @@ -543,14 +543,14 @@ subroutine acc_enter_data_derived_type() !CHECK: %[[D_COORD:.*]] = hlfir.designate %[[DECLB]]#0{"d"} : (!fir.ref}>}>>) -> !fir.ref}>> !CHECK: %[[DATA_COORD:.*]] = hlfir.designate %[[D_COORD]]{"data"} : (!fir.ref}>>) -> !fir.ref -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DATA_COORD]] : !fir.ref) -> !fir.ref {name = "b%d%data", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[DATA_COORD]] : !fir.ref) -> !fir.ref {name = "b%d%data"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref) !$acc enter data create(a%array) !CHECK: %[[ARRAY_COORD:.*]] = hlfir.designate %[[DECLA]]#0{"array"} shape %{{.*}} : (!fir.ref}>>, !fir.shape<1>) -> !fir.ref> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) -> !fir.ref> {name = "a%array", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) -> !fir.ref> {name = "a%array"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(a%array(:)) @@ -562,7 +562,7 @@ subroutine acc_enter_data_derived_type() !CHECK: %[[C1:.*]] = arith.constant 1 : index !CHECK: %[[UB:.*]] = arith.subi %[[C10]], %[[C1]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[C10]] : index) stride(%[[C1]] : index) startIdx(%[[C1]] : index) -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a%array(:)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a%array(:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(a%array(1:5)) @@ -573,7 +573,7 @@ subroutine acc_enter_data_derived_type() !CHECK: %[[C0:.*]] = arith.constant 0 : index !CHECK: %[[C4:.*]] = arith.constant 4 : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[C0]] : index) upperbound(%[[C4]] : index) extent(%[[C10]] : index) stride(%[[C1]] : index) startIdx(%[[C1]] : index) -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a%array(1:5)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a%array(1:5)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(a%array(:5)) @@ -584,7 +584,7 @@ subroutine acc_enter_data_derived_type() !CHECK: %[[C1:.*]] = arith.constant 1 : index !CHECK: %[[C4:.*]] = arith.constant 4 : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[C4]] : index) extent(%[[C10]] : index) stride(%[[C1]] : index) startIdx(%[[C1]] : index) -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a%array(:5)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a%array(:5)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(a%array(2:)) @@ -596,7 +596,7 @@ subroutine acc_enter_data_derived_type() !CHECK: %[[LB:.*]] = arith.constant 1 : index !CHECK: %[[UB:.*]] = arith.subi %[[C10]], %[[ONE]] : index !CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[C10]] : index) stride(%[[ONE]] : index) startIdx(%[[ONE]] : index) -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a%array(2:)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a%array(2:)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) !$acc enter data create(b%d%array) @@ -605,14 +605,14 @@ subroutine acc_enter_data_derived_type() !CHECK: %[[D_COORD:.*]] = hlfir.designate %[[DECLB]]#0{"d"} : (!fir.ref}>}>>) -> !fir.ref}>> !CHECK: %[[ARRAY_COORD:.*]] = hlfir.designate %[[D_COORD]]{"array"} shape %{{.*}} : (!fir.ref}>>, !fir.shape<1>) -> !fir.ref> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) -> !fir.ref> {name = "b%d%array", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) -> !fir.ref> {name = "b%d%array"} !$acc enter data create(c%data) !CHECK: %[[DATA_COORD:.*]] = hlfir.designate %[[DECLC]]#0{"data"} {fortran_attrs = #fir.var_attrs} : (!fir.ref>>}>>) -> !fir.ref>>> !CHECK: %[[DATA_BOX:.*]] = fir.load %[[DATA_COORD]] : !fir.ref>>> -!CHECK: %[[CREATE:.*]] = acc.create var(%[[DATA_BOX]] : !fir.box>>) -> !fir.box>> {name = "c%data", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create var(%[[DATA_BOX]] : !fir.box>>) -> !fir.box>> {name = "c%data"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.box>>) !$acc enter data create (d%d(1)%array) @@ -620,7 +620,7 @@ subroutine acc_enter_data_derived_type() !CHECK: %[[ONE:.*]] = arith.constant 1 : index !CHECK: %[[D1_COORD:.*]] = hlfir.designate %[[DECLD]]#0{"d"} <%{{.*}}> (%[[ONE]]) : (!fir.ref}>>}>>, !fir.shape<1>, index) -> !fir.ref}>> !CHECK: %[[ARRAY_COORD:.*]] = hlfir.designate %[[D1_COORD]]{"array"} shape %{{.*}} : (!fir.ref}>>, !fir.shape<1>) -> !fir.ref> -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) -> !fir.ref> {name = "d%d(1_8)%array", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARRAY_COORD]] : !fir.ref>) -> !fir.ref> {name = "d%d(1_8)%array"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.ref>) end subroutine @@ -647,7 +647,7 @@ subroutine acc_enter_data_single_array_element() !CHECK: %[[VAL_46:.*]] = arith.constant 2 : index !CHECK: %[[VAL_47:.*]] = arith.subi %[[VAL_46]], %[[VAL_40]]#0 : index !CHECK: %[[VAL_48:.*]] = acc.bounds lowerbound(%[[VAL_47]] : index) upperbound(%[[VAL_47]] : index) extent(%[[VAL_42]] : index) stride(%[[VAL_42]] : index) startIdx(%[[VAL_40]]#0 : index) -!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[VAL_41]] : !fir.heap>) bounds(%[[VAL_45]], %[[VAL_48]]) -> !fir.heap> {name = "e(2_8)%a(1,2)", structured = false} +!CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[VAL_41]] : !fir.heap>) bounds(%[[VAL_45]], %[[VAL_48]]) -> !fir.heap> {name = "e(2_8)%a(1,2)"} !CHECK: acc.enter_data dataOperands(%[[CREATE]] : !fir.heap>) end subroutine diff --git a/flang/test/Lower/OpenACC/acc-exit-data-unwrap-defaultbounds.f90 b/flang/test/Lower/OpenACC/acc-exit-data-unwrap-defaultbounds.f90 index 7999a7647f49b..b047f584d20d7 100644 --- a/flang/test/Lower/OpenACC/acc-exit-data-unwrap-defaultbounds.f90 +++ b/flang/test/Lower/OpenACC/acc-exit-data-unwrap-defaultbounds.f90 @@ -18,90 +18,90 @@ subroutine acc_exit_data !CHECK: %[[DECLD:.*]]:2 = hlfir.declare %[[D]] !$acc exit data delete(a) -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: acc.exit_data dataOperands(%[[DEVPTR]] : !fir.ref>) -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "a"} !$acc exit data delete(a) if(.true.) -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: %[[IF1:.*]] = arith.constant true !CHECK: acc.exit_data if(%[[IF1]]) dataOperands(%[[DEVPTR]] : !fir.ref>) -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "a"} !$acc exit data delete(a) if(ifCondition) -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: %[[IFCOND:.*]] = fir.load %{{.*}} : !fir.ref> !CHECK: %[[IF2:.*]] = fir.convert %[[IFCOND]] : (!fir.logical<4>) -> i1 !CHECK: acc.exit_data if(%[[IF2]]) dataOperands(%[[DEVPTR]] : !fir.ref>){{$}} -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "a"} !$acc exit data delete(a) delete(b) delete(c) -!CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} -!CHECK: %[[DEVPTR_B:.*]] = acc.getdeviceptr varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "b", structured = false} -!CHECK: %[[DEVPTR_C:.*]] = acc.getdeviceptr varPtr(%[[DECLC]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "c", structured = false} +!CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a"} +!CHECK: %[[DEVPTR_B:.*]] = acc.getdeviceptr varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "b"} +!CHECK: %[[DEVPTR_C:.*]] = acc.getdeviceptr varPtr(%[[DECLC]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "c"} !CHECK: acc.exit_data dataOperands(%[[DEVPTR_A]], %[[DEVPTR_B]], %[[DEVPTR_C]] : !fir.ref>, !fir.ref>, !fir.ref>){{$}} -!CHECK: acc.delete accPtr(%[[DEVPTR_A]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "a", structured = false} -!CHECK: acc.delete accPtr(%[[DEVPTR_B]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "b", structured = false} -!CHECK: acc.delete accPtr(%[[DEVPTR_C]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "c", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR_A]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "a"} +!CHECK: acc.delete accPtr(%[[DEVPTR_B]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "b"} +!CHECK: acc.delete accPtr(%[[DEVPTR_C]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "c"} !$acc exit data copyout(a) delete(b) detach(d) -!CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} -!CHECK: %[[DEVPTR_B:.*]] = acc.getdeviceptr varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "b", structured = false} +!CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a"} +!CHECK: %[[DEVPTR_B:.*]] = acc.getdeviceptr varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "b"} !CHECK: %[[BOX_D:.*]] = fir.load %[[DECLD]]#0 : !fir.ref>> !CHECK: %[[D_ADDR:.*]] = fir.box_addr %[[BOX_D]] : (!fir.box>) -> !fir.ptr -!CHECK: %[[DEVPTR_D:.*]] = acc.getdeviceptr varPtr(%[[D_ADDR]] : !fir.ptr) -> !fir.ptr {dataClause = #acc, name = "d", structured = false} +!CHECK: %[[DEVPTR_D:.*]] = acc.getdeviceptr varPtr(%[[D_ADDR]] : !fir.ptr) -> !fir.ptr {dataClause = #acc, name = "d"} !CHECK: acc.exit_data dataOperands(%[[DEVPTR_A]], %[[DEVPTR_B]], %[[DEVPTR_D]] : !fir.ref>, !fir.ref>, !fir.ptr) -!CHECK: acc.copyout accPtr(%[[DEVPTR_A]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a", structured = false} -!CHECK: acc.delete accPtr(%[[DEVPTR_B]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "b", structured = false} -!CHECK: acc.detach accPtr(%[[DEVPTR_D]] : !fir.ptr) {name = "d", structured = false} +!CHECK: acc.copyout accPtr(%[[DEVPTR_A]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a"} +!CHECK: acc.delete accPtr(%[[DEVPTR_B]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "b"} +!CHECK: acc.detach accPtr(%[[DEVPTR_D]] : !fir.ptr) {name = "d"} !$acc exit data delete(a) async -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {asyncOnly = [#acc.device_type], dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: acc.exit_data dataOperands(%[[DEVPTR]] : !fir.ref>) attributes {async} -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {asyncOnly = [#acc.device_type], name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "a"} !$acc exit data delete(a) wait -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: acc.exit_data dataOperands(%[[DEVPTR]] : !fir.ref>) attributes {wait} -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "a"} !$acc exit data delete(a) async wait -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {asyncOnly = [#acc.device_type], dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: acc.exit_data dataOperands(%[[DEVPTR]] : !fir.ref>) attributes {async, wait} -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {asyncOnly = [#acc.device_type], name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "a"} !$acc exit data delete(a) async(1) !CHECK: %[[ASYNC1:.*]] = arith.constant 1 : i32 -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) async(%[[ASYNC1]] : i32) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: acc.exit_data async(%[[ASYNC1]] : i32) dataOperands(%[[DEVPTR]] : !fir.ref>) -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) async(%[[ASYNC1]] : i32) {name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "a"} !$acc exit data delete(a) async(async) !CHECK: %[[ASYNC2:.*]] = fir.load %{{.*}} : !fir.ref -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) async(%[[ASYNC2]] : i32) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: acc.exit_data async(%[[ASYNC2]] : i32) dataOperands(%[[DEVPTR]] : !fir.ref>) -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) async(%[[ASYNC2]] : i32) {name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "a"} !$acc exit data delete(a) wait(1) -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: %[[WAIT1:.*]] = arith.constant 1 : i32 !CHECK: acc.exit_data wait(%[[WAIT1]] : i32) dataOperands(%[[DEVPTR]] : !fir.ref>) -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "a"} !$acc exit data delete(a) wait(queues: 1, 2) -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: %[[WAIT2:.*]] = arith.constant 1 : i32 !CHECK: %[[WAIT3:.*]] = arith.constant 2 : i32 !CHECK: acc.exit_data wait(%[[WAIT2]], %[[WAIT3]] : i32, i32) dataOperands(%[[DEVPTR]] : !fir.ref>) -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "a"} !$acc exit data delete(a) wait(devnum: 1: queues: 1, 2) -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: %[[WAIT4:.*]] = arith.constant 1 : i32 !CHECK: %[[WAIT5:.*]] = arith.constant 2 : i32 !CHECK: %[[WAIT6:.*]] = arith.constant 1 : i32 !CHECK: acc.exit_data wait_devnum(%[[WAIT6]] : i32) wait(%[[WAIT4]], %[[WAIT5]] : i32, i32) dataOperands(%[[DEVPTR]] : !fir.ref>) -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) {name = "a"} end subroutine acc_exit_data diff --git a/flang/test/Lower/OpenACC/acc-exit-data.f90 b/flang/test/Lower/OpenACC/acc-exit-data.f90 index bf5f7094913a1..20314a30d745f 100644 --- a/flang/test/Lower/OpenACC/acc-exit-data.f90 +++ b/flang/test/Lower/OpenACC/acc-exit-data.f90 @@ -18,89 +18,89 @@ subroutine acc_exit_data !CHECK: %[[DECLD:.*]]:2 = hlfir.declare %[[D]] !$acc exit data delete(a) -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: acc.exit_data dataOperands(%[[DEVPTR]] : !fir.ref>) -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) {name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) {name = "a"} !$acc exit data delete(a) if(.true.) -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: %[[IF1:.*]] = arith.constant true !CHECK: acc.exit_data if(%[[IF1]]) dataOperands(%[[DEVPTR]] : !fir.ref>) -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) {name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) {name = "a"} !$acc exit data delete(a) if(ifCondition) -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: %[[IFCOND:.*]] = fir.load %{{.*}} : !fir.ref> !CHECK: %[[IF2:.*]] = fir.convert %[[IFCOND]] : (!fir.logical<4>) -> i1 !CHECK: acc.exit_data if(%[[IF2]]) dataOperands(%[[DEVPTR]] : !fir.ref>){{$}} -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) {name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) {name = "a"} !$acc exit data delete(a) delete(b) delete(c) -!CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} -!CHECK: %[[DEVPTR_B:.*]] = acc.getdeviceptr varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "b", structured = false} -!CHECK: %[[DEVPTR_C:.*]] = acc.getdeviceptr varPtr(%[[DECLC]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "c", structured = false} +!CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} +!CHECK: %[[DEVPTR_B:.*]] = acc.getdeviceptr varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "b"} +!CHECK: %[[DEVPTR_C:.*]] = acc.getdeviceptr varPtr(%[[DECLC]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "c"} !CHECK: acc.exit_data dataOperands(%[[DEVPTR_A]], %[[DEVPTR_B]], %[[DEVPTR_C]] : !fir.ref>, !fir.ref>, !fir.ref>){{$}} -!CHECK: acc.delete accPtr(%[[DEVPTR_A]] : !fir.ref>) {name = "a", structured = false} -!CHECK: acc.delete accPtr(%[[DEVPTR_B]] : !fir.ref>) {name = "b", structured = false} -!CHECK: acc.delete accPtr(%[[DEVPTR_C]] : !fir.ref>) {name = "c", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR_A]] : !fir.ref>) {name = "a"} +!CHECK: acc.delete accPtr(%[[DEVPTR_B]] : !fir.ref>) {name = "b"} +!CHECK: acc.delete accPtr(%[[DEVPTR_C]] : !fir.ref>) {name = "c"} !$acc exit data copyout(a) delete(b) detach(d) -!CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} -!CHECK: %[[DEVPTR_B:.*]] = acc.getdeviceptr varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "b", structured = false} -!CHECK: %[[DEVPTR_D:.*]] = acc.getdeviceptr varPtr(%[[DECLD]]#0 : !fir.ref>>) -> !fir.ref>> {dataClause = #acc, name = "d", structured = false} +!CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} +!CHECK: %[[DEVPTR_B:.*]] = acc.getdeviceptr varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "b"} +!CHECK: %[[DEVPTR_D:.*]] = acc.getdeviceptr varPtr(%[[DECLD]]#0 : !fir.ref>>) -> !fir.ref>> {dataClause = #acc, name = "d"} !CHECK: acc.exit_data dataOperands(%[[DEVPTR_A]], %[[DEVPTR_B]], %[[DEVPTR_D]] : !fir.ref>, !fir.ref>, !fir.ref>>) -!CHECK: acc.copyout accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a", structured = false} -!CHECK: acc.delete accPtr(%[[DEVPTR_B]] : !fir.ref>) {name = "b", structured = false} -!CHECK: acc.detach accPtr(%[[DEVPTR_D]] : !fir.ref>>) {name = "d", structured = false} +!CHECK: acc.copyout accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a"} +!CHECK: acc.delete accPtr(%[[DEVPTR_B]] : !fir.ref>) {name = "b"} +!CHECK: acc.detach accPtr(%[[DEVPTR_D]] : !fir.ref>>) {name = "d"} !$acc exit data delete(a) async -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {asyncOnly = [#acc.device_type], dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: acc.exit_data dataOperands(%[[DEVPTR]] : !fir.ref>) attributes {async} -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) {asyncOnly = [#acc.device_type], name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) {name = "a"} !$acc exit data delete(a) wait -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: acc.exit_data dataOperands(%[[DEVPTR]] : !fir.ref>) attributes {wait} -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) {name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) {name = "a"} !$acc exit data delete(a) async wait -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {asyncOnly = [#acc.device_type], dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: acc.exit_data dataOperands(%[[DEVPTR]] : !fir.ref>) attributes {async, wait} -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) {asyncOnly = [#acc.device_type], name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) {name = "a"} !$acc exit data delete(a) async(1) !CHECK: %[[ASYNC1:.*]] = arith.constant 1 : i32 -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) async(%[[ASYNC1]] : i32) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: acc.exit_data async(%[[ASYNC1]] : i32) dataOperands(%[[DEVPTR]] : !fir.ref>) -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) async(%[[ASYNC1]] : i32) {name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) {name = "a"} !$acc exit data delete(a) async(async) !CHECK: %[[ASYNC2:.*]] = fir.load %{{.*}} : !fir.ref -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) async(%[[ASYNC2]] : i32) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: acc.exit_data async(%[[ASYNC2]] : i32) dataOperands(%[[DEVPTR]] : !fir.ref>) -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) async(%[[ASYNC2]] : i32) {name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) {name = "a"} !$acc exit data delete(a) wait(1) -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: %[[WAIT1:.*]] = arith.constant 1 : i32 !CHECK: acc.exit_data wait(%[[WAIT1]] : i32) dataOperands(%[[DEVPTR]] : !fir.ref>) -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) {name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) {name = "a"} !$acc exit data delete(a) wait(queues: 1, 2) -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: %[[WAIT2:.*]] = arith.constant 1 : i32 !CHECK: %[[WAIT3:.*]] = arith.constant 2 : i32 !CHECK: acc.exit_data wait(%[[WAIT2]], %[[WAIT3]] : i32, i32) dataOperands(%[[DEVPTR]] : !fir.ref>) -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) {name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) {name = "a"} !$acc exit data delete(a) wait(devnum: 1: queues: 1, 2) -!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +!CHECK: %[[DEVPTR:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} !CHECK: %[[WAIT4:.*]] = arith.constant 1 : i32 !CHECK: %[[WAIT5:.*]] = arith.constant 2 : i32 !CHECK: %[[WAIT6:.*]] = arith.constant 1 : i32 !CHECK: acc.exit_data wait_devnum(%[[WAIT6]] : i32) wait(%[[WAIT4]], %[[WAIT5]] : i32, i32) dataOperands(%[[DEVPTR]] : !fir.ref>) -!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) {name = "a", structured = false} +!CHECK: acc.delete accPtr(%[[DEVPTR]] : !fir.ref>) {name = "a"} !$acc exit data delete(a) finalize !CHECK: acc.exit_data dataOperands(%{{.*}} : !fir.ref>) attributes {finalize} diff --git a/flang/test/Lower/OpenACC/acc-parallel.f90 b/flang/test/Lower/OpenACC/acc-parallel.f90 index e00ea41210966..cba3ad538b4e2 100644 --- a/flang/test/Lower/OpenACC/acc-parallel.f90 +++ b/flang/test/Lower/OpenACC/acc-parallel.f90 @@ -330,10 +330,11 @@ subroutine acc_parallel !$acc parallel private(a) firstprivate(b) private(c) async(1) !$acc end parallel -! CHECK: %[[ACC_PRIVATE_A:.*]] = acc.private varPtr(%[[DECLA]]#0 : !fir.ref>) async([[ASYNC3:%.*]]) -> !fir.ref> {name = "a"} -! CHECK: %[[ACC_FPRIVATE_B:.*]] = acc.firstprivate varPtr(%[[DECLB]]#0 : !fir.ref>) async([[ASYNC3]]) -> !fir.ref> {name = "b"} -! CHECK: %[[ACC_PRIVATE_C:.*]] = acc.private varPtr(%[[DECLC]]#0 : !fir.ref>) async([[ASYNC3]]) -> !fir.ref> {name = "c"} -! CHECK: acc.parallel async([[ASYNC3]]) firstprivate(@firstprivatization_ref_10x10xf32 -> %[[ACC_FPRIVATE_B]] : !fir.ref>) private(@privatization_ref_10x10xf32 -> %[[ACC_PRIVATE_A]] : !fir.ref>, @privatization_ref_10x10xf32 -> %[[ACC_PRIVATE_C]] : !fir.ref>) { +! CHECK-DAG: %[[ACC_PRIVATE_A:.*]] = acc.private varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a"} +! CHECK-DAG: %[[ACC_FPRIVATE_B:.*]] = acc.firstprivate varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {name = "b"} +! CHECK-DAG: %[[ACC_PRIVATE_C:.*]] = acc.private varPtr(%[[DECLC]]#0 : !fir.ref>) -> !fir.ref> {name = "c"} +! CHECK-DAG: acc.parallel async(%[[ASYNC3:.*]] : i32) firstprivate(@firstprivatization_ref_10x10xf32 -> %[[ACC_FPRIVATE_B]] : !fir.ref>) private(@privatization_ref_10x10xf32 -> %[[ACC_PRIVATE_A]] : !fir.ref>, @privatization_ref_10x10xf32 -> %[[ACC_PRIVATE_C]] : !fir.ref>) { +! CHECK-DAG: %[[ASYNC3]] = arith.constant 1 : i32 ! CHECK: acc.yield ! CHECK-NEXT: }{{$}} diff --git a/flang/test/Lower/OpenACC/acc-update.f90 b/flang/test/Lower/OpenACC/acc-update.f90 index f96b105ed93bd..4d74da38bb8e6 100644 --- a/flang/test/Lower/OpenACC/acc-update.f90 +++ b/flang/test/Lower/OpenACC/acc-update.f90 @@ -15,101 +15,101 @@ subroutine acc_update ! CHECK: %[[DECLC:.*]]:2 = hlfir.declare %[[C]] !$acc update host(a) -! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} ! CHECK: acc.update dataOperands(%[[DEVPTR_A]] : !fir.ref>){{$}} -! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a", structured = false} +! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a"} !$acc update host(a) if_present -! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} ! CHECK: acc.update dataOperands(%[[DEVPTR_A]] : !fir.ref>) attributes {ifPresent}{{$}} -! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a", structured = false} +! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a"} !$acc update host(a) if_present if_present ! CHECK: acc.update dataOperands(%{{.*}} : !fir.ref>) attributes {ifPresent}{{$}} !$acc update self(a) -! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} ! CHECK: acc.update dataOperands(%[[DEVPTR_A]] : !fir.ref>){{$}} -! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {dataClause = #acc, name = "a", structured = false} +! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {dataClause = #acc, name = "a"} !$acc update host(a) if(.true.) -! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} ! CHECK: %[[IF1:.*]] = arith.constant true ! CHECK: acc.update if(%[[IF1]]) dataOperands(%[[DEVPTR_A]] : !fir.ref>){{$}} -! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a", structured = false} +! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a"} !$acc update host(a) if(ifCondition) -! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} ! CHECK: %[[IFCOND:.*]] = fir.load %{{.*}} : !fir.ref> ! CHECK: %[[IF2:.*]] = fir.convert %[[IFCOND]] : (!fir.logical<4>) -> i1 ! CHECK: acc.update if(%[[IF2]]) dataOperands(%[[DEVPTR_A]] : !fir.ref>){{$}} -! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a", structured = false} +! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a"} !$acc update host(a) host(b) host(c) -! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} -! CHECK: %[[DEVPTR_B:.*]] = acc.getdeviceptr varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "b", structured = false} -! CHECK: %[[DEVPTR_C:.*]] = acc.getdeviceptr varPtr(%[[DECLC]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "c", structured = false} +! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} +! CHECK: %[[DEVPTR_B:.*]] = acc.getdeviceptr varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "b"} +! CHECK: %[[DEVPTR_C:.*]] = acc.getdeviceptr varPtr(%[[DECLC]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "c"} ! CHECK: acc.update dataOperands(%[[DEVPTR_A]], %[[DEVPTR_B]], %[[DEVPTR_C]] : !fir.ref>, !fir.ref>, !fir.ref>){{$}} -! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a", structured = false} -! CHECK: acc.update_host accPtr(%[[DEVPTR_B]] : !fir.ref>) to varPtr(%[[DECLB]]#0 : !fir.ref>) {name = "b", structured = false} -! CHECK: acc.update_host accPtr(%[[DEVPTR_C]] : !fir.ref>) to varPtr(%[[DECLC]]#0 : !fir.ref>) {name = "c", structured = false} +! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a"} +! CHECK: acc.update_host accPtr(%[[DEVPTR_B]] : !fir.ref>) to varPtr(%[[DECLB]]#0 : !fir.ref>) {name = "b"} +! CHECK: acc.update_host accPtr(%[[DEVPTR_C]] : !fir.ref>) to varPtr(%[[DECLC]]#0 : !fir.ref>) {name = "c"} !$acc update host(a) host(b) device(c) -! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} -! CHECK: %[[DEVPTR_B:.*]] = acc.getdeviceptr varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "b", structured = false} -! CHECK: %[[DEVPTR_C:.*]] = acc.update_device varPtr(%[[DECLC]]#0 : !fir.ref>) -> !fir.ref> {name = "c", structured = false} +! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} +! CHECK: %[[DEVPTR_B:.*]] = acc.getdeviceptr varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "b"} +! CHECK: %[[DEVPTR_C:.*]] = acc.update_device varPtr(%[[DECLC]]#0 : !fir.ref>) -> !fir.ref> {name = "c"} ! CHECK: acc.update dataOperands(%[[DEVPTR_C]], %[[DEVPTR_A]], %[[DEVPTR_B]] : !fir.ref>, !fir.ref>, !fir.ref>){{$}} -! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a", structured = false} -! CHECK: acc.update_host accPtr(%[[DEVPTR_B]] : !fir.ref>) to varPtr(%[[DECLB]]#0 : !fir.ref>) {name = "b", structured = false} +! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a"} +! CHECK: acc.update_host accPtr(%[[DEVPTR_B]] : !fir.ref>) to varPtr(%[[DECLB]]#0 : !fir.ref>) {name = "b"} !$acc update host(a) async -! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {asyncOnly = [#acc.device_type], dataClause = #acc, name = "a", structured = false} -! CHECK: acc.update async dataOperands(%[[DEVPTR_A]] : !fir.ref>) -! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {asyncOnly = [#acc.device_type], name = "a", structured = false} +! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} +! CHECK: acc.update dataOperands(%[[DEVPTR_A]] : !fir.ref>) attributes {asyncOnly = [#acc.device_type]} +! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a"} !$acc update host(a) wait -! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} ! CHECK: acc.update wait dataOperands(%[[DEVPTR_A]] : !fir.ref>) -! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a", structured = false} +! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a"} !$acc update host(a) async wait -! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {asyncOnly = [#acc.device_type], dataClause = #acc, name = "a", structured = false} -! CHECK: acc.update async wait dataOperands(%[[DEVPTR_A]] : !fir.ref>) -! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {asyncOnly = [#acc.device_type], name = "a", structured = false} +! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} +! CHECK: acc.update wait dataOperands(%[[DEVPTR_A]] : !fir.ref>) attributes {asyncOnly = [#acc.device_type]} +! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a"} !$acc update host(a) async(1) ! CHECK: [[ASYNC1:%.*]] = arith.constant 1 : i32 -! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) async([[ASYNC1]] : i32) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} ! CHECK: acc.update async([[ASYNC1]] : i32) dataOperands(%[[DEVPTR_A]] : !fir.ref>) -! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) async([[ASYNC1]] : i32) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a", structured = false} +! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a"} !$acc update host(a) async(async) ! CHECK: [[ASYNC2:%.*]] = fir.load %{{.*}} : !fir.ref -! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) async([[ASYNC2]] : i32) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} ! CHECK: acc.update async([[ASYNC2]] : i32) dataOperands(%[[DEVPTR_A]] : !fir.ref>) -! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) async([[ASYNC2]] : i32) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a", structured = false} +! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a"} !$acc update host(a) wait(1) ! CHECK: [[WAIT1:%.*]] = arith.constant 1 : i32 -! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} ! CHECK: acc.update wait({[[WAIT1]] : i32}) dataOperands(%[[DEVPTR_A]] : !fir.ref>) -! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a", structured = false} +! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a"} !$acc update host(a) wait(queues: 1, 2) ! CHECK: [[WAIT2:%.*]] = arith.constant 1 : i32 ! CHECK: [[WAIT3:%.*]] = arith.constant 2 : i32 -! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} ! CHECK: acc.update wait({[[WAIT2]] : i32, [[WAIT3]] : i32}) dataOperands(%[[DEVPTR_A]] : !fir.ref>) -! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a", structured = false} +! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a"} !$acc update host(a) wait(devnum: 1: queues: 1, 2) -! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a", structured = false} +! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} ! CHECK: acc.update wait({devnum: %c1{{.*}} : i32, %c1{{.*}} : i32, %c2{{.*}} : i32}) dataOperands(%[[DEVPTR_A]] : !fir.ref>) -! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a", structured = false} +! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a"} !$acc update host(a) device_type(host, nvidia) async -! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {asyncOnly = [#acc.device_type, #acc.device_type], dataClause = #acc, name = "a", structured = false} -! CHECK: acc.update async([#acc.device_type, #acc.device_type]) dataOperands(%[[DEVPTR_A]] : !fir.ref>) -! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {asyncOnly = [#acc.device_type, #acc.device_type], name = "a", structured = false} +! CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {dataClause = #acc, name = "a"} +! CHECK: acc.update dataOperands(%[[DEVPTR_A]] : !fir.ref>) attributes {asyncOnly = [#acc.device_type, #acc.device_type]} +! CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : !fir.ref>) to varPtr(%[[DECLA]]#0 : !fir.ref>) {name = "a"} end subroutine acc_update diff --git a/mlir/test/Dialect/OpenACC/invalid.mlir b/mlir/test/Dialect/OpenACC/invalid.mlir index c8d7a87112917..e2287009fe2fd 100644 --- a/mlir/test/Dialect/OpenACC/invalid.mlir +++ b/mlir/test/Dialect/OpenACC/invalid.mlir @@ -130,7 +130,7 @@ acc.update %value = memref.alloc() : memref %0 = acc.update_device varPtr(%value : memref) -> memref // expected-error@+1 {{async attribute cannot appear with asyncOperand}} -acc.update async(%cst: index) dataOperands(%0 : memref) attributes {async = [#acc.device_type]} +acc.update async(%cst: index) dataOperands(%0 : memref) attributes {asyncOnly = [#acc.device_type]} // ----- diff --git a/mlir/test/Dialect/OpenACC/ops.mlir b/mlir/test/Dialect/OpenACC/ops.mlir index 4c842a26f8dc4..8a05ee75ae9d3 100644 --- a/mlir/test/Dialect/OpenACC/ops.mlir +++ b/mlir/test/Dialect/OpenACC/ops.mlir @@ -938,7 +938,7 @@ func.func @testupdateop(%a: memref, %b: memref, %c: memref) -> () acc.update if(%ifCond) dataOperands(%0: memref) acc.update dataOperands(%0: memref) acc.update dataOperands(%0, %1, %2 : memref, memref, memref) - acc.update async dataOperands(%0, %1, %2 : memref, memref, memref) + acc.update dataOperands(%0, %1, %2 : memref, memref, memref) attributes {asyncOnly = [#acc.device_type]} acc.update wait dataOperands(%0, %1, %2 : memref, memref, memref) acc.update dataOperands(%0, %1, %2 : memref, memref, memref) attributes {ifPresent} return @@ -957,7 +957,7 @@ func.func @testupdateop(%a: memref, %b: memref, %c: memref) -> () // CHECK: acc.update if([[IFCOND]]) dataOperands(%{{.*}} : memref) // CHECK: acc.update dataOperands(%{{.*}} : memref) // CHECK: acc.update dataOperands(%{{.*}}, %{{.*}}, %{{.*}} : memref, memref, memref) -// CHECK: acc.update async dataOperands(%{{.*}}, %{{.*}}, %{{.*}} : memref, memref, memref) +// CHECK: acc.update dataOperands(%{{.*}}, %{{.*}}, %{{.*}} : memref, memref, memref) attributes {asyncOnly = [#acc.device_type]} // CHECK: acc.update wait dataOperands(%{{.*}}, %{{.*}}, %{{.*}} : memref, memref, memref) // CHECK: acc.update dataOperands(%{{.*}}, %{{.*}}, %{{.*}} : memref, memref, memref) attributes {ifPresent} @@ -1342,28 +1342,28 @@ func.func @teststructureddataclauseops(%a: memref<10xf32>, %b: memref) -> () { - %copyin = acc.copyin varPtr(%a : memref<10xf32>) varType(tensor<10xf32>) -> memref<10xf32> {structured = false} + %copyin = acc.copyin varPtr(%a : memref<10xf32>) varType(tensor<10xf32>) -> memref<10xf32> acc.enter_data dataOperands(%copyin : memref<10xf32>) %devptr = acc.getdeviceptr varPtr(%a : memref<10xf32>) varType(tensor<10xf32>) -> memref<10xf32> {dataClause = #acc} acc.exit_data dataOperands(%devptr : memref<10xf32>) - acc.copyout accPtr(%devptr : memref<10xf32>) to varPtr(%a : memref<10xf32>) varType(tensor<10xf32>) {structured = false} + acc.copyout accPtr(%devptr : memref<10xf32>) to varPtr(%a : memref<10xf32>) varType(tensor<10xf32>) return } // CHECK: func.func @testunstructuredclauseops([[ARGA:%.*]]: memref<10xf32>) { -// CHECK: [[COPYIN:%.*]] = acc.copyin varPtr([[ARGA]] : memref<10xf32>) varType(tensor<10xf32>) -> memref<10xf32> {structured = false} +// CHECK: [[COPYIN:%.*]] = acc.copyin varPtr([[ARGA]] : memref<10xf32>) varType(tensor<10xf32>) -> memref<10xf32> // CHECK-NEXT: acc.enter_data dataOperands([[COPYIN]] : memref<10xf32>) // CHECK: [[DEVPTR:%.*]] = acc.getdeviceptr varPtr([[ARGA]] : memref<10xf32>) varType(tensor<10xf32>) -> memref<10xf32> {dataClause = #acc} // CHECK-NEXT: acc.exit_data dataOperands([[DEVPTR]] : memref<10xf32>) -// CHECK-NEXT: acc.copyout accPtr([[DEVPTR]] : memref<10xf32>) to varPtr([[ARGA]] : memref<10xf32>) varType(tensor<10xf32>) {structured = false} +// CHECK-NEXT: acc.copyout accPtr([[DEVPTR]] : memref<10xf32>) to varPtr([[ARGA]] : memref<10xf32>) varType(tensor<10xf32>) // ----- func.func @host_device_ops(%a: memref) -> () { %devptr = acc.getdeviceptr varPtr(%a : memref) -> memref - acc.update_host accPtr(%devptr : memref) to varPtr(%a : memref) {structured = false} + acc.update_host accPtr(%devptr : memref) to varPtr(%a : memref) acc.update dataOperands(%devptr : memref) %accPtr = acc.update_device varPtr(%a : memref) -> memref @@ -1374,7 +1374,7 @@ func.func @host_device_ops(%a: memref) -> () { // CHECK-LABEL: func.func @host_device_ops( // CHECK-SAME: %[[A:.*]]: memref) // CHECK: %[[DEVPTR_A:.*]] = acc.getdeviceptr varPtr(%[[A]] : memref) -> memref -// CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : memref) to varPtr(%[[A]] : memref) {structured = false} +// CHECK: acc.update_host accPtr(%[[DEVPTR_A]] : memref) to varPtr(%[[A]] : memref) // CHECK: acc.update dataOperands(%[[DEVPTR_A]] : memref) // CHECK: %[[DEVPTR_A:.*]] = acc.update_device varPtr(%[[A]] : memref) -> memref // CHECK: acc.update dataOperands(%[[DEVPTR_A]] : memref)