blob: d4547d41f62c1d0331aaf85ffac751e44d5d5a09 [file]
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -passes='loop(indvars),instcombine' -replexitval=always -S < %s | FileCheck %s --check-prefixes=CHECK,ALWAYS
; RUN: opt -passes='loop(indvars),instcombine' -replexitval=cheap -S < %s | FileCheck %s --check-prefixes=CHECK,CHEAP
;; Test that loop's exit value is rewritten to its initial
;; value from loop preheader
define i32 @test1(ptr %var) {
; CHECK-LABEL: @test1(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[COND:%.*]] = icmp eq ptr [[VAR:%.*]], null
; CHECK-NEXT: br label [[HEADER:%.*]]
; CHECK: header:
; CHECK-NEXT: br i1 [[COND]], label [[LOOP:%.*]], label [[EXIT:%.*]]
; CHECK: loop:
; CHECK-NEXT: br label [[HEADER]]
; CHECK: exit:
; CHECK-NEXT: ret i32 0
;
entry:
%cond = icmp eq ptr %var, null
br label %header
header:
%phi_indvar = phi i32 [0, %entry], [%indvar, %loop]
br i1 %cond, label %loop, label %exit
loop:
%indvar = add i32 %phi_indvar, 1
br label %header
exit:
ret i32 %phi_indvar
}
;; Test that we can not rewrite loop exit value if it's not
;; a phi node (%indvar is an add instruction in this test).
define i32 @test2(ptr %var) {
; CHECK-LABEL: @test2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[COND:%.*]] = icmp eq ptr [[VAR:%.*]], null
; CHECK-NEXT: br label [[HEADER:%.*]]
; CHECK: header:
; CHECK-NEXT: [[PHI_INDVAR:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INDVAR:%.*]], [[HEADER]] ]
; CHECK-NEXT: [[INDVAR]] = add i32 [[PHI_INDVAR]], 1
; CHECK-NEXT: br i1 [[COND]], label [[HEADER]], label [[EXIT:%.*]]
; CHECK: exit:
; CHECK-NEXT: ret i32 [[INDVAR]]
;
entry:
%cond = icmp eq ptr %var, null
br label %header
header:
%phi_indvar = phi i32 [0, %entry], [%indvar, %header]
%indvar = add i32 %phi_indvar, 1
br i1 %cond, label %header, label %exit
exit:
ret i32 %indvar
}
;; Test that we can not rewrite loop exit value if the condition
;; is not in loop header.
define i32 @test3(ptr %var) {
; CHECK-LABEL: @test3(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[COND1:%.*]] = icmp eq ptr [[VAR:%.*]], null
; CHECK-NEXT: br label [[HEADER:%.*]]
; CHECK: header:
; CHECK-NEXT: [[PHI_INDVAR:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INDVAR:%.*]], [[HEADER_BACKEDGE:%.*]] ]
; CHECK-NEXT: [[INDVAR]] = add i32 [[PHI_INDVAR]], 1
; CHECK-NEXT: [[COND2:%.*]] = icmp eq i32 [[INDVAR]], 10
; CHECK-NEXT: br i1 [[COND2]], label [[HEADER_BACKEDGE]], label [[BODY:%.*]]
; CHECK: header.backedge:
; CHECK-NEXT: br label [[HEADER]]
; CHECK: body:
; CHECK-NEXT: br i1 [[COND1]], label [[HEADER_BACKEDGE]], label [[EXIT:%.*]]
; CHECK: exit:
; CHECK-NEXT: ret i32 [[PHI_INDVAR]]
;
entry:
%cond1 = icmp eq ptr %var, null
br label %header
header:
%phi_indvar = phi i32 [0, %entry], [%indvar, %header], [%indvar, %body]
%indvar = add i32 %phi_indvar, 1
%cond2 = icmp eq i32 %indvar, 10
br i1 %cond2, label %header, label %body
body:
br i1 %cond1, label %header, label %exit
exit:
ret i32 %phi_indvar
}
; Multiple exits dominating latch
define i32 @test4(i1 %cond1, i1 %cond2) {
; CHECK-LABEL: @test4(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[HEADER:%.*]]
; CHECK: header:
; CHECK-NEXT: br i1 [[COND1:%.*]], label [[LOOP:%.*]], label [[EXIT:%.*]]
; CHECK: loop:
; CHECK-NEXT: br i1 [[COND2:%.*]], label [[HEADER]], label [[EXIT]]
; CHECK: exit:
; CHECK-NEXT: ret i32 0
;
entry:
br label %header
header:
%phi_indvar = phi i32 [0, %entry], [%indvar, %loop]
br i1 %cond1, label %loop, label %exit
loop:
%indvar = add i32 %phi_indvar, 1
br i1 %cond2, label %header, label %exit
exit:
ret i32 %phi_indvar
}
; A conditionally executed exit.
define i32 @test5(ptr %addr, i1 %cond2) {
; CHECK-LABEL: @test5(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[HEADER:%.*]]
; CHECK: header:
; CHECK-NEXT: [[PHI_INDVAR:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INDVAR:%.*]], [[LOOP:%.*]] ]
; CHECK-NEXT: [[COND1:%.*]] = load volatile i1, ptr [[ADDR:%.*]], align 1
; CHECK-NEXT: br i1 [[COND1]], label [[LOOP]], label [[MAYBE:%.*]]
; CHECK: maybe:
; CHECK-NEXT: br i1 [[COND2:%.*]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[INDVAR]] = add i32 [[PHI_INDVAR]], 1
; CHECK-NEXT: br label [[HEADER]]
; CHECK: exit:
; CHECK-NEXT: ret i32 [[PHI_INDVAR]]
;
entry:
br label %header
header:
%phi_indvar = phi i32 [0, %entry], [%indvar, %loop]
%cond1 = load volatile i1, ptr %addr
br i1 %cond1, label %loop, label %maybe
maybe:
br i1 %cond2, label %loop, label %exit
loop:
%indvar = add i32 %phi_indvar, 1
br label %header
exit:
ret i32 %phi_indvar
}
define i16 @pr57336(i16 %end, i16 %m) mustprogress {
; CHECK-LABEL: @pr57336(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[FOR_BODY:%.*]]
; CHECK: for.body:
; CHECK-NEXT: br i1 true, label [[CRIT_EDGE:%.*]], label [[FOR_BODY]]
; CHECK: crit_edge:
; CHECK-NEXT: [[TMP0:%.*]] = add i16 [[END:%.*]], 1
; CHECK-NEXT: [[SMAX:%.*]] = call i16 @llvm.smax.i16(i16 [[TMP0]], i16 0)
; CHECK-NEXT: [[TMP1:%.*]] = icmp ult i16 [[END]], 32767
; CHECK-NEXT: [[UMIN:%.*]] = zext i1 [[TMP1]] to i16
; CHECK-NEXT: [[TMP2:%.*]] = sub nsw i16 [[SMAX]], [[UMIN]]
; CHECK-NEXT: [[UMAX:%.*]] = call i16 @llvm.umax.i16(i16 [[M:%.*]], i16 1)
; CHECK-NEXT: [[TMP3:%.*]] = udiv i16 [[TMP2]], [[UMAX]]
; CHECK-NEXT: [[TMP4:%.*]] = add i16 [[TMP3]], [[UMIN]]
; CHECK-NEXT: ret i16 [[TMP4]]
;
entry:
br label %for.body
for.body:
%inc8 = phi i16 [ %inc, %for.body ], [ 0, %entry ]
%inc137 = phi i32 [ %inc1, %for.body ], [ 0, %entry ]
%inc1 = add nsw i32 %inc137, 1
%inc = add nsw i16 %inc8, 1
%mul = mul nsw i16 %m, %inc8
%cmp.not = icmp slt i16 %end, %mul
br i1 %cmp.not, label %crit_edge, label %for.body
crit_edge:
%inc137.lcssa = phi i32 [ %inc137, %for.body ]
%conv = trunc i32 %inc137.lcssa to i16
ret i16 %conv
}
define i32 @vscale_slt_with_vp_umin(ptr nocapture %A, i32 %n) mustprogress vscale_range(2,1024) {
; ALWAYS-LABEL: @vscale_slt_with_vp_umin(
; ALWAYS-NEXT: entry:
; ALWAYS-NEXT: [[VSCALE:%.*]] = call i32 @llvm.vscale.i32()
; ALWAYS-NEXT: [[VF:%.*]] = shl nuw nsw i32 [[VSCALE]], 2
; ALWAYS-NEXT: [[CMP4:%.*]] = icmp sgt i32 [[N:%.*]], 0
; ALWAYS-NEXT: br i1 [[CMP4]], label [[FOR_BODY_PREHEADER:%.*]], label [[EARLY_EXIT:%.*]]
; ALWAYS: for.body.preheader:
; ALWAYS-NEXT: br label [[FOR_BODY:%.*]]
; ALWAYS: early.exit:
; ALWAYS-NEXT: ret i32 0
; ALWAYS: for.body:
; ALWAYS-NEXT: [[I_05:%.*]] = phi i32 [ [[ADD:%.*]], [[FOR_BODY]] ], [ 0, [[FOR_BODY_PREHEADER]] ]
; ALWAYS-NEXT: [[LEFT:%.*]] = sub nsw i32 [[N]], [[I_05]]
; ALWAYS-NEXT: [[VF_CAPPED:%.*]] = call i32 @llvm.umin.i32(i32 [[VF]], i32 [[LEFT]])
; ALWAYS-NEXT: store i32 [[VF_CAPPED]], ptr [[A:%.*]], align 4
; ALWAYS-NEXT: [[ADD]] = add nuw nsw i32 [[I_05]], [[VF]]
; ALWAYS-NEXT: [[CMP:%.*]] = icmp slt i32 [[ADD]], [[N]]
; ALWAYS-NEXT: br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END:%.*]]
; ALWAYS: for.end:
; ALWAYS-NEXT: [[TMP0:%.*]] = add nsw i32 [[N]], -1
; ALWAYS-NEXT: [[TMP1:%.*]] = call range(i32 2, 33) i32 @llvm.cttz.i32(i32 [[VF]], i1 true)
; ALWAYS-NEXT: [[TMP2:%.*]] = lshr i32 [[TMP0]], [[TMP1]]
; ALWAYS-NEXT: [[TMP3:%.*]] = mul i32 [[TMP2]], [[VSCALE]]
; ALWAYS-NEXT: [[TMP4:%.*]] = shl i32 [[TMP3]], 2
; ALWAYS-NEXT: [[TMP5:%.*]] = sub i32 [[N]], [[TMP4]]
; ALWAYS-NEXT: [[UMIN:%.*]] = call i32 @llvm.umin.i32(i32 [[VF]], i32 [[TMP5]])
; ALWAYS-NEXT: ret i32 [[UMIN]]
;
; CHEAP-LABEL: @vscale_slt_with_vp_umin(
; CHEAP-NEXT: entry:
; CHEAP-NEXT: [[VSCALE:%.*]] = call i32 @llvm.vscale.i32()
; CHEAP-NEXT: [[VF:%.*]] = shl nuw nsw i32 [[VSCALE]], 2
; CHEAP-NEXT: [[CMP4:%.*]] = icmp sgt i32 [[N:%.*]], 0
; CHEAP-NEXT: br i1 [[CMP4]], label [[FOR_BODY_PREHEADER:%.*]], label [[EARLY_EXIT:%.*]]
; CHEAP: for.body.preheader:
; CHEAP-NEXT: br label [[FOR_BODY:%.*]]
; CHEAP: early.exit:
; CHEAP-NEXT: ret i32 0
; CHEAP: for.body:
; CHEAP-NEXT: [[I_05:%.*]] = phi i32 [ [[ADD:%.*]], [[FOR_BODY]] ], [ 0, [[FOR_BODY_PREHEADER]] ]
; CHEAP-NEXT: [[LEFT:%.*]] = sub nsw i32 [[N]], [[I_05]]
; CHEAP-NEXT: [[VF_CAPPED:%.*]] = call i32 @llvm.umin.i32(i32 [[VF]], i32 [[LEFT]])
; CHEAP-NEXT: store i32 [[VF_CAPPED]], ptr [[A:%.*]], align 4
; CHEAP-NEXT: [[ADD]] = add nuw nsw i32 [[I_05]], [[VF]]
; CHEAP-NEXT: [[CMP:%.*]] = icmp slt i32 [[ADD]], [[N]]
; CHEAP-NEXT: br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END:%.*]]
; CHEAP: for.end:
; CHEAP-NEXT: ret i32 [[VF_CAPPED]]
;
entry:
%vscale = call i32 @llvm.vscale.i32()
%VF = shl nuw nsw i32 %vscale, 2
%cmp4 = icmp sgt i32 %n, 0
br i1 %cmp4, label %for.body, label %early.exit
early.exit:
ret i32 0
for.body:
%i.05 = phi i32 [ %add, %for.body ], [ 0, %entry ]
%arrayidx = getelementptr inbounds i32, ptr %A, i32 %i.05
%left = sub i32 %n, %i.05
%VF.capped = call i32 @llvm.umin.i32(i32 %VF, i32 %left)
store i32 %VF.capped, ptr %A
%add = add nsw i32 %i.05, %VF
%cmp = icmp slt i32 %add, %n
br i1 %cmp, label %for.body, label %for.end
for.end:
ret i32 %VF.capped
}
define i32 @vscale_slt_with_vp_umin2(ptr nocapture %A, i32 %n) mustprogress vscale_range(2,1024) {
; ALWAYS-LABEL: @vscale_slt_with_vp_umin2(
; ALWAYS-NEXT: entry:
; ALWAYS-NEXT: [[VSCALE:%.*]] = call i32 @llvm.vscale.i32()
; ALWAYS-NEXT: [[VF:%.*]] = shl nuw nsw i32 [[VSCALE]], 2
; ALWAYS-NEXT: [[CMP4:%.*]] = icmp sgt i32 [[N:%.*]], [[VF]]
; ALWAYS-NEXT: br i1 [[CMP4]], label [[FOR_BODY_PREHEADER:%.*]], label [[EARLY_EXIT:%.*]]
; ALWAYS: for.body.preheader:
; ALWAYS-NEXT: br label [[FOR_BODY:%.*]]
; ALWAYS: early.exit:
; ALWAYS-NEXT: ret i32 0
; ALWAYS: for.body:
; ALWAYS-NEXT: [[I_05:%.*]] = phi i32 [ [[ADD:%.*]], [[FOR_BODY]] ], [ 0, [[FOR_BODY_PREHEADER]] ]
; ALWAYS-NEXT: [[LEFT:%.*]] = sub i32 [[N]], [[I_05]]
; ALWAYS-NEXT: [[VF_CAPPED:%.*]] = call i32 @llvm.umin.i32(i32 [[VF]], i32 [[LEFT]])
; ALWAYS-NEXT: store i32 [[VF_CAPPED]], ptr [[A:%.*]], align 4
; ALWAYS-NEXT: [[ADD]] = add nuw nsw i32 [[I_05]], [[VF]]
; ALWAYS-NEXT: [[CMP:%.*]] = icmp slt i32 [[ADD]], [[N]]
; ALWAYS-NEXT: br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END:%.*]]
; ALWAYS: for.end:
; ALWAYS-NEXT: [[TMP0:%.*]] = add i32 [[N]], -1
; ALWAYS-NEXT: [[TMP1:%.*]] = call range(i32 2, 33) i32 @llvm.cttz.i32(i32 [[VF]], i1 true)
; ALWAYS-NEXT: [[TMP2:%.*]] = lshr i32 [[TMP0]], [[TMP1]]
; ALWAYS-NEXT: [[TMP3:%.*]] = mul i32 [[TMP2]], [[VSCALE]]
; ALWAYS-NEXT: [[TMP4:%.*]] = shl i32 [[TMP3]], 2
; ALWAYS-NEXT: [[TMP5:%.*]] = sub i32 [[N]], [[TMP4]]
; ALWAYS-NEXT: [[UMIN:%.*]] = call i32 @llvm.umin.i32(i32 [[VF]], i32 [[TMP5]])
; ALWAYS-NEXT: ret i32 [[UMIN]]
;
; CHEAP-LABEL: @vscale_slt_with_vp_umin2(
; CHEAP-NEXT: entry:
; CHEAP-NEXT: [[VSCALE:%.*]] = call i32 @llvm.vscale.i32()
; CHEAP-NEXT: [[VF:%.*]] = shl nuw nsw i32 [[VSCALE]], 2
; CHEAP-NEXT: [[CMP4:%.*]] = icmp sgt i32 [[N:%.*]], [[VF]]
; CHEAP-NEXT: br i1 [[CMP4]], label [[FOR_BODY_PREHEADER:%.*]], label [[EARLY_EXIT:%.*]]
; CHEAP: for.body.preheader:
; CHEAP-NEXT: br label [[FOR_BODY:%.*]]
; CHEAP: early.exit:
; CHEAP-NEXT: ret i32 0
; CHEAP: for.body:
; CHEAP-NEXT: [[I_05:%.*]] = phi i32 [ [[ADD:%.*]], [[FOR_BODY]] ], [ 0, [[FOR_BODY_PREHEADER]] ]
; CHEAP-NEXT: [[LEFT:%.*]] = sub i32 [[N]], [[I_05]]
; CHEAP-NEXT: [[VF_CAPPED:%.*]] = call i32 @llvm.umin.i32(i32 [[VF]], i32 [[LEFT]])
; CHEAP-NEXT: store i32 [[VF_CAPPED]], ptr [[A:%.*]], align 4
; CHEAP-NEXT: [[ADD]] = add nuw nsw i32 [[I_05]], [[VF]]
; CHEAP-NEXT: [[CMP:%.*]] = icmp slt i32 [[ADD]], [[N]]
; CHEAP-NEXT: br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END:%.*]]
; CHEAP: for.end:
; CHEAP-NEXT: ret i32 [[VF_CAPPED]]
;
entry:
%vscale = call i32 @llvm.vscale.i32()
%VF = shl nuw nsw i32 %vscale, 2
%cmp4 = icmp sgt i32 %n, %VF
br i1 %cmp4, label %for.body, label %early.exit
early.exit:
ret i32 0
for.body:
%i.05 = phi i32 [ %add, %for.body ], [ 0, %entry ]
%arrayidx = getelementptr inbounds i32, ptr %A, i32 %i.05
%left = sub i32 %n, %i.05
%VF.capped = call i32 @llvm.umin.i32(i32 %VF, i32 %left)
store i32 %VF.capped, ptr %A
%add = add nsw i32 %i.05, %VF
%cmp = icmp slt i32 %add, %n
br i1 %cmp, label %for.body, label %for.end
for.end:
ret i32 %VF.capped
}
; Rewrite a comparison by expanding its operands at the loop exit.
define i1 @rewrite_computable_icmp(i32 %start, i32 %limit) {
; CHECK-LABEL: @rewrite_computable_icmp(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: br i1 false, label [[BODY:%.*]], label [[EXIT:%.*]]
; CHECK: body:
; CHECK-NEXT: br label [[LOOP]]
; CHECK: exit:
; CHECK-NEXT: [[TMP0:%.*]] = freeze i32 [[LIMIT:%.*]]
; CHECK-NEXT: [[TMP1:%.*]] = add i32 [[START:%.*]], -42
; CHECK-NEXT: [[UMIN:%.*]] = call i32 @llvm.umin.i32(i32 [[TMP0]], i32 [[TMP1]])
; CHECK-NEXT: [[TMP2:%.*]] = sub i32 [[START]], [[UMIN]]
; CHECK-NEXT: [[CMP_EXIT:%.*]] = icmp ne i32 [[TMP2]], 42
; CHECK-NEXT: ret i1 [[CMP_EXIT]]
;
entry:
br label %loop
loop:
%iv = phi i32 [ %start, %entry ], [ %iv.next, %body ]
%index = phi i32 [ 0, %entry ], [ %index.next, %body ]
%cmp = icmp ne i32 %iv, 42
%inrange = icmp ult i32 %index, %limit
%continue = select i1 %cmp, i1 %inrange, i1 false
br i1 %continue, label %body, label %exit
body:
%iv.next = add nsw i32 %iv, -1
%index.next = add nuw i32 %index, 1
br label %loop
exit:
ret i1 %cmp
}
; Rewrite multiple comparisons when doing so makes all live-outs invariant.
define i1 @rewrite_multiple_icmps(i32 %start, i32 %rhs.start, i32 %limit) {
; CHECK-LABEL: @rewrite_multiple_icmps(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: br i1 false, label [[BODY:%.*]], label [[EXIT:%.*]]
; CHECK: body:
; CHECK-NEXT: br label [[LOOP]]
; CHECK: exit:
; CHECK-NEXT: [[TMP0:%.*]] = freeze i32 [[LIMIT:%.*]]
; CHECK-NEXT: [[TMP1:%.*]] = add i32 [[START:%.*]], -42
; CHECK-NEXT: [[UMIN:%.*]] = call i32 @llvm.umin.i32(i32 [[TMP0]], i32 [[TMP1]])
; CHECK-NEXT: [[TMP2:%.*]] = sub i32 [[START]], [[UMIN]]
; CHECK-NEXT: [[CMP0_EXIT:%.*]] = icmp ne i32 [[TMP2]], 42
; CHECK-NEXT: [[TMP3:%.*]] = shl i32 [[UMIN]], 1
; CHECK-NEXT: [[TMP4:%.*]] = add i32 [[RHS_START:%.*]], [[TMP3]]
; CHECK-NEXT: [[CMP1_EXIT:%.*]] = icmp sgt i32 [[TMP2]], [[TMP4]]
; CHECK-NEXT: [[RESULT:%.*]] = and i1 [[CMP0_EXIT]], [[CMP1_EXIT]]
; CHECK-NEXT: ret i1 [[RESULT]]
;
entry:
br label %loop
loop:
%iv = phi i32 [ %start, %entry ], [ %iv.next, %body ]
%rhs = phi i32 [ %rhs.start, %entry ], [ %rhs.next, %body ]
%index = phi i32 [ 0, %entry ], [ %index.next, %body ]
%cmp0 = icmp ne i32 %iv, 42
%cmp1 = icmp sgt i32 %iv, %rhs
%inrange = icmp ult i32 %index, %limit
%continue = select i1 %cmp0, i1 %inrange, i1 false
br i1 %continue, label %body, label %exit
body:
%iv.next = add nsw i32 %iv, -1
%rhs.next = add i32 %rhs, 2
%index.next = add nuw i32 %index, 1
br label %loop
exit:
%result = and i1 %cmp0, %cmp1
ret i1 %result
}
; Do not rewrite a comparison if SCEV cannot compute an operand's exit value.
define i1 @do_not_rewrite_uncomputable_icmp(i1 %c, i32 %start) {
; CHECK-LABEL: @do_not_rewrite_uncomputable_icmp(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[IV:%.*]] = phi i32 [ [[START:%.*]], [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP]] ]
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[IV]], 0
; CHECK-NEXT: [[SELECTED:%.*]] = select i1 [[CMP]], i1 [[C:%.*]], i1 false
; CHECK-NEXT: [[IV_NEXT]] = add i32 [[IV]], 1
; CHECK-NEXT: br i1 [[SELECTED]], label [[LOOP]], label [[EXIT:%.*]]
; CHECK: exit:
; CHECK-NEXT: ret i1 [[CMP]]
;
entry:
br label %loop
loop:
%iv = phi i32 [ %start, %entry ], [ %iv.next, %loop ]
%cmp = icmp ne i32 %iv, 0
%selected = select i1 %cmp, i1 %c, i1 false
%iv.next = add i32 %iv, 1
br i1 %selected, label %loop, label %exit
exit:
ret i1 %cmp
}
; Operand-based rewriting is high cost unless it makes the loop deletable.
define i1 @rewrite_icmp_in_live_loop(i32 %start, i32 %limit) {
; ALWAYS-LABEL: @rewrite_icmp_in_live_loop(
; ALWAYS-NEXT: entry:
; ALWAYS-NEXT: br label [[LOOP:%.*]]
; ALWAYS: loop:
; ALWAYS-NEXT: [[INDEX:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INDEX_NEXT:%.*]], [[BODY:%.*]] ]
; ALWAYS-NEXT: [[INRANGE:%.*]] = icmp ult i32 [[INDEX]], [[LIMIT:%.*]]
; ALWAYS-NEXT: call void @side_effect()
; ALWAYS-NEXT: br i1 [[INRANGE]], label [[BODY]], label [[EXIT:%.*]]
; ALWAYS: body:
; ALWAYS-NEXT: [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 1
; ALWAYS-NEXT: br label [[LOOP]]
; ALWAYS: exit:
; ALWAYS-NEXT: [[TMP0:%.*]] = sub i32 [[START:%.*]], [[LIMIT]]
; ALWAYS-NEXT: [[CMP_EXIT:%.*]] = icmp ne i32 [[TMP0]], 42
; ALWAYS-NEXT: ret i1 [[CMP_EXIT]]
;
; CHEAP-LABEL: @rewrite_icmp_in_live_loop(
; CHEAP-NEXT: entry:
; CHEAP-NEXT: br label [[LOOP:%.*]]
; CHEAP: loop:
; CHEAP-NEXT: [[IV:%.*]] = phi i32 [ [[START:%.*]], [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[BODY:%.*]] ]
; CHEAP-NEXT: [[INDEX:%.*]] = phi i32 [ 0, [[ENTRY]] ], [ [[INDEX_NEXT:%.*]], [[BODY]] ]
; CHEAP-NEXT: [[INRANGE:%.*]] = icmp ult i32 [[INDEX]], [[LIMIT:%.*]]
; CHEAP-NEXT: call void @side_effect()
; CHEAP-NEXT: br i1 [[INRANGE]], label [[BODY]], label [[EXIT:%.*]]
; CHEAP: body:
; CHEAP-NEXT: [[IV_NEXT]] = add nsw i32 [[IV]], -1
; CHEAP-NEXT: [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 1
; CHEAP-NEXT: br label [[LOOP]]
; CHEAP: exit:
; CHEAP-NEXT: [[CMP:%.*]] = icmp ne i32 [[IV]], 42
; CHEAP-NEXT: ret i1 [[CMP]]
;
entry:
br label %loop
loop:
%iv = phi i32 [ %start, %entry ], [ %iv.next, %body ]
%index = phi i32 [ 0, %entry ], [ %index.next, %body ]
%cmp = icmp ne i32 %iv, 42
%inrange = icmp ult i32 %index, %limit
call void @side_effect()
br i1 %inrange, label %body, label %exit
body:
%iv.next = add nsw i32 %iv, -1
%index.next = add nuw i32 %index, 1
br label %loop
exit:
ret i1 %cmp
}
; Rewrite a pointer comparison when its operand exit values are computable.
define i1 @rewrite_pointer_icmp(ptr %start, ptr %end, i32 %limit) {
; CHECK-LABEL: @rewrite_pointer_icmp(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: br i1 false, label [[BODY:%.*]], label [[EXIT:%.*]]
; CHECK: body:
; CHECK-NEXT: br label [[LOOP]]
; CHECK: exit:
; CHECK-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START:%.*]] to i64
; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END:%.*]] to i64
; CHECK-NEXT: [[LIMIT_FR:%.*]] = freeze i32 [[LIMIT:%.*]]
; CHECK-NEXT: [[TMP0:%.*]] = zext i32 [[LIMIT_FR]] to i64
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[END1]], [[START2]]
; CHECK-NEXT: [[UMIN:%.*]] = call i64 @llvm.umin.i64(i64 [[TMP0]], i64 [[TMP1]])
; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr [[START]], i64 [[UMIN]]
; CHECK-NEXT: [[CMP_EXIT:%.*]] = icmp ne ptr [[SCEVGEP]], [[END]]
; CHECK-NEXT: ret i1 [[CMP_EXIT]]
;
entry:
br label %loop
loop:
%ptr = phi ptr [ %start, %entry ], [ %ptr.next, %body ]
%index = phi i32 [ 0, %entry ], [ %index.next, %body ]
%cmp = icmp ne ptr %ptr, %end
%inrange = icmp ult i32 %index, %limit
%continue = select i1 %cmp, i1 %inrange, i1 false
br i1 %continue, label %body, label %exit
body:
%ptr.next = getelementptr i8, ptr %ptr, i64 1
%index.next = add nuw i32 %index, 1
br label %loop
exit:
ret i1 %cmp
}
declare void @use.i1(i1)
declare void @side_effect()