Skip to content

Commit 6ceefbe

Browse files
erichkeaneerichkeane
authored
[OpenACC][CIR] Implement || and && reduction combiner lowering (#164298)
These two operations are expressed as LHS = LHS || RHS, for any construct in which that is valid. Fortunately, the mechanism for codegen from previous reduction works great for this, so it saw minimal changes. This is the last of the reduction construct lowering.
1 parent 6e0553f commit 6ceefbe

21 files changed

+4516
-146
lines changed

‎clang/lib/Sema/SemaOpenACC.cpp‎

Lines changed: 19 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -2999,11 +2999,11 @@ bool SemaOpenACC::CreateReductionCombinerRecipe(
29992999
BinOp = BinaryOperatorKind::BO_LT;
30003000
break;
30013001
case OpenACCReductionOperator::And:
3002+
BinOp = BinaryOperatorKind::BO_LAnd;
3003+
break;
30023004
case OpenACCReductionOperator::Or:
3003-
// We just want a 'NYI' error in the backend, so leave an empty combiner
3004-
// recipe, and claim success.
3005-
CombinerRecipes.push_back({nullptr, nullptr, nullptr});
3006-
return false;
3005+
BinOp = BinaryOperatorKind::BO_LOr;
3006+
break;
30073007
}
30083008

30093009
// If VarTy is an array type, at the top level only, we want to do our
@@ -3068,8 +3068,21 @@ bool SemaOpenACC::CreateReductionCombinerRecipe(
30683068
: CombinerFailureKind::Assignment};
30693069
}
30703070
case OpenACCReductionOperator::And:
3071-
case OpenACCReductionOperator::Or:
3072-
llvm_unreachable("And/Or not implemented, but should fail earlier");
3071+
case OpenACCReductionOperator::Or: {
3072+
// These are done as LHS = LHS && RHS (or LHS = LHS || RHS). So after the
3073+
// binop, all we have to do is the assignment.
3074+
if (!BinOpRes.isUsable())
3075+
return {BinOpRes, CombinerFailureKind::BinOp};
3076+
3077+
// Build assignment.
3078+
ExprResult Assignment = SemaRef.BuildBinOp(SemaRef.getCurScope(), Loc,
3079+
BinaryOperatorKind::BO_Assign,
3080+
LHSDRE, BinOpRes.get(),
3081+
/*ForFoldExpr=*/false);
3082+
return {Assignment, Assignment.isUsable()
3083+
? CombinerFailureKind::None
3084+
: CombinerFailureKind::Assignment};
3085+
}
30733086
case OpenACCReductionOperator::Invalid:
30743087
llvm_unreachable("Invalid should have been caught above");
30753088
}

‎clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-default-ops.cpp‎

Lines changed: 529 additions & 5 deletions
Large diffs are not rendered by default.

‎clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-float.cpp‎

