llvm/test/Transforms/LoopInterchange/profitability-vectorization.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6
; RUN: opt < %s -passes=loop-interchange -cache-line-size=64 \
; RUN:     -loop-interchange-profitabilities=instorder -S | FileCheck --check-prefix=PROFIT-CACHE %s
; RUN: opt < %s -passes=loop-interchange -cache-line-size=64 \
; RUN:     -loop-interchange-profitabilities=vectorize,cache,instorder -S | FileCheck --check-prefix=PROFIT-VEC %s

@A = dso_local global [256 x [256 x float]] zeroinitializer
@B = dso_local global [256 x [256 x float]] zeroinitializer
@C = dso_local global [256 x [256 x float]] zeroinitializer
@D = dso_local global [256 x [256 x float]] zeroinitializer
@E = dso_local global [256 x [256 x float]] zeroinitializer
@F = dso_local global [256 x [256 x float]] zeroinitializer

; Check the behavior of the LoopInterchange cost-model. In the below code,
; exchanging the loops is not profitable in terms of cache, but it is necessary
; to vectorize the innermost loop.
;
; for (int i = 0; i < 256; i++)
;   for (int j = 1; j < 256; j++)
;     A[j][i] = A[j-1][i] + B[j][i] + C[i][j] + D[i][j] + E[i][j] + F[i][j];
;

