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 _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