Lines changed: 173 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
// RUN: not %clang_cc1 -fopenacc -triple x86_64-linux-gnu -Wno-openacc-self-if-potential-conflict -emit-cir -fclangir -triple x86_64-linux-pc %s -o - | FileCheck %s
1+
// RUN: %clang_cc1 -fopenacc -triple x86_64-linux-gnu -Wno-openacc-self-if-potential-conflict -emit-cir -fclangir -triple x86_64-linux-pc %s -o - | FileCheck %s
22
template<typename T>
33
void acc_combined() {
44
T someVar;
@@ -92,7 +92,18 @@ void acc_combined() {
9292
// CHECK-NEXT: acc.yield
9393
// CHECK-NEXT: } combiner {
9494
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.float> {{.*}})
95-
// TODO OpenACC: Expecting combination operation here
95+
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHSARG]] : !cir.ptr<!cir.float>
96+
// CHECK-NEXT: %[[LHS_TO_BOOL:.*]] = cir.cast float_to_bool %[[LHS_LOAD]] : !cir.float -> !cir.bool
97+
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[LHS_TO_BOOL]], true {
98+
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHSARG]] : !cir.ptr<!cir.float>
99+
// CHECK-NEXT: %[[RHS_TO_BOOL:.*]] = cir.cast float_to_bool %[[RHS_LOAD]] : !cir.float -> !cir.bool
100+
// CHECK-NEXT: cir.yield %[[RHS_TO_BOOL]] : !cir.bool
101+
// CHECK-NEXT: }, false {
102+
// CHECK-NEXT: %[[FALSE:.*]] = cir.const #false
103+
// CHECK-NEXT: cir.yield %[[FALSE]] : !cir.bool
104+
// CHECK-NEXT: }) : (!cir.bool) -> !cir.bool
105+
// CHECK-NEXT: %[[RES_TO_VAL:.*]] = cir.cast bool_to_float %[[TERNARY]] : !cir.bool -> !cir.float
106+
// CHECK-NEXT: cir.store{{.*}} %[[RES_TO_VAL]], %[[LHSARG]] : !cir.float, !cir.ptr<!cir.float>
96107
// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.float>
97108
// CHECK-NEXT: }
98109
for(int i=0;i < 5; ++i);
@@ -106,7 +117,18 @@ void acc_combined() {
106117
//
107118
// CHECK-NEXT: } combiner {
108119
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.float> {{.*}})
109-
// TODO OpenACC: Expecting combination operation here
120+
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHSARG]] : !cir.ptr<!cir.float>
121+
// CHECK-NEXT: %[[LHS_TO_BOOL:.*]] = cir.cast float_to_bool %[[LHS_LOAD]] : !cir.float -> !cir.bool
122+
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[LHS_TO_BOOL]], true {
123+
// CHECK-NEXT: %[[TRUE:.*]] = cir.const #true
124+
// CHECK-NEXT: cir.yield %[[TRUE]] : !cir.bool
125+
// CHECK-NEXT: }, false {
126+
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHSARG]] : !cir.ptr<!cir.float>
127+
// CHECK-NEXT: %[[RHS_TO_BOOL:.*]] = cir.cast float_to_bool %[[RHS_LOAD]] : !cir.float -> !cir.bool
128+
// CHECK-NEXT: cir.yield %[[RHS_TO_BOOL]] : !cir.bool
129+
// CHECK-NEXT: }) : (!cir.bool) -> !cir.bool
130+
// CHECK-NEXT: %[[RES_TO_VAL:.*]] = cir.cast bool_to_float %[[TERNARY]] : !cir.bool -> !cir.float
131+
// CHECK-NEXT: cir.store{{.*}} %[[RES_TO_VAL]], %[[LHSARG]] : !cir.float, !cir.ptr<!cir.float>
110132
// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.float>
111133
// CHECK-NEXT: }
112134
for(int i=0;i < 5; ++i);
@@ -371,7 +393,41 @@ void acc_combined() {
371393
//
372394
// CHECK-NEXT: } combiner {
373395
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
374-
// TODO OpenACC: Expecting combination operation here
396+
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
397+
// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
398+
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
399+
// CHECK-NEXT: cir.for : cond {
400+
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
401+
// CHECK-NEXT: %[[END_VAL:.*]] = cir.const #cir.int<5> : !s64i
402+
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(lt, %[[ITR_LOAD]], %[[END_VAL]]) : !s64i, !cir.bool
403+
// CHECK-NEXT: cir.condition(%[[CMP]])
404+
// CHECK-NEXT: } body {
405+
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
406+
// CHECK-NEXT: %[[LHS_DECAY:.*]] = cir.cast array_to_ptrdecay %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float>
407+
// CHECK-NEXT: %[[LHS_STRIDE:.*]] = cir.ptr_stride %[[LHS_DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float>
408+
// CHECK-NEXT: %[[RHS_DECAY:.*]] = cir.cast array_to_ptrdecay %[[RHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float>
409+
// CHECK-NEXT: %[[RHS_STRIDE:.*]] = cir.ptr_stride %[[RHS_DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float>
410+
//
411+
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHS_STRIDE]] : !cir.ptr<!cir.float>, !cir.float
412+
// CHECK-NEXT: %[[LHS_TO_BOOL:.*]] = cir.cast float_to_bool %[[LHS_LOAD]] : !cir.float -> !cir.bool
413+
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[LHS_TO_BOOL]], true {
414+
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHS_STRIDE]] : !cir.ptr<!cir.float>, !cir.float
415+
// CHECK-NEXT: %[[RHS_TO_BOOL:.*]] = cir.cast float_to_bool %[[RHS_LOAD]] : !cir.float -> !cir.bool
416+
// CHECK-NEXT: cir.yield %[[RHS_TO_BOOL]] : !cir.bool
417+
// CHECK-NEXT: }, false {
418+
// CHECK-NEXT: %[[FALSE:.*]] = cir.const #false
419+
// CHECK-NEXT: cir.yield %[[FALSE]] : !cir.bool
420+
// CHECK-NEXT: }) : (!cir.bool) -> !cir.bool
421+
// CHECK-NEXT: %[[RES_TO_VAL:.*]] = cir.cast bool_to_float %[[TERNARY]] : !cir.bool -> !cir.float
422+
// CHECK-NEXT: cir.store{{.*}} %[[RES_TO_VAL]], %[[LHS_STRIDE]] : !cir.float, !cir.ptr<!cir.float>
423+
//
424+
// CHECK-NEXT: cir.yield
425+
// CHECK-NEXT: } step {
426+
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
427+
// CHECK-NEXT: %[[INC:.*]] = cir.unary(inc, %[[ITR_LOAD]]) : !s64i, !s64i
428+
// CHECK-NEXT: cir.store %[[INC]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
429+
// CHECK-NEXT: cir.yield
430+
// CHECK-NEXT: }
375431
// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>>
376432
// CHECK-NEXT: }
377433
for(int i=0;i < 5; ++i);
@@ -401,7 +457,41 @@ void acc_combined() {
401457
//
402458
// CHECK-NEXT: } combiner {
403459
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
404-
// TODO OpenACC: Expecting combination operation here
460+
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
461+
// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
462+
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
463+
// CHECK-NEXT: cir.for : cond {
464+
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
465+
// CHECK-NEXT: %[[END_VAL:.*]] = cir.const #cir.int<5> : !s64i
466+
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(lt, %[[ITR_LOAD]], %[[END_VAL]]) : !s64i, !cir.bool
467+
// CHECK-NEXT: cir.condition(%[[CMP]])
468+
// CHECK-NEXT: } body {
469+
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
470+
// CHECK-NEXT: %[[LHS_DECAY:.*]] = cir.cast array_to_ptrdecay %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float>
471+
// CHECK-NEXT: %[[LHS_STRIDE:.*]] = cir.ptr_stride %[[LHS_DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float>
472+
// CHECK-NEXT: %[[RHS_DECAY:.*]] = cir.cast array_to_ptrdecay %[[RHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float>
473+
// CHECK-NEXT: %[[RHS_STRIDE:.*]] = cir.ptr_stride %[[RHS_DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float>
474+
//
475+
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHS_STRIDE]] : !cir.ptr<!cir.float>, !cir.float
476+
// CHECK-NEXT: %[[LHS_TO_BOOL:.*]] = cir.cast float_to_bool %[[LHS_LOAD]] : !cir.float -> !cir.bool
477+
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[LHS_TO_BOOL]], true {
478+
// CHECK-NEXT: %[[TRUE:.*]] = cir.const #true
479+
// CHECK-NEXT: cir.yield %[[TRUE]] : !cir.bool
480+
// CHECK-NEXT: }, false {
481+
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHS_STRIDE]] : !cir.ptr<!cir.float>, !cir.float
482+
// CHECK-NEXT: %[[RHS_TO_BOOL:.*]] = cir.cast float_to_bool %[[RHS_LOAD]] : !cir.float -> !cir.bool
483+
// CHECK-NEXT: cir.yield %[[RHS_TO_BOOL]] : !cir.bool
484+
// CHECK-NEXT: }) : (!cir.bool) -> !cir.bool
485+
// CHECK-NEXT: %[[RES_TO_VAL:.*]] = cir.cast bool_to_float %[[TERNARY]] : !cir.bool -> !cir.float
486+
// CHECK-NEXT: cir.store{{.*}} %[[RES_TO_VAL]], %[[LHS_STRIDE]] : !cir.float, !cir.ptr<!cir.float>
487+
//
488+
// CHECK-NEXT: cir.yield
489+
// CHECK-NEXT: } step {
490+
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
491+
// CHECK-NEXT: %[[INC:.*]] = cir.unary(inc, %[[ITR_LOAD]]) : !s64i, !s64i
492+
// CHECK-NEXT: cir.store %[[INC]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
493+
// CHECK-NEXT: cir.yield
494+
// CHECK-NEXT: }
405495
// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>>
406496
// CHECK-NEXT: }
407497
for(int i=0;i < 5; ++i);
@@ -708,7 +798,45 @@ void acc_combined() {
708798
// CHECK-NEXT: acc.yield
709799
// CHECK-NEXT: } combiner {
710800
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
711-
// TODO OpenACC: Expecting combination operation here
801+
// CHECK-NEXT: cir.scope {
802+
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
803+
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
804+
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
805+
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
806+
// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
807+
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
808+
// CHECK-NEXT: cir.for : cond {
809+
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
810+
// CHECK-NEXT: %[[COND:.*]] = cir.cmp(lt, %[[ITR_LOAD]], %[[UB_CAST]]) : !u64i, !cir.bool
811+
// CHECK-NEXT: cir.condition(%[[COND]])
812+
// CHECK-NEXT: } body {
813+
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
814+
// CHECK-NEXT: %[[LHS_DECAY:.*]] = cir.cast array_to_ptrdecay %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float>
815+
// CHECK-NEXT: %[[LHS_STRIDE:.*]] = cir.ptr_stride %[[LHS_DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!cir.float>, !u64i) -> !cir.ptr<!cir.float>
816+
// CHECK-NEXT: %[[RHS_DECAY:.*]] = cir.cast array_to_ptrdecay %[[RHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float>
817+
// CHECK-NEXT: %[[RHS_STRIDE:.*]] = cir.ptr_stride %[[RHS_DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!cir.float>, !u64i) -> !cir.ptr<!cir.float>
818+
//
819+
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHS_STRIDE]] : !cir.ptr<!cir.float>, !cir.float
820+
// CHECK-NEXT: %[[LHS_TO_BOOL:.*]] = cir.cast float_to_bool %[[LHS_LOAD]] : !cir.float -> !cir.bool
821+
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[LHS_TO_BOOL]], true {
822+
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHS_STRIDE]] : !cir.ptr<!cir.float>, !cir.float
823+
// CHECK-NEXT: %[[RHS_TO_BOOL:.*]] = cir.cast float_to_bool %[[RHS_LOAD]] : !cir.float -> !cir.bool
824+
// CHECK-NEXT: cir.yield %[[RHS_TO_BOOL]] : !cir.bool
825+
// CHECK-NEXT: }, false {
826+
// CHECK-NEXT: %[[FALSE:.*]] = cir.const #false
827+
// CHECK-NEXT: cir.yield %[[FALSE]] : !cir.bool
828+
// CHECK-NEXT: }) : (!cir.bool) -> !cir.bool
829+
// CHECK-NEXT: %[[RES_TO_VAL:.*]] = cir.cast bool_to_float %[[TERNARY]] : !cir.bool -> !cir.float
830+
// CHECK-NEXT: cir.store{{.*}} %[[RES_TO_VAL]], %[[LHS_STRIDE]] : !cir.float, !cir.ptr<!cir.float>
831+
//
832+
// CHECK-NEXT: cir.yield
833+
// CHECK-NEXT: } step {
834+
// CHECK-NEXT: %[[ITR_LOAD]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
835+
// CHECK-NEXT: %[[INC:.*]] = cir.unary(inc, %[[ITR_LOAD]]) : !u64i, !u64i
836+
// CHECK-NEXT: cir.store %[[INC]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
837+
// CHECK-NEXT: cir.yield
838+
// CHECK-NEXT: }
839+
// CHECK-NEXT: }
712840
// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>>
713841
// CHECK-NEXT: }
714842
for(int i=0;i < 5; ++i);
@@ -744,7 +872,45 @@ void acc_combined() {
744872
// CHECK-NEXT: acc.yield
745873
// CHECK-NEXT: } combiner {
746874
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
747-
// TODO OpenACC: Expecting combination operation here
875+
// CHECK-NEXT: cir.scope {
876+
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
877+
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
878+
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
879+
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
880+
// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
881+
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
882+
// CHECK-NEXT: cir.for : cond {
883+
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
884+
// CHECK-NEXT: %[[COND:.*]] = cir.cmp(lt, %[[ITR_LOAD]], %[[UB_CAST]]) : !u64i, !cir.bool
885+
// CHECK-NEXT: cir.condition(%[[COND]])
886+
// CHECK-NEXT: } body {
887+
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
888+
// CHECK-NEXT: %[[LHS_DECAY:.*]] = cir.cast array_to_ptrdecay %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float>
889+
// CHECK-NEXT: %[[LHS_STRIDE:.*]] = cir.ptr_stride %[[LHS_DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!cir.float>, !u64i) -> !cir.ptr<!cir.float>
890+
// CHECK-NEXT: %[[RHS_DECAY:.*]] = cir.cast array_to_ptrdecay %[[RHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float>
891+
// CHECK-NEXT: %[[RHS_STRIDE:.*]] = cir.ptr_stride %[[RHS_DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!cir.float>, !u64i) -> !cir.ptr<!cir.float>
892+
//
893+
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHS_STRIDE]] : !cir.ptr<!cir.float>, !cir.float
894+
// CHECK-NEXT: %[[LHS_TO_BOOL:.*]] = cir.cast float_to_bool %[[LHS_LOAD]] : !cir.float -> !cir.bool
895+
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[LHS_TO_BOOL]], true {
896+
// CHECK-NEXT: %[[TRUE:.*]] = cir.const #true
897+
// CHECK-NEXT: cir.yield %[[TRUE]] : !cir.bool
898+
// CHECK-NEXT: }, false {
899+
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHS_STRIDE]] : !cir.ptr<!cir.float>, !cir.float
900+
// CHECK-NEXT: %[[RHS_TO_BOOL:.*]] = cir.cast float_to_bool %[[RHS_LOAD]] : !cir.float -> !cir.bool
901+
// CHECK-NEXT: cir.yield %[[RHS_TO_BOOL]] : !cir.bool
902+
// CHECK-NEXT: }) : (!cir.bool) -> !cir.bool
903+
// CHECK-NEXT: %[[RES_TO_VAL:.*]] = cir.cast bool_to_float %[[TERNARY]] : !cir.bool -> !cir.float
904+
// CHECK-NEXT: cir.store{{.*}} %[[RES_TO_VAL]], %[[LHS_STRIDE]] : !cir.float, !cir.ptr<!cir.float>
905+
//
906+
// CHECK-NEXT: cir.yield
907+
// CHECK-NEXT: } step {
908+
// CHECK-NEXT: %[[ITR_LOAD]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
909+
// CHECK-NEXT: %[[INC:.*]] = cir.unary(inc, %[[ITR_LOAD]]) : !u64i, !u64i
910+
// CHECK-NEXT: cir.store %[[INC]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
911+
// CHECK-NEXT: cir.yield
912+
// CHECK-NEXT: }
913+
// CHECK-NEXT: }
748914
// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>>
749915
// CHECK-NEXT: }
750916
for(int i=0;i < 5; ++i);

0 commit comments

Comments
 (0)