diff --git a/llvm/test/Transforms/LoopInterchange/ninf.ll b/llvm/test/Transforms/LoopInterchange/ninf.ll
new file mode 100644
index 0000000000000..896c8467efdc0
--- /dev/null
+++ b/llvm/test/Transforms/LoopInterchange/ninf.ll
@@ -0,0 +1,154 @@
+; 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 ninf 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
+}