[clang] Revert "[OpenACC] Sema changes for +*&|^ reduction combiner recipes (… (PR #162920)
via cfe-commits
cfe-commits at lists.llvm.org
Fri Oct 10 14:05:06 PDT 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang
Author: Erich Keane (erichkeane)
<details>
<summary>Changes</summary>
…#<!-- -->162740)"
This reverts commit 6010df0402e2f5cca0ded446a70492dedc43ab7e.
This apparently fails some sanitizer test as reported here: https://github.com/llvm/llvm-project/pull/162740
It isn't really clear where this happens, but reverting as it is a friday, and I have no idea if I'll be able to repro this anytime soon,
let alone fix it.
---
Patch is 297.34 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/162920.diff
16 Files Affected:
- (modified) clang/include/clang/Basic/DiagnosticSemaKinds.td (-5)
- (modified) clang/include/clang/Sema/SemaOpenACC.h (-5)
- (modified) clang/lib/Sema/SemaOpenACC.cpp (+1-168)
- (modified) clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-default-ops.cpp (+211-140)
- (modified) clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-float.cpp (+243)
- (modified) clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.c (+187-130)
- (modified) clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.cpp (+204-133)
- (modified) clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.c (+244)
- (modified) clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.cpp (+243)
- (modified) clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-default-ops.cpp (+214-143)
- (modified) clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-float.cpp (+243)
- (modified) clang/test/SemaOpenACC/combined-construct-reduction-clause.cpp (+1-6)
- (modified) clang/test/SemaOpenACC/compute-construct-clause-ast.cpp (+27)
- (modified) clang/test/SemaOpenACC/compute-construct-reduction-clause.c (+3-14)
- (modified) clang/test/SemaOpenACC/compute-construct-reduction-clause.cpp (+1-15)
- (modified) clang/test/SemaOpenACC/loop-construct-reduction-ast.cpp (+54)
``````````diff
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 40bc7b9a4e45e..3df28f2ef3334 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -13665,11 +13665,6 @@ def warn_acc_var_referenced_lacks_op
"reference has no effect">,
InGroup<DiagGroup<"openacc-var-lacks-operation">>,
DefaultError;
-def err_acc_reduction_recipe_no_op
- : Error<"variable of type %0 referenced in OpenACC 'reduction' clause does "
- "not have a valid operation available">;
-def note_acc_reduction_recipe_noop_field
- : Note<"while forming combiner for compound type %0">;
// AMDGCN builtins diagnostics
def err_amdgcn_load_lds_size_invalid_value : Error<"invalid size value">;
diff --git a/clang/include/clang/Sema/SemaOpenACC.h b/clang/include/clang/Sema/SemaOpenACC.h
index 16e7f1bc83019..6cadc343cd728 100644
--- a/clang/include/clang/Sema/SemaOpenACC.h
+++ b/clang/include/clang/Sema/SemaOpenACC.h
@@ -228,11 +228,6 @@ class SemaOpenACC : public SemaBase {
bool DiagnoseAllowedClauses(OpenACCDirectiveKind DK, OpenACCClauseKind CK,
SourceLocation ClauseLoc);
- bool CreateReductionCombinerRecipe(
- SourceLocation loc, OpenACCReductionOperator ReductionOperator,
- QualType VarTy,
- llvm::SmallVectorImpl<OpenACCReductionRecipe::CombinerRecipe>
- &CombinerRecipes);
public:
// Needed from the visitor, so should be public.
diff --git a/clang/lib/Sema/SemaOpenACC.cpp b/clang/lib/Sema/SemaOpenACC.cpp
index 779b6e9cb6b4d..f3969a96b8ced 100644
--- a/clang/lib/Sema/SemaOpenACC.cpp
+++ b/clang/lib/Sema/SemaOpenACC.cpp
@@ -2898,15 +2898,6 @@ OpenACCReductionRecipe SemaOpenACC::CreateReductionInitRecipe(
dyn_cast<ArraySectionExpr>(VarExpr->IgnoreParenImpCasts()))
VarTy = ASE->getElementType();
- llvm::SmallVector<OpenACCReductionRecipe::CombinerRecipe, 1> CombinerRecipes;
-
- // We use the 'set-ness' of the alloca-decl to determine whether the combiner
- // is 'set' or not, so we can skip any attempts at it if we're going to fail
- // at any of the combiners.
- if (CreateReductionCombinerRecipe(VarExpr->getBeginLoc(), ReductionOperator,
- VarTy, CombinerRecipes))
- return OpenACCReductionRecipe::Empty();
-
VarDecl *AllocaDecl = CreateAllocaDecl(
getASTContext(), SemaRef.getCurContext(), VarExpr->getBeginLoc(),
&getASTContext().Idents.get("openacc.reduction.init"), VarTy);
@@ -2955,163 +2946,5 @@ OpenACCReductionRecipe SemaOpenACC::CreateReductionInitRecipe(
AllocaDecl->setInit(Init.get());
AllocaDecl->setInitStyle(VarDecl::CallInit);
}
-
- return OpenACCReductionRecipe(AllocaDecl, CombinerRecipes);
-}
-
-bool SemaOpenACC::CreateReductionCombinerRecipe(
- SourceLocation Loc, OpenACCReductionOperator ReductionOperator,
- QualType VarTy,
- llvm::SmallVectorImpl<OpenACCReductionRecipe::CombinerRecipe>
- &CombinerRecipes) {
- // Now we can try to generate the 'combiner' recipe. This is a little
- // complicated in that if the 'VarTy' is an array type, we want to take its
- // element type so we can generate that. Additionally, if this is a struct,
- // we have two options: If there is overloaded operators, we want to take
- // THOSE, else we want to do the individual elements.
-
- BinaryOperatorKind BinOp;
- switch (ReductionOperator) {
- case OpenACCReductionOperator::Invalid:
- // This can only happen when there is an error, and since these inits
- // are used for code generation, we can just ignore/not bother doing any
- // initialization here.
- CombinerRecipes.push_back({nullptr, nullptr, nullptr});
- return false;
- case OpenACCReductionOperator::Addition:
- BinOp = BinaryOperatorKind::BO_AddAssign;
- break;
- case OpenACCReductionOperator::Multiplication:
- BinOp = BinaryOperatorKind::BO_MulAssign;
- break;
- case OpenACCReductionOperator::BitwiseAnd:
- BinOp = BinaryOperatorKind::BO_AndAssign;
- break;
- case OpenACCReductionOperator::BitwiseOr:
- BinOp = BinaryOperatorKind::BO_OrAssign;
- break;
- case OpenACCReductionOperator::BitwiseXOr:
- BinOp = BinaryOperatorKind::BO_XorAssign;
- break;
-
- case OpenACCReductionOperator::Max:
- case OpenACCReductionOperator::Min:
- case OpenACCReductionOperator::And:
- case OpenACCReductionOperator::Or:
- // We just want a 'NYI' error in the backend, so leave an empty combiner
- // recipe, and claim success.
- CombinerRecipes.push_back({nullptr, nullptr, nullptr});
- return false;
- }
-
- // If VarTy is an array type, at the top level only, we want to do our
- // compares/decomp/etc at the element level.
- if (auto *AT = getASTContext().getAsArrayType(VarTy))
- VarTy = AT->getElementType();
-
- assert(!VarTy->isArrayType() && "Only 1 level of array allowed");
-
- auto tryCombiner = [&, this](DeclRefExpr *LHSDRE, DeclRefExpr *RHSDRE,
- bool IncludeTrap) {
- // TODO: OpenACC: we have to figure out based on the bin-op how to do the
- // ones that we can't just use compound operators for. So &&, ||, max, and
- // min aren't really clear what we could do here.
- if (IncludeTrap) {
- // Trap all of the errors here, we'll emit our own at the end.
- Sema::TentativeAnalysisScope Trap{SemaRef};
-
- return SemaRef.BuildBinOp(SemaRef.getCurScope(), Loc, BinOp, LHSDRE,
- RHSDRE,
- /*ForFoldExpr=*/false);
- } else {
- return SemaRef.BuildBinOp(SemaRef.getCurScope(), Loc, BinOp, LHSDRE,
- RHSDRE,
- /*ForFoldExpr=*/false);
- }
- };
-
- struct CombinerAttemptTy {
- VarDecl *LHS;
- DeclRefExpr *LHSDRE;
- VarDecl *RHS;
- DeclRefExpr *RHSDRE;
- Expr *Op;
- };
-
- auto formCombiner = [&, this](QualType Ty) -> CombinerAttemptTy {
- VarDecl *LHSDecl = CreateAllocaDecl(
- getASTContext(), SemaRef.getCurContext(), Loc,
- &getASTContext().Idents.get("openacc.reduction.combiner.lhs"), Ty);
- auto *LHSDRE = DeclRefExpr::Create(
- getASTContext(), NestedNameSpecifierLoc{}, SourceLocation{}, LHSDecl,
- /*ReferstoEnclosingVariableOrCapture=*/false,
- DeclarationNameInfo{DeclarationName{LHSDecl->getDeclName()},
- LHSDecl->getBeginLoc()},
- Ty, clang::VK_LValue, LHSDecl, nullptr, NOUR_None);
- VarDecl *RHSDecl = CreateAllocaDecl(
- getASTContext(), SemaRef.getCurContext(), Loc,
- &getASTContext().Idents.get("openacc.reduction.combiner.lhs"), Ty);
- auto *RHSDRE = DeclRefExpr::Create(
- getASTContext(), NestedNameSpecifierLoc{}, SourceLocation{}, RHSDecl,
- /*ReferstoEnclosingVariableOrCapture=*/false,
- DeclarationNameInfo{DeclarationName{RHSDecl->getDeclName()},
- RHSDecl->getBeginLoc()},
- Ty, clang::VK_LValue, RHSDecl, nullptr, NOUR_None);
-
- ExprResult BinOpResult = tryCombiner(LHSDRE, RHSDRE, /*IncludeTrap=*/true);
-
- return {LHSDecl, LHSDRE, RHSDecl, RHSDRE, BinOpResult.get()};
- };
-
- CombinerAttemptTy TopLevelCombinerInfo = formCombiner(VarTy);
-
- if (TopLevelCombinerInfo.Op) {
- if (!TopLevelCombinerInfo.Op->containsErrors() &&
- TopLevelCombinerInfo.Op->isInstantiationDependent()) {
- // If this is instantiation dependent, we're just going to 'give up' here
- // and count on us to get it right during instantaition.
- CombinerRecipes.push_back({nullptr, nullptr, nullptr});
- return false;
- } else if (!TopLevelCombinerInfo.Op->containsErrors()) {
- // Else, we succeeded, we can just return this combiner.
- CombinerRecipes.push_back({TopLevelCombinerInfo.LHS,
- TopLevelCombinerInfo.RHS,
- TopLevelCombinerInfo.Op});
- return false;
- }
- }
-
- // Since the 'root' level didn't fail, the only thing that could be successful
- // is a struct that we decompose on its individual fields.
-
- RecordDecl *RD = VarTy->getAsRecordDecl();
- if (!RD) {
- Diag(Loc, diag::err_acc_reduction_recipe_no_op) << VarTy;
- tryCombiner(TopLevelCombinerInfo.LHSDRE, TopLevelCombinerInfo.RHSDRE,
- /*IncludeTrap=*/false);
- return true;
- }
-
- for (const FieldDecl *FD : RD->fields()) {
- CombinerAttemptTy FieldCombinerInfo = formCombiner(FD->getType());
-
- if (!FieldCombinerInfo.Op || FieldCombinerInfo.Op->containsErrors()) {
- Diag(Loc, diag::err_acc_reduction_recipe_no_op) << FD->getType();
- Diag(FD->getBeginLoc(), diag::note_acc_reduction_recipe_noop_field) << RD;
- tryCombiner(FieldCombinerInfo.LHSDRE, FieldCombinerInfo.RHSDRE,
- /*IncludeTrap=*/false);
- return true;
- }
-
- if (FieldCombinerInfo.Op->isInstantiationDependent()) {
- // If this is instantiation dependent, we're just going to 'give up' here
- // and count on us to get it right during instantaition.
- CombinerRecipes.push_back({nullptr, nullptr, nullptr});
- } else {
- CombinerRecipes.push_back(
- {FieldCombinerInfo.LHS, FieldCombinerInfo.RHS, FieldCombinerInfo.Op});
- }
- }
-
- return false;
+ return OpenACCReductionRecipe(AllocaDecl, {});
}
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-default-ops.cpp b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-default-ops.cpp
index 040ddd3ca458c..7b74b7cee1e75 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-default-ops.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-default-ops.cpp
@@ -8,19 +8,12 @@ struct DefaultOperators {
bool b;
};
-struct DefaultOperatorsNoFloats {
- int i;
- unsigned int u;
- bool b;
-};
-
template<typename T>
void acc_combined() {
T someVar;
T someVarArr[5];
- struct DefaultOperatorsNoFloats someVarNoFloats;
- struct DefaultOperatorsNoFloats someVarArrNoFloats[5];
#pragma acc parallel loop reduction(+:someVar)
+ for(int i=0;i < 5; ++i);
// CHECK: acc.reduction.recipe @reduction_add__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
@@ -46,7 +39,6 @@ void acc_combined() {
// TODO OpenACC: Expecting combination operation here
// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: }
- for(int i=0;i < 5; ++i);
#pragma acc parallel loop reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <mul> init {
@@ -129,67 +121,86 @@ void acc_combined() {
// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: }
for(int i=0;i < 5; ++i);
-#pragma acc parallel loop reduction(&:someVarNoFloats)
-// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <iand> init {
-// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i>
+#pragma acc parallel loop reduction(&:someVar)
+
+// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <iand> init {
+// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
-// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i>
+// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i>
-// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool>
+// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[ALLOCA]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float
+// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[ALLOCA]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double>
+// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double
+// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double>
+// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool>
// CHECK-NEXT: acc.yield
//
// CHECK-NEXT: } combiner {
-// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}})
+// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}})
// TODO OpenACC: Expecting combination operation here
-// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperatorsNoFloats>
+// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: }
- for(int i = 0; i < 5; ++i);
-#pragma acc parallel loop reduction(|:someVarNoFloats)
-// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <ior> init {
-// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i>
+ for(int i=0;i < 5; ++i);
+#pragma acc parallel loop reduction(|:someVar)
+// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <ior> init {
+// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
-// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i>
+// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i>
-// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool>
+// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[ALLOCA]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float
+// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[ALLOCA]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double>
+// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double
+// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double>
+// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #false
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool>
// CHECK-NEXT: acc.yield
//
// CHECK-NEXT: } combiner {
-// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}})
+// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}})
// TODO OpenACC: Expecting combination operation here
-// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperatorsNoFloats>
+// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: }
- for(int i = 0; i < 5; ++i);
-#pragma acc parallel loop reduction(^:someVarNoFloats)
-// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <xor> init {
-// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i>
+ for(int i=0;i < 5; ++i);
+#pragma acc parallel loop reduction(^:someVar)
+// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <xor> init {
+// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
-// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i>
+// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i>
-// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool>
+// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[ALLOCA]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float
+// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[ALLOCA]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double>
+// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double
+// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double>
+// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #false
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool>
// CHECK-NEXT: acc.yield
//
// CHECK-NEXT: } combiner {
-// CHECK-NEXT: ^bb0(%[[LHSARG:.*...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/162920
More information about the cfe-commits
mailing list