test/Transforms/LoopInterchange/ninf.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6
; RUN: opt < %s -passes=loop-interchange -loop-interchange-profitabilities=ignore -S | FileCheck %s

; sum = 0.0;
; for (i = 0; i < 2; i++)
;   for (j = 0; j < 2; j++)
;     sum += A[i][j];
;
; The fadd instruction has reassoc flag, so it's legal to interchange the
; loops. However, it also has ninf flag, which means the transformation
; potentially produces a poison due to the change of the order of evaluation.
; For example, consider the case where
; A[2][2] = {{FLT_MAX, -FLT_MAX}, {FLT_MAX, -FLT_MAX}}.
;
; FIXME: The ninf flag should be dropped when the loop interchange is applied.
;
define noundef float @reduction_reassoc_ninf(ptr %A) {
; CHECK-LABEL: define noundef float @reduction_reassoc_ninf(
; CHECK-SAME: ptr [[A:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    br label %[[FOR_J_PREHEADER:.*]]
; CHECK:       [[FOR_I_HEADER_PREHEADER:.*]]:
; CHECK-NEXT:    br label %[[FOR_I_HEADER:.*]]
; CHECK:       [[FOR_I_HEADER]]:
; CHECK-NEXT:    [[I:%.*]] = phi i64 [ [[I_INC:%.*]], %[[FOR_I_LATCH:.*]] ], [ 0, %[[FOR_I_HEADER_PREHEADER]] ]
; CHECK-NEXT:    [[SUM_J:%.*]] = phi float [ [[SUM_J_NEXT:%.*]], %[[FOR_I_LATCH]] ], [ [[SUM_I:%.*]], %[[FOR_I_HEADER_PREHEADER]] ]
; CHECK-NEXT:    br label %[[FOR_J_SPLIT1:.*]]
; CHECK:       [[FOR_J_PREHEADER]]:
; CHECK-NEXT:    br label %[[FOR_J:.*]]
; CHECK:       [[FOR_J]]:
; CHECK-NEXT:    [[J:%.*]] = phi i64 [ [[TMP0:%.*]], %[[FOR_J_SPLIT:.*]] ], [ 0, %[[FOR_J_PREHEADER]] ]
; CHECK-NEXT:    [[SUM_I]] = phi float [ [[SUM_I_NEXT:%.*]], %[[FOR_J_SPLIT]] ], [ 0.000000e+00, %[[FOR_J_PREHEADER]] ]
; CHECK-NEXT:    br label %[[FOR_I_HEADER_PREHEADER]]
; CHECK:       [[FOR_J_SPLIT1]]:
; CHECK-NEXT:    [[GEP:%.*]] = getelementptr [2 x float], ptr [[A]], i64 [[I]], i64 [[J]]
; CHECK-NEXT:    [[VAL:%.*]] = load float, ptr [[GEP]], align 4
; CHECK-NEXT:    [[SUM_J_NEXT]] = fadd reassoc float [[SUM_J]], [[VAL]]
; CHECK-NEXT:    [[J_INC:%.*]] = add i64 [[J]], 1
; CHECK-NEXT:    [[EC_J:%.*]] = icmp eq i64 [[J_INC]], 2
; CHECK-NEXT:    br label %[[FOR_I_LATCH]]
; CHECK:       [[FOR_J_SPLIT]]:
; CHECK-NEXT:    [[SUM_I_NEXT]] = phi float [ [[SUM_J_NEXT]], %[[FOR_I_LATCH]] ]
; CHECK-NEXT:    [[TMP0]] = add i64 [[J]], 1
; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[TMP0]], 2
; CHECK-NEXT:    br i1 [[TMP1]], label %[[EXIT:.*]], label %[[FOR_J]]
; CHECK:       [[FOR_I_LATCH]]:
; CHECK-NEXT:    [[I_INC]] = add i64 [[I]], 1
; CHECK-NEXT:    [[EC_I:%.*]] = icmp eq i64 [[I_INC]], 2
; CHECK-NEXT:    br i1 [[EC_I]], label %[[FOR_J_SPLIT]], label %[[FOR_I_HEADER]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    [[SUM_I_NEXT_LCSSA:%.*]] = phi float [ [[SUM_I_NEXT]], %[[FOR_J_SPLIT]] ]
; CHECK-NEXT:    ret float [[SUM_I_NEXT_LCSSA]]
;
entry:
  br label %for.i.header

for.i.header:
  %i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.latch ]
  %sum.i = phi float [ 0.0, %entry ], [ %sum.i.next, %for.i.latch ]
  br label %for.j

for.j:
  %j = phi i64 [ 0, %for.i.header ], [ %j.inc, %for.j ]
  %sum.j = phi float [ %sum.i, %for.i.header ], [ %sum.j.next, %for.j ]
  %gep = getelementptr [2 x float], ptr %A, i64 %i, i64 %j
  %val = load float, ptr %gep
  %sum.j.next = fadd reassoc ninf float %sum.j, %val
  %j.inc = add i64 %j, 1
  %ec.j = icmp eq i64 %j.inc, 2
  br i1 %ec.j, label %for.i.latch, label %for.j

for.i.latch:
  %sum.i.next = phi float [ %sum.j.next, %for.j ]
  %i.inc = add i64 %i, 1
  %ec.i = icmp eq i64 %i.inc, 2
  br i1 %ec.i, label %exit, label %for.i.header

exit:
  ret float %sum.i.next
}

; for (i = 0; i < 2; i++)
;   for (j = 0; j < 2; j++)
;     C[i][j] = A[i][j] + B[i][j];
;
; The fadd instruction has ninf flag, but different from the above example,
; it's not a reduction so interchanging the loops shouldn't result in a poison
; value.
;
define void @non_reduction_ninf(ptr %A, ptr %B, ptr noalias %C) {
; CHECK-LABEL: define void @non_reduction_ninf(
; CHECK-SAME: ptr [[A:%.*]], ptr [[B:%.*]], ptr noalias [[C:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    br label %[[FOR_J_PREHEADER:.*]]
; CHECK:       [[FOR_I_HEADER_PREHEADER:.*]]:
; CHECK-NEXT:    br label %[[FOR_I_HEADER:.*]]
; CHECK:       [[FOR_I_HEADER]]:
; CHECK-NEXT:    [[I:%.*]] = phi i64 [ [[I_INC:%.*]], %[[FOR_I_LATCH:.*]] ], [ 0, %[[FOR_I_HEADER_PREHEADER]] ]
; CHECK-NEXT:    br label %[[FOR_J_SPLIT1:.*]]
; CHECK:       [[FOR_J_PREHEADER]]:
; CHECK-NEXT:    br label %[[FOR_J:.*]]
; CHECK:       [[FOR_J]]:
; CHECK-NEXT:    [[J:%.*]] = phi i64 [ [[TMP0:%.*]], %[[FOR_J_SPLIT:.*]] ], [ 0, %[[FOR_J_PREHEADER]] ]
; CHECK-NEXT:    br label %[[FOR_I_HEADER_PREHEADER]]
; CHECK:       [[FOR_J_SPLIT1]]:
; CHECK-NEXT:    [[GEP_A:%.*]] = getelementptr [2 x float], ptr [[A]], i64 [[I]], i64 [[J]]
; CHECK-NEXT:    [[VAL_A:%.*]] = load float, ptr [[GEP_A]], align 4
; CHECK-NEXT:    [[GEP_B:%.*]] = getelementptr [2 x float], ptr [[B]], i64 [[I]], i64 [[J]]
; CHECK-NEXT:    [[VAL_B:%.*]] = load float, ptr [[GEP_B]], align 4
; CHECK-NEXT:    [[SUM:%.*]] = fadd ninf float [[VAL_A]], [[VAL_B]]
; CHECK-NEXT:    [[GEP_C:%.*]] = getelementptr [2 x float], ptr [[C]], i64 [[I]], i64 [[J]]
; CHECK-NEXT:    store float [[SUM]], ptr [[GEP_C]], align 4
; CHECK-NEXT:    [[J_INC:%.*]] = add i64 [[J]], 1
; CHECK-NEXT:    [[EC_J:%.*]] = icmp eq i64 [[J_INC]], 2
; CHECK-NEXT:    br label %[[FOR_I_LATCH]]
; CHECK:       [[FOR_J_SPLIT]]:
; CHECK-NEXT:    [[TMP0]] = add i64 [[J]], 1
; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[TMP0]], 2
; CHECK-NEXT:    br i1 [[TMP1]], label %[[EXIT:.*]], label %[[FOR_J]]
; CHECK:       [[FOR_I_LATCH]]:
; CHECK-NEXT:    [[I_INC]] = add i64 [[I]], 1
; CHECK-NEXT:    [[EC_I:%.*]] = icmp eq i64 [[I_INC]], 2
; CHECK-NEXT:    br i1 [[EC_I]], label %[[FOR_J_SPLIT]], label %[[FOR_I_HEADER]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %for.i.header

for.i.header:
  %i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.latch ]
  br label %for.j

for.j:
  %j = phi i64 [ 0, %for.i.header ], [ %j.inc, %for.j ]
  %gep.A = getelementptr [2 x float], ptr %A, i64 %i, i64 %j
  %val.A = load float, ptr %gep.A
  %gep.B = getelementptr [2 x float], ptr %B, i64 %i, i64 %j
  %val.B = load float, ptr %gep.B
  %sum = fadd ninf float %val.A, %val.B
  %gep.C = getelementptr [2 x float], ptr %C, i64 %i, i64 %j
  store float %sum, ptr %gep.C
  %j.inc = add i64 %j, 1
  %ec.j = icmp eq i64 %j.inc, 2
  br i1 %ec.j, label %for.i.latch, label %for.j

for.i.latch:
  %i.inc = add i64 %i, 1
  %ec.i = icmp eq i64 %i.inc, 2
  br i1 %ec.i, label %exit, label %for.i.header

exit:
  ret void
}