test/Transforms/LoopInterchange/dependency-all-neg-eq.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

; for (i = 0; i < 100; i++)
;   for (j = 0; j < 255; j++)
;     for (k = 0; k < 256; k++)
;       A[j + 1][k] = A[j][k] + 1;
;
; The above loop nest has a direction vector of [* > =]. In principle, it is
; legal to interchange the j-loop and the k-loop, but at the moment the
; legality check doesn't handle such cases.
;
; FIXME: The direction vector of [* > =] should be normalized to [* < =] at the
; beginning.
;

define void @all_neg_eq(ptr %A) {
; CHECK-LABEL: define void @all_neg_eq(
; CHECK-SAME: ptr [[A:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*]]:
; CHECK-NEXT:    br label %[[FOR_I_HEADER:.*]]
; CHECK:       [[FOR_I_HEADER]]:
; CHECK-NEXT:    [[I:%.*]] = phi i64 [ 0, %[[ENTRY]] ], [ [[I_INC:%.*]], %[[FOR_I_LATCH:.*]] ]
; CHECK-NEXT:    br label %[[FOR_J_HEADER:.*]]
; CHECK:       [[FOR_J_HEADER]]:
; CHECK-NEXT:    [[J:%.*]] = phi i64 [ 0, %[[FOR_I_HEADER]] ], [ [[J_INC:%.*]], %[[FOR_J_LATCH:.*]] ]
; CHECK-NEXT:    [[J_INC]] = add i64 [[J]], 1
; CHECK-NEXT:    br label %[[FOR_K:.*]]
; CHECK:       [[FOR_K]]:
; CHECK-NEXT:    [[K:%.*]] = phi i64 [ 0, %[[FOR_J_HEADER]] ], [ [[K_INC:%.*]], %[[FOR_K]] ]
; CHECK-NEXT:    [[PTR_LOAD:%.*]] = getelementptr [256 x i8], ptr [[A]], i64 [[J]], i64 [[K]]
; CHECK-NEXT:    [[LD:%.*]] = load i8, ptr [[PTR_LOAD]], align 1
; CHECK-NEXT:    [[ADD:%.*]] = add i8 [[LD]], 1
; CHECK-NEXT:    [[PTR_STORE:%.*]] = getelementptr [256 x i8], ptr [[A]], i64 [[J_INC]], i64 [[K]]
; CHECK-NEXT:    store i8 [[ADD]], ptr [[PTR_STORE]], align 1
; CHECK-NEXT:    [[K_INC]] = add i64 [[K]], 1
; CHECK-NEXT:    [[EC_K:%.*]] = icmp eq i64 [[K_INC]], 256
; CHECK-NEXT:    br i1 [[EC_K]], label %[[FOR_J_LATCH]], label %[[FOR_K]]
; CHECK:       [[FOR_J_LATCH]]:
; CHECK-NEXT:    [[EC_J:%.*]] = icmp eq i64 [[J_INC]], 255
; CHECK-NEXT:    br i1 [[EC_J]], label %[[FOR_I_LATCH]], label %[[FOR_J_HEADER]]
; CHECK:       [[FOR_I_LATCH]]:
; CHECK-NEXT:    [[I_INC]] = add i64 [[I]], 1
; CHECK-NEXT:    [[EC_I:%.*]] = icmp eq i64 [[I_INC]], 100
; CHECK-NEXT:    br i1 [[EC_I]], label %[[EXIT:.*]], 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.header

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

for.k:
  %k = phi i64 [ 0, %for.j.header ], [ %k.inc, %for.k ]
  %ptr.load = getelementptr [256 x i8], ptr %A, i64 %j, i64 %k
  %ld = load i8, ptr %ptr.load
  %add = add i8 %ld, 1
  %ptr.store = getelementptr [256 x i8], ptr %A, i64 %j.inc, i64 %k
  store i8 %add, ptr %ptr.store
  %k.inc = add i64 %k, 1
  %ec.k = icmp eq i64 %k.inc, 256
  br i1 %ec.k, label %for.j.latch, label %for.k

for.j.latch:
  %ec.j = icmp eq i64 %j.inc, 255
  br i1 %ec.j, label %for.i.latch, label %for.j.header

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

exit:
  ret void
}