llvm/test/Transforms/CorrelatedValuePropagation/ashr.ll

   1 ; RUN: opt < %s -passes=correlated-propagation -S | FileCheck %s
   2
   3 ; Check that debug locations are preserved. For more info see:
   4 ;   https://llvm.org/docs/SourceLevelDebugging.html#fixing-errors
   5 ; RUN: opt < %s -enable-debugify -passes=correlated-propagation -S 2>&1 | \
   6 ; RUN:   FileCheck %s -check-prefix=DEBUG
   7 ; DEBUG: CheckModuleDebugify: PASS
   8
   9 ; CHECK-LABEL: @test1
  10 define void @test1(i32 %n) {
  11 entry:
  12   br label %for.cond
  13
  14 for.cond:                                         ; preds = %for.body, %entry
  15   %a = phi i32 [ %n, %entry ], [ %shr, %for.body ]
  16   %cmp = icmp sgt i32 %a, 1
  17   br i1 %cmp, label %for.body, label %for.end
  18
  19 for.body:                                         ; preds = %for.cond
  20 ; CHECK: lshr i32 %a, 5
  21   %shr = ashr i32 %a, 5
  22   br label %for.cond
  23
  24 for.end:                                          ; preds = %for.cond
  25   ret void
  26 }
  27
  28 ;; Negative test to show transform doesn't happen unless n > 0.
  29 ; CHECK-LABEL: @test2
  30 define void @test2(i32 %n) {
  31 entry:
  32   br label %for.cond
  33
  34 for.cond:                                         ; preds = %for.body, %entry
  35   %a = phi i32 [ %n, %entry ], [ %shr, %for.body ]
  36   %cmp = icmp sgt i32 %a, -2
  37   br i1 %cmp, label %for.body, label %for.end
  38
  39 for.body:                                         ; preds = %for.cond
  40 ; CHECK: ashr i32 %a, 2
  41   %shr = ashr i32 %a, 2
  42   br label %for.cond
  43
  44 for.end:                                          ; preds = %for.cond
  45   ret void
  46 }
  47
  48 ;; Non looping test case.
  49 ; CHECK-LABEL: @test3
  50 define void @test3(i32 %n) {
  51 entry:
  52   %cmp = icmp sgt i32 %n, 0
  53   br i1 %cmp, label %bb, label %exit
  54
  55 bb:
  56 ; CHECK: lshr exact i32 %n, 4
  57   %shr = ashr exact i32 %n, 4
  58   br label %exit
  59
  60 exit:
  61   ret void
  62 }
  63
  64 ; looping case where loop has exactly one block
  65 ; at the point of ashr, we know that the operand is always greater than 0,
  66 ; because of the guard before it, so we can transform it to lshr.
  67 declare void @llvm.experimental.guard(i1,...)
  68 ; CHECK-LABEL: @test4
  69 define void @test4(i32 %n) {
  70 entry:
  71   %cmp = icmp sgt i32 %n, 0
  72   br i1 %cmp, label %loop, label %exit
  73
  74 loop:
  75 ; CHECK: lshr i32 %a, 1
  76   %a = phi i32 [ %n, %entry ], [ %shr, %loop ]
  77   %cond = icmp sgt i32 %a, 2
  78   call void(i1,...) @llvm.experimental.guard(i1 %cond) [ "deopt"() ]
  79   %shr = ashr i32 %a, 1
  80   br i1 %cond, label %loop, label %exit
  81
  82 exit:
  83   ret void
  84 }
  85
  86 ; same test as above with assume instead of guard.
  87 declare void @llvm.assume(i1)
  88 ; CHECK-LABEL: @test5
  89 define void @test5(i32 %n) {
  90 entry:
  91   %cmp = icmp sgt i32 %n, 0
  92   br i1 %cmp, label %loop, label %exit
  93
  94 loop:
  95 ; CHECK: lshr i32 %a, 1
  96   %a = phi i32 [ %n, %entry ], [ %shr, %loop ]
  97   %cond = icmp sgt i32 %a, 4
  98   call void @llvm.assume(i1 %cond)
  99   %shr = ashr i32 %a, 1
 100   %loopcond = icmp sgt i32 %shr, 8
 101   br i1 %loopcond, label %loop, label %exit
 102
 103 exit:
 104   ret void
 105 }
 106
 107 ; check that ashr of -1 or 0 is optimized away
 108 ; CHECK-LABEL: @test6
 109 define i32 @test6(i32 %f, i32 %g) {
 110 entry:
 111   %0 = add i32 %f, 1
 112   %1 = icmp ult i32 %0, 2
 113   tail call void @llvm.assume(i1 %1)
 114 ; CHECK: ret i32 %f
 115   %shr = ashr i32 %f, %g
 116   ret i32 %shr
 117 }
 118
 119 ; same test as above with different numbers
 120 ; CHECK-LABEL: @test7
 121 define i32 @test7(i32 %f, i32 %g) {
 122 entry:
 123   %0 = and i32 %f, -2
 124   %1 = icmp eq i32 %0, 6
 125   tail call void @llvm.assume(i1 %1)
 126   %sub = add nsw i32 %f, -7
 127 ; CHECK: ret i32 %sub
 128   %shr = ashr i32 %sub, %g
 129   ret i32 %shr
 130 }
 131
 132 ; check that ashr of -2 or 1 is not optimized away
 133 ; CHECK-LABEL: @test8
 134 define i32 @test8(i32 %f, i32 %g, i1 %s) {
 135 entry:
 136 ; CHECK: ashr i32 -2, %f
 137   %0 = ashr i32 -2, %f
 138 ; CHECK: lshr i32 1, %g
 139   %1 = ashr i32 1, %g
 140   %2 = select i1 %s, i32 %0, i32 %1
 141   ret i32 %2
 142 }
 143
 144 define i32 @may_including_undef(i1 %c.1, i1 %c.2) {
 145 ; CHECK-LABEL: define i32 @may_including_undef
 146 ; CHECK-SAME: (i1 [[C_1:%.*]], i1 [[C_2:%.*]]) {
 147 ; CHECK-NEXT:    br i1 [[C_1]], label [[TRUE_1:%.*]], label [[FALSE:%.*]]
 148 ; CHECK:       true.1:
 149 ; CHECK-NEXT:    br i1 [[C_2]], label [[TRUE_2:%.*]], label [[EXIT:%.*]]
 150 ; CHECK:       true.2:
 151 ; CHECK-NEXT:    br label [[EXIT]]
 152 ; CHECK:       false:
 153 ; CHECK-NEXT:    br label [[EXIT]]
 154 ; CHECK:       exit:
 155 ; CHECK-NEXT:    [[P:%.*]] = phi i32 [ 2, [[TRUE_1]] ], [ 4, [[TRUE_2]] ], [ undef, [[FALSE]] ]
 156 ; CHECK-NEXT:    [[R:%.*]] = ashr i32 [[P]], 1
 157 ; CHECK-NEXT:    ret i32 [[R]]
 158 ;
 159   br i1 %c.1, label %true.1, label %false
 160
 161 true.1:
 162   br i1 %c.2, label %true.2, label %exit
 163
 164 true.2:
 165   br label %exit
 166
 167 false:
 168   br label %exit
 169
 170 exit:
 171   %p = phi i32 [ 2, %true.1 ], [ 4, %true.2], [ undef, %false ]
 172   %r = ashr i32 %p, 1
 173   ret i32 %r
 174 }