| ; 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() |