From 4e24d9765993dcece195f59b0761a87fed540e71 Mon Sep 17 00:00:00 2001 From: Razvan Lupusoru Date: Wed, 16 Jul 2025 15:44:55 -0700 Subject: [PATCH 1/6] [draft][acc][flang] Add recipes to data entry operations Currently recipes are held as part of the constructs. But the recipes are needed specifically for materializing semantics of the data clauses. There is no reason to not have this on the data clauses themselves. TODO: Fix the IR in flang tests which do not expect new operand TODO: Deprecate the recipe list held on the constructs --- flang/lib/Lower/OpenACC.cpp | 8 +++++ mlir/include/mlir/Dialect/OpenACC/OpenACC.h | 3 ++ .../mlir/Dialect/OpenACC/OpenACCOps.td | 24 +++++++++++-- mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp | 34 +++++++++++++++++++ 4 files changed, 66 insertions(+), 3 deletions(-) diff --git a/flang/lib/Lower/OpenACC.cpp b/flang/lib/Lower/OpenACC.cpp index 39e4444cde4e3..c2a884d8e4c3a 100644 --- a/flang/lib/Lower/OpenACC.cpp +++ b/flang/lib/Lower/OpenACC.cpp @@ -1340,6 +1340,8 @@ static void genPrivatizationRecipes( builder, operandLocation, info.addr, asFortran, bounds, true, /*implicit=*/false, mlir::acc::DataClause::acc_private, retTy, async, asyncDeviceTypes, asyncOnlyDeviceTypes, /*unwrapBoxAddr=*/true); + op.setRecipeAttr(mlir::SymbolRefAttr::get(builder.getContext(), + recipe.getSymName().str())); dataOperands.push_back(op.getAccVar()); } else { std::string suffix = @@ -1353,6 +1355,8 @@ static void genPrivatizationRecipes( /*implicit=*/false, mlir::acc::DataClause::acc_firstprivate, retTy, async, asyncDeviceTypes, asyncOnlyDeviceTypes, /*unwrapBoxAddr=*/true); + op.setRecipeAttr(mlir::SymbolRefAttr::get(builder.getContext(), + recipe.getSymName().str())); dataOperands.push_back(op.getAccVar()); } privatizationRecipes.push_back(mlir::SymbolRefAttr::get( @@ -1787,6 +1791,8 @@ genReductions(const Fortran::parser::AccObjectListWithReduction &objectList, mlir::acc::ReductionRecipeOp recipe = Fortran::lower::createOrGetReductionRecipe( builder, recipeName, operandLocation, ty, mlirOp, bounds); + op.setRecipeAttr(mlir::SymbolRefAttr::get(builder.getContext(), + recipe.getSymName().str())); reductionRecipes.push_back(mlir::SymbolRefAttr::get( builder.getContext(), recipe.getSymName().str())); reductionOperands.push_back(op.getAccVar()); @@ -2038,6 +2044,8 @@ privatizeIv(Fortran::lower::AbstractConverter &converter, builder, loc, ivValue, asFortran, {}, true, /*implicit=*/true, mlir::acc::DataClause::acc_private, ivValue.getType(), /*async=*/{}, /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{}); + op.setRecipeAttr(mlir::SymbolRefAttr::get(builder.getContext(), + recipe.getSymName().str())); privateOp = op.getOperation(); privateOperands.push_back(op.getAccVar()); diff --git a/mlir/include/mlir/Dialect/OpenACC/OpenACC.h b/mlir/include/mlir/Dialect/OpenACC/OpenACC.h index 4eb666239d4e4..b3a29d10e10e4 100644 --- a/mlir/include/mlir/Dialect/OpenACC/OpenACC.h +++ b/mlir/include/mlir/Dialect/OpenACC/OpenACC.h @@ -151,6 +151,9 @@ mlir::ValueRange getDataOperands(mlir::Operation *accOp); /// Used to get a mutable range iterating over the data operands. mlir::MutableOperandRange getMutableDataOperands(mlir::Operation *accOp); +/// Used to get the recipe attribute from a data clause operation. +mlir::SymbolRefAttr getRecipe(mlir::Operation *accOp); + /// Used to obtain the enclosing compute construct operation that contains /// the provided `region`. Returns nullptr if no compute construct operation /// is found. The returns operation is one of types defined by diff --git a/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td b/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td index 66378f116784e..dd395912f9e7b 100644 --- a/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td +++ b/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td @@ -514,7 +514,8 @@ class OpenACC_DataEntryOp:$implicit, DefaultValuedAttr:$modifiers, - OptionalAttr:$name)); + OptionalAttr:$name, + OptionalAttr:$recipe)); let description = !strconcat(extraDescription, [{ Description of arguments: @@ -623,7 +624,7 @@ class OpenACC_DataEntryOp, OpBuilder<(ins "::mlir::Value":$var, "bool":$structured, "bool":$implicit, @@ -641,7 +642,7 @@ class OpenACC_DataEntryOp, OpBuilder<(ins "::mlir::Type":$accVarType, "::mlir::Value":$var, "::mlir::Type":$varType, "::mlir::Value":$varPtrPtr, @@ -652,10 +653,27 @@ class OpenACC_DataEntryOp, + OpBuilder<(ins "::mlir::Type":$accVarType, "::mlir::Value":$var, + "::mlir::Type":$varType, "::mlir::Value":$varPtrPtr, + "::mlir::ValueRange":$bounds, + "::mlir::ValueRange":$asyncOperands, + "::mlir::ArrayAttr":$asyncOperandsDeviceType, + "::mlir::ArrayAttr":$asyncOnly, + "::mlir::acc::DataClause":$dataClause, "bool":$structured, + "bool":$implicit, + "::mlir::acc::DataClauseModifier":$modifiers, + "::mlir::StringAttr":$name), + [{ + // Builder provided to simplify building after recipe operand was added. + build($_builder, $_state, accVarType, var, varType, varPtrPtr, bounds, + asyncOperands, asyncOperandsDeviceType, asyncOnly, dataClause, + structured, implicit, modifiers, name, /*recipe=*/nullptr); + }]>, ]; } diff --git a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp index f2eab62b286af..eb56d2d8933a0 100644 --- a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp +++ b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp @@ -332,6 +332,13 @@ checkValidModifier(Op op, acc::DataClauseModifier validModifiers) { return success(); } +template +static LogicalResult checkNoRecipe(Op op) { + if (op.getRecipe().has_value()) + return op.emitError("no recipes are allowed"); + return success(); +} + static ParseResult parseVar(mlir::OpAsmParser &parser, OpAsmParser::UnresolvedOperand &var) { // Either `var` or `varPtr` keyword is required. @@ -1063,6 +1070,24 @@ checkSymOperandList(Operation *op, std::optional attributes, return op->emitOpError() << "expected as many " << symbolName << " symbol reference as " << operandName << " operands"; + if (attributes) { + for (auto operandAndAttribute : llvm::zip(operands, *attributes)) { + mlir::Value operand = std::get<0>(operandAndAttribute); + if (auto *definingOp = operand.getDefiningOp()) { + mlir::SymbolRefAttr operandRecipe = getRecipe(definingOp); + // If the operand operation has a recipe - check that it is consistent + // with the one recorded in the construct. + if (operandRecipe) { + if (operandRecipe.getLeafReference().compare( + llvm::cast( + std::get<1>(operandAndAttribute)) + .getLeafReference()) != 0) + return op->emitOpError() << "expected consistent recipe for " + << operandName << " operand"; + } + } + } + } } else { if (attributes) return op->emitOpError() @@ -4075,6 +4100,15 @@ mlir::acc::getMutableDataOperands(mlir::Operation *accOp) { return dataOperands; } +mlir::SymbolRefAttr mlir::acc::getRecipe(mlir::Operation *accOp) { + auto recipe{ + llvm::TypeSwitch(accOp) + .Case( + [&](auto entry) { return entry.getRecipeAttr(); }) + .Default([&](mlir::Operation *) { return mlir::SymbolRefAttr{}; })}; + return recipe; +} + mlir::Operation *mlir::acc::getEnclosingComputeOp(mlir::Region ®ion) { mlir::Operation *parentOp = region.getParentOp(); while (parentOp) { From ad2a3027a3507f6a7a9b6ca62ab8828200493433 Mon Sep 17 00:00:00 2001 From: Razvan Lupusoru Date: Tue, 22 Jul 2025 16:16:30 -0700 Subject: [PATCH 2/6] Remove construct recipes and fix all tests --- flang/lib/Lower/OpenACC.cpp | 46 +---- flang/test/Lower/OpenACC/acc-kernels-loop.f90 | 4 +- flang/test/Lower/OpenACC/acc-loop.f90 | 73 ++++--- .../test/Lower/OpenACC/acc-parallel-loop.f90 | 12 +- flang/test/Lower/OpenACC/acc-parallel.f90 | 12 +- .../acc-private-unwrap-defaultbounds.f90 | 63 +++--- flang/test/Lower/OpenACC/acc-private.f90 | 69 ++++--- .../acc-reduction-unwrap-defaultbounds.f90 | 144 ++++++------- flang/test/Lower/OpenACC/acc-reduction.f90 | 144 ++++++------- flang/test/Lower/OpenACC/acc-serial-loop.f90 | 12 +- flang/test/Lower/OpenACC/acc-serial.f90 | 12 +- .../mlir/Dialect/OpenACC/OpenACCOps.td | 46 ++--- mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp | 194 +++++++----------- mlir/test/Dialect/OpenACC/invalid.mlir | 10 +- mlir/test/Dialect/OpenACC/legalize-data.mlir | 24 +-- mlir/test/Dialect/OpenACC/ops.mlir | 107 ++++++---- 16 files changed, 476 insertions(+), 496 deletions(-) diff --git a/flang/lib/Lower/OpenACC.cpp b/flang/lib/Lower/OpenACC.cpp index ab27678e9ab95..50571a70e3aaf 100644 --- a/flang/lib/Lower/OpenACC.cpp +++ b/flang/lib/Lower/OpenACC.cpp @@ -1323,7 +1323,6 @@ static void genPrivatizationRecipes( Fortran::semantics::SemanticsContext &semanticsContext, Fortran::lower::StatementContext &stmtCtx, llvm::SmallVectorImpl &dataOperands, - llvm::SmallVector &privatizationRecipes, llvm::ArrayRef async, llvm::ArrayRef asyncDeviceTypes, llvm::ArrayRef asyncOnlyDeviceTypes) { @@ -1377,8 +1376,6 @@ static void genPrivatizationRecipes( recipe.getSymName().str())); dataOperands.push_back(op.getAccVar()); } - privatizationRecipes.push_back(mlir::SymbolRefAttr::get( - builder.getContext(), recipe.getSymName().str())); } } @@ -1757,7 +1754,6 @@ 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) { @@ -1811,8 +1807,6 @@ genReductions(const Fortran::parser::AccObjectListWithReduction &objectList, builder, recipeName, operandLocation, ty, mlirOp, bounds); op.setRecipeAttr(mlir::SymbolRefAttr::get(builder.getContext(), recipe.getSymName().str())); - reductionRecipes.push_back(mlir::SymbolRefAttr::get( - builder.getContext(), recipe.getSymName().str())); reductionOperands.push_back(op.getAccVar()); } } @@ -2024,7 +2018,6 @@ privatizeIv(Fortran::lower::AbstractConverter &converter, llvm::SmallVector &ivLocs, llvm::SmallVector &privateOperands, llvm::SmallVector &ivPrivate, - llvm::SmallVector &privatizationRecipes, bool isDoConcurrent = false) { fir::FirOpBuilder &builder = converter.getFirOpBuilder(); @@ -2067,8 +2060,6 @@ privatizeIv(Fortran::lower::AbstractConverter &converter, privateOp = op.getOperation(); privateOperands.push_back(op.getAccVar()); - privatizationRecipes.push_back(mlir::SymbolRefAttr::get( - builder.getContext(), recipe.getSymName().str())); } // Map the new private iv to its symbol for the scope of the loop. bindSymbol @@ -2161,7 +2152,6 @@ static mlir::acc::LoopOp createLoopOp( llvm::SmallVector tileOperands, privateOperands, ivPrivate, reductionOperands, cacheOperands, vectorOperands, workerNumOperands, gangOperands, lowerbounds, upperbounds, steps; - llvm::SmallVector privatizationRecipes, reductionRecipes; llvm::SmallVector tileOperandsSegments, gangOperandsSegments; llvm::SmallVector collapseValues; @@ -2284,13 +2274,13 @@ static mlir::acc::LoopOp createLoopOp( &clause.u)) { genPrivatizationRecipes( privateClause->v, converter, semanticsContext, stmtCtx, - privateOperands, privatizationRecipes, /*async=*/{}, + privateOperands, /*async=*/{}, /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{}); } else if (const auto *reductionClause = std::get_if( &clause.u)) { genReductions(reductionClause->v, converter, semanticsContext, stmtCtx, - reductionOperands, reductionRecipes, /*async=*/{}, + reductionOperands, /*async=*/{}, /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{}); } else if (std::get_if(&clause.u)) { for (auto crtDeviceTypeAttr : crtDeviceTypes) @@ -2368,7 +2358,7 @@ static mlir::acc::LoopOp createLoopOp( const auto &name = std::get(control.t); privatizeIv(converter, *name.symbol, currentLocation, ivTypes, ivLocs, - privateOperands, ivPrivate, privatizationRecipes, + privateOperands, ivPrivate, isDoConcurrent); inclusiveBounds.push_back(true); @@ -2407,7 +2397,7 @@ static mlir::acc::LoopOp createLoopOp( Fortran::semantics::Symbol &ivSym = bounds->name.thing.symbol->GetUltimate(); privatizeIv(converter, ivSym, currentLocation, ivTypes, ivLocs, - privateOperands, ivPrivate, privatizationRecipes); + privateOperands, ivPrivate); inclusiveBounds.push_back(true); @@ -2489,14 +2479,6 @@ static mlir::acc::LoopOp createLoopOp( if (!autoDeviceTypes.empty()) loopOp.setAuto_Attr(builder.getArrayAttr(autoDeviceTypes)); - if (!privatizationRecipes.empty()) - loopOp.setPrivatizationRecipesAttr( - mlir::ArrayAttr::get(builder.getContext(), privatizationRecipes)); - - if (!reductionRecipes.empty()) - loopOp.setReductionRecipesAttr( - mlir::ArrayAttr::get(builder.getContext(), reductionRecipes)); - if (!collapseValues.empty()) loopOp.setCollapseAttr(builder.getI64ArrayAttr(collapseValues)); if (!collapseDeviceTypes.empty()) @@ -2618,8 +2600,6 @@ static Op createComputeOp( llvm::SmallVector reductionOperands, privateOperands, firstprivateOperands; - llvm::SmallVector privatizationRecipes, - firstPrivatizationRecipes, reductionRecipes; // Self clause has optional values but can be present with // no value as well. When there is no value, the op has an attribute to @@ -2827,14 +2807,14 @@ static Op createComputeOp( if (!combinedConstructs) genPrivatizationRecipes( privateClause->v, converter, semanticsContext, stmtCtx, - privateOperands, privatizationRecipes, async, asyncDeviceTypes, + privateOperands, async, asyncDeviceTypes, asyncOnlyDeviceTypes); } else if (const auto *firstprivateClause = std::get_if( &clause.u)) { genPrivatizationRecipes( firstprivateClause->v, converter, semanticsContext, stmtCtx, - firstprivateOperands, firstPrivatizationRecipes, async, + firstprivateOperands, async, asyncDeviceTypes, asyncOnlyDeviceTypes); } else if (const auto *reductionClause = std::get_if( @@ -2846,7 +2826,7 @@ static Op createComputeOp( // instead. if (!combinedConstructs) { genReductions(reductionClause->v, converter, semanticsContext, stmtCtx, - reductionOperands, reductionRecipes, async, + reductionOperands, async, asyncDeviceTypes, asyncOnlyDeviceTypes); } else { auto crtDataStart = dataClauseOperands.size(); @@ -2938,18 +2918,6 @@ static Op createComputeOp( if (!waitOnlyDeviceTypes.empty()) computeOp.setWaitOnlyAttr(builder.getArrayAttr(waitOnlyDeviceTypes)); - if constexpr (!std::is_same_v) { - if (!privatizationRecipes.empty()) - computeOp.setPrivatizationRecipesAttr( - mlir::ArrayAttr::get(builder.getContext(), privatizationRecipes)); - if (!reductionRecipes.empty()) - computeOp.setReductionRecipesAttr( - mlir::ArrayAttr::get(builder.getContext(), reductionRecipes)); - if (!firstPrivatizationRecipes.empty()) - computeOp.setFirstprivatizationRecipesAttr(mlir::ArrayAttr::get( - builder.getContext(), firstPrivatizationRecipes)); - } - if (combinedConstructs) computeOp.setCombinedAttr(builder.getUnitAttr()); diff --git a/flang/test/Lower/OpenACC/acc-kernels-loop.f90 b/flang/test/Lower/OpenACC/acc-kernels-loop.f90 index 8d95f35b186ee..fd6cb0bbda472 100644 --- a/flang/test/Lower/OpenACC/acc-kernels-loop.f90 +++ b/flang/test/Lower/OpenACC/acc-kernels-loop.f90 @@ -704,7 +704,9 @@ subroutine acc_kernels_loop ! CHECK: %[[COPYINREDR:.*]] = acc.copyin varPtr(%{{.*}} : !fir.ref) -> !fir.ref {dataClause = #acc, implicit = true, name = "reduction_r"} ! CHECK: %[[COPYINREDI:.*]] = acc.copyin varPtr(%{{.*}} : !fir.ref) -> !fir.ref {dataClause = #acc, implicit = true, name = "reduction_i"} ! CHECK: acc.kernels {{.*}} dataOperands(%[[COPYINREDR]], %[[COPYINREDI]] : !fir.ref, !fir.ref) { -! CHECK: acc.loop {{.*}} reduction(@reduction_add_ref_f32 -> %{{.*}} : !fir.ref, @reduction_mul_ref_i32 -> %{{.*}} : !fir.ref) {{.*}} { +! CHECK: %[[REDUCTION_R:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) recipe(@reduction_add_ref_f32) -> !fir.ref {name = "reduction_r"} +! CHECK: %[[REDUCTION_I:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) recipe(@reduction_mul_ref_i32) -> !fir.ref {name = "reduction_i"} +! CHECK: acc.loop {{.*}} reduction(%[[REDUCTION_R]], %[[REDUCTION_I]] : !fir.ref, !fir.ref) {{.*}} { ! CHECK: acc.yield ! CHECK-NEXT: }{{$}} ! CHECK: acc.terminator diff --git a/flang/test/Lower/OpenACC/acc-loop.f90 b/flang/test/Lower/OpenACC/acc-loop.f90 index f9f5e8c2165d5..0c394f849baf0 100644 --- a/flang/test/Lower/OpenACC/acc-loop.f90 +++ b/flang/test/Lower/OpenACC/acc-loop.f90 @@ -27,7 +27,8 @@ program acc_loop a(i) = b(i) END DO -! CHECK: acc.loop private(@privatization_ref_i32 -> %{{.*}} : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { +! CHECK: %[[PRIVATE_I:.*]] = acc.private varPtr(%{{.*}} : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "i"} +! CHECK: acc.loop private(%[[PRIVATE_I]] : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { ! CHECK: acc.yield ! CHECK-NEXT: } attributes {inclusiveUpperbound = array, independent = [#acc.device_type]}{{$}} @@ -36,7 +37,8 @@ program acc_loop a(i) = b(i) END DO -! CHECK: acc.loop private(@privatization_ref_i32 -> %{{.*}} : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { +! CHECK: %[[PRIVATE_I:.*]] = acc.private varPtr(%{{.*}} : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "i"} +! CHECK: acc.loop private(%[[PRIVATE_I]] : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { ! CHECK: acc.yield ! CHECK-NEXT: } attributes {inclusiveUpperbound = array, seq = [#acc.device_type]} @@ -45,7 +47,8 @@ program acc_loop a(i) = b(i) END DO -! CHECK: acc.loop private(@privatization_ref_i32 -> %{{.*}} : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { +! CHECK: %[[PRIVATE_I:.*]] = acc.private varPtr(%{{.*}} : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "i"} +! CHECK: acc.loop private(%[[PRIVATE_I]] : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { ! CHECK: acc.yield ! CHECK-NEXT: } attributes {auto_ = [#acc.device_type], inclusiveUpperbound = array} @@ -54,7 +57,8 @@ program acc_loop a(i) = b(i) END DO -! CHECK: acc.loop private(@privatization_ref_i32 -> %{{.*}} : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { +! CHECK: %[[PRIVATE_I:.*]] = acc.private varPtr(%{{.*}} : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "i"} +! CHECK: acc.loop private(%[[PRIVATE_I]] : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { ! CHECK: acc.yield ! CHECK-NEXT: } attributes {inclusiveUpperbound = array, independent = [#acc.device_type]} @@ -63,7 +67,8 @@ program acc_loop a(i) = b(i) END DO -! CHECK: acc.loop gang private(@privatization_ref_i32 -> %{{.*}} : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { +! CHECK: %[[PRIVATE_I:.*]] = acc.private varPtr(%{{.*}} : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "i"} +! CHECK: acc.loop gang private(%[[PRIVATE_I]] : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { ! CHECK: acc.yield ! CHECK-NEXT: } attributes {inclusiveUpperbound = array, independent = [#acc.device_type]} @@ -73,7 +78,8 @@ program acc_loop END DO ! CHECK: [[GANGNUM1:%.*]] = arith.constant 8 : i32 -! CHECK: acc.loop gang({num=[[GANGNUM1]] : i32}) private(@privatization_ref_i32 -> %{{.*}} : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { +! CHECK: %[[PRIVATE_I:.*]] = acc.private varPtr(%{{.*}} : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "i"} +! CHECK: acc.loop gang({num=[[GANGNUM1]] : i32}) private(%[[PRIVATE_I]] : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { ! CHECK: acc.yield ! CHECK-NEXT: } attributes {inclusiveUpperbound = array, independent = [#acc.device_type]} @@ -83,7 +89,8 @@ program acc_loop END DO ! CHECK: [[GANGNUM2:%.*]] = fir.load %{{.*}} : !fir.ref -! CHECK: acc.loop gang({num=[[GANGNUM2]] : i32}) private(@privatization_ref_i32 -> %{{.*}} : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { +! CHECK: %[[PRIVATE_I:.*]] = acc.private varPtr(%{{.*}} : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "i"} +! CHECK: acc.loop gang({num=[[GANGNUM2]] : i32}) private(%[[PRIVATE_I]] : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { ! CHECK: acc.yield ! CHECK-NEXT: } attributes {inclusiveUpperbound = array, independent = [#acc.device_type]} @@ -92,7 +99,8 @@ program acc_loop a(i) = b(i) END DO -! CHECK: acc.loop gang({num=%{{.*}} : i32, static=%{{.*}} : i32}) private(@privatization_ref_i32 -> %{{.*}} : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { +! CHECK: %[[PRIVATE_I:.*]] = acc.private varPtr(%{{.*}} : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "i"} +! CHECK: acc.loop gang({num=%{{.*}} : i32, static=%{{.*}} : i32}) private(%[[PRIVATE_I]] : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { ! CHECK: acc.yield ! CHECK-NEXT: } attributes {inclusiveUpperbound = array, independent = [#acc.device_type]} @@ -101,7 +109,8 @@ program acc_loop a(i) = b(i) END DO -! CHECK: acc.loop vector private(@privatization_ref_i32 -> %{{.*}} : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { +! CHECK: %[[PRIVATE_I:.*]] = acc.private varPtr(%{{.*}} : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "i"} +! CHECK: acc.loop vector private(%[[PRIVATE_I]] : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { ! CHECK: acc.yield ! CHECK-NEXT: } attributes {inclusiveUpperbound = array, independent = [#acc.device_type]} @@ -110,8 +119,9 @@ program acc_loop a(i) = b(i) END DO -! CHECK: [[CONSTANT128:%.*]] = arith.constant 128 : i32 -! CHECK: acc.loop vector([[CONSTANT128]] : i32) private(@privatization_ref_i32 -> %{{.*}} : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { +! CHECK: [[CONSTANT128:%.*]] = arith.constant 128 : i32 +! CHECK: %[[PRIVATE_I:.*]] = acc.private varPtr(%{{.*}} : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "i"} +! CHECK: acc.loop vector([[CONSTANT128]] : i32) private(%[[PRIVATE_I]] : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { ! CHECK: acc.yield ! CHECK-NEXT: } attributes {inclusiveUpperbound = array, independent = [#acc.device_type]} @@ -121,7 +131,8 @@ program acc_loop END DO ! CHECK: [[VECTORLENGTH:%.*]] = fir.load %{{.*}} : !fir.ref -! CHECK: acc.loop vector([[VECTORLENGTH]] : i32) private(@privatization_ref_i32 -> %{{.*}} : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { +! CHECK: %[[PRIVATE_I:.*]] = acc.private varPtr(%{{.*}} : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "i"} +! CHECK: acc.loop vector([[VECTORLENGTH]] : i32) private(%[[PRIVATE_I]] : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { ! CHECK: acc.yield ! CHECK-NEXT: } attributes {inclusiveUpperbound = array, independent = [#acc.device_type]} @@ -130,7 +141,8 @@ program acc_loop a(i) = b(i) END DO -! CHECK: acc.loop worker private(@privatization_ref_i32 -> %{{.*}} : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { +! CHECK: %[[PRIVATE_I:.*]] = acc.private varPtr(%{{.*}} : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "i"} +! CHECK: acc.loop worker private(%[[PRIVATE_I]] : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { ! CHECK: acc.yield ! CHECK-NEXT: } attributes {inclusiveUpperbound = array, independent = [#acc.device_type]} @@ -139,8 +151,9 @@ program acc_loop a(i) = b(i) END DO -! CHECK: [[WORKER128:%.*]] = arith.constant 128 : i32 -! CHECK: acc.loop worker([[WORKER128]] : i32) private(@privatization_ref_i32 -> %{{.*}} : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { +! CHECK: [[WORKER128:%.*]] = arith.constant 128 : i32 +! CHECK: %[[PRIVATE_I:.*]] = acc.private varPtr(%{{.*}} : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "i"} +! CHECK: acc.loop worker([[WORKER128]] : i32) private(%[[PRIVATE_I]] : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { ! CHECK: acc.yield ! CHECK-NEXT: } attributes {inclusiveUpperbound = array, independent = [#acc.device_type]} @@ -149,7 +162,9 @@ program acc_loop c(:,i) = d(:,i) END DO -! CHECK: acc.loop private(@privatization_ref_10x10xf32 -> %{{.*}} : !fir.ref>, @privatization_ref_i32 -> %{{.*}} : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { +! CHECK: %[[PRIVATE_C:.*]] = acc.private varPtr(%{{.*}} : !fir.ref>) recipe(@privatization_ref_10x10xf32) -> !fir.ref> {name = "c"} +! CHECK: %[[PRIVATE_I:.*]] = acc.private varPtr(%{{.*}} : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "i"} +! CHECK: acc.loop private(%[[PRIVATE_C]], %[[PRIVATE_I]] : !fir.ref>, !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { ! CHECK: acc.yield ! CHECK-NEXT: } attributes {inclusiveUpperbound = array, independent = [#acc.device_type]} @@ -159,7 +174,8 @@ program acc_loop a(i) = b(i) END DO -! CHECK: acc.loop private(@privatization_ref_i32 -> %{{.*}} : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { +! CHECK: %[[PRIVATE_I:.*]] = acc.private varPtr(%{{.*}} : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {name = "i"} +! CHECK: acc.loop private(%[[PRIVATE_I]] : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { ! CHECK: acc.yield ! CHECK-NEXT: } attributes {inclusiveUpperbound = array, independent = [#acc.device_type]} @@ -168,7 +184,10 @@ program acc_loop c(:,i) = d(:,i) END DO -! CHECK: acc.loop private(@privatization_ref_10x10xf32 -> %{{.*}} : !fir.ref>, @privatization_ref_10x10xf32 -> %{{.*}} : !fir.ref>, @privatization_ref_i32 -> %{{.*}} : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { +! CHECK: %[[PRIVATE_C:.*]] = acc.private varPtr(%{{.*}} : !fir.ref>) recipe(@privatization_ref_10x10xf32) -> !fir.ref> {name = "c"} +! CHECK: %[[PRIVATE_D:.*]] = acc.private varPtr(%{{.*}} : !fir.ref>) recipe(@privatization_ref_10x10xf32) -> !fir.ref> {name = "d"} +! CHECK: %[[PRIVATE_I:.*]] = acc.private varPtr(%{{.*}} : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "i"} +! CHECK: acc.loop private(%[[PRIVATE_C]], %[[PRIVATE_D]], %[[PRIVATE_I]] : !fir.ref>, !fir.ref>, !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { ! CHECK: acc.yield ! CHECK-NEXT: } attributes {inclusiveUpperbound = array, independent = [#acc.device_type]} @@ -177,7 +196,10 @@ program acc_loop c(:,i) = d(:,i) END DO -! CHECK: acc.loop private(@privatization_ref_10x10xf32 -> %{{.*}} : !fir.ref>, @privatization_ref_10x10xf32 -> %{{.*}} : !fir.ref>, @privatization_ref_i32 -> %{{.*}} : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { +! CHECK: %[[PRIVATE_C:.*]] = acc.private varPtr(%{{.*}} : !fir.ref>) recipe(@privatization_ref_10x10xf32) -> !fir.ref> {name = "c"} +! CHECK: %[[PRIVATE_D:.*]] = acc.private varPtr(%{{.*}} : !fir.ref>) recipe(@privatization_ref_10x10xf32) -> !fir.ref> {name = "d"} +! CHECK: %[[PRIVATE_I:.*]] = acc.private varPtr(%{{.*}} : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "i"} +! CHECK: acc.loop private(%[[PRIVATE_C]], %[[PRIVATE_D]], %[[PRIVATE_I]] : !fir.ref>, !fir.ref>, !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { ! CHECK: acc.yield ! CHECK-NEXT: } attributes {inclusiveUpperbound = array, independent = [#acc.device_type]} @@ -312,7 +334,10 @@ program acc_loop reduction_i = 1 end do -! CHECK: acc.loop private(@privatization_ref_i32 -> %{{.*}} : !fir.ref) reduction(@reduction_add_ref_f32 -> %{{.*}} : !fir.ref, @reduction_mul_ref_i32 -> %{{.*}} : !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { +! CHECK: %[[REDUCTION_R:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) recipe(@reduction_add_ref_f32) -> !fir.ref {name = "reduction_r"} +! CHECK: %[[REDUCTION_I:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) recipe(@reduction_mul_ref_i32) -> !fir.ref {name = "reduction_i"} +! CHECK: %[[PRIVATE_I:.*]] = acc.private varPtr(%{{.*}} : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "i"} +! CHECK: acc.loop private(%[[PRIVATE_I]] : !fir.ref) reduction(%[[REDUCTION_R]], %[[REDUCTION_I]] : !fir.ref, !fir.ref) control(%arg0 : i32) = (%{{.*}} : i32) to (%{{.*}} : i32) step (%{{.*}} : i32) { ! CHECK: acc.yield ! CHECK-NEXT: } attributes {inclusiveUpperbound = array, independent = [#acc.device_type]} @@ -379,8 +404,8 @@ subroutine sub1(i, j, k) ! CHECK: %[[DC_J:.*]]:2 = hlfir.declare %[[ARG_J]] dummy_scope %0 ! CHECK: %[[DC_K:.*]]:2 = hlfir.declare %[[ARG_K]] dummy_scope %0 ! CHECK: acc.parallel combined(loop) -! CHECK: %[[P_I:.*]] = acc.private varPtr(%[[DC_I]]#0 : !fir.ref) -> !fir.ref {implicit = true, name = "i"} -! CHECK: %[[P_J:.*]] = acc.private varPtr(%[[DC_J]]#0 : !fir.ref) -> !fir.ref {implicit = true, name = "j"} -! CHECK: %[[P_K:.*]] = acc.private varPtr(%[[DC_K]]#0 : !fir.ref) -> !fir.ref {implicit = true, name = "k"} -! CHECK: acc.loop combined(parallel) private(@privatization_ref_i32 -> %[[P_I]] : !fir.ref, @privatization_ref_i32 -> %[[P_J]] : !fir.ref, @privatization_ref_i32 -> %[[P_K]] : !fir.ref) control(%{{.*}} : i32, %{{.*}} : i32, %{{.*}} : i32) = (%c1{{.*}}, %c1{{.*}}, %c1{{.*}} : i32, i32, i32) to (%c10{{.*}}, %c100{{.*}}, %c200{{.*}} : i32, i32, i32) step (%c1{{.*}}, %c1{{.*}}, %c1{{.*}} : i32, i32, i32) +! CHECK: %[[P_I:.*]] = acc.private varPtr(%[[DC_I]]#0 : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "i"} +! CHECK: %[[P_J:.*]] = acc.private varPtr(%[[DC_J]]#0 : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "j"} +! CHECK: %[[P_K:.*]] = acc.private varPtr(%[[DC_K]]#0 : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "k"} +! CHECK: acc.loop combined(parallel) private(%[[P_I]], %[[P_J]], %[[P_K]] : !fir.ref, !fir.ref, !fir.ref) control(%{{.*}} : i32, %{{.*}} : i32, %{{.*}} : i32) = (%c1{{.*}}, %c1{{.*}}, %c1{{.*}} : i32, i32, i32) to (%c10{{.*}}, %c100{{.*}}, %c200{{.*}} : i32, i32, i32) step (%c1{{.*}}, %c1{{.*}}, %c1{{.*}} : i32, i32, i32) ! CHECK: } attributes {inclusiveUpperbound = array, independent = [#acc.device_type]} diff --git a/flang/test/Lower/OpenACC/acc-parallel-loop.f90 b/flang/test/Lower/OpenACC/acc-parallel-loop.f90 index 8086080bd3797..186a28fce7d5e 100644 --- a/flang/test/Lower/OpenACC/acc-parallel-loop.f90 +++ b/flang/test/Lower/OpenACC/acc-parallel-loop.f90 @@ -451,10 +451,10 @@ subroutine acc_parallel_loop a(i) = b(i) END DO -! CHECK: %[[ACC_PRIVATE_B:.*]] = acc.firstprivate varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {name = "b"} -! CHECK: acc.parallel {{.*}} firstprivate(@firstprivatization_ref_10xf32 -> %[[ACC_PRIVATE_B]] : !fir.ref>) { -! CHECK: %[[ACC_PRIVATE_A:.*]] = acc.private varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a"} -! CHECK: acc.loop {{.*}} private({{.*}}@privatization_ref_10xf32 -> %[[ACC_PRIVATE_A]] : !fir.ref>{{.*}}) +! CHECK: %[[ACC_PRIVATE_B:.*]] = acc.firstprivate varPtr(%[[DECLB]]#0 : !fir.ref>) recipe(@firstprivatization_ref_10xf32) -> !fir.ref> {name = "b"} +! CHECK: acc.parallel {{.*}} firstprivate(%[[ACC_PRIVATE_B]] : !fir.ref>) { +! CHECK: %[[ACC_PRIVATE_A:.*]] = acc.private varPtr(%[[DECLA]]#0 : !fir.ref>) recipe(@privatization_ref_10xf32) -> !fir.ref> {name = "a"} +! CHECK: acc.loop {{.*}} private(%[[ACC_PRIVATE_A]]{{.*}} : !fir.ref>{{.*}}) ! CHECK-NOT: fir.do_loop ! CHECK: acc.yield ! CHECK-NEXT: }{{$}} @@ -722,7 +722,9 @@ subroutine acc_parallel_loop ! CHECK: %[[COPYINREDR:.*]] = acc.copyin varPtr(%{{.*}} : !fir.ref) -> !fir.ref {dataClause = #acc, implicit = true, name = "reduction_r"} ! CHECK: %[[COPYINREDI:.*]] = acc.copyin varPtr(%{{.*}} : !fir.ref) -> !fir.ref {dataClause = #acc, implicit = true, name = "reduction_i"} ! CHECK: acc.parallel {{.*}} dataOperands(%[[COPYINREDR]], %[[COPYINREDI]] : !fir.ref, !fir.ref) { -! CHECK: acc.loop {{.*}} reduction(@reduction_add_ref_f32 -> %{{.*}} : !fir.ref, @reduction_mul_ref_i32 -> %{{.*}} : !fir.ref) {{.*}} +! CHECK: %[[REDUCTION_R:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) recipe(@reduction_add_ref_f32) -> !fir.ref {name = "reduction_r"} +! CHECK: %[[REDUCTION_I:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) recipe(@reduction_mul_ref_i32) -> !fir.ref {name = "reduction_i"} +! CHECK: acc.loop {{.*}} reduction(%[[REDUCTION_R]], %[[REDUCTION_I]] : !fir.ref, !fir.ref) {{.*}} ! CHECK: acc.yield ! CHECK-NEXT: }{{$}} ! CHECK: acc.yield diff --git a/flang/test/Lower/OpenACC/acc-parallel.f90 b/flang/test/Lower/OpenACC/acc-parallel.f90 index 1eae106ba61b2..24c18f99bb8a5 100644 --- a/flang/test/Lower/OpenACC/acc-parallel.f90 +++ b/flang/test/Lower/OpenACC/acc-parallel.f90 @@ -330,17 +330,19 @@ 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: %[[ACC_PRIVATE_A:.*]] = acc.private varPtr(%[[DECLA]]#0 : !fir.ref>) async([[ASYNC3:%.*]]) recipe(@privatization_ref_10x10xf32) -> !fir.ref> {name = "a"} +! CHECK: %[[ACC_FPRIVATE_B:.*]] = acc.firstprivate varPtr(%[[DECLB]]#0 : !fir.ref>) async([[ASYNC3]]) recipe(@firstprivatization_ref_10x10xf32) -> !fir.ref> {name = "b"} +! CHECK: %[[ACC_PRIVATE_C:.*]] = acc.private varPtr(%[[DECLC]]#0 : !fir.ref>) async([[ASYNC3]]) recipe(@privatization_ref_10x10xf32) -> !fir.ref> {name = "c"} +! CHECK: acc.parallel async([[ASYNC3]]) firstprivate(%[[ACC_FPRIVATE_B]] : !fir.ref>) private(%[[ACC_PRIVATE_A]], %[[ACC_PRIVATE_C]] : !fir.ref>, !fir.ref>) { ! CHECK: acc.yield ! CHECK-NEXT: }{{$}} !$acc parallel reduction(+:reduction_r) reduction(*:reduction_i) !$acc end parallel -! CHECK: acc.parallel reduction(@reduction_add_ref_f32 -> %{{.*}} : !fir.ref, @reduction_mul_ref_i32 -> %{{.*}} : !fir.ref) { +! CHECK: %[[REDUCTION_R:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) recipe(@reduction_add_ref_f32) -> !fir.ref +! CHECK: %[[REDUCTION_I:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) recipe(@reduction_mul_ref_i32) -> !fir.ref +! CHECK: acc.parallel reduction(%[[REDUCTION_R]], %[[REDUCTION_I]] : !fir.ref, !fir.ref) { ! CHECK: acc.yield ! CHECK-NEXT: }{{$}} diff --git a/flang/test/Lower/OpenACC/acc-private-unwrap-defaultbounds.f90 b/flang/test/Lower/OpenACC/acc-private-unwrap-defaultbounds.f90 index b1dc4e79f9f73..c03c5d7d21781 100644 --- a/flang/test/Lower/OpenACC/acc-private-unwrap-defaultbounds.f90 +++ b/flang/test/Lower/OpenACC/acc-private-unwrap-defaultbounds.f90 @@ -190,8 +190,8 @@ program acc_private a(i) = b(i) + c END DO -! CHECK: %[[C_PRIVATE:.*]] = acc.private varPtr(%[[DECLC]]#0 : !fir.ref) -> !fir.ref {name = "c"} -! CHECK: acc.loop private({{.*}}@privatization_ref_i32 -> %[[C_PRIVATE]] : !fir.ref{{.*}}) +! CHECK: %[[C_PRIVATE:.*]] = acc.private varPtr(%[[DECLC]]#0 : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {name = "c"} +! CHECK: acc.loop private(%[[C_PRIVATE]]{{.*}} : !fir.ref{{.*}}) ! CHECK: acc.yield !$acc loop private(b) @@ -204,8 +204,8 @@ program acc_private ! CHECK: %[[LB:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.subi %{{.*}}, %[[C1]] : index ! CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%{{.*}} : index) stride(%[[C1]] : index) startIdx(%[[C1]] : index) -! CHECK: %[[B_PRIVATE:.*]] = acc.private varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "b"} -! CHECK: acc.loop private({{.*}}@privatization_ref_100xf32 -> %[[B_PRIVATE]] : !fir.ref>{{.*}}) +! CHECK: %[[B_PRIVATE:.*]] = acc.private varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%[[BOUND]]) recipe(@privatization_ref_100xf32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop private(%[[B_PRIVATE]]{{.*}} : !fir.ref>{{.*}}) ! CHECK: acc.yield !$acc loop private(b(1:50)) @@ -218,8 +218,8 @@ program acc_private ! CHECK: %[[LB:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.constant 49 : index ! CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%{{.*}} : index) stride(%[[C1]] : index) startIdx(%[[C1]] : index) -! CHECK: %[[B_PRIVATE:.*]] = acc.private varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "b(1:50)"} -! CHECK: acc.loop private({{.*}}@privatization_ref_50xf32 -> %[[B_PRIVATE]] : !fir.ref>{{.*}}) +! CHECK: %[[B_PRIVATE:.*]] = acc.private varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%[[BOUND]]) recipe(@privatization_ref_50xf32) -> !fir.ref> {name = "b(1:50)"} +! CHECK: acc.loop private(%[[B_PRIVATE]]{{.*}} : !fir.ref>{{.*}}) !$acc parallel loop firstprivate(c) DO i = 1, n @@ -227,8 +227,8 @@ program acc_private a(i) = b(i) + c END DO -! CHECK: %[[FP_C:.*]] = acc.firstprivate varPtr(%[[DECLC]]#0 : !fir.ref) -> !fir.ref {name = "c"} -! CHECK: acc.parallel {{.*}} firstprivate(@firstprivatization_ref_i32 -> %[[FP_C]] : !fir.ref) +! CHECK: %[[FP_C:.*]] = acc.firstprivate varPtr(%[[DECLC]]#0 : !fir.ref) recipe(@firstprivatization_ref_i32) -> !fir.ref {name = "c"} +! CHECK: acc.parallel {{.*}} firstprivate(%[[FP_C]] : !fir.ref) ! CHECK: acc.yield !$acc parallel loop firstprivate(b) @@ -241,8 +241,8 @@ program acc_private ! CHECK: %[[LB:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.subi %{{.*}}, %[[C1]] : index ! CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%{{.*}} : index) stride(%[[C1]] : index) startIdx(%[[C1]] : index) -! CHECK: %[[FP_B:.*]] = acc.firstprivate varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "b"} -! CHECK: acc.parallel {{.*}} firstprivate(@firstprivatization_section_ext100_ref_100xf32 -> %[[FP_B]] : !fir.ref>) +! CHECK: %[[FP_B:.*]] = acc.firstprivate varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%[[BOUND]]) recipe(@firstprivatization_section_ext100_ref_100xf32) -> !fir.ref> {name = "b"} +! CHECK: acc.parallel {{.*}} firstprivate(%[[FP_B]] : !fir.ref>) ! CHECK: acc.yield !$acc parallel loop firstprivate(b(51:100)) @@ -255,8 +255,8 @@ program acc_private ! CHECK: %[[LB:.*]] = arith.constant 50 : index ! CHECK: %[[UB:.*]] = arith.constant 99 : index ! CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%{{.*}} : index) stride(%[[C1]] : index) startIdx(%[[C1]] : index) -! CHECK: %[[FP_B:.*]] = acc.firstprivate varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "b(51:100)"} -! CHECK: acc.parallel {{.*}} firstprivate(@firstprivatization_section_lb50.ub99_ref_50xf32 -> %[[FP_B]] : !fir.ref>) +! CHECK: %[[FP_B:.*]] = acc.firstprivate varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%[[BOUND]]) recipe(@firstprivatization_section_lb50.ub99_ref_50xf32) -> !fir.ref> {name = "b(51:100)"} +! CHECK: acc.parallel {{.*}} firstprivate(%[[FP_B]] : !fir.ref>) end program @@ -274,8 +274,8 @@ subroutine acc_private_assumed_shape(a, n) ! CHECK: %[[DECL_A:.*]]:2 = hlfir.declare %[[ARG0]] dummy_scope %{{[0-9]+}} {uniq_name = "_QFacc_private_assumed_shapeEa"} : (!fir.box>, !fir.dscope) -> (!fir.box>, !fir.box>) ! CHECK: acc.parallel {{.*}} { ! CHECK: %[[ADDR:.*]] = fir.box_addr %[[DECL_A]]#0 : (!fir.box>) -> !fir.ref> -! CHECK: %[[PRIVATE:.*]] = acc.private varPtr(%[[ADDR]] : !fir.ref>) bounds(%{{.*}}) -> !fir.ref> {name = "a"} -! CHECK: acc.loop {{.*}} private({{.*}}@privatization_box_Uxi32 -> %[[PRIVATE]] : !fir.ref>{{.*}}) +! CHECK: %[[PRIVATE:.*]] = acc.private varPtr(%[[ADDR]] : !fir.ref>) bounds(%{{.*}}) recipe(@privatization_box_Uxi32) -> !fir.ref> {name = "a"} +! CHECK: acc.loop {{.*}} private(%[[PRIVATE]]{{.*}} : !fir.ref>{{.*}}) subroutine acc_private_allocatable_array(a, n) integer, allocatable :: a(:) @@ -297,9 +297,10 @@ subroutine acc_private_allocatable_array(a, n) ! CHECK: acc.parallel {{.*}} { ! CHECK: %[[BOX:.*]] = fir.load %[[DECLA_A]]#0 : !fir.ref>>> ! CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[BOX]] : (!fir.box>>) -> !fir.heap> -! CHECK: %[[PRIVATE:.*]] = acc.private varPtr(%[[BOX_ADDR]] : !fir.heap>) bounds(%{{.*}}) -> !fir.heap> {name = "a"} -! CHECK: acc.loop {{.*}} private({{.*}}@privatization_box_heap_Uxi32 -> %[[PRIVATE]] : !fir.heap>{{.*}}) -! CHECK: acc.serial private(@privatization_box_heap_Uxi32 -> %{{.*}} : !fir.heap>) +! CHECK: %[[PRIVATE:.*]] = acc.private varPtr(%[[BOX_ADDR]] : !fir.heap>) bounds(%{{.*}}) recipe(@privatization_box_heap_Uxi32) -> !fir.heap> {name = "a"} +! CHECK: acc.loop {{.*}} private(%[[PRIVATE]]{{.*}} : !fir.heap>{{.*}}) +! CHECK: %[[PRIVATE_SERIAL:.*]] = acc.private varPtr(%{{.*}} : !fir.heap>) bounds(%{{.*}}) recipe(@privatization_box_heap_Uxi32) -> !fir.heap> +! CHECK: acc.serial private(%[[PRIVATE_SERIAL]] : !fir.heap>) subroutine acc_private_pointer_array(a, n) integer, pointer :: a(:) @@ -317,8 +318,8 @@ subroutine acc_private_pointer_array(a, n) ! CHECK: acc.parallel {{.*}} { ! CHECK: %[[BOX:.*]] = fir.load %[[DECLA_A]]#0 : !fir.ref>>> ! CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[BOX]] : (!fir.box>>) -> !fir.ptr> -! CHECK: %[[PRIVATE:.*]] = acc.private varPtr(%[[BOX_ADDR]] : !fir.ptr>) bounds(%{{.*}}) -> !fir.ptr> {name = "a"} -! CHECK: acc.loop {{.*}} private({{.*}}@privatization_box_ptr_Uxi32 -> %[[PRIVATE]] : !fir.ptr>{{.*}}) +! CHECK: %[[PRIVATE:.*]] = acc.private varPtr(%[[BOX_ADDR]] : !fir.ptr>) bounds(%{{.*}}) recipe(@privatization_box_ptr_Uxi32) -> !fir.ptr> {name = "a"} +! CHECK: acc.loop {{.*}} private(%[[PRIVATE]]{{.*}} : !fir.ptr>{{.*}}) subroutine acc_private_dynamic_extent(a, n) integer :: n, i @@ -336,8 +337,8 @@ subroutine acc_private_dynamic_extent(a, n) ! CHECK: %[[DECL_A:.*]]:2 = hlfir.declare %[[ARG0]](%{{.*}}) dummy_scope %{{[0-9]+}} {uniq_name = "_QFacc_private_dynamic_extentEa"} : (!fir.ref>, !fir.shape<3>, !fir.dscope) -> (!fir.box>, !fir.ref>) ! CHECK: acc.parallel {{.*}} { ! CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[DECL_A]]#0 : (!fir.box>) -> !fir.ref> -! CHECK: %[[PRIV:.*]] = acc.private varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}, %{{.*}}) -> !fir.ref> {name = "a"} -! CHECK: acc.loop {{.*}} private({{.*}}@privatization_box_UxUx2xi32 -> %[[PRIV]] : !fir.ref>{{.*}}) +! CHECK: %[[PRIV:.*]] = acc.private varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}, %{{.*}}) recipe(@privatization_box_UxUx2xi32) -> !fir.ref> {name = "a"} +! CHECK: acc.loop {{.*}} private(%[[PRIV]]{{.*}} : !fir.ref>{{.*}}) subroutine acc_firstprivate_assumed_shape(a, n) integer :: a(:), i, n @@ -348,6 +349,10 @@ subroutine acc_firstprivate_assumed_shape(a, n) end do end subroutine +! CHECK-LABEL: func.func @_QPacc_firstprivate_assumed_shape +! CHECK: %[[FIRSTPRIVATE_A:.*]] = acc.firstprivate varPtr(%{{.*}} : !fir.ref>) bounds(%{{.*}}) recipe(@firstprivatization_box_Uxi32) -> !fir.ref> {name = "a"} +! CHECK: acc.parallel {{.*}}firstprivate(%[[FIRSTPRIVATE_A]] : !fir.ref>) + subroutine acc_firstprivate_assumed_shape_with_section(a, n) integer :: a(:), i, n @@ -357,6 +362,10 @@ subroutine acc_firstprivate_assumed_shape_with_section(a, n) end do end subroutine +! CHECK-LABEL: func.func @_QPacc_firstprivate_assumed_shape_with_section +! CHECK: %[[FIRSTPRIVATE_A:.*]] = acc.firstprivate varPtr(%{{.*}} : !fir.ref>) bounds(%{{.*}}) recipe(@firstprivatization_section_lb4.ub9_box_Uxi32) -> !fir.ref> {name = "a(5:10)"} +! CHECK: acc.parallel {{.*}}firstprivate(%[[FIRSTPRIVATE_A]] : !fir.ref>) + subroutine acc_firstprivate_dynamic_extent(a, n) integer :: n, i integer :: a(n, n, 2) @@ -367,7 +376,9 @@ subroutine acc_firstprivate_dynamic_extent(a, n) end do end subroutine -! CHECK: acc.parallel {{.*}} firstprivate(@firstprivatization_box_UxUx2xi32 -> %{{.*}} : !fir.ref>) +! CHECK-LABEL: func.func @_QPacc_firstprivate_dynamic_extent +! CHECK: %[[FIRSTPRIVATE_A:.*]] = acc.firstprivate varPtr(%{{.*}} : !fir.ref>) bounds(%{{.*}}, %{{.*}}, %{{.*}}) recipe(@firstprivatization_box_UxUx2xi32) -> !fir.ref> {name = "a"} +! CHECK: acc.parallel {{.*}}firstprivate(%[[FIRSTPRIVATE_A]] : !fir.ref>) module acc_declare_equivalent integer, parameter :: n = 10 @@ -381,7 +392,9 @@ subroutine sub1() end subroutine end module -! CHECK: acc.parallel private(@privatization_ref_10xf32 -> %{{.*}} : !fir.ref>) +! CHECK-LABEL: func.func @_QMacc_declare_equivalentPsub1 +! CHECK: %[[PRIVATE_V2:.*]] = acc.private varPtr(%{{.*}} : !fir.ptr>) bounds(%{{.*}}) recipe(@privatization_ref_10xf32) -> !fir.ref> {name = "v2"} +! CHECK: acc.parallel private(%[[PRIVATE_V2]] : !fir.ref>) subroutine acc_private_use() integer :: i, j @@ -396,8 +409,8 @@ subroutine acc_private_use() ! CHECK: %[[I:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFacc_private_useEi"} ! CHECK: %[[DECL_I:.*]]:2 = hlfir.declare %[[I]] {uniq_name = "_QFacc_private_useEi"} : (!fir.ref) -> (!fir.ref, !fir.ref) ! CHECK: acc.parallel -! CHECK: %[[PRIV_I:.*]] = acc.private varPtr(%[[DECL_I]]#0 : !fir.ref) -> !fir.ref {implicit = true, name = "i"} +! CHECK: %[[PRIV_I:.*]] = acc.private varPtr(%[[DECL_I]]#0 : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "i"} ! CHECK: %[[DECL_PRIV_I:.*]]:2 = hlfir.declare %[[PRIV_I]] {uniq_name = "_QFacc_private_useEi"} : (!fir.ref) -> (!fir.ref, !fir.ref) -! CHECK: acc.loop {{.*}} private(@privatization_ref_i32 -> %[[PRIV_I]] : !fir.ref) control(%[[IV0:.*]] : i32) = (%c1{{.*}} : i32) to (%c10{{.*}} : i32) step (%c1{{.*}} : i32) +! CHECK: acc.loop {{.*}} private(%[[PRIV_I]] : !fir.ref) control(%[[IV0:.*]] : i32) = (%c1{{.*}} : i32) to (%c10{{.*}} : i32) step (%c1{{.*}} : i32) ! CHECK: fir.store %[[IV0]] to %[[DECL_PRIV_I]]#0 : !fir.ref ! CHECK: %{{.*}} = fir.load %[[DECL_PRIV_I]]#0 : !fir.ref diff --git a/flang/test/Lower/OpenACC/acc-private.f90 b/flang/test/Lower/OpenACC/acc-private.f90 index b1bfb02439f03..85075384c41b2 100644 --- a/flang/test/Lower/OpenACC/acc-private.f90 +++ b/flang/test/Lower/OpenACC/acc-private.f90 @@ -207,8 +207,8 @@ program acc_private a(i) = b(i) + c END DO -! CHECK: %[[C_PRIVATE:.*]] = acc.private varPtr(%[[DECLC]]#0 : !fir.ref) -> !fir.ref {name = "c"} -! CHECK: acc.loop private({{.*}}@privatization_ref_i32 -> %[[C_PRIVATE]] : !fir.ref{{.*}}) +! CHECK: %[[C_PRIVATE:.*]] = acc.private varPtr(%[[DECLC]]#0 : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {name = "c"} +! CHECK: acc.loop private(%[[C_PRIVATE]]{{.*}} : !fir.ref{{.*}}) ! CHECK: acc.yield !$acc loop private(b) @@ -217,8 +217,8 @@ program acc_private a(i) = b(i) + c END DO -! CHECK: %[[B_PRIVATE:.*]] = acc.private varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {name = "b"} -! CHECK: acc.loop private({{.*}}@privatization_ref_100xf32 -> %[[B_PRIVATE]] : !fir.ref>{{.*}}) +! CHECK: %[[B_PRIVATE:.*]] = acc.private varPtr(%[[DECLB]]#0 : !fir.ref>) recipe(@privatization_ref_100xf32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop private(%[[B_PRIVATE]]{{.*}} : !fir.ref>{{.*}}) ! CHECK: acc.yield !$acc loop private(b(1:50)) @@ -231,8 +231,8 @@ program acc_private ! CHECK: %[[LB:.*]] = arith.constant 0 : index ! CHECK: %[[UB:.*]] = arith.constant 49 : index ! CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%{{.*}} : index) stride(%[[C1]] : index) startIdx(%[[C1]] : index) -! CHECK: %[[B_PRIVATE:.*]] = acc.private varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "b(1:50)"} -! CHECK: acc.loop private({{.*}}@privatization_ref_50xf32 -> %[[B_PRIVATE]] : !fir.ref>{{.*}}) +! CHECK: %[[B_PRIVATE:.*]] = acc.private varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%[[BOUND]]) recipe(@privatization_ref_50xf32) -> !fir.ref> {name = "b(1:50)"} +! CHECK: acc.loop private(%[[B_PRIVATE]]{{.*}} : !fir.ref>{{.*}}) !$acc parallel loop firstprivate(c) DO i = 1, n @@ -240,8 +240,8 @@ program acc_private a(i) = b(i) + c END DO -! CHECK: %[[FP_C:.*]] = acc.firstprivate varPtr(%[[DECLC]]#0 : !fir.ref) -> !fir.ref {name = "c"} -! CHECK: acc.parallel {{.*}} firstprivate(@firstprivatization_ref_i32 -> %[[FP_C]] : !fir.ref) +! CHECK: %[[FP_C:.*]] = acc.firstprivate varPtr(%[[DECLC]]#0 : !fir.ref) recipe(@firstprivatization_ref_i32) -> !fir.ref {name = "c"} +! CHECK: acc.parallel {{.*}} firstprivate(%[[FP_C]] : !fir.ref) ! CHECK: acc.yield !$acc parallel loop firstprivate(b) @@ -250,8 +250,8 @@ program acc_private a(i) = b(i) + c END DO -! CHECK: %[[FP_B:.*]] = acc.firstprivate varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {name = "b"} -! CHECK: acc.parallel {{.*}} firstprivate(@firstprivatization_ref_100xf32 -> %[[FP_B]] : !fir.ref>) +! CHECK: %[[FP_B:.*]] = acc.firstprivate varPtr(%[[DECLB]]#0 : !fir.ref>) recipe(@firstprivatization_ref_100xf32) -> !fir.ref> {name = "b"} +! CHECK: acc.parallel {{.*}} firstprivate(%[[FP_B]] : !fir.ref>) ! CHECK: acc.yield !$acc parallel loop firstprivate(b(51:100)) @@ -264,8 +264,8 @@ program acc_private ! CHECK: %[[LB:.*]] = arith.constant 50 : index ! CHECK: %[[UB:.*]] = arith.constant 99 : index ! CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%{{.*}} : index) stride(%[[C1]] : index) startIdx(%[[C1]] : index) -! CHECK: %[[FP_B:.*]] = acc.firstprivate varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "b(51:100)"} -! CHECK: acc.parallel {{.*}} firstprivate(@firstprivatization_section_lb50.ub99_ref_50xf32 -> %[[FP_B]] : !fir.ref>) +! CHECK: %[[FP_B:.*]] = acc.firstprivate varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%[[BOUND]]) recipe(@firstprivatization_section_lb50.ub99_ref_50xf32) -> !fir.ref> {name = "b(51:100)"} +! CHECK: acc.parallel {{.*}} firstprivate(%[[FP_B]] : !fir.ref>) end program @@ -282,8 +282,8 @@ subroutine acc_private_assumed_shape(a, n) ! CHECK-SAME: %[[ARG0:.*]]: !fir.box> {fir.bindc_name = "a"} ! CHECK: %[[DECL_A:.*]]:2 = hlfir.declare %[[ARG0]] dummy_scope %{{[0-9]+}} {uniq_name = "_QFacc_private_assumed_shapeEa"} : (!fir.box>, !fir.dscope) -> (!fir.box>, !fir.box>) ! CHECK: acc.parallel {{.*}} { -! CHECK: %[[PRIVATE:.*]] = acc.private var(%[[DECL_A]]#0 : !fir.box>) -> !fir.box> {name = "a"} -! CHECK: acc.loop {{.*}} private({{.*}}@privatization_box_Uxi32 -> %[[PRIVATE]] : !fir.box>{{.*}}) +! CHECK: %[[PRIVATE:.*]] = acc.private var(%[[DECL_A]]#0 : !fir.box>) recipe(@privatization_box_Uxi32) -> !fir.box> {name = "a"} +! CHECK: acc.loop {{.*}} private(%[[PRIVATE]]{{.*}} : !fir.box>{{.*}}) subroutine acc_private_allocatable_array(a, n) integer, allocatable :: a(:) @@ -303,9 +303,10 @@ subroutine acc_private_allocatable_array(a, n) ! CHECK-SAME: %[[ARG0:.*]]: !fir.ref>>> {fir.bindc_name = "a"} ! CHECK: %[[DECLA_A:.*]]:2 = hlfir.declare %[[ARG0]] dummy_scope %{{[0-9]+}} {fortran_attrs = #fir.var_attrs, uniq_name = "_QFacc_private_allocatable_arrayEa"} : (!fir.ref>>>, !fir.dscope) -> (!fir.ref>>>, !fir.ref>>>) ! CHECK: acc.parallel {{.*}} { -! CHECK: %[[PRIVATE:.*]] = acc.private varPtr(%[[DECLA_A]]#0 : !fir.ref>>>) -> !fir.ref>>> {name = "a"} -! CHECK: acc.loop {{.*}} private({{.*}}@privatization_ref_box_heap_Uxi32 -> %[[PRIVATE]] : !fir.ref>>>{{.*}}) -! CHECK: acc.serial private(@privatization_ref_box_heap_Uxi32 -> %{{.*}} : !fir.ref>>>) +! CHECK: %[[PRIVATE:.*]] = acc.private varPtr(%[[DECLA_A]]#0 : !fir.ref>>>) recipe(@privatization_ref_box_heap_Uxi32) -> !fir.ref>>> {name = "a"} +! CHECK: acc.loop {{.*}} private(%[[PRIVATE]]{{.*}} : !fir.ref>>>{{.*}}) +! CHECK: %[[PRIVATE_SERIAL:.*]] = acc.private varPtr(%{{.*}} : !fir.ref>>>) recipe(@privatization_ref_box_heap_Uxi32) -> !fir.ref>>> +! CHECK: acc.serial private(%[[PRIVATE_SERIAL]] : !fir.ref>>>) subroutine acc_private_allocatable_scalar(b, a, n) integer :: a(n) @@ -326,9 +327,10 @@ subroutine acc_private_allocatable_scalar(b, a, n) ! CHECK-SAME: %[[ARG0:.*]]: !fir.ref>> {fir.bindc_name = "b"} ! CHECK: %[[DECLA_B:.*]]:2 = hlfir.declare %arg0 dummy_scope %0 {fortran_attrs = #fir.var_attrs, uniq_name = "_QFacc_private_allocatable_scalarEb"} : (!fir.ref>>, !fir.dscope) -> (!fir.ref>>, !fir.ref>>) ! CHECK: acc.parallel {{.*}} { -! CHECK: %[[PRIVATE:.*]] = acc.private varPtr(%[[DECLA_B]]#0 : !fir.ref>>) -> !fir.ref>> {name = "b"} -! CHECK: acc.loop {{.*}} private({{.*}}@privatization_ref_box_heap_i32 -> %[[PRIVATE]] : !fir.ref>>{{.*}}) -! CHECK: acc.serial private(@privatization_ref_box_heap_i32 -> %{{.*}} : !fir.ref>>) { +! CHECK: %[[PRIVATE:.*]] = acc.private varPtr(%[[DECLA_B]]#0 : !fir.ref>>) recipe(@privatization_ref_box_heap_i32) -> !fir.ref>> {name = "b"} +! CHECK: acc.loop {{.*}} private(%[[PRIVATE]]{{.*}} : !fir.ref>>{{.*}}) +! CHECK: %[[PRIVATE_SERIAL:.*]] = acc.private varPtr(%{{.*}} : !fir.ref>>) recipe(@privatization_ref_box_heap_i32) -> !fir.ref>> +! CHECK: acc.serial private(%[[PRIVATE_SERIAL]] : !fir.ref>>) { subroutine acc_private_pointer_array(a, n) integer, pointer :: a(:) @@ -344,8 +346,8 @@ subroutine acc_private_pointer_array(a, n) ! CHECK-SAME: %[[ARG0:.*]]: !fir.ref>>> {fir.bindc_name = "a"}, %arg1: !fir.ref {fir.bindc_name = "n"}) { ! CHECK: %[[DECL_A:.*]]:2 = hlfir.declare %arg0 dummy_scope %{{[0-9]+}} {fortran_attrs = #fir.var_attrs, uniq_name = "_QFacc_private_pointer_arrayEa"} : (!fir.ref>>>, !fir.dscope) -> (!fir.ref>>>, !fir.ref>>>) ! CHECK: acc.parallel {{.*}} { -! CHECK: %[[PRIVATE:.*]] = acc.private varPtr(%[[DECLA_A]]#0 : !fir.ref>>>) -> !fir.ref>>> {name = "a"} -! CHECK: acc.loop {{.*}} private({{.*}}@privatization_ref_box_ptr_Uxi32 -> %[[PRIVATE]] : !fir.ref>>>{{.*}}) +! CHECK: %[[PRIVATE:.*]] = acc.private varPtr(%[[DECLA_A]]#0 : !fir.ref>>>) recipe(@privatization_ref_box_ptr_Uxi32) -> !fir.ref>>> {name = "a"} +! CHECK: acc.loop {{.*}} private(%[[PRIVATE]]{{.*}} : !fir.ref>>>{{.*}}) subroutine acc_private_dynamic_extent(a, n) integer :: n, i @@ -362,8 +364,8 @@ subroutine acc_private_dynamic_extent(a, n) ! CHECK: %[[DECL_N:.*]]:2 = hlfir.declare %[[ARG1]] dummy_scope %{{[0-9]+}} {uniq_name = "_QFacc_private_dynamic_extentEn"} : (!fir.ref, !fir.dscope) -> (!fir.ref, !fir.ref) ! CHECK: %[[DECL_A:.*]]:2 = hlfir.declare %[[ARG0]](%{{.*}}) dummy_scope %{{[0-9]+}} {uniq_name = "_QFacc_private_dynamic_extentEa"} : (!fir.ref>, !fir.shape<3>, !fir.dscope) -> (!fir.box>, !fir.ref>) ! CHECK: acc.parallel {{.*}} { -! CHECK: %[[PRIV:.*]] = acc.private var(%[[DECL_A]]#0 : !fir.box>) -> !fir.box> {name = "a"} -! CHECK: acc.loop {{.*}} private({{.*}}@privatization_box_UxUx2xi32 -> %[[PRIV]] : !fir.box>{{.*}}) +! CHECK: %[[PRIV:.*]] = acc.private var(%[[DECL_A]]#0 : !fir.box>) recipe(@privatization_box_UxUx2xi32) -> !fir.box> {name = "a"} +! CHECK: acc.loop {{.*}} private(%[[PRIV]]{{.*}} : !fir.box>{{.*}}) subroutine acc_firstprivate_assumed_shape(a, n) integer :: a(:), i, n @@ -374,6 +376,10 @@ subroutine acc_firstprivate_assumed_shape(a, n) end do end subroutine +! CHECK-LABEL: func.func @_QPacc_firstprivate_assumed_shape +! CHECK: %[[FIRSTPRIVATE_A:.*]] = acc.firstprivate var(%{{.*}} : !fir.box>) recipe(@firstprivatization_box_Uxi32) -> !fir.box> {name = "a"} +! CHECK: acc.parallel {{.*}}firstprivate(%[[FIRSTPRIVATE_A]] : !fir.box>) { + subroutine acc_firstprivate_assumed_shape_with_section(a, n) integer :: a(:), i, n @@ -383,6 +389,10 @@ subroutine acc_firstprivate_assumed_shape_with_section(a, n) end do end subroutine +! CHECK-LABEL: func.func @_QPacc_firstprivate_assumed_shape_with_section +! CHECK: %[[FIRSTPRIVATE_A:.*]] = acc.firstprivate var(%{{.*}} : !fir.box>) bounds(%{{.*}}) recipe(@firstprivatization_section_lb4.ub9_box_Uxi32) -> !fir.box> {name = "a(5:10)"} +! CHECK: acc.parallel {{.*}}firstprivate(%[[FIRSTPRIVATE_A]] : !fir.box>) + subroutine acc_firstprivate_dynamic_extent(a, n) integer :: n, i integer :: a(n, n, 2) @@ -393,7 +403,9 @@ subroutine acc_firstprivate_dynamic_extent(a, n) end do end subroutine -! CHECK: acc.parallel {{.*}} firstprivate(@firstprivatization_box_UxUx2xi32 -> %{{.*}} : !fir.box>) +! CHECK-LABEL: func.func @_QPacc_firstprivate_dynamic_extent +! CHECK: %[[FIRSTPRIVATE_A:.*]] = acc.firstprivate var(%{{.*}} : !fir.box>) recipe(@firstprivatization_box_UxUx2xi32) -> !fir.box> {name = "a"} +! CHECK: acc.parallel {{.*}}firstprivate(%[[FIRSTPRIVATE_A]] : !fir.box>) module acc_declare_equivalent integer, parameter :: n = 10 @@ -407,7 +419,8 @@ subroutine sub1() end subroutine end module -! CHECK: acc.parallel private(@privatization_ptr_10xf32 -> %{{.*}} : !fir.ptr>) +! CHECK: %[[PRIVATE_V2:.*]] = acc.private varPtr(%{{.*}} : !fir.ptr>) recipe(@privatization_ptr_10xf32) -> !fir.ptr> +! CHECK: acc.parallel private(%[[PRIVATE_V2]] : !fir.ptr>) subroutine acc_private_use() integer :: i, j @@ -422,8 +435,8 @@ subroutine acc_private_use() ! CHECK: %[[I:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFacc_private_useEi"} ! CHECK: %[[DECL_I:.*]]:2 = hlfir.declare %[[I]] {uniq_name = "_QFacc_private_useEi"} : (!fir.ref) -> (!fir.ref, !fir.ref) ! CHECK: acc.parallel -! CHECK: %[[PRIV_I:.*]] = acc.private varPtr(%[[DECL_I]]#0 : !fir.ref) -> !fir.ref {implicit = true, name = "i"} +! CHECK: %[[PRIV_I:.*]] = acc.private varPtr(%[[DECL_I]]#0 : !fir.ref) recipe(@privatization_ref_i32) -> !fir.ref {implicit = true, name = "i"} ! CHECK: %[[DECL_PRIV_I:.*]]:2 = hlfir.declare %[[PRIV_I]] {uniq_name = "_QFacc_private_useEi"} : (!fir.ref) -> (!fir.ref, !fir.ref) -! CHECK: acc.loop {{.*}} private(@privatization_ref_i32 -> %[[PRIV_I]] : !fir.ref) control(%[[IV0:.*]] : i32) = (%c1{{.*}} : i32) to (%c10{{.*}} : i32) step (%c1{{.*}} : i32) +! CHECK: acc.loop {{.*}} private(%[[PRIV_I]] : !fir.ref) control(%[[IV0:.*]] : i32) = (%c1{{.*}} : i32) to (%c10{{.*}} : i32) step (%c1{{.*}} : i32) ! CHECK: fir.store %[[IV0]] to %[[DECL_PRIV_I]]#0 : !fir.ref ! CHECK: %{{.*}} = fir.load %[[DECL_PRIV_I]]#0 : !fir.ref diff --git a/flang/test/Lower/OpenACC/acc-reduction-unwrap-defaultbounds.f90 b/flang/test/Lower/OpenACC/acc-reduction-unwrap-defaultbounds.f90 index 5bb751678ed53..8ec089ea265a7 100644 --- a/flang/test/Lower/OpenACC/acc-reduction-unwrap-defaultbounds.f90 +++ b/flang/test/Lower/OpenACC/acc-reduction-unwrap-defaultbounds.f90 @@ -704,8 +704,8 @@ subroutine acc_reduction_add_int(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_add_int( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) -> !fir.ref {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_add_ref_i32 -> %[[RED_B]] : !fir.ref) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) recipe(@reduction_add_ref_i32) -> !fir.ref {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref) subroutine acc_reduction_add_int_array_1d(a, b) integer :: a(100) @@ -720,8 +720,8 @@ subroutine acc_reduction_add_int_array_1d(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_add_int_array_1d( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref> {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%{{.*}}) -> !fir.ref> {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_add_section_ext100_ref_100xi32 -> %[[RED_B]] : !fir.ref>) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%{{.*}}) recipe(@reduction_add_section_ext100_ref_100xi32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref>) subroutine acc_reduction_add_int_array_2d(a, b) integer :: a(100, 10), b(100, 10) @@ -738,8 +738,8 @@ subroutine acc_reduction_add_int_array_2d(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_add_int_array_2d( ! CHECK-SAME: %[[ARG0:.*]]: !fir.ref> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.ref> {fir.bindc_name = "b"}) { ! CHECK: %[[DECLARG1:.*]]:2 = hlfir.declare %[[ARG1]] -! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_add_section_ext100xext10_ref_100x10xi32 -> %[[RED_ARG1]] : !fir.ref>) +! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) recipe(@reduction_add_section_ext100xext10_ref_100x10xi32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_ARG1]] : !fir.ref>) ! CHECK: } attributes {collapse = [2]{{.*}} subroutine acc_reduction_add_int_array_3d(a, b) @@ -759,8 +759,8 @@ subroutine acc_reduction_add_int_array_3d(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_add_int_array_3d( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.ref> {fir.bindc_name = "b"}) ! CHECK: %[[DECLARG1:.*]]:2 = hlfir.declare %[[ARG1]] -! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}, %{{.*}}) -> !fir.ref> {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_add_section_ext100xext10xext2_ref_100x10x2xi32 -> %[[RED_ARG1]] : !fir.ref>) +! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}, %{{.*}}) recipe(@reduction_add_section_ext100xext10xext2_ref_100x10x2xi32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_ARG1]] : !fir.ref>) ! CHECK: } attributes {collapse = [3]{{.*}} subroutine acc_reduction_add_float(a, b) @@ -776,8 +776,8 @@ subroutine acc_reduction_add_float(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_add_float( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) -> !fir.ref {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_add_ref_f32 -> %[[RED_B]] : !fir.ref) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) recipe(@reduction_add_ref_f32) -> !fir.ref {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref) subroutine acc_reduction_add_float_array_1d(a, b) real :: a(100), b(100) @@ -792,8 +792,8 @@ subroutine acc_reduction_add_float_array_1d(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_add_float_array_1d( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref> {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%{{.*}}) -> !fir.ref> {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_add_section_ext100_ref_100xf32 -> %[[RED_B]] : !fir.ref>) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%{{.*}}) recipe(@reduction_add_section_ext100_ref_100xf32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref>) subroutine acc_reduction_mul_int(a, b) integer :: a(100) @@ -808,8 +808,8 @@ subroutine acc_reduction_mul_int(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_mul_int( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) -> !fir.ref {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_mul_ref_i32 -> %[[RED_B]] : !fir.ref) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) recipe(@reduction_mul_ref_i32) -> !fir.ref {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref) subroutine acc_reduction_mul_int_array_1d(a, b) integer :: a(100) @@ -824,8 +824,8 @@ subroutine acc_reduction_mul_int_array_1d(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_mul_int_array_1d( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref> {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%{{.*}}) -> !fir.ref> {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_mul_section_ext100_ref_100xi32 -> %[[RED_B]] : !fir.ref>) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%{{.*}}) recipe(@reduction_mul_section_ext100_ref_100xi32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref>) subroutine acc_reduction_mul_float(a, b) real :: a(100), b @@ -840,8 +840,8 @@ subroutine acc_reduction_mul_float(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_mul_float( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) -> !fir.ref {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_mul_ref_f32 -> %[[RED_B]] : !fir.ref) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) recipe(@reduction_mul_ref_f32) -> !fir.ref {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref) subroutine acc_reduction_mul_float_array_1d(a, b) real :: a(100), b(100) @@ -856,8 +856,8 @@ subroutine acc_reduction_mul_float_array_1d(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_mul_float_array_1d( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref> {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%{{.*}}) -> !fir.ref> {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_mul_section_ext100_ref_100xf32 -> %[[RED_B]] : !fir.ref>) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref>) bounds(%{{.*}}) recipe(@reduction_mul_section_ext100_ref_100xf32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref>) subroutine acc_reduction_min_int(a, b) integer :: a(100) @@ -872,8 +872,8 @@ subroutine acc_reduction_min_int(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_min_int( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) -> !fir.ref {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_min_ref_i32 -> %[[RED_B]] : !fir.ref) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) recipe(@reduction_min_ref_i32) -> !fir.ref {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref) subroutine acc_reduction_min_int_array_1d(a, b) integer :: a(100), b(100) @@ -888,8 +888,8 @@ subroutine acc_reduction_min_int_array_1d(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_min_int_array_1d( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.ref> {fir.bindc_name = "b"}) ! CHECK: %[[DECLARG1:.*]]:2 = hlfir.declare %[[ARG1]] -! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) bounds(%{{.*}}) -> !fir.ref> {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_min_section_ext100_ref_100xi32 -> %[[RED_ARG1]] : !fir.ref>) +! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) bounds(%{{.*}}) recipe(@reduction_min_section_ext100_ref_100xi32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_ARG1]] : !fir.ref>) subroutine acc_reduction_min_float(a, b) real :: a(100), b @@ -904,8 +904,8 @@ subroutine acc_reduction_min_float(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_min_float( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) -> !fir.ref {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_min_ref_f32 -> %[[RED_B]] : !fir.ref) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) recipe(@reduction_min_ref_f32) -> !fir.ref {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref) subroutine acc_reduction_min_float_array2d(a, b) real :: a(100, 10), b(100, 10) @@ -922,8 +922,8 @@ subroutine acc_reduction_min_float_array2d(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_min_float_array2d( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.ref> {fir.bindc_name = "b"}) ! CHECK: %[[DECLARG1:.*]]:2 = hlfir.declare %[[ARG1]] -! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_min_section_ext100xext10_ref_100x10xf32 -> %[[RED_ARG1]] : !fir.ref>) +! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) recipe(@reduction_min_section_ext100xext10_ref_100x10xf32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_ARG1]] : !fir.ref>) ! CHECK: attributes {collapse = [2]{{.*}} subroutine acc_reduction_max_int(a, b) @@ -939,8 +939,8 @@ subroutine acc_reduction_max_int(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_max_int( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) -> !fir.ref {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_max_ref_i32 -> %[[RED_B]] : !fir.ref) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) recipe(@reduction_max_ref_i32) -> !fir.ref {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref) subroutine acc_reduction_max_int_array2d(a, b) integer :: a(100, 10), b(100, 10) @@ -957,8 +957,8 @@ subroutine acc_reduction_max_int_array2d(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_max_int_array2d( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.ref> {fir.bindc_name = "b"}) ! CHECK: %[[DECLARG1:.*]]:2 = hlfir.declare %[[ARG1]] -! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_max_section_ext100xext10_ref_100x10xi32 -> %[[RED_ARG1]] : !fir.ref>) +! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) bounds(%{{.*}}, %{{.*}}) recipe(@reduction_max_section_ext100xext10_ref_100x10xi32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_ARG1]] : !fir.ref>) subroutine acc_reduction_max_float(a, b) real :: a(100), b @@ -973,8 +973,8 @@ subroutine acc_reduction_max_float(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_max_float( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) -> !fir.ref {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_max_ref_f32 -> %[[RED_B]] : !fir.ref) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) recipe(@reduction_max_ref_f32) -> !fir.ref {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref) subroutine acc_reduction_max_float_array1d(a, b) real :: a(100), b(100) @@ -989,8 +989,8 @@ subroutine acc_reduction_max_float_array1d(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_max_float_array1d( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.ref> {fir.bindc_name = "b"}) ! CHECK: %[[DECLARG1:.*]]:2 = hlfir.declare %[[ARG1]] -! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) bounds(%{{.*}}) -> !fir.ref> {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_max_section_ext100_ref_100xf32 -> %[[RED_ARG1]] : !fir.ref>) +! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) bounds(%{{.*}}) recipe(@reduction_max_section_ext100_ref_100xf32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_ARG1]] : !fir.ref>) subroutine acc_reduction_iand() integer :: i @@ -999,8 +999,8 @@ subroutine acc_reduction_iand() end subroutine ! CHECK-LABEL: func.func @_QPacc_reduction_iand() -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) -> !fir.ref {name = "i"} -! CHECK: acc.parallel reduction(@reduction_iand_ref_i32 -> %[[RED]] : !fir.ref) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) recipe(@reduction_iand_ref_i32) -> !fir.ref {name = "i"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref) subroutine acc_reduction_ior() integer :: i @@ -1009,8 +1009,8 @@ subroutine acc_reduction_ior() end subroutine ! CHECK-LABEL: func.func @_QPacc_reduction_ior() -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) -> !fir.ref {name = "i"} -! CHECK: acc.parallel reduction(@reduction_ior_ref_i32 -> %[[RED]] : !fir.ref) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) recipe(@reduction_ior_ref_i32) -> !fir.ref {name = "i"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref) subroutine acc_reduction_ieor() integer :: i @@ -1019,8 +1019,8 @@ subroutine acc_reduction_ieor() end subroutine ! CHECK-LABEL: func.func @_QPacc_reduction_ieor() -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) -> !fir.ref {name = "i"} -! CHECK: acc.parallel reduction(@reduction_xor_ref_i32 -> %[[RED]] : !fir.ref) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) recipe(@reduction_xor_ref_i32) -> !fir.ref {name = "i"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref) subroutine acc_reduction_and() logical :: l @@ -1031,8 +1031,8 @@ subroutine acc_reduction_and() ! CHECK-LABEL: func.func @_QPacc_reduction_and() ! CHECK: %[[L:.*]] = fir.alloca !fir.logical<4> {bindc_name = "l", uniq_name = "_QFacc_reduction_andEl"} ! CHECK: %[[DECLL:.*]]:2 = hlfir.declare %[[L]] -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[DECLL]]#0 : !fir.ref>) -> !fir.ref> {name = "l"} -! CHECK: acc.parallel reduction(@reduction_land_ref_l32 -> %[[RED]] : !fir.ref>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[DECLL]]#0 : !fir.ref>) recipe(@reduction_land_ref_l32) -> !fir.ref> {name = "l"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>) subroutine acc_reduction_or() logical :: l @@ -1041,8 +1041,8 @@ subroutine acc_reduction_or() end subroutine ! CHECK-LABEL: func.func @_QPacc_reduction_or() -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) -> !fir.ref> {name = "l"} -! CHECK: acc.parallel reduction(@reduction_lor_ref_l32 -> %[[RED]] : !fir.ref>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) recipe(@reduction_lor_ref_l32) -> !fir.ref> {name = "l"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>) subroutine acc_reduction_eqv() logical :: l @@ -1051,8 +1051,8 @@ subroutine acc_reduction_eqv() end subroutine ! CHECK-LABEL: func.func @_QPacc_reduction_eqv() -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) -> !fir.ref> {name = "l"} -! CHECK: acc.parallel reduction(@reduction_eqv_ref_l32 -> %[[RED]] : !fir.ref>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) recipe(@reduction_eqv_ref_l32) -> !fir.ref> {name = "l"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>) subroutine acc_reduction_neqv() logical :: l @@ -1061,8 +1061,8 @@ subroutine acc_reduction_neqv() end subroutine ! CHECK-LABEL: func.func @_QPacc_reduction_neqv() -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) -> !fir.ref> {name = "l"} -! CHECK: acc.parallel reduction(@reduction_neqv_ref_l32 -> %[[RED]] : !fir.ref>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) recipe(@reduction_neqv_ref_l32) -> !fir.ref> {name = "l"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>) subroutine acc_reduction_add_cmplx() complex :: c @@ -1071,8 +1071,8 @@ subroutine acc_reduction_add_cmplx() end subroutine ! CHECK-LABEL: func.func @_QPacc_reduction_add_cmplx() -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) -> !fir.ref> {name = "c"} -! CHECK: acc.parallel reduction(@reduction_add_ref_z32 -> %[[RED]] : !fir.ref>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) recipe(@reduction_add_ref_z32) -> !fir.ref> {name = "c"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>) subroutine acc_reduction_mul_cmplx() complex :: c @@ -1081,8 +1081,8 @@ subroutine acc_reduction_mul_cmplx() end subroutine ! CHECK-LABEL: func.func @_QPacc_reduction_mul_cmplx() -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) -> !fir.ref> {name = "c"} -! CHECK: acc.parallel reduction(@reduction_mul_ref_z32 -> %[[RED]] : !fir.ref>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) recipe(@reduction_mul_ref_z32) -> !fir.ref> {name = "c"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>) subroutine acc_reduction_add_alloc() integer, allocatable :: i @@ -1096,8 +1096,8 @@ subroutine acc_reduction_add_alloc() ! CHECK: %[[DECL:.*]]:2 = hlfir.declare %[[ALLOCA]] ! CHECK: %[[LOAD:.*]] = fir.load %[[DECL]]#0 : !fir.ref>> ! CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[LOAD]] : (!fir.box>) -> !fir.heap -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[BOX_ADDR]] : !fir.heap) -> !fir.heap {name = "i"} -! CHECK: acc.parallel reduction(@reduction_add_heap_i32 -> %[[RED]] : !fir.heap) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[BOX_ADDR]] : !fir.heap) recipe(@reduction_add_heap_i32) -> !fir.heap {name = "i"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.heap) subroutine acc_reduction_add_pointer(i) integer, pointer :: i @@ -1110,8 +1110,8 @@ subroutine acc_reduction_add_pointer(i) ! CHECK: %[[DECLARG0:.*]]:2 = hlfir.declare %[[ARG0]] ! CHECK: %[[LOAD:.*]] = fir.load %[[DECLARG0]]#0 : !fir.ref>> ! CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[LOAD]] : (!fir.box>) -> !fir.ptr -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[BOX_ADDR]] : !fir.ptr) -> !fir.ptr {name = "i"} -! CHECK: acc.parallel reduction(@reduction_add_ptr_i32 -> %[[RED]] : !fir.ptr) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[BOX_ADDR]] : !fir.ptr) recipe(@reduction_add_ptr_i32) -> !fir.ptr {name = "i"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ptr) subroutine acc_reduction_add_static_slice(a) integer :: a(100) @@ -1127,8 +1127,8 @@ subroutine acc_reduction_add_static_slice(a) ! CHECK: %[[LB:.*]] = arith.constant 10 : index ! CHECK: %[[UB:.*]] = arith.constant 19 : index ! CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[C100]] : index) stride(%[[C1]] : index) startIdx(%[[C1]] : index) -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[DECLARG0]]#0 : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(11:20)"} -! CHECK: acc.parallel reduction(@reduction_add_section_lb10.ub19_ref_100xi32 -> %[[RED]] : !fir.ref>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[DECLARG0]]#0 : !fir.ref>) bounds(%[[BOUND]]) recipe(@reduction_add_section_lb10.ub19_ref_100xi32) -> !fir.ref> {name = "a(11:20)"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>) subroutine acc_reduction_add_dynamic_extent_add(a) integer :: a(:) @@ -1139,8 +1139,8 @@ subroutine acc_reduction_add_dynamic_extent_add(a) ! CHECK-LABEL: func.func @_QPacc_reduction_add_dynamic_extent_add( ! CHECK-SAME: %[[ARG0:.*]]: !fir.box> {fir.bindc_name = "a"}) ! CHECK: %[[DECLARG0:.*]]:2 = hlfir.declare %[[ARG0]] -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) bounds(%{{.*}}) -> !fir.ref> {name = "a"} -! CHECK: acc.parallel reduction(@reduction_add_box_Uxi32 -> %[[RED:.*]] : !fir.ref>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) bounds(%{{.*}}) recipe(@reduction_add_box_Uxi32) -> !fir.ref> {name = "a"} +! CHECK: acc.parallel reduction(%[[RED:.*]] : !fir.ref>) subroutine acc_reduction_add_assumed_shape_max(a) real :: a(:) @@ -1151,8 +1151,8 @@ subroutine acc_reduction_add_assumed_shape_max(a) ! CHECK-LABEL: func.func @_QPacc_reduction_add_assumed_shape_max( ! CHECK-SAME: %[[ARG0:.*]]: !fir.box> {fir.bindc_name = "a"}) ! CHECK: %[[DECLARG0:.*]]:2 = hlfir.declare %[[ARG0]] -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) bounds(%{{.*}}) -> !fir.ref> {name = "a"} -! CHECK: acc.parallel reduction(@reduction_max_box_Uxf32 -> %[[RED]] : !fir.ref>) { +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) bounds(%{{.*}}) recipe(@reduction_max_box_Uxf32) -> !fir.ref> {name = "a"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>) { subroutine acc_reduction_add_dynamic_extent_add_with_section(a) integer :: a(:) @@ -1165,8 +1165,8 @@ subroutine acc_reduction_add_dynamic_extent_add_with_section(a) ! CHECK: %[[DECL:.*]]:2 = hlfir.declare %[[ARG0]] dummy_scope %{{[0-9]+}} {uniq_name = "_QFacc_reduction_add_dynamic_extent_add_with_sectionEa"} : (!fir.box>, !fir.dscope) -> (!fir.box>, !fir.box>) ! CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%c1{{.*}} : index) upperbound(%c3{{.*}} : index) extent(%{{.*}}#1 : index) stride(%{{.*}}#2 : index) startIdx(%{{.*}} : index) {strideInBytes = true} ! CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[DECL]]#0 : (!fir.box>) -> !fir.ref> -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(2:4)"} -! CHECK: acc.parallel reduction(@reduction_add_section_lb1.ub3_box_Uxi32 -> %[[RED]] : !fir.ref>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[BOX_ADDR]] : !fir.ref>) bounds(%[[BOUND]]) recipe(@reduction_add_section_lb1.ub3_box_Uxi32) -> !fir.ref> {name = "a(2:4)"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>) subroutine acc_reduction_add_allocatable(a) real, allocatable :: a(:) @@ -1180,8 +1180,8 @@ subroutine acc_reduction_add_allocatable(a) ! CHECK: %[[BOX:.*]] = fir.load %[[DECL]]#0 : !fir.ref>>> ! CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%c0{{.*}} : index) upperbound(%{{.*}} : index) extent(%{{.*}}#1 : index) stride(%{{.*}}#2 : index) startIdx(%{{.*}}#0 : index) {strideInBytes = true} ! CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[BOX]] : (!fir.box>>) -> !fir.heap> -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[BOX_ADDR]] : !fir.heap>) bounds(%{{[0-9]+}}) -> !fir.heap> {name = "a"} -! CHECK: acc.parallel reduction(@reduction_max_box_heap_Uxf32 -> %[[RED]] : !fir.heap>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[BOX_ADDR]] : !fir.heap>) bounds(%{{[0-9]+}}) recipe(@reduction_max_box_heap_Uxf32) -> !fir.heap> {name = "a"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.heap>) subroutine acc_reduction_add_pointer_array(a) real, pointer :: a(:) @@ -1195,8 +1195,8 @@ subroutine acc_reduction_add_pointer_array(a) ! CHECK: %[[BOX:.*]] = fir.load %[[DECL]]#0 : !fir.ref>>> ! CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%c0{{.*}} : index) upperbound(%{{.*}} : index) extent(%{{.*}}#1 : index) stride(%{{.*}}#2 : index) startIdx(%{{.*}}#0 : index) {strideInBytes = true} ! CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[BOX]] : (!fir.box>>) -> !fir.ptr> -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[BOX_ADDR]] : !fir.ptr>) bounds(%[[BOUND]]) -> !fir.ptr> {name = "a"} -! CHECK: acc.parallel reduction(@reduction_max_box_ptr_Uxf32 -> %[[RED]] : !fir.ptr>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[BOX_ADDR]] : !fir.ptr>) bounds(%[[BOUND]]) recipe(@reduction_max_box_ptr_Uxf32) -> !fir.ptr> {name = "a"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ptr>) subroutine acc_reduction_max_dynamic_extent_max(a, n) integer :: n @@ -1209,5 +1209,5 @@ subroutine acc_reduction_max_dynamic_extent_max(a, n) ! CHECK-SAME: %[[ARG0:.*]]: !fir.ref> {fir.bindc_name = "a"}, %{{.*}}: !fir.ref {fir.bindc_name = "n"}) ! CHECK: %[[DECL_A:.*]]:2 = hlfir.declare %[[ARG0]](%{{.*}}) dummy_scope %{{[0-9]+}} {uniq_name = "_QFacc_reduction_max_dynamic_extent_maxEa"} : (!fir.ref>, !fir.shape<2>, !fir.dscope) -> (!fir.box>, !fir.ref>) ! CHECK: %[[ADDR:.*]] = fir.box_addr %[[DECL_A]]#0 : (!fir.box>) -> !fir.ref> -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[ADDR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) -> !fir.ref> {name = "a"} -! CHECK: acc.parallel reduction(@reduction_max_box_UxUxf32 -> %[[RED]] : !fir.ref>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[ADDR]] : !fir.ref>) bounds(%{{.*}}, %{{.*}}) recipe(@reduction_max_box_UxUxf32) -> !fir.ref> {name = "a"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>) diff --git a/flang/test/Lower/OpenACC/acc-reduction.f90 b/flang/test/Lower/OpenACC/acc-reduction.f90 index 20b5ad28f78a1..2c7e64af848fe 100644 --- a/flang/test/Lower/OpenACC/acc-reduction.f90 +++ b/flang/test/Lower/OpenACC/acc-reduction.f90 @@ -745,8 +745,8 @@ subroutine acc_reduction_add_int(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_add_int( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) -> !fir.ref {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_add_ref_i32 -> %[[RED_B]] : !fir.ref) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) recipe(@reduction_add_ref_i32) -> !fir.ref {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref) subroutine acc_reduction_add_int_array_1d(a, b) integer :: a(100) @@ -761,8 +761,8 @@ subroutine acc_reduction_add_int_array_1d(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_add_int_array_1d( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref> {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_add_ref_100xi32 -> %[[RED_B]] : !fir.ref>) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref>) recipe(@reduction_add_ref_100xi32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref>) subroutine acc_reduction_add_int_array_2d(a, b) integer :: a(100, 10), b(100, 10) @@ -779,8 +779,8 @@ subroutine acc_reduction_add_int_array_2d(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_add_int_array_2d( ! CHECK-SAME: %[[ARG0:.*]]: !fir.ref> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.ref> {fir.bindc_name = "b"}) { ! CHECK: %[[DECLARG1:.*]]:2 = hlfir.declare %[[ARG1]] -! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) -> !fir.ref> {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_add_ref_100x10xi32 -> %[[RED_ARG1]] : !fir.ref>) +! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) recipe(@reduction_add_ref_100x10xi32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_ARG1]] : !fir.ref>) ! CHECK: } attributes {collapse = [2]{{.*}} subroutine acc_reduction_add_int_array_3d(a, b) @@ -800,8 +800,8 @@ subroutine acc_reduction_add_int_array_3d(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_add_int_array_3d( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.ref> {fir.bindc_name = "b"}) ! CHECK: %[[DECLARG1:.*]]:2 = hlfir.declare %[[ARG1]] -! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) -> !fir.ref> {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_add_ref_100x10x2xi32 -> %[[RED_ARG1]] : !fir.ref>) +! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) recipe(@reduction_add_ref_100x10x2xi32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_ARG1]] : !fir.ref>) ! CHECK: } attributes {collapse = [3]{{.*}} subroutine acc_reduction_add_float(a, b) @@ -817,8 +817,8 @@ subroutine acc_reduction_add_float(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_add_float( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) -> !fir.ref {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_add_ref_f32 -> %[[RED_B]] : !fir.ref) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) recipe(@reduction_add_ref_f32) -> !fir.ref {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref) subroutine acc_reduction_add_float_array_1d(a, b) real :: a(100), b(100) @@ -833,8 +833,8 @@ subroutine acc_reduction_add_float_array_1d(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_add_float_array_1d( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref> {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_add_ref_100xf32 -> %[[RED_B]] : !fir.ref>) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref>) recipe(@reduction_add_ref_100xf32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref>) subroutine acc_reduction_mul_int(a, b) integer :: a(100) @@ -849,8 +849,8 @@ subroutine acc_reduction_mul_int(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_mul_int( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) -> !fir.ref {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_mul_ref_i32 -> %[[RED_B]] : !fir.ref) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) recipe(@reduction_mul_ref_i32) -> !fir.ref {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref) subroutine acc_reduction_mul_int_array_1d(a, b) integer :: a(100) @@ -865,8 +865,8 @@ subroutine acc_reduction_mul_int_array_1d(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_mul_int_array_1d( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref> {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_mul_ref_100xi32 -> %[[RED_B]] : !fir.ref>) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref>) recipe(@reduction_mul_ref_100xi32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref>) subroutine acc_reduction_mul_float(a, b) real :: a(100), b @@ -881,8 +881,8 @@ subroutine acc_reduction_mul_float(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_mul_float( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) -> !fir.ref {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_mul_ref_f32 -> %[[RED_B]] : !fir.ref) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) recipe(@reduction_mul_ref_f32) -> !fir.ref {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref) subroutine acc_reduction_mul_float_array_1d(a, b) real :: a(100), b(100) @@ -897,8 +897,8 @@ subroutine acc_reduction_mul_float_array_1d(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_mul_float_array_1d( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref> {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_mul_ref_100xf32 -> %[[RED_B]] : !fir.ref>) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref>) recipe(@reduction_mul_ref_100xf32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref>) subroutine acc_reduction_min_int(a, b) integer :: a(100) @@ -913,8 +913,8 @@ subroutine acc_reduction_min_int(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_min_int( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) -> !fir.ref {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_min_ref_i32 -> %[[RED_B]] : !fir.ref) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) recipe(@reduction_min_ref_i32) -> !fir.ref {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref) subroutine acc_reduction_min_int_array_1d(a, b) integer :: a(100), b(100) @@ -929,8 +929,8 @@ subroutine acc_reduction_min_int_array_1d(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_min_int_array_1d( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.ref> {fir.bindc_name = "b"}) ! CHECK: %[[DECLARG1:.*]]:2 = hlfir.declare %[[ARG1]] -! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) -> !fir.ref> {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_min_ref_100xi32 -> %[[RED_ARG1]] : !fir.ref>) +! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) recipe(@reduction_min_ref_100xi32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_ARG1]] : !fir.ref>) subroutine acc_reduction_min_float(a, b) real :: a(100), b @@ -945,8 +945,8 @@ subroutine acc_reduction_min_float(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_min_float( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) -> !fir.ref {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_min_ref_f32 -> %[[RED_B]] : !fir.ref) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) recipe(@reduction_min_ref_f32) -> !fir.ref {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref) subroutine acc_reduction_min_float_array2d(a, b) real :: a(100, 10), b(100, 10) @@ -963,8 +963,8 @@ subroutine acc_reduction_min_float_array2d(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_min_float_array2d( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.ref> {fir.bindc_name = "b"}) ! CHECK: %[[DECLARG1:.*]]:2 = hlfir.declare %[[ARG1]] -! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) -> !fir.ref> {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_min_ref_100x10xf32 -> %[[RED_ARG1]] : !fir.ref>) +! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) recipe(@reduction_min_ref_100x10xf32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_ARG1]] : !fir.ref>) ! CHECK: attributes {collapse = [2]{{.*}} subroutine acc_reduction_max_int(a, b) @@ -980,8 +980,8 @@ subroutine acc_reduction_max_int(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_max_int( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) -> !fir.ref {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_max_ref_i32 -> %[[RED_B]] : !fir.ref) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) recipe(@reduction_max_ref_i32) -> !fir.ref {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref) subroutine acc_reduction_max_int_array2d(a, b) integer :: a(100, 10), b(100, 10) @@ -998,8 +998,8 @@ subroutine acc_reduction_max_int_array2d(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_max_int_array2d( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.ref> {fir.bindc_name = "b"}) ! CHECK: %[[DECLARG1:.*]]:2 = hlfir.declare %[[ARG1]] -! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) -> !fir.ref> {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_max_ref_100x10xi32 -> %[[RED_ARG1]] : !fir.ref>) +! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) recipe(@reduction_max_ref_100x10xi32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_ARG1]] : !fir.ref>) subroutine acc_reduction_max_float(a, b) real :: a(100), b @@ -1014,8 +1014,8 @@ subroutine acc_reduction_max_float(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_max_float( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref {fir.bindc_name = "b"}) ! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[B]] -! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) -> !fir.ref {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_max_ref_f32 -> %[[RED_B]] : !fir.ref) +! CHECK: %[[RED_B:.*]] = acc.reduction varPtr(%[[DECLB]]#0 : !fir.ref) recipe(@reduction_max_ref_f32) -> !fir.ref {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_B]] : !fir.ref) subroutine acc_reduction_max_float_array1d(a, b) real :: a(100), b(100) @@ -1030,8 +1030,8 @@ subroutine acc_reduction_max_float_array1d(a, b) ! CHECK-LABEL: func.func @_QPacc_reduction_max_float_array1d( ! CHECK-SAME: %{{.*}}: !fir.ref> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.ref> {fir.bindc_name = "b"}) ! CHECK: %[[DECLARG1:.*]]:2 = hlfir.declare %[[ARG1]] -! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) -> !fir.ref> {name = "b"} -! CHECK: acc.loop {{.*}} reduction(@reduction_max_ref_100xf32 -> %[[RED_ARG1]] : !fir.ref>) +! CHECK: %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[DECLARG1]]#0 : !fir.ref>) recipe(@reduction_max_ref_100xf32) -> !fir.ref> {name = "b"} +! CHECK: acc.loop {{.*}} reduction(%[[RED_ARG1]] : !fir.ref>) subroutine acc_reduction_iand() integer :: i @@ -1040,8 +1040,8 @@ subroutine acc_reduction_iand() end subroutine ! CHECK-LABEL: func.func @_QPacc_reduction_iand() -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) -> !fir.ref {name = "i"} -! CHECK: acc.parallel reduction(@reduction_iand_ref_i32 -> %[[RED]] : !fir.ref) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) recipe(@reduction_iand_ref_i32) -> !fir.ref {name = "i"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref) subroutine acc_reduction_ior() integer :: i @@ -1050,8 +1050,8 @@ subroutine acc_reduction_ior() end subroutine ! CHECK-LABEL: func.func @_QPacc_reduction_ior() -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) -> !fir.ref {name = "i"} -! CHECK: acc.parallel reduction(@reduction_ior_ref_i32 -> %[[RED]] : !fir.ref) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) recipe(@reduction_ior_ref_i32) -> !fir.ref {name = "i"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref) subroutine acc_reduction_ieor() integer :: i @@ -1060,8 +1060,8 @@ subroutine acc_reduction_ieor() end subroutine ! CHECK-LABEL: func.func @_QPacc_reduction_ieor() -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) -> !fir.ref {name = "i"} -! CHECK: acc.parallel reduction(@reduction_xor_ref_i32 -> %[[RED]] : !fir.ref) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) recipe(@reduction_xor_ref_i32) -> !fir.ref {name = "i"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref) subroutine acc_reduction_and() logical :: l @@ -1072,8 +1072,8 @@ subroutine acc_reduction_and() ! CHECK-LABEL: func.func @_QPacc_reduction_and() ! CHECK: %[[L:.*]] = fir.alloca !fir.logical<4> {bindc_name = "l", uniq_name = "_QFacc_reduction_andEl"} ! CHECK: %[[DECLL:.*]]:2 = hlfir.declare %[[L]] -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[DECLL]]#0 : !fir.ref>) -> !fir.ref> {name = "l"} -! CHECK: acc.parallel reduction(@reduction_land_ref_l32 -> %[[RED]] : !fir.ref>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[DECLL]]#0 : !fir.ref>) recipe(@reduction_land_ref_l32) -> !fir.ref> {name = "l"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>) subroutine acc_reduction_or() logical :: l @@ -1082,8 +1082,8 @@ subroutine acc_reduction_or() end subroutine ! CHECK-LABEL: func.func @_QPacc_reduction_or() -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) -> !fir.ref> {name = "l"} -! CHECK: acc.parallel reduction(@reduction_lor_ref_l32 -> %[[RED]] : !fir.ref>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) recipe(@reduction_lor_ref_l32) -> !fir.ref> {name = "l"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>) subroutine acc_reduction_eqv() logical :: l @@ -1092,8 +1092,8 @@ subroutine acc_reduction_eqv() end subroutine ! CHECK-LABEL: func.func @_QPacc_reduction_eqv() -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) -> !fir.ref> {name = "l"} -! CHECK: acc.parallel reduction(@reduction_eqv_ref_l32 -> %[[RED]] : !fir.ref>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) recipe(@reduction_eqv_ref_l32) -> !fir.ref> {name = "l"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>) subroutine acc_reduction_neqv() logical :: l @@ -1102,8 +1102,8 @@ subroutine acc_reduction_neqv() end subroutine ! CHECK-LABEL: func.func @_QPacc_reduction_neqv() -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) -> !fir.ref> {name = "l"} -! CHECK: acc.parallel reduction(@reduction_neqv_ref_l32 -> %[[RED]] : !fir.ref>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) recipe(@reduction_neqv_ref_l32) -> !fir.ref> {name = "l"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>) subroutine acc_reduction_add_cmplx() complex :: c @@ -1112,8 +1112,8 @@ subroutine acc_reduction_add_cmplx() end subroutine ! CHECK-LABEL: func.func @_QPacc_reduction_add_cmplx() -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) -> !fir.ref> {name = "c"} -! CHECK: acc.parallel reduction(@reduction_add_ref_z32 -> %[[RED]] : !fir.ref>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) recipe(@reduction_add_ref_z32) -> !fir.ref> {name = "c"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>) subroutine acc_reduction_mul_cmplx() complex :: c @@ -1122,8 +1122,8 @@ subroutine acc_reduction_mul_cmplx() end subroutine ! CHECK-LABEL: func.func @_QPacc_reduction_mul_cmplx() -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) -> !fir.ref> {name = "c"} -! CHECK: acc.parallel reduction(@reduction_mul_ref_z32 -> %[[RED]] : !fir.ref>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref>) recipe(@reduction_mul_ref_z32) -> !fir.ref> {name = "c"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>) subroutine acc_reduction_add_alloc() integer, allocatable :: i @@ -1135,8 +1135,8 @@ subroutine acc_reduction_add_alloc() ! CHECK-LABEL: func.func @_QPacc_reduction_add_alloc() ! CHECK: %[[ALLOCA:.*]] = fir.alloca !fir.box> {bindc_name = "i", uniq_name = "_QFacc_reduction_add_allocEi"} ! CHECK: %[[DECL:.*]]:2 = hlfir.declare %[[ALLOCA]] -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[DECL]]#0 : !fir.ref>>) -> !fir.ref>> {name = "i"} -! CHECK: acc.parallel reduction(@reduction_add_ref_box_heap_i32 -> %[[RED]] : !fir.ref>>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[DECL]]#0 : !fir.ref>>) recipe(@reduction_add_ref_box_heap_i32) -> !fir.ref>> {name = "i"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>>) subroutine acc_reduction_add_pointer(i) integer, pointer :: i @@ -1147,8 +1147,8 @@ subroutine acc_reduction_add_pointer(i) ! CHECK-LABEL: func.func @_QPacc_reduction_add_pointer( ! CHECK-SAME: %[[ARG0:.*]]: !fir.ref>> {fir.bindc_name = "i"}) ! CHECK: %[[DECLARG0:.*]]:2 = hlfir.declare %[[ARG0]] -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[DECLARG0]]#0 : !fir.ref>>) -> !fir.ref>> {name = "i"} -! CHECK: acc.parallel reduction(@reduction_add_ref_box_ptr_i32 -> %[[RED]] : !fir.ref>>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[DECLARG0]]#0 : !fir.ref>>) recipe(@reduction_add_ref_box_ptr_i32) -> !fir.ref>> {name = "i"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>>) subroutine acc_reduction_add_static_slice(a) integer :: a(100) @@ -1164,8 +1164,8 @@ subroutine acc_reduction_add_static_slice(a) ! CHECK: %[[LB:.*]] = arith.constant 10 : index ! CHECK: %[[UB:.*]] = arith.constant 19 : index ! CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%[[LB]] : index) upperbound(%[[UB]] : index) extent(%[[C100]] : index) stride(%[[C1]] : index) startIdx(%[[C1]] : index) -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[DECLARG0]]#0 : !fir.ref>) bounds(%[[BOUND]]) -> !fir.ref> {name = "a(11:20)"} -! CHECK: acc.parallel reduction(@reduction_add_section_lb10.ub19_ref_100xi32 -> %[[RED]] : !fir.ref>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[DECLARG0]]#0 : !fir.ref>) bounds(%[[BOUND]]) recipe(@reduction_add_section_lb10.ub19_ref_100xi32) -> !fir.ref> {name = "a(11:20)"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>) subroutine acc_reduction_add_dynamic_extent_add(a) integer :: a(:) @@ -1176,8 +1176,8 @@ subroutine acc_reduction_add_dynamic_extent_add(a) ! CHECK-LABEL: func.func @_QPacc_reduction_add_dynamic_extent_add( ! CHECK-SAME: %[[ARG0:.*]]: !fir.box> {fir.bindc_name = "a"}) ! CHECK: %[[DECLARG0:.*]]:2 = hlfir.declare %[[ARG0]] -! CHECK: %[[RED:.*]] = acc.reduction var(%{{.*}} : !fir.box>) -> !fir.box> {name = "a"} -! CHECK: acc.parallel reduction(@reduction_add_box_Uxi32 -> %[[RED:.*]] : !fir.box>) +! CHECK: %[[RED:.*]] = acc.reduction var(%{{.*}} : !fir.box>) recipe(@reduction_add_box_Uxi32) -> !fir.box> {name = "a"} +! CHECK: acc.parallel reduction(%[[RED:.*]] : !fir.box>) subroutine acc_reduction_add_assumed_shape_max(a) real :: a(:) @@ -1188,8 +1188,8 @@ subroutine acc_reduction_add_assumed_shape_max(a) ! CHECK-LABEL: func.func @_QPacc_reduction_add_assumed_shape_max( ! CHECK-SAME: %[[ARG0:.*]]: !fir.box> {fir.bindc_name = "a"}) ! CHECK: %[[DECLARG0:.*]]:2 = hlfir.declare %[[ARG0]] -! CHECK: %[[RED:.*]] = acc.reduction var(%{{.*}} : !fir.box>) -> !fir.box> {name = "a"} -! CHECK: acc.parallel reduction(@reduction_max_box_Uxf32 -> %[[RED]] : !fir.box>) { +! CHECK: %[[RED:.*]] = acc.reduction var(%{{.*}} : !fir.box>) recipe(@reduction_max_box_Uxf32) -> !fir.box> {name = "a"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.box>) { subroutine acc_reduction_add_dynamic_extent_add_with_section(a) integer :: a(:) @@ -1201,8 +1201,8 @@ subroutine acc_reduction_add_dynamic_extent_add_with_section(a) ! CHECK-SAME: %[[ARG0:.*]]: !fir.box> {fir.bindc_name = "a"}) ! CHECK: %[[DECL:.*]]:2 = hlfir.declare %[[ARG0]] dummy_scope %{{[0-9]+}} {uniq_name = "_QFacc_reduction_add_dynamic_extent_add_with_sectionEa"} : (!fir.box>, !fir.dscope) -> (!fir.box>, !fir.box>) ! CHECK: %[[BOUND:.*]] = acc.bounds lowerbound(%c1{{.*}} : index) upperbound(%c3{{.*}} : index) extent(%{{.*}}#1 : index) stride(%{{.*}}#2 : index) startIdx(%{{.*}} : index) {strideInBytes = true} -! CHECK: %[[RED:.*]] = acc.reduction var(%[[DECL]]#0 : !fir.box>) bounds(%[[BOUND]]) -> !fir.box> {name = "a(2:4)"} -! CHECK: acc.parallel reduction(@reduction_add_section_lb1.ub3_box_Uxi32 -> %[[RED]] : !fir.box>) +! CHECK: %[[RED:.*]] = acc.reduction var(%[[DECL]]#0 : !fir.box>) bounds(%[[BOUND]]) recipe(@reduction_add_section_lb1.ub3_box_Uxi32) -> !fir.box> {name = "a(2:4)"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.box>) subroutine acc_reduction_add_allocatable(a) real, allocatable :: a(:) @@ -1213,8 +1213,8 @@ subroutine acc_reduction_add_allocatable(a) ! CHECK-LABEL: func.func @_QPacc_reduction_add_allocatable( ! CHECK-SAME: %[[ARG0:.*]]: !fir.ref>>> {fir.bindc_name = "a"}) ! CHECK: %[[DECL:.*]]:2 = hlfir.declare %[[ARG0]] dummy_scope %{{[0-9]+}} {fortran_attrs = #fir.var_attrs, uniq_name = "_QFacc_reduction_add_allocatableEa"} : (!fir.ref>>>, !fir.dscope) -> (!fir.ref>>>, !fir.ref>>>) -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[DECL]]#0 : !fir.ref>>>) -> !fir.ref>>> {name = "a"} -! CHECK: acc.parallel reduction(@reduction_max_ref_box_heap_Uxf32 -> %[[RED]] : !fir.ref>>>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[DECL]]#0 : !fir.ref>>>) recipe(@reduction_max_ref_box_heap_Uxf32) -> !fir.ref>>> {name = "a"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>>>) subroutine acc_reduction_add_pointer_array(a) real, pointer :: a(:) @@ -1225,8 +1225,8 @@ subroutine acc_reduction_add_pointer_array(a) ! CHECK-LABEL: func.func @_QPacc_reduction_add_pointer_array( ! CHECK-SAME: %[[ARG0:.*]]: !fir.ref>>> {fir.bindc_name = "a"}) ! CHECK: %[[DECL:.*]]:2 = hlfir.declare %[[ARG0]] dummy_scope %{{[0-9]+}} {fortran_attrs = #fir.var_attrs, uniq_name = "_QFacc_reduction_add_pointer_arrayEa"} : (!fir.ref>>>, !fir.dscope) -> (!fir.ref>>>, !fir.ref>>>) -! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[DECL]]#0 : !fir.ref>>>) -> !fir.ref>>> {name = "a"} -! CHECK: acc.parallel reduction(@reduction_max_ref_box_ptr_Uxf32 -> %[[RED]] : !fir.ref>>>) +! CHECK: %[[RED:.*]] = acc.reduction varPtr(%[[DECL]]#0 : !fir.ref>>>) recipe(@reduction_max_ref_box_ptr_Uxf32) -> !fir.ref>>> {name = "a"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.ref>>>) subroutine acc_reduction_max_dynamic_extent_max(a, n) integer :: n @@ -1238,5 +1238,5 @@ subroutine acc_reduction_max_dynamic_extent_max(a, n) ! CHECK-LABEL: func.func @_QPacc_reduction_max_dynamic_extent_max( ! CHECK-SAME: %[[ARG0:.*]]: !fir.ref> {fir.bindc_name = "a"}, %{{.*}}: !fir.ref {fir.bindc_name = "n"}) ! CHECK: %[[DECL_A:.*]]:2 = hlfir.declare %[[ARG0]](%{{.*}}) dummy_scope %{{[0-9]+}} {uniq_name = "_QFacc_reduction_max_dynamic_extent_maxEa"} : (!fir.ref>, !fir.shape<2>, !fir.dscope) -> (!fir.box>, !fir.ref>) -! CHECK: %[[RED:.*]] = acc.reduction var(%[[DECL_A]]#0 : !fir.box>) -> !fir.box> {name = "a"} -! CHECK: acc.parallel reduction(@reduction_max_box_UxUxf32 -> %[[RED]] : !fir.box>) +! CHECK: %[[RED:.*]] = acc.reduction var(%[[DECL_A]]#0 : !fir.box>) recipe(@reduction_max_box_UxUxf32) -> !fir.box> {name = "a"} +! CHECK: acc.parallel reduction(%[[RED]] : !fir.box>) diff --git a/flang/test/Lower/OpenACC/acc-serial-loop.f90 b/flang/test/Lower/OpenACC/acc-serial-loop.f90 index cad0ee73f6cc5..9825142befeb5 100644 --- a/flang/test/Lower/OpenACC/acc-serial-loop.f90 +++ b/flang/test/Lower/OpenACC/acc-serial-loop.f90 @@ -392,10 +392,10 @@ subroutine acc_serial_loop a(i) = b(i) END DO -! CHECK: %[[ACC_FPRIVATE_B:.*]] = acc.firstprivate varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {name = "b"} -! CHECK: acc.serial {{.*}} firstprivate(@firstprivatization_ref_10xf32 -> %[[ACC_FPRIVATE_B]] : !fir.ref>) { -! CHECK: %[[ACC_PRIVATE_A:.*]] = acc.private varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a"} -! CHECK: acc.loop {{.*}} private({{.*}}@privatization_ref_10xf32 -> %[[ACC_PRIVATE_A]] : !fir.ref>{{.*}}) +! CHECK: %[[ACC_FPRIVATE_B:.*]] = acc.firstprivate varPtr(%[[DECLB]]#0 : !fir.ref>) recipe(@firstprivatization_ref_10xf32) -> !fir.ref> {name = "b"} +! CHECK: acc.serial {{.*}} firstprivate(%[[ACC_FPRIVATE_B]] : !fir.ref>) { +! CHECK: %[[ACC_PRIVATE_A:.*]] = acc.private varPtr(%[[DECLA]]#0 : !fir.ref>) recipe(@privatization_ref_10xf32) -> !fir.ref> {name = "a"} +! CHECK: acc.loop {{.*}} private(%[[ACC_PRIVATE_A]]{{.*}} : !fir.ref>{{.*}}) ! CHECK-NOT: fir.do_loop ! CHECK: acc.yield ! CHECK-NEXT: }{{$}} @@ -661,7 +661,9 @@ subroutine acc_serial_loop ! CHECK: %[[COPYINREDR:.*]] = acc.copyin varPtr(%{{.*}} : !fir.ref) -> !fir.ref {dataClause = #acc, implicit = true, name = "reduction_r"} ! CHECK: %[[COPYINREDI:.*]] = acc.copyin varPtr(%{{.*}} : !fir.ref) -> !fir.ref {dataClause = #acc, implicit = true, name = "reduction_i"} ! CHECK: acc.serial {{.*}} dataOperands(%[[COPYINREDR]], %[[COPYINREDI]] : !fir.ref, !fir.ref) { -! CHECK: acc.loop {{.*}} reduction(@reduction_add_ref_f32 -> %{{.*}} : !fir.ref, @reduction_mul_ref_i32 -> %{{.*}} : !fir.ref) +! CHECK: %[[REDUCTION_R:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) recipe(@reduction_add_ref_f32) -> !fir.ref {name = "reduction_r"} +! CHECK: %[[REDUCTION_I:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) recipe(@reduction_mul_ref_i32) -> !fir.ref {name = "reduction_i"} +! CHECK: acc.loop {{.*}} reduction(%[[REDUCTION_R]], %[[REDUCTION_I]] : !fir.ref, !fir.ref) ! CHECK-NOT: fir.do_loop ! CHECK: acc.yield ! CHECK-NEXT: }{{$}} diff --git a/flang/test/Lower/OpenACC/acc-serial.f90 b/flang/test/Lower/OpenACC/acc-serial.f90 index 1e4f32fd209ef..ea66252287325 100644 --- a/flang/test/Lower/OpenACC/acc-serial.f90 +++ b/flang/test/Lower/OpenACC/acc-serial.f90 @@ -272,17 +272,19 @@ subroutine acc_serial !$acc serial private(a) firstprivate(b) private(c) !$acc end serial -! CHECK: %[[ACC_PRIVATE_A:.*]] = acc.private varPtr(%[[DECLA]]#0 : !fir.ref>) -> !fir.ref> {name = "a"} -! CHECK: %[[ACC_FPRIVATE_B:.*]] = acc.firstprivate varPtr(%[[DECLB]]#0 : !fir.ref>) -> !fir.ref> {name = "b"} -! CHECK: %[[ACC_PRIVATE_C:.*]] = acc.private varPtr(%[[DECLC]]#0 : !fir.ref>) -> !fir.ref> {name = "c"} -! CHECK: acc.serial 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: %[[ACC_PRIVATE_A:.*]] = acc.private varPtr(%[[DECLA]]#0 : !fir.ref>) recipe(@privatization_ref_10x10xf32) -> !fir.ref> {name = "a"} +! CHECK: %[[ACC_FPRIVATE_B:.*]] = acc.firstprivate varPtr(%[[DECLB]]#0 : !fir.ref>) recipe(@firstprivatization_ref_10x10xf32) -> !fir.ref> {name = "b"} +! CHECK: %[[ACC_PRIVATE_C:.*]] = acc.private varPtr(%[[DECLC]]#0 : !fir.ref>) recipe(@privatization_ref_10x10xf32) -> !fir.ref> {name = "c"} +! CHECK: acc.serial firstprivate(%[[ACC_FPRIVATE_B]] : !fir.ref>) private(%[[ACC_PRIVATE_A]], %[[ACC_PRIVATE_C]] : !fir.ref>, !fir.ref>) { ! CHECK: acc.yield ! CHECK-NEXT: }{{$}} !$acc serial reduction(+:reduction_r) reduction(*:reduction_i) !$acc end serial -! CHECK: acc.serial reduction(@reduction_add_ref_f32 -> %{{.*}} : !fir.ref, @reduction_mul_ref_i32 -> %{{.*}} : !fir.ref) { +! CHECK: %[[REDUCTION_R:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) recipe(@reduction_add_ref_f32) -> !fir.ref {name = "reduction_r"} +! CHECK: %[[REDUCTION_I:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref) recipe(@reduction_mul_ref_i32) -> !fir.ref {name = "reduction_i"} +! CHECK: acc.serial reduction(%[[REDUCTION_R]], %[[REDUCTION_I]] : !fir.ref, !fir.ref) { ! CHECK: acc.yield ! CHECK-NEXT: }{{$}} diff --git a/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td b/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td index c1a404b496f8d..e9d12827f6c27 100644 --- a/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td +++ b/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td @@ -603,6 +603,7 @@ class OpenACC_DataEntryOp($asyncOperands, type($asyncOperands), $asyncOperandsDeviceType, $asyncOnly) + | `recipe` `(` custom($recipe) `)` ) `->` type($accVar) attr-dict }]; @@ -1422,12 +1423,9 @@ def OpenACC_ParallelOp : OpenACC_Op<"parallel", Optional:$ifCond, Optional:$selfCond, UnitAttr:$selfAttr, - Variadic:$reductionOperands, - OptionalAttr:$reductionRecipes, + Variadic:$reductionOperands, Variadic:$privateOperands, - OptionalAttr:$privatizationRecipes, Variadic:$firstprivateOperands, - OptionalAttr:$firstprivatizationRecipes, Variadic:$dataClauseOperands, OptionalAttr:$defaultAttr, UnitAttr:$combined); @@ -1540,16 +1538,12 @@ def OpenACC_ParallelOp : OpenACC_Op<"parallel", `dataOperands` `(` $dataClauseOperands `:` type($dataClauseOperands) `)` | `async` `` custom($asyncOperands, type($asyncOperands), $asyncOperandsDeviceType, $asyncOnly) - | `firstprivate` `(` custom($firstprivateOperands, - type($firstprivateOperands), $firstprivatizationRecipes) - `)` + | `firstprivate` `(` $firstprivateOperands `:` type($firstprivateOperands) `)` | `num_gangs` `(` custom($numGangs, type($numGangs), $numGangsDeviceType, $numGangsSegments) `)` | `num_workers` `(` custom($numWorkers, type($numWorkers), $numWorkersDeviceType) `)` - | `private` `(` custom( - $privateOperands, type($privateOperands), $privatizationRecipes) - `)` + | `private` `(` $privateOperands `:` type($privateOperands) `)` | `vector_length` `(` custom($vectorLength, type($vectorLength), $vectorLengthDeviceType) `)` | `wait` `` custom($waitOperands, type($waitOperands), @@ -1557,9 +1551,7 @@ def OpenACC_ParallelOp : OpenACC_Op<"parallel", $waitOnly) | `self` `(` $selfCond `)` | `if` `(` $ifCond `)` - | `reduction` `(` custom( - $reductionOperands, type($reductionOperands), $reductionRecipes) - `)` + | `reduction` `(` $reductionOperands `:` type($reductionOperands) `)` ) $region attr-dict-with-keyword }]; @@ -1607,12 +1599,9 @@ def OpenACC_SerialOp : OpenACC_Op<"serial", Optional:$ifCond, Optional:$selfCond, UnitAttr:$selfAttr, - Variadic:$reductionOperands, - OptionalAttr:$reductionRecipes, + Variadic:$reductionOperands, Variadic:$privateOperands, - OptionalAttr:$privatizationRecipes, Variadic:$firstprivateOperands, - OptionalAttr:$firstprivatizationRecipes, Variadic:$dataClauseOperands, OptionalAttr:$defaultAttr, UnitAttr:$combined); @@ -1682,20 +1671,14 @@ def OpenACC_SerialOp : OpenACC_Op<"serial", `dataOperands` `(` $dataClauseOperands `:` type($dataClauseOperands) `)` | `async` `` custom($asyncOperands, type($asyncOperands), $asyncOperandsDeviceType, $asyncOnly) - | `firstprivate` `(` custom($firstprivateOperands, - type($firstprivateOperands), $firstprivatizationRecipes) - `)` - | `private` `(` custom( - $privateOperands, type($privateOperands), $privatizationRecipes) - `)` + | `firstprivate` `(` $firstprivateOperands `:` type($firstprivateOperands) `)` + | `private` `(` $privateOperands `:` type($privateOperands) `)` | `wait` `` custom($waitOperands, type($waitOperands), $waitOperandsDeviceType, $waitOperandsSegments, $hasWaitDevnum, $waitOnly) | `self` `(` $selfCond `)` | `if` `(` $ifCond `)` - | `reduction` `(` custom( - $reductionOperands, type($reductionOperands), $reductionRecipes) - `)` + | `reduction` `(` $reductionOperands `:` type($reductionOperands) `)` ) $region attr-dict-with-keyword }]; @@ -2243,9 +2226,7 @@ def OpenACC_LoopOp : OpenACC_Op<"loop", OptionalAttr:$tileOperandsDeviceType, Variadic:$cacheOperands, Variadic:$privateOperands, - OptionalAttr:$privatizationRecipes, - Variadic:$reductionOperands, - OptionalAttr:$reductionRecipes, + Variadic:$reductionOperands, OptionalAttr:$combined ); @@ -2405,14 +2386,11 @@ def OpenACC_LoopOp : OpenACC_Op<"loop", $workerNumOperandsDeviceType, $worker) | `vector` `` custom($vectorOperands, type($vectorOperands), $vectorOperandsDeviceType, $vector) - | `private` `(` custom( - $privateOperands, type($privateOperands), $privatizationRecipes) `)` + | `private` `(` $privateOperands `:` type($privateOperands) `)` | `tile` `(` custom($tileOperands, type($tileOperands), $tileOperandsDeviceType, $tileOperandsSegments) `)` - | `reduction` `(` custom( - $reductionOperands, type($reductionOperands), $reductionRecipes) - `)` + | `reduction` `(` $reductionOperands `:` type($reductionOperands) `)` | `cache` `(` $cacheOperands `:` type($cacheOperands) `)` ) custom($region, $lowerbound, type($lowerbound), $upperbound, diff --git a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp index 9e4982dc59d49..0039c6bde89e4 100644 --- a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp +++ b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp @@ -333,10 +333,18 @@ checkValidModifier(Op op, acc::DataClauseModifier validModifiers) { return success(); } -template -static LogicalResult checkNoRecipe(Op op) { - if (op.getRecipe().has_value()) - return op.emitError("no recipes are allowed"); +template +static LogicalResult checkRecipe(OpT op, llvm::StringRef operandName) { + mlir::SymbolRefAttr operandRecipe = op.getRecipeAttr(); + if (!operandRecipe) + return op->emitOpError() << "recipe expected for " << operandName; + + auto decl = + SymbolTable::lookupNearestSymbolFrom(op, operandRecipe); + if (!decl) + return op->emitOpError() + << "expected symbol reference " << operandRecipe << " to point to a " + << operandName << " declaration"; return success(); } @@ -446,6 +454,18 @@ static void printVarPtrType(mlir::OpAsmPrinter &p, mlir::Operation *op, } } +static ParseResult parseRecipeSym(mlir::OpAsmParser &parser, + mlir::SymbolRefAttr &recipeAttr) { + if (failed(parser.parseAttribute(recipeAttr))) + return failure(); + return success(); +} + +static void printRecipeSym(mlir::OpAsmPrinter &p, mlir::Operation *op, + mlir::SymbolRefAttr recipeAttr) { + p << recipeAttr; +} + //===----------------------------------------------------------------------===// // DataBoundsOp //===----------------------------------------------------------------------===// @@ -468,6 +488,9 @@ LogicalResult acc::PrivateOp::verify() { return failure(); if (failed(checkNoModifier(*this))) return failure(); + if (failed( + checkRecipe(*this, "private"))) + return failure(); return success(); } @@ -482,6 +505,9 @@ LogicalResult acc::FirstprivateOp::verify() { return failure(); if (failed(checkNoModifier(*this))) return failure(); + if (failed(checkRecipe( + *this, "firstprivate"))) + return failure(); return success(); } @@ -496,6 +522,9 @@ LogicalResult acc::ReductionOp::verify() { return failure(); if (failed(checkNoModifier(*this))) return failure(); + if (failed(checkRecipe( + *this, "reduction"))) + return failure(); return success(); } @@ -1008,40 +1037,6 @@ LogicalResult acc::ReductionRecipeOp::verifyRegions() { return success(); } -//===----------------------------------------------------------------------===// -// Custom parser and printer verifier for private clause -//===----------------------------------------------------------------------===// - -static ParseResult parseSymOperandList( - mlir::OpAsmParser &parser, - llvm::SmallVectorImpl &operands, - llvm::SmallVectorImpl &types, mlir::ArrayAttr &symbols) { - llvm::SmallVector attributes; - if (failed(parser.parseCommaSeparatedList([&]() { - if (parser.parseAttribute(attributes.emplace_back()) || - parser.parseArrow() || - parser.parseOperand(operands.emplace_back()) || - parser.parseColonType(types.emplace_back())) - return failure(); - return success(); - }))) - return failure(); - llvm::SmallVector arrayAttr(attributes.begin(), - attributes.end()); - symbols = ArrayAttr::get(parser.getContext(), arrayAttr); - return success(); -} - -static void printSymOperandList(mlir::OpAsmPrinter &p, mlir::Operation *op, - mlir::OperandRange operands, - mlir::TypeRange types, - std::optional attributes) { - llvm::interleaveComma(llvm::zip(*attributes, operands), p, [&](auto it) { - p << std::get<0>(it) << " -> " << std::get<1>(it) << " : " - << std::get<1>(it).getType(); - }); -} - //===----------------------------------------------------------------------===// // ParallelOp //===----------------------------------------------------------------------===// @@ -1050,7 +1045,7 @@ static void printSymOperandList(mlir::OpAsmPrinter &p, mlir::Operation *op, template static LogicalResult checkDataOperands(Op op, const mlir::ValueRange &operands) { - for (mlir::Value operand : operands) + for (mlir::Value operand : operands) { if (!mlir::isa( @@ -1058,66 +1053,26 @@ static LogicalResult checkDataOperands(Op op, return op.emitError( "expect data entry/exit operation or acc.getdeviceptr " "as defining op"); + mlir::SymbolRefAttr operandRecipe = getRecipe(operand.getDefiningOp()); + if (operandRecipe) + return op.emitError("recipe not expected for data mapping operations"); + } return success(); } -template -static LogicalResult -checkSymOperandList(Operation *op, std::optional attributes, - mlir::OperandRange operands, llvm::StringRef operandName, - llvm::StringRef symbolName, bool checkOperandType = true) { - if (!operands.empty()) { - if (!attributes || attributes->size() != operands.size()) - return op->emitOpError() - << "expected as many " << symbolName << " symbol reference as " - << operandName << " operands"; - if (attributes) { - for (auto operandAndAttribute : llvm::zip(operands, *attributes)) { - mlir::Value operand = std::get<0>(operandAndAttribute); - if (auto *definingOp = operand.getDefiningOp()) { - mlir::SymbolRefAttr operandRecipe = getRecipe(definingOp); - // If the operand operation has a recipe - check that it is consistent - // with the one recorded in the construct. - if (operandRecipe) { - if (operandRecipe.getLeafReference().compare( - llvm::cast( - std::get<1>(operandAndAttribute)) - .getLeafReference()) != 0) - return op->emitOpError() << "expected consistent recipe for " - << operandName << " operand"; - } - } - } - } - } else { - if (attributes) - return op->emitOpError() - << "unexpected " << symbolName << " symbol reference"; - return success(); - } - +template +static LogicalResult checkPrivateOperands(mlir::Operation *accConstructOp, + const mlir::ValueRange &operands, + llvm::StringRef operandName) { llvm::DenseSet set; - for (auto args : llvm::zip(operands, *attributes)) { - mlir::Value operand = std::get<0>(args); - + for (mlir::Value operand : operands) { + if (!mlir::isa(operand.getDefiningOp())) + return accConstructOp->emitOpError() + << "expect " << operandName << " as defining op"; if (!set.insert(operand).second) - return op->emitOpError() + return accConstructOp->emitOpError() << operandName << " operand appears more than once"; - - mlir::Type varType = operand.getType(); - auto symbolRef = llvm::cast(std::get<1>(args)); - auto decl = SymbolTable::lookupNearestSymbolFrom(op, symbolRef); - if (!decl) - return op->emitOpError() - << "expected symbol reference " << symbolRef << " to point to a " - << operandName << " declaration"; - - if (checkOperandType && decl.getType() && decl.getType() != varType) - return op->emitOpError() << "expected " << operandName << " (" << varType - << ") to be the same type as " << operandName - << " declaration (" << decl.getType() << ")"; } - return success(); } @@ -1174,17 +1129,17 @@ static LogicalResult verifyDeviceTypeAndSegmentCountMatch( } LogicalResult acc::ParallelOp::verify() { - if (failed(checkSymOperandList( - *this, getPrivatizationRecipes(), getPrivateOperands(), "private", - "privatizations", /*checkOperandType=*/false))) + if (failed(checkPrivateOperands( + *this, getPrivateOperands(), "private"))) return failure(); - if (failed(checkSymOperandList( - *this, getFirstprivatizationRecipes(), getFirstprivateOperands(), - "firstprivate", "firstprivatizations", /*checkOperandType=*/false))) + if (failed(checkPrivateOperands( + *this, getFirstprivateOperands(), "firstprivate"))) return failure(); - if (failed(checkSymOperandList( - *this, getReductionRecipes(), getReductionOperands(), "reduction", - "reductions", false))) + if (failed(checkPrivateOperands( + *this, getReductionOperands(), "reduction"))) return failure(); if (failed(verifyDeviceTypeAndSegmentCountMatch( @@ -1315,7 +1270,6 @@ void ParallelOp::build(mlir::OpBuilder &odsBuilder, mlir::ValueRange gangPrivateOperands, mlir::ValueRange gangFirstPrivateOperands, mlir::ValueRange dataClauseOperands) { - ParallelOp::build( odsBuilder, odsState, asyncOperands, /*asyncOperandsDeviceType=*/nullptr, /*asyncOnly=*/nullptr, waitOperands, /*waitOperandsSegments=*/nullptr, @@ -1324,9 +1278,8 @@ void ParallelOp::build(mlir::OpBuilder &odsBuilder, /*numGangsDeviceType=*/nullptr, numWorkers, /*numWorkersDeviceType=*/nullptr, vectorLength, /*vectorLengthDeviceType=*/nullptr, ifCond, selfCond, - /*selfAttr=*/nullptr, reductionOperands, /*reductionRecipes=*/nullptr, - gangPrivateOperands, /*privatizations=*/nullptr, gangFirstPrivateOperands, - /*firstprivatizations=*/nullptr, dataClauseOperands, + /*selfAttr=*/nullptr, reductionOperands, gangPrivateOperands, + gangFirstPrivateOperands, dataClauseOperands, /*defaultAttr=*/nullptr, /*combined=*/nullptr); } @@ -1965,17 +1918,17 @@ mlir::Value SerialOp::getWaitDevnum(mlir::acc::DeviceType deviceType) { } LogicalResult acc::SerialOp::verify() { - if (failed(checkSymOperandList( - *this, getPrivatizationRecipes(), getPrivateOperands(), "private", - "privatizations", /*checkOperandType=*/false))) + if (failed(checkPrivateOperands( + *this, getPrivateOperands(), "private"))) return failure(); - if (failed(checkSymOperandList( - *this, getFirstprivatizationRecipes(), getFirstprivateOperands(), - "firstprivate", "firstprivatizations", /*checkOperandType=*/false))) + if (failed(checkPrivateOperands( + *this, getFirstprivateOperands(), "firstprivate"))) return failure(); - if (failed(checkSymOperandList( - *this, getReductionRecipes(), getReductionOperands(), "reduction", - "reductions", false))) + if (failed(checkPrivateOperands( + *this, getReductionOperands(), "reduction"))) return failure(); if (failed(verifyDeviceTypeAndSegmentCountMatch( @@ -2606,14 +2559,13 @@ LogicalResult acc::LoopOp::verify() { } } - if (failed(checkSymOperandList( - *this, getPrivatizationRecipes(), getPrivateOperands(), "private", - "privatizations", false))) + if (failed(checkPrivateOperands( + *this, getPrivateOperands(), "private"))) return failure(); - - if (failed(checkSymOperandList( - *this, getReductionRecipes(), getReductionOperands(), "reduction", - "reductions", false))) + if (failed(checkPrivateOperands( + *this, getReductionOperands(), "reduction"))) return failure(); if (getCombined().has_value() && diff --git a/mlir/test/Dialect/OpenACC/invalid.mlir b/mlir/test/Dialect/OpenACC/invalid.mlir index 68afd9fccba79..1d9fe0a1a0c35 100644 --- a/mlir/test/Dialect/OpenACC/invalid.mlir +++ b/mlir/test/Dialect/OpenACC/invalid.mlir @@ -483,15 +483,6 @@ acc.loop gang({static=%i64Value: i64, ) control(%iv : i32) = (%1 : i32) to (%2 : // ----- -func.func @fct1(%0 : !llvm.ptr) -> () { - // expected-error@+1 {{expected symbol reference @privatization_i32 to point to a private declaration}} - acc.serial private(@privatization_i32 -> %0 : !llvm.ptr) { - } - return -} - -// ----- - // expected-error@+1 {{expect at least one of num, dim or static values}} acc.loop gang({}) { "test.openacc_dummy_op"() : () -> () @@ -831,3 +822,4 @@ func.func @acc_loop_container() { %value = memref.alloc() : memref // expected-error @below {{invalid data clause modifiers: readonly}} %0 = acc.create varPtr(%value : memref) -> memref {modifiers = #acc} + diff --git a/mlir/test/Dialect/OpenACC/legalize-data.mlir b/mlir/test/Dialect/OpenACC/legalize-data.mlir index 40604dcc736de..c7ef47ccc7e97 100644 --- a/mlir/test/Dialect/OpenACC/legalize-data.mlir +++ b/mlir/test/Dialect/OpenACC/legalize-data.mlir @@ -129,8 +129,8 @@ func.func @test(%a: memref<10xf32>) { %lb = arith.constant 0 : index %st = arith.constant 1 : index %c10 = arith.constant 10 : index - %p1 = acc.private varPtr(%a : memref<10xf32>) varType(tensor<10xf32>) -> memref<10xf32> - acc.parallel private(@privatization_memref_10_f32 -> %p1 : memref<10xf32>) { + %p1 = acc.private varPtr(%a : memref<10xf32>) varType(tensor<10xf32>) recipe(@privatization_memref_10_f32) -> memref<10xf32> + acc.parallel private(%p1 : memref<10xf32>) { acc.loop control(%i : index) = (%lb : index) to (%c10 : index) step (%st : index) { %ci = memref.load %a[%i] : memref<10xf32> acc.yield @@ -142,8 +142,8 @@ func.func @test(%a: memref<10xf32>) { // CHECK-LABEL: func.func @test // CHECK-SAME: (%[[A:.*]]: memref<10xf32>) -// CHECK: %[[PRIVATE:.*]] = acc.private varPtr(%[[A]] : memref<10xf32>) varType(tensor<10xf32>) -> memref<10xf32> -// CHECK: acc.parallel private(@privatization_memref_10_f32 -> %[[PRIVATE]] : memref<10xf32>) { +// CHECK: %[[PRIVATE:.*]] = acc.private varPtr(%[[A]] : memref<10xf32>) varType(tensor<10xf32>) recipe(@privatization_memref_10_f32) -> memref<10xf32> +// CHECK: acc.parallel private(%[[PRIVATE]] : memref<10xf32>) { // CHECK: acc.loop control(%[[I:.*]] : index) = (%{{.*}} : index) to (%{{.*}} : index) step (%{{.*}} : index) { // DEVICE: %{{.*}} = memref.load %[[PRIVATE:.*]][%[[I]]] : memref<10xf32> // CHECK: acc.yield @@ -167,9 +167,9 @@ func.func @test(%a: memref<10xf32>) { %lb = arith.constant 0 : index %st = arith.constant 1 : index %c10 = arith.constant 10 : index - %p1 = acc.private varPtr(%a : memref<10xf32>) varType(tensor<10xf32>) -> memref<10xf32> + %p1 = acc.private varPtr(%a : memref<10xf32>) varType(tensor<10xf32>) recipe(@privatization_memref_10_f32) -> memref<10xf32> acc.parallel { - acc.loop private(@privatization_memref_10_f32 -> %p1 : memref<10xf32>) control(%i : index) = (%lb : index) to (%c10 : index) step (%st : index) { + acc.loop private(%p1 : memref<10xf32>) control(%i : index) = (%lb : index) to (%c10 : index) step (%st : index) { %ci = memref.load %a[%i] : memref<10xf32> acc.yield } attributes {independent = [#acc.device_type]} @@ -180,9 +180,9 @@ func.func @test(%a: memref<10xf32>) { // CHECK-LABEL: func.func @test // CHECK-SAME: (%[[A:.*]]: memref<10xf32>) -// CHECK: %[[PRIVATE:.*]] = acc.private varPtr(%[[A]] : memref<10xf32>) varType(tensor<10xf32>) -> memref<10xf32> +// CHECK: %[[PRIVATE:.*]] = acc.private varPtr(%[[A]] : memref<10xf32>) varType(tensor<10xf32>) recipe(@privatization_memref_10_f32) -> memref<10xf32> // CHECK: acc.parallel { -// CHECK: acc.loop private(@privatization_memref_10_f32 -> %[[PRIVATE]] : memref<10xf32>) control(%[[I:.*]] : index) = (%{{.*}} : index) to (%{{.*}} : index) step (%{{.*}} : index) { +// CHECK: acc.loop private(%[[PRIVATE]] : memref<10xf32>) control(%[[I:.*]] : index) = (%{{.*}} : index) to (%{{.*}} : index) step (%{{.*}} : index) { // DEVICE: %{{.*}} = memref.load %[[PRIVATE:.*]][%[[I]]] : memref<10xf32> // CHECK: acc.yield // CHECK: } attributes {independent = [#acc.device_type]} @@ -205,8 +205,8 @@ func.func @test(%a: memref<10xf32>) { %lb = arith.constant 0 : index %st = arith.constant 1 : index %c10 = arith.constant 10 : index - %p1 = acc.private varPtr(%a : memref<10xf32>) varType(tensor<10xf32>) -> memref<10xf32> - acc.serial private(@privatization_memref_10_f32 -> %p1 : memref<10xf32>) { + %p1 = acc.private varPtr(%a : memref<10xf32>) varType(tensor<10xf32>) recipe(@privatization_memref_10_f32) -> memref<10xf32> + acc.serial private(%p1 : memref<10xf32>) { acc.loop control(%i : index) = (%lb : index) to (%c10 : index) step (%st : index) { %ci = memref.load %a[%i] : memref<10xf32> acc.yield @@ -218,8 +218,8 @@ func.func @test(%a: memref<10xf32>) { // CHECK-LABEL: func.func @test // CHECK-SAME: (%[[A:.*]]: memref<10xf32>) -// CHECK: %[[PRIVATE:.*]] = acc.private varPtr(%[[A]] : memref<10xf32>) varType(tensor<10xf32>) -> memref<10xf32> -// CHECK: acc.serial private(@privatization_memref_10_f32 -> %[[PRIVATE]] : memref<10xf32>) { +// CHECK: %[[PRIVATE:.*]] = acc.private varPtr(%[[A]] : memref<10xf32>) varType(tensor<10xf32>) recipe(@privatization_memref_10_f32) -> memref<10xf32> +// CHECK: acc.serial private(%[[PRIVATE]] : memref<10xf32>) { // CHECK: acc.loop control(%[[I:.*]] : index) = (%{{.*}} : index) to (%{{.*}} : index) step (%{{.*}} : index) { // DEVICE: %{{.*}} = memref.load %[[PRIVATE:.*]][%[[I]]] : memref<10xf32> // CHECK: acc.yield diff --git a/mlir/test/Dialect/OpenACC/ops.mlir b/mlir/test/Dialect/OpenACC/ops.mlir index 7bb6cf43e49a7..ffafef294066d 100644 --- a/mlir/test/Dialect/OpenACC/ops.mlir +++ b/mlir/test/Dialect/OpenACC/ops.mlir @@ -120,8 +120,8 @@ func.func @compute3(%a: memref<10x10xf32>, %b: memref<10x10xf32>, %c: memref<10x %pc = acc.present varPtr(%c : memref<10xf32>) varType(tensor<10xf32>) -> memref<10xf32> %pd = acc.present varPtr(%d : memref<10xf32>) varType(tensor<10xf32>) -> memref<10xf32> acc.data dataOperands(%pa, %pb, %pc, %pd: memref<10x10xf32>, memref<10x10xf32>, memref<10xf32>, memref<10xf32>) { - %private = acc.private varPtr(%c : memref<10xf32>) varType(tensor<10xf32>) -> memref<10xf32> - acc.parallel num_gangs({%numGangs: i64}) num_workers(%numWorkers: i64 [#acc.device_type]) private(@privatization_memref_10_f32 -> %private : memref<10xf32>) { + %private = acc.private varPtr(%c : memref<10xf32>) varType(tensor<10xf32>) recipe(@privatization_memref_10_f32) -> memref<10xf32> + acc.parallel num_gangs({%numGangs: i64}) num_workers(%numWorkers: i64 [#acc.device_type]) private(%private : memref<10xf32>) { acc.loop gang control(%x : index) = (%lb : index) to (%c10 : index) step (%st : index) { acc.loop worker control(%y : index) = (%lb : index) to (%c10 : index) step (%st : index) { %axy = memref.load %a[%x, %y] : memref<10x10xf32> @@ -157,8 +157,8 @@ func.func @compute3(%a: memref<10x10xf32>, %b: memref<10x10xf32>, %c: memref<10x // CHECK-NEXT: [[NUMGANG:%.*]] = arith.constant 10 : i64 // CHECK-NEXT: [[NUMWORKERS:%.*]] = arith.constant 10 : i64 // CHECK: acc.data dataOperands(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : memref<10x10xf32>, memref<10x10xf32>, memref<10xf32>, memref<10xf32>) { -// CHECK-NEXT: %[[P_ARG2:.*]] = acc.private varPtr([[ARG2]] : memref<10xf32>) varType(tensor<10xf32>) -> memref<10xf32> -// CHECK-NEXT: acc.parallel num_gangs({[[NUMGANG]] : i64}) num_workers([[NUMWORKERS]] : i64 [#acc.device_type]) private(@privatization_memref_10_f32 -> %[[P_ARG2]] : memref<10xf32>) { +// CHECK-NEXT: %[[P_ARG2:.*]] = acc.private varPtr([[ARG2]] : memref<10xf32>) varType(tensor<10xf32>) recipe(@privatization_memref_10_f32) -> memref<10xf32> +// CHECK-NEXT: acc.parallel num_gangs({[[NUMGANG]] : i64}) num_workers([[NUMWORKERS]] : i64 [#acc.device_type]) private(%[[P_ARG2]] : memref<10xf32>) { // CHECK-NEXT: acc.loop gang control(%{{.*}}) = (%{{.*}}) to (%{{.*}}) step (%{{.*}}) { // CHECK-NEXT: acc.loop worker control(%{{.*}}) = (%{{.*}}) to (%{{.*}}) step (%{{.*}}) { // CHECK-NEXT: %{{.*}} = memref.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32> @@ -429,7 +429,10 @@ func.func @testparallelop(%a: memref<10xf32>, %b: memref<10xf32>, %c: memref<10x } acc.parallel vector_length(%idxValue: index) { } - acc.parallel private(@privatization_memref_10_f32 -> %a : memref<10xf32>, @privatization_memref_10_10_f32 -> %c : memref<10x10xf32>) firstprivate(@privatization_memref_10xf32 -> %b: memref<10xf32>) { + %private_a = acc.private varPtr(%a : memref<10xf32>) recipe(@privatization_memref_10_f32) -> memref<10xf32> + %private_c = acc.private varPtr(%c : memref<10x10xf32>) recipe(@privatization_memref_10_10_f32) -> memref<10x10xf32> + %firstprivate_b = acc.firstprivate varPtr(%b : memref<10xf32>) recipe(@privatization_memref_10xf32) -> memref<10xf32> + acc.parallel private(%private_a, %private_c : memref<10xf32>, memref<10x10xf32>) firstprivate(%firstprivate_b : memref<10xf32>) { } acc.parallel { } attributes {defaultAttr = #acc} @@ -482,7 +485,10 @@ func.func @testparallelop(%a: memref<10xf32>, %b: memref<10xf32>, %c: memref<10x // CHECK-NEXT: } // CHECK: acc.parallel vector_length([[IDXVALUE]] : index) { // CHECK-NEXT: } -// CHECK: acc.parallel firstprivate(@privatization_memref_10xf32 -> [[ARGB]] : memref<10xf32>) private(@privatization_memref_10_f32 -> [[ARGA]] : memref<10xf32>, @privatization_memref_10_10_f32 -> [[ARGC]] : memref<10x10xf32>) { +// CHECK: %[[PRIVATE_A:.*]] = acc.private varPtr([[ARGA]] : memref<10xf32>) recipe(@privatization_memref_10_f32) -> memref<10xf32> +// CHECK-NEXT: %[[PRIVATE_C:.*]] = acc.private varPtr([[ARGC]] : memref<10x10xf32>) recipe(@privatization_memref_10_10_f32) -> memref<10x10xf32> +// CHECK-NEXT: %[[FIRSTPRIVATE_B:.*]] = acc.firstprivate varPtr([[ARGB]] : memref<10xf32>) recipe(@privatization_memref_10xf32) -> memref<10xf32> +// CHECK-NEXT: acc.parallel firstprivate(%[[FIRSTPRIVATE_B]] : memref<10xf32>) private(%[[PRIVATE_A]], %[[PRIVATE_C]] : memref<10xf32>, memref<10x10xf32>) { // CHECK-NEXT: } // CHECK: acc.parallel { // CHECK-NEXT: } attributes {defaultAttr = #acc} @@ -560,8 +566,10 @@ func.func @testserialop(%a: memref<10xf32>, %b: memref<10xf32>, %c: memref<10x10 } acc.serial wait({%i64value : i64, %i32value : i32, %idxValue : index}) { } - %firstprivate = acc.firstprivate varPtr(%b : memref<10xf32>) varType(tensor<10xf32>) -> memref<10xf32> - acc.serial private(@privatization_memref_10_f32 -> %a : memref<10xf32>, @privatization_memref_10_10_f32 -> %c : memref<10x10xf32>) firstprivate(@firstprivatization_memref_10xf32 -> %firstprivate : memref<10xf32>) { + %private_a = acc.private varPtr(%a : memref<10xf32>) recipe(@privatization_memref_10_f32) -> memref<10xf32> + %private_c = acc.private varPtr(%c : memref<10x10xf32>) recipe(@privatization_memref_10_10_f32) -> memref<10x10xf32> + %firstprivate = acc.firstprivate varPtr(%b : memref<10xf32>) varType(tensor<10xf32>) recipe(@firstprivatization_memref_10xf32) -> memref<10xf32> + acc.serial private(%private_a, %private_c : memref<10xf32>, memref<10x10xf32>) firstprivate(%firstprivate : memref<10xf32>) { } acc.serial { } attributes {defaultAttr = #acc} @@ -597,8 +605,10 @@ func.func @testserialop(%a: memref<10xf32>, %b: memref<10xf32>, %c: memref<10x10 // CHECK-NEXT: } // CHECK: acc.serial wait({[[I64VALUE]] : i64, [[I32VALUE]] : i32, [[IDXVALUE]] : index}) { // CHECK-NEXT: } -// CHECK: %[[FIRSTP:.*]] = acc.firstprivate varPtr([[ARGB]] : memref<10xf32>) varType(tensor<10xf32>) -> memref<10xf32> -// CHECK: acc.serial firstprivate(@firstprivatization_memref_10xf32 -> %[[FIRSTP]] : memref<10xf32>) private(@privatization_memref_10_f32 -> [[ARGA]] : memref<10xf32>, @privatization_memref_10_10_f32 -> [[ARGC]] : memref<10x10xf32>) { +// CHECK: %[[PRIVATE_A:.*]] = acc.private varPtr([[ARGA]] : memref<10xf32>) recipe(@privatization_memref_10_f32) -> memref<10xf32> +// CHECK-NEXT: %[[PRIVATE_C:.*]] = acc.private varPtr([[ARGC]] : memref<10x10xf32>) recipe(@privatization_memref_10_10_f32) -> memref<10x10xf32> +// CHECK-NEXT: %[[FIRSTP:.*]] = acc.firstprivate varPtr([[ARGB]] : memref<10xf32>) varType(tensor<10xf32>) recipe(@firstprivatization_memref_10xf32) -> memref<10xf32> +// CHECK-NEXT: acc.serial firstprivate(%[[FIRSTP]] : memref<10xf32>) private(%[[PRIVATE_A]], %[[PRIVATE_C]] : memref<10xf32>, memref<10x10xf32>) { // CHECK-NEXT: } // CHECK: acc.serial { // CHECK-NEXT: } attributes {defaultAttr = #acc} @@ -1475,32 +1485,43 @@ acc.private.recipe @privatization_struct_i32_i64 : !llvm.struct<(i32, i32)> init // ----- -acc.reduction.recipe @reduction_add_i64 : i64 reduction_operator init { -^bb0(%arg0: i64): - %0 = arith.constant 0 : i64 - acc.yield %0 : i64 +acc.reduction.recipe @reduction_add_memref_i64 : memref reduction_operator init { +^bb0(%arg0: memref): + %c0_i64 = arith.constant 0 : i64 + %alloca = memref.alloca() : memref + memref.store %c0_i64, %alloca[] : memref + acc.yield %alloca : memref } combiner { -^bb0(%arg0: i64, %arg1: i64): - %0 = arith.addi %arg0, %arg1 : i64 - acc.yield %0 : i64 +^bb0(%arg0: memref, %arg1: memref): + %0 = memref.load %arg0[] : memref + %1 = memref.load %arg1[] : memref + %2 = arith.addi %0, %1 : i64 + memref.store %2, %arg0[] : memref + acc.yield %arg0 : memref } -// CHECK-LABEL: acc.reduction.recipe @reduction_add_i64 : i64 reduction_operator init { -// CHECK: ^bb0(%{{.*}}: i64): +// CHECK-LABEL: acc.reduction.recipe @reduction_add_memref_i64 : memref reduction_operator init { +// CHECK: ^bb0(%{{.*}}: memref): // CHECK: %[[C0:.*]] = arith.constant 0 : i64 -// CHECK: acc.yield %[[C0]] : i64 +// CHECK: %[[ALLOCA:.*]] = memref.alloca() : memref +// CHECK: memref.store %[[C0]], %[[ALLOCA]][] : memref +// CHECK: acc.yield %[[ALLOCA]] : memref // CHECK: } combiner { -// CHECK: ^bb0(%[[ARG0:.*]]: i64, %[[ARG1:.*]]: i64): -// CHECK: %[[RES:.*]] = arith.addi %[[ARG0]], %[[ARG1]] : i64 -// CHECK: acc.yield %[[RES]] : i64 +// CHECK: ^bb0(%[[ARG0:.*]]: memref, %[[ARG1:.*]]: memref): +// CHECK: %[[LOAD0:.*]] = memref.load %[[ARG0]][] : memref +// CHECK: %[[LOAD1:.*]] = memref.load %[[ARG1]][] : memref +// CHECK: %[[RES:.*]] = arith.addi %[[LOAD0]], %[[LOAD1]] : i64 +// CHECK: memref.store %[[RES]], %[[ARG0]][] : memref +// CHECK: acc.yield %[[ARG0]] : memref // CHECK: } -func.func @acc_reduc_test(%a : i64) -> () { +func.func @acc_reduc_test(%a : memref) -> () { %c0 = arith.constant 0 : index %c10 = arith.constant 10 : index %c1 = arith.constant 1 : index - acc.parallel reduction(@reduction_add_i64 -> %a : i64) { - acc.loop reduction(@reduction_add_i64 -> %a : i64) control(%iv : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) { + %reduction_a = acc.reduction varPtr(%a : memref) recipe(@reduction_add_memref_i64) -> memref + acc.parallel reduction(%reduction_a : memref) { + acc.loop reduction(%reduction_a : memref) control(%iv : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) { acc.yield } attributes {inclusiveUpperbound = array, independent = [#acc.device_type]} acc.yield @@ -1509,31 +1530,39 @@ func.func @acc_reduc_test(%a : i64) -> () { } // CHECK-LABEL: func.func @acc_reduc_test( -// CHECK-SAME: %[[ARG0:.*]]: i64) -// CHECK: acc.parallel reduction(@reduction_add_i64 -> %[[ARG0]] : i64) -// CHECK: acc.loop reduction(@reduction_add_i64 -> %[[ARG0]] : i64) +// CHECK-SAME: %[[ARG0:.*]]: memref) +// CHECK: %[[REDUCTION_A:.*]] = acc.reduction varPtr(%[[ARG0]] : memref) recipe(@reduction_add_memref_i64) -> memref +// CHECK-NEXT: acc.parallel reduction(%[[REDUCTION_A]] : memref) +// CHECK: acc.loop reduction(%[[REDUCTION_A]] : memref) // ----- -acc.reduction.recipe @reduction_add_i64 : i64 reduction_operator init { -^bb0(%0: i64): - %1 = arith.constant 0 : i64 - acc.yield %1 : i64 +acc.reduction.recipe @reduction_add_memref_i64 : memref reduction_operator init { +^bb0(%arg0: memref): + %c0_i64 = arith.constant 0 : i64 + %alloca = memref.alloca() : memref + memref.store %c0_i64, %alloca[] : memref + acc.yield %alloca : memref } combiner { -^bb0(%0: i64, %1: i64): +^bb0(%arg0: memref, %arg1: memref): + %0 = memref.load %arg0[] : memref + %1 = memref.load %arg1[] : memref %2 = arith.addi %0, %1 : i64 - acc.yield %2 : i64 + memref.store %2, %arg0[] : memref + acc.yield %arg0 : memref } -func.func @acc_reduc_test(%a : i64) -> () { - acc.serial reduction(@reduction_add_i64 -> %a : i64) { +func.func @acc_reduc_test(%a : memref) -> () { + %reduction_a = acc.reduction varPtr(%a : memref) recipe(@reduction_add_memref_i64) -> memref + acc.serial reduction(%reduction_a : memref) { } return } // CHECK-LABEL: func.func @acc_reduc_test( -// CHECK-SAME: %[[ARG0:.*]]: i64) -// CHECK: acc.serial reduction(@reduction_add_i64 -> %[[ARG0]] : i64) +// CHECK-SAME: %[[ARG0:.*]]: memref) +// CHECK: %[[REDUCTION_A:.*]] = acc.reduction varPtr(%[[ARG0]] : memref) recipe(@reduction_add_memref_i64) -> memref +// CHECK-NEXT: acc.serial reduction(%[[REDUCTION_A]] : memref) // ----- From fb1b8c86c55feb193063c3e7751f4d18e553f8da Mon Sep 17 00:00:00 2001 From: Razvan Lupusoru Date: Tue, 22 Jul 2025 16:38:38 -0700 Subject: [PATCH 3/6] Update invalid test to include new messages --- mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp | 2 +- mlir/test/Dialect/OpenACC/invalid.mlir | 45 +++++++++++++++++++++++++ 2 files changed, 46 insertions(+), 1 deletion(-) diff --git a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp index 0039c6bde89e4..122cadbb11922 100644 --- a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp +++ b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp @@ -1068,7 +1068,7 @@ static LogicalResult checkPrivateOperands(mlir::Operation *accConstructOp, for (mlir::Value operand : operands) { if (!mlir::isa(operand.getDefiningOp())) return accConstructOp->emitOpError() - << "expect " << operandName << " as defining op"; + << "expected " << operandName << " as defining op"; if (!set.insert(operand).second) return accConstructOp->emitOpError() << operandName << " operand appears more than once"; diff --git a/mlir/test/Dialect/OpenACC/invalid.mlir b/mlir/test/Dialect/OpenACC/invalid.mlir index 1d9fe0a1a0c35..bb3aef339639f 100644 --- a/mlir/test/Dialect/OpenACC/invalid.mlir +++ b/mlir/test/Dialect/OpenACC/invalid.mlir @@ -823,3 +823,48 @@ func.func @acc_loop_container() { // expected-error @below {{invalid data clause modifiers: readonly}} %0 = acc.create varPtr(%value : memref) -> memref {modifiers = #acc} +// ----- + +func.func @fct1(%0 : !llvm.ptr) -> () { + // expected-error @below {{expected symbol reference @privatization_i32 to point to a private declaration}} + %priv = acc.private varPtr(%0 : !llvm.ptr) varType(i32) recipe(@privatization_i32) -> !llvm.ptr + return +} + +// ----- + +acc.private.recipe @privatization_i32 : !llvm.ptr init { +^bb0(%arg0: !llvm.ptr): + %c1 = arith.constant 1 : i32 + %c0 = arith.constant 0 : i32 + %0 = llvm.alloca %c1 x i32 : (i32) -> !llvm.ptr + llvm.store %c0, %0 : i32, !llvm.ptr + acc.yield %0 : !llvm.ptr +} + +func.func @fct1(%0 : !llvm.ptr) -> () { + %priv = acc.private varPtr(%0 : !llvm.ptr) varType(i32) recipe(@privatization_i32) -> !llvm.ptr + // expected-error @below {{expected firstprivate as defining op}} + acc.serial firstprivate(%priv : !llvm.ptr) { + } + return +} + +// ----- + +acc.private.recipe @privatization_i32 : !llvm.ptr init { +^bb0(%arg0: !llvm.ptr): + %c1 = arith.constant 1 : i32 + %c0 = arith.constant 0 : i32 + %0 = llvm.alloca %c1 x i32 : (i32) -> !llvm.ptr + llvm.store %c0, %0 : i32, !llvm.ptr + acc.yield %0 : !llvm.ptr +} + +func.func @fct1(%0 : !llvm.ptr) -> () { + %priv = acc.private varPtr(%0 : !llvm.ptr) varType(i32) recipe(@privatization_i32) -> !llvm.ptr + // expected-error @below {{op private operand appears more than once}} + acc.serial private(%priv, %priv : !llvm.ptr, !llvm.ptr) { + } + return +} From 3d04bd6fdf4b7e5d57ceffa617c803e9044bbbc4 Mon Sep 17 00:00:00 2001 From: Razvan Lupusoru Date: Tue, 22 Jul 2025 16:41:25 -0700 Subject: [PATCH 4/6] Fix format --- flang/lib/Lower/OpenACC.cpp | 47 ++++++++++++------------- mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp | 2 +- 2 files changed, 23 insertions(+), 26 deletions(-) diff --git a/flang/lib/Lower/OpenACC.cpp b/flang/lib/Lower/OpenACC.cpp index 50571a70e3aaf..366632e43db83 100644 --- a/flang/lib/Lower/OpenACC.cpp +++ b/flang/lib/Lower/OpenACC.cpp @@ -1317,15 +1317,15 @@ mlir::Type getTypeFromBounds(llvm::SmallVector &bounds, } template -static void genPrivatizationRecipes( - const Fortran::parser::AccObjectList &objectList, - Fortran::lower::AbstractConverter &converter, - Fortran::semantics::SemanticsContext &semanticsContext, - Fortran::lower::StatementContext &stmtCtx, - llvm::SmallVectorImpl &dataOperands, - llvm::ArrayRef async, - llvm::ArrayRef asyncDeviceTypes, - llvm::ArrayRef asyncOnlyDeviceTypes) { +static void +genPrivatizationRecipes(const Fortran::parser::AccObjectList &objectList, + Fortran::lower::AbstractConverter &converter, + Fortran::semantics::SemanticsContext &semanticsContext, + Fortran::lower::StatementContext &stmtCtx, + llvm::SmallVectorImpl &dataOperands, + llvm::ArrayRef async, + llvm::ArrayRef asyncDeviceTypes, + llvm::ArrayRef asyncOnlyDeviceTypes) { fir::FirOpBuilder &builder = converter.getFirOpBuilder(); Fortran::evaluate::ExpressionAnalyzer ea{semanticsContext}; for (const auto &accObject : objectList.v) { @@ -2011,14 +2011,14 @@ mlir::Type getTypeFromIvTypeSize(fir::FirOpBuilder &builder, return builder.getIntegerType(ivTypeSize * 8); } -static void -privatizeIv(Fortran::lower::AbstractConverter &converter, - const Fortran::semantics::Symbol &sym, mlir::Location loc, - llvm::SmallVector &ivTypes, - llvm::SmallVector &ivLocs, - llvm::SmallVector &privateOperands, - llvm::SmallVector &ivPrivate, - bool isDoConcurrent = false) { +static void privatizeIv(Fortran::lower::AbstractConverter &converter, + const Fortran::semantics::Symbol &sym, + mlir::Location loc, + llvm::SmallVector &ivTypes, + llvm::SmallVector &ivLocs, + llvm::SmallVector &privateOperands, + llvm::SmallVector &ivPrivate, + bool isDoConcurrent = false) { fir::FirOpBuilder &builder = converter.getFirOpBuilder(); mlir::Type ivTy = getTypeFromIvTypeSize(builder, sym); @@ -2358,8 +2358,7 @@ static mlir::acc::LoopOp createLoopOp( const auto &name = std::get(control.t); privatizeIv(converter, *name.symbol, currentLocation, ivTypes, ivLocs, - privateOperands, ivPrivate, - isDoConcurrent); + privateOperands, ivPrivate, isDoConcurrent); inclusiveBounds.push_back(true); } @@ -2807,15 +2806,13 @@ static Op createComputeOp( if (!combinedConstructs) genPrivatizationRecipes( privateClause->v, converter, semanticsContext, stmtCtx, - privateOperands, async, asyncDeviceTypes, - asyncOnlyDeviceTypes); + privateOperands, async, asyncDeviceTypes, asyncOnlyDeviceTypes); } else if (const auto *firstprivateClause = std::get_if( &clause.u)) { genPrivatizationRecipes( firstprivateClause->v, converter, semanticsContext, stmtCtx, - firstprivateOperands, async, - asyncDeviceTypes, asyncOnlyDeviceTypes); + firstprivateOperands, async, asyncDeviceTypes, asyncOnlyDeviceTypes); } else if (const auto *reductionClause = std::get_if( &clause.u)) { @@ -2826,8 +2823,8 @@ static Op createComputeOp( // instead. if (!combinedConstructs) { genReductions(reductionClause->v, converter, semanticsContext, stmtCtx, - reductionOperands, async, - asyncDeviceTypes, asyncOnlyDeviceTypes); + reductionOperands, async, asyncDeviceTypes, + asyncOnlyDeviceTypes); } else { auto crtDataStart = dataClauseOperands.size(); genDataOperandOperations( diff --git a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp index 122cadbb11922..5a7c8a4f65e69 100644 --- a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp +++ b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp @@ -462,7 +462,7 @@ static ParseResult parseRecipeSym(mlir::OpAsmParser &parser, } static void printRecipeSym(mlir::OpAsmPrinter &p, mlir::Operation *op, - mlir::SymbolRefAttr recipeAttr) { + mlir::SymbolRefAttr recipeAttr) { p << recipeAttr; } From a10166228354f73aef14a60624d750c5168b2f3a Mon Sep 17 00:00:00 2001 From: Razvan Lupusoru Date: Tue, 22 Jul 2025 16:46:55 -0700 Subject: [PATCH 5/6] Restore the data operands verifier --- mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp index 5a7c8a4f65e69..7c601b706c064 100644 --- a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp +++ b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp @@ -1045,7 +1045,7 @@ LogicalResult acc::ReductionRecipeOp::verifyRegions() { template static LogicalResult checkDataOperands(Op op, const mlir::ValueRange &operands) { - for (mlir::Value operand : operands) { + for (mlir::Value operand : operands) if (!mlir::isa( @@ -1053,10 +1053,6 @@ static LogicalResult checkDataOperands(Op op, return op.emitError( "expect data entry/exit operation or acc.getdeviceptr " "as defining op"); - mlir::SymbolRefAttr operandRecipe = getRecipe(operand.getDefiningOp()); - if (operandRecipe) - return op.emitError("recipe not expected for data mapping operations"); - } return success(); } From 0b47fd46e78d9048a77487b5b9a8e6bd53b17037 Mon Sep 17 00:00:00 2001 From: Razvan Lupusoru Date: Tue, 22 Jul 2025 16:49:39 -0700 Subject: [PATCH 6/6] Add missed invalid cases --- mlir/test/Dialect/OpenACC/invalid.mlir | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/mlir/test/Dialect/OpenACC/invalid.mlir b/mlir/test/Dialect/OpenACC/invalid.mlir index bb3aef339639f..a19953e87bc91 100644 --- a/mlir/test/Dialect/OpenACC/invalid.mlir +++ b/mlir/test/Dialect/OpenACC/invalid.mlir @@ -868,3 +868,27 @@ func.func @fct1(%0 : !llvm.ptr) -> () { } return } + +// ----- + +func.func @fct1(%0 : !llvm.ptr) -> () { + // expected-error @below {{op recipe expected for private}} + %priv = acc.private varPtr(%0 : !llvm.ptr) varType(i32) -> !llvm.ptr + return +} + +// ----- + +func.func @fct1(%0 : !llvm.ptr) -> () { + // expected-error @below {{op recipe expected for firstprivate}} + %priv = acc.firstprivate varPtr(%0 : !llvm.ptr) varType(i32) -> !llvm.ptr + return +} + +// ----- + +func.func @fct1(%0 : !llvm.ptr) -> () { + // expected-error @below {{op recipe expected for reduction}} + %priv = acc.reduction varPtr(%0 : !llvm.ptr) varType(i32) -> !llvm.ptr + return +}