define void @f() {
; PROFIT-CACHE-LABEL: define void @f() {
; PROFIT-CACHE-NEXT:  [[ENTRY:.*]]:
; PROFIT-CACHE-NEXT:    br label %[[FOR_I_HEADER:.*]]
; PROFIT-CACHE:       [[FOR_I_HEADER]]:
; PROFIT-CACHE-NEXT:    [[I:%.*]] = phi i64 [ 0, %[[ENTRY]] ], [ [[I_NEXT:%.*]], %[[FOR_I_INC:.*]] ]
; PROFIT-CACHE-NEXT:    br label %[[FOR_J_BODY:.*]]
; PROFIT-CACHE:       [[FOR_J_BODY]]:
; PROFIT-CACHE-NEXT:    [[J:%.*]] = phi i64 [ 1, %[[FOR_I_HEADER]] ], [ [[J_NEXT:%.*]], %[[FOR_J_BODY]] ]
; PROFIT-CACHE-NEXT:    [[J_DEC:%.*]] = add nsw i64 [[J]], -1
; PROFIT-CACHE-NEXT:    [[A_0_INDEX:%.*]] = getelementptr inbounds nuw [256 x [256 x float]], ptr @A, i64 0, i64 [[J_DEC]], i64 [[I]]
; PROFIT-CACHE-NEXT:    [[B_INDEX:%.*]] = getelementptr inbounds nuw [256 x [256 x float]], ptr @B, i64 0, i64 [[J]], i64 [[I]]
; PROFIT-CACHE-NEXT:    [[C_INDEX:%.*]] = getelementptr inbounds nuw [256 x [256 x float]], ptr @C, i64 0, i64 [[I]], i64 [[J]]
; PROFIT-CACHE-NEXT:    [[D_INDEX:%.*]] = getelementptr inbounds nuw [256 x [256 x float]], ptr @D, i64 0, i64 [[I]], i64 [[J]]
; PROFIT-CACHE-NEXT:    [[E_INDEX:%.*]] = getelementptr inbounds nuw [256 x [256 x float]], ptr @E, i64 0, i64 [[I]], i64 [[J]]
; PROFIT-CACHE-NEXT:    [[F_INDEX:%.*]] = getelementptr inbounds nuw [256 x [256 x float]], ptr @F, i64 0, i64 [[I]], i64 [[J]]
; PROFIT-CACHE-NEXT:    [[A_0:%.*]] = load float, ptr [[A_0_INDEX]], align 4
; PROFIT-CACHE-NEXT:    [[B:%.*]] = load float, ptr [[B_INDEX]], align 4
; PROFIT-CACHE-NEXT:    [[C:%.*]] = load float, ptr [[C_INDEX]], align 4
; PROFIT-CACHE-NEXT:    [[D:%.*]] = load float, ptr [[D_INDEX]], align 4
; PROFIT-CACHE-NEXT:    [[E:%.*]] = load float, ptr [[E_INDEX]], align 4
; PROFIT-CACHE-NEXT:    [[F:%.*]] = load float, ptr [[F_INDEX]], align 4
; PROFIT-CACHE-NEXT:    [[ADD_0:%.*]] = fadd float [[A_0]], [[B]]
; PROFIT-CACHE-NEXT:    [[ADD_1:%.*]] = fadd float [[ADD_0]], [[C]]
; PROFIT-CACHE-NEXT:    [[ADD_2:%.*]] = fadd float [[ADD_1]], [[D]]
; PROFIT-CACHE-NEXT:    [[ADD_3:%.*]] = fadd float [[ADD_2]], [[E]]
; PROFIT-CACHE-NEXT:    [[ADD_4:%.*]] = fadd float [[ADD_3]], [[F]]
; PROFIT-CACHE-NEXT:    [[A_1_INDEX:%.*]] = getelementptr inbounds nuw [256 x float], ptr @A, i64 [[J]], i64 [[I]]
; PROFIT-CACHE-NEXT:    store float [[ADD_4]], ptr [[A_1_INDEX]], align 4
; PROFIT-CACHE-NEXT:    [[J_NEXT]] = add nuw nsw i64 [[J]], 1
; PROFIT-CACHE-NEXT:    [[CMP_J:%.*]] = icmp eq i64 [[J_NEXT]], 256
; PROFIT-CACHE-NEXT:    br i1 [[CMP_J]], label %[[FOR_I_INC]], label %[[FOR_J_BODY]]
; PROFIT-CACHE:       [[FOR_I_INC]]:
; PROFIT-CACHE-NEXT:    [[I_NEXT]] = add nuw nsw i64 [[I]], 1
; PROFIT-CACHE-NEXT:    [[CMP_I:%.*]] = icmp eq i64 [[I_NEXT]], 256
; PROFIT-CACHE-NEXT:    br i1 [[CMP_I]], label %[[EXIT:.*]], label %[[FOR_I_HEADER]]
; PROFIT-CACHE:       [[EXIT]]:
; PROFIT-CACHE-NEXT:    ret void
;
; PROFIT-VEC-LABEL: define void @f() {
; PROFIT-VEC-NEXT:  [[ENTRY:.*:]]
; PROFIT-VEC-NEXT:    br label %[[FOR_J_BODY_PREHEADER:.*]]
; PROFIT-VEC:       [[FOR_I_HEADER_PREHEADER:.*]]:
; PROFIT-VEC-NEXT:    br label %[[FOR_I_HEADER:.*]]
; PROFIT-VEC:       [[FOR_I_HEADER]]:
; PROFIT-VEC-NEXT:    [[I:%.*]] = phi i64 [ [[I_NEXT:%.*]], %[[FOR_I_INC:.*]] ], [ 0, %[[FOR_I_HEADER_PREHEADER]] ]
; PROFIT-VEC-NEXT:    br label %[[FOR_J_BODY_SPLIT1:.*]]
; PROFIT-VEC:       [[FOR_J_BODY_PREHEADER]]:
; PROFIT-VEC-NEXT:    br label %[[FOR_J_BODY:.*]]
; PROFIT-VEC:       [[FOR_J_BODY]]:
; PROFIT-VEC-NEXT:    [[J:%.*]] = phi i64 [ [[TMP0:%.*]], %[[FOR_J_BODY_SPLIT:.*]] ], [ 1, %[[FOR_J_BODY_PREHEADER]] ]
; PROFIT-VEC-NEXT:    br label %[[FOR_I_HEADER_PREHEADER]]
; PROFIT-VEC:       [[FOR_J_BODY_SPLIT1]]:
; PROFIT-VEC-NEXT:    [[J_DEC:%.*]] = add nsw i64 [[J]], -1
; PROFIT-VEC-NEXT:    [[A_0_INDEX:%.*]] = getelementptr inbounds nuw [256 x [256 x float]], ptr @A, i64 0, i64 [[J_DEC]], i64 [[I]]
; PROFIT-VEC-NEXT:    [[B_INDEX:%.*]] = getelementptr inbounds nuw [256 x [256 x float]], ptr @B, i64 0, i64 [[J]], i64 [[I]]
; PROFIT-VEC-NEXT:    [[C_INDEX:%.*]] = getelementptr inbounds nuw [256 x [256 x float]], ptr @C, i64 0, i64 [[I]], i64 [[J]]
; PROFIT-VEC-NEXT:    [[D_INDEX:%.*]] = getelementptr inbounds nuw [256 x [256 x float]], ptr @D, i64 0, i64 [[I]], i64 [[J]]
; PROFIT-VEC-NEXT:    [[E_INDEX:%.*]] = getelementptr inbounds nuw [256 x [256 x float]], ptr @E, i64 0, i64 [[I]], i64 [[J]]
; PROFIT-VEC-NEXT:    [[F_INDEX:%.*]] = getelementptr inbounds nuw [256 x [256 x float]], ptr @F, i64 0, i64 [[I]], i64 [[J]]
; PROFIT-VEC-NEXT:    [[A_0:%.*]] = load float, ptr [[A_0_INDEX]], align 4
; PROFIT-VEC-NEXT:    [[B:%.*]] = load float, ptr [[B_INDEX]], align 4
; PROFIT-VEC-NEXT:    [[C:%.*]] = load float, ptr [[C_INDEX]], align 4
; PROFIT-VEC-NEXT:    [[D:%.*]] = load float, ptr [[D_INDEX]], align 4
; PROFIT-VEC-NEXT:    [[E:%.*]] = load float, ptr [[E_INDEX]], align 4
; PROFIT-VEC-NEXT:    [[F:%.*]] = load float, ptr [[F_INDEX]], align 4
; PROFIT-VEC-NEXT:    [[ADD_0:%.*]] = fadd float [[A_0]], [[B]]
; PROFIT-VEC-NEXT:    [[ADD_1:%.*]] = fadd float [[ADD_0]], [[C]]
; PROFIT-VEC-NEXT:    [[ADD_2:%.*]] = fadd float [[ADD_1]], [[D]]
; PROFIT-VEC-NEXT:    [[ADD_3:%.*]] = fadd float [[ADD_2]], [[E]]
; PROFIT-VEC-NEXT:    [[ADD_4:%.*]] = fadd float [[ADD_3]], [[F]]
; PROFIT-VEC-NEXT:    [[A_1_INDEX:%.*]] = getelementptr inbounds nuw [256 x float], ptr @A, i64 [[J]], i64 [[I]]
; PROFIT-VEC-NEXT:    store float [[ADD_4]], ptr [[A_1_INDEX]], align 4
; PROFIT-VEC-NEXT:    [[J_NEXT:%.*]] = add nuw nsw i64 [[J]], 1
; PROFIT-VEC-NEXT:    [[CMP_J:%.*]] = icmp eq i64 [[J_NEXT]], 256
; PROFIT-VEC-NEXT:    br label %[[FOR_I_INC]]
; PROFIT-VEC:       [[FOR_J_BODY_SPLIT]]:
; PROFIT-VEC-NEXT:    [[TMP0]] = add nuw nsw i64 [[J]], 1
; PROFIT-VEC-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[TMP0]], 256
; PROFIT-VEC-NEXT:    br i1 [[TMP1]], label %[[EXIT:.*]], label %[[FOR_J_BODY]]
; PROFIT-VEC:       [[FOR_I_INC]]:
; PROFIT-VEC-NEXT:    [[I_NEXT]] = add nuw nsw i64 [[I]], 1
; PROFIT-VEC-NEXT:    [[CMP_I:%.*]] = icmp eq i64 [[I_NEXT]], 256
; PROFIT-VEC-NEXT:    br i1 [[CMP_I]], label %[[FOR_J_BODY_SPLIT]], label %[[FOR_I_HEADER]]
; PROFIT-VEC:       [[EXIT]]:
; PROFIT-VEC-NEXT:    ret void
;
entry:
  br label %for.i.header

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

for.j.body:
  %j = phi i64 [ 1, %for.i.header ], [ %j.next, %for.j.body ]
  %j.dec = add nsw i64 %j, -1
  %a.0.index = getelementptr nuw inbounds [256 x [256 x float]], ptr @A, i64 0, i64 %j.dec, i64 %i
  %b.index = getelementptr nuw inbounds [256 x [256 x float]], ptr @B, i64 0, i64 %j, i64 %i
  %c.index = getelementptr nuw inbounds [256 x [256 x float]], ptr @C, i64 0, i64 %i, i64 %j
  %d.index = getelementptr nuw inbounds [256 x [256 x float]], ptr @D, i64 0, i64 %i, i64 %j
  %e.index = getelementptr nuw inbounds [256 x [256 x float]], ptr @E, i64 0, i64 %i, i64 %j
  %f.index = getelementptr nuw inbounds [256 x [256 x float]], ptr @F, i64 0, i64 %i, i64 %j
  %a.0 = load float, ptr %a.0.index, align 4
  %b = load float, ptr %b.index, align 4
  %c = load float, ptr %c.index, align 4
  %d = load float, ptr %d.index, align 4
  %e = load float, ptr %e.index, align 4
  %f = load float, ptr %f.index, align 4
  %add.0 = fadd float %a.0, %b
  %add.1 = fadd float %add.0, %c
  %add.2 = fadd float %add.1, %d
  %add.3 = fadd float %add.2, %e
  %add.4 = fadd float %add.3, %f
  %a.1.index = getelementptr nuw inbounds [256 x float], ptr @A, i64 %j, i64 %i
  store float %add.4, ptr %a.1.index, align 4
  %j.next = add nuw nsw i64 %j, 1
  %cmp.j = icmp eq i64 %j.next, 256
  br i1 %cmp.j, label %for.i.inc, label %for.j.body

for.i.inc:
  %i.next = add nuw nsw i64 %i, 1
  %cmp.i = icmp eq i64 %i.next, 256
  br i1 %cmp.i, label %exit, label %for.i.header

exit:
  ret void
}