test/Transforms/GVN/PRE/load-pre-licm.ll

   1 ; RUN: opt -S -basicaa -gvn < %s | FileCheck %s
   2 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32"
   3 target triple = "i386-apple-darwin11.0.0"
   4
   5 @sortlist = external global [5001 x i32], align 4
   6
   7 define void @Bubble() nounwind noinline {
   8 ; CHECK: entry:
   9 ; CHECK-NEXT: %tmp7.pre = load i32
  10 entry:
  11   br label %while.body5
  12
  13 ; CHECK: while.body5:
  14 ; CHECK: %tmp7 = phi i32
  15 ; CHECK-NOT: %tmp7 = load i32
  16 while.body5:
  17   %indvar = phi i32 [ 0, %entry ], [ %tmp6, %if.end ]
  18   %tmp5 = add i32 %indvar, 2
  19   %arrayidx9 = getelementptr [5001 x i32], [5001 x i32]* @sortlist, i32 0, i32 %tmp5
  20   %tmp6 = add i32 %indvar, 1
  21   %arrayidx = getelementptr [5001 x i32], [5001 x i32]* @sortlist, i32 0, i32 %tmp6
  22   %tmp7 = load i32, i32* %arrayidx, align 4
  23   %tmp10 = load i32, i32* %arrayidx9, align 4
  24   %cmp11 = icmp sgt i32 %tmp7, %tmp10
  25   br i1 %cmp11, label %if.then, label %if.end
  26
  27 ; CHECK: if.then:
  28 if.then:
  29   store i32 %tmp10, i32* %arrayidx, align 4
  30   store i32 %tmp7, i32* %arrayidx9, align 4
  31   br label %if.end
  32
  33 if.end:
  34   %exitcond = icmp eq i32 %tmp6, 100
  35   br i1 %exitcond, label %while.end.loopexit, label %while.body5
  36
  37 while.end.loopexit:
  38   ret void
  39 }
  40
  41 declare void @hold(i32) readonly
  42 declare void @clobber()
  43
  44 ; This is a classic LICM case
  45 define i32 @test1(i1 %cnd, i32* %p) {
  46 ; CHECK-LABEL: @test1
  47 entry:
  48 ; CHECK-LABEL: entry
  49 ; CHECK-NEXT: %v1.pre = load i32, i32* %p
  50   br label %header
  51
  52 header:
  53 ; CHECK-LABEL: header
  54   %v1 = load i32, i32* %p
  55   call void @hold(i32 %v1)
  56   br label %header
  57 }
  58
  59
  60 ; Slightly more complicated case to highlight that MemoryDependenceAnalysis
  61 ; can compute availability for internal control flow.  In this case, because
  62 ; the value is fully available across the backedge, we only need to establish
  63 ; anticipation for the preheader block (which is trivial in this case.)
  64 define i32 @test2(i1 %cnd, i32* %p) {
  65 ; CHECK-LABEL: @test2
  66 entry:
  67 ; CHECK-LABEL: entry
  68 ; CHECK-NEXT: %v1.pre = load i32, i32* %p
  69   br label %header
  70
  71 header:
  72 ; CHECK-LABEL: header
  73   %v1 = load i32, i32* %p
  74   call void @hold(i32 %v1)
  75   br i1 %cnd, label %bb1, label %bb2
  76
  77 bb1:
  78   br label %merge
  79
  80 bb2:
  81   br label %merge
  82
  83 merge:
  84   br label %header
  85 }
  86
  87
  88 ; TODO: at the moment, our anticipation check does not handle anything
  89 ; other than straight-line unconditional fallthrough.  This particular
  90 ; case could be solved through either a backwards anticipation walk or
  91 ; use of the "safe to speculate" status (if we annotate the param)
  92 define i32 @test3(i1 %cnd, i32* %p) {
  93 entry:
  94 ; CHECK-LABEL: @test3
  95 ; CHECK-LABEL: entry
  96   br label %header
  97
  98 header:
  99   br i1 %cnd, label %bb1, label %bb2
 100
 101 bb1:
 102   br label %merge
 103
 104 bb2:
 105   br label %merge
 106
 107 merge:
 108 ; CHECK-LABEL: merge
 109 ; CHECK: load i32, i32* %p
 110   %v1 = load i32, i32* %p
 111   call void @hold(i32 %v1)
 112   br label %header
 113 }
 114
 115 ; Highlight that we can PRE into a latch block when there are multiple
 116 ; latches only one of which clobbers an otherwise invariant value.
 117 define i32 @test4(i1 %cnd, i32* %p) {
 118 ; CHECK-LABEL: @test4
 119 entry:
 120 ; CHECK-LABEL: entry
 121   %v1 = load i32, i32* %p
 122   call void @hold(i32 %v1)
 123   br label %header
 124
 125 header:
 126 ; CHECK-LABEL: header
 127   %v2 = load i32, i32* %p
 128   call void @hold(i32 %v2)
 129   br i1 %cnd, label %bb1, label %bb2
 130
 131 bb1:
 132   br label %header
 133
 134 bb2:
 135 ; CHECK-LABEL: bb2
 136 ; CHECK:       call void @clobber()
 137 ; CHECK-NEXT:  %v2.pre = load i32, i32* %p
 138 ; CHECK-NEXT:  br label %header
 139
 140   call void @clobber()
 141   br label %header
 142 }
 143
 144 ; Highlight the fact that we can PRE into a single clobbering latch block
 145 ; even in loop simplify form (though multiple applications of the same
 146 ; transformation).
 147 define i32 @test5(i1 %cnd, i32* %p) {
 148 ; CHECK-LABEL: @test5
 149 entry:
 150 ; CHECK-LABEL: entry
 151   %v1 = load i32, i32* %p
 152   call void @hold(i32 %v1)
 153   br label %header
 154
 155 header:
 156 ; CHECK-LABEL: header
 157   %v2 = load i32, i32* %p
 158   call void @hold(i32 %v2)
 159   br i1 %cnd, label %bb1, label %bb2
 160
 161 bb1:
 162   br label %merge
 163
 164 bb2:
 165 ; CHECK-LABEL: bb2
 166 ; CHECK:       call void @clobber()
 167 ; CHECK-NEXT:  %v2.pre.pre = load i32, i32* %p
 168 ; CHECK-NEXT:  br label %merge
 169
 170   call void @clobber()
 171   br label %merge
 172
 173 merge:
 174   br label %header
 175 }
 176
 177 declare void @llvm.experimental.guard(i1 %cnd, ...)
 178
 179 ; These two tests highlight speculation safety when we can not establish
 180 ; anticipation (since the original load might actually not execcute)
 181 define i32 @test6a(i1 %cnd, i32* %p) {
 182 entry:
 183 ; CHECK-LABEL: @test6a
 184   br label %header
 185
 186 header:
 187 ; CHECK-LABEL: header
 188 ; CHECK: load i32, i32* %p
 189   call void (i1, ...) @llvm.experimental.guard(i1 %cnd) ["deopt"()]
 190   %v1 = load i32, i32* %p
 191   call void @hold(i32 %v1)
 192   br label %header
 193 }
 194
 195 define i32 @test6b(i1 %cnd, i32* dereferenceable(8) %p) {
 196 entry:
 197 ; CHECK-LABEL: @test6b
 198 ; CHECK: load i32, i32* %p
 199   br label %header
 200
 201 header:
 202 ; CHECK-LABEL: header
 203   call void (i1, ...) @llvm.experimental.guard(i1 %cnd) ["deopt"()]
 204   %v1 = load i32, i32* %p
 205   call void @hold(i32 %v1)
 206   br label %header
 207 }