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

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt -S -passes=gvn < %s | FileCheck %s
   3 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"
   4 target triple = "i386-apple-darwin11.0.0"
   5
   6 @sortlist = external global [5001 x i32], align 4
   7
   8 define void @Bubble() nounwind noinline {
   9 ; CHECK-LABEL: @Bubble(
  10 ; CHECK-NEXT:  entry:
  11 ; CHECK-NEXT:    [[TMP7_PRE:%.*]] = load i32, ptr getelementptr inbounds (i8, ptr @sortlist, i32 4), align 4
  12 ; CHECK-NEXT:    br label [[WHILE_BODY5:%.*]]
  13 ; CHECK:       while.body5:
  14 ; CHECK-NEXT:    [[TMP7:%.*]] = phi i32 [ [[TMP7_PRE]], [[ENTRY:%.*]] ], [ [[TMP71:%.*]], [[IF_END:%.*]] ]
  15 ; CHECK-NEXT:    [[INDVAR:%.*]] = phi i32 [ 0, [[ENTRY]] ], [ [[TMP6:%.*]], [[IF_END]] ]
  16 ; CHECK-NEXT:    [[TMP5:%.*]] = add i32 [[INDVAR]], 2
  17 ; CHECK-NEXT:    [[ARRAYIDX9:%.*]] = getelementptr [5001 x i32], ptr @sortlist, i32 0, i32 [[TMP5]]
  18 ; CHECK-NEXT:    [[TMP6]] = add i32 [[INDVAR]], 1
  19 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr [5001 x i32], ptr @sortlist, i32 0, i32 [[TMP6]]
  20 ; CHECK-NEXT:    [[TMP10:%.*]] = load i32, ptr [[ARRAYIDX9]], align 4
  21 ; CHECK-NEXT:    [[CMP11:%.*]] = icmp sgt i32 [[TMP7]], [[TMP10]]
  22 ; CHECK-NEXT:    br i1 [[CMP11]], label [[IF_THEN:%.*]], label [[IF_END]]
  23 ; CHECK:       if.then:
  24 ; CHECK-NEXT:    store i32 [[TMP10]], ptr [[ARRAYIDX]], align 4
  25 ; CHECK-NEXT:    store i32 [[TMP7]], ptr [[ARRAYIDX9]], align 4
  26 ; CHECK-NEXT:    br label [[IF_END]]
  27 ; CHECK:       if.end:
  28 ; CHECK-NEXT:    [[TMP71]] = phi i32 [ [[TMP7]], [[IF_THEN]] ], [ [[TMP10]], [[WHILE_BODY5]] ]
  29 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[TMP6]], 100
  30 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[WHILE_END_LOOPEXIT:%.*]], label [[WHILE_BODY5]]
  31 ; CHECK:       while.end.loopexit:
  32 ; CHECK-NEXT:    ret void
  33 ;
  34 entry:
  35   br label %while.body5
  36
  37 while.body5:
  38   %indvar = phi i32 [ 0, %entry ], [ %tmp6, %if.end ]
  39   %tmp5 = add i32 %indvar, 2
  40   %arrayidx9 = getelementptr [5001 x i32], ptr @sortlist, i32 0, i32 %tmp5
  41   %tmp6 = add i32 %indvar, 1
  42   %arrayidx = getelementptr [5001 x i32], ptr @sortlist, i32 0, i32 %tmp6
  43   %tmp7 = load i32, ptr %arrayidx, align 4
  44   %tmp10 = load i32, ptr %arrayidx9, align 4
  45   %cmp11 = icmp sgt i32 %tmp7, %tmp10
  46   br i1 %cmp11, label %if.then, label %if.end
  47
  48 if.then:
  49   store i32 %tmp10, ptr %arrayidx, align 4
  50   store i32 %tmp7, ptr %arrayidx9, align 4
  51   br label %if.end
  52
  53 if.end:
  54   %exitcond = icmp eq i32 %tmp6, 100
  55   br i1 %exitcond, label %while.end.loopexit, label %while.body5
  56
  57 while.end.loopexit:
  58   ret void
  59 }
  60
  61 declare void @hold(i32) readonly
  62 declare void @clobber()
  63
  64 ; This is a classic LICM case
  65 define i32 @test1(i1 %cnd, ptr %p) {
  66 ; CHECK-LABEL: @test1(
  67 ; CHECK-NEXT:  entry:
  68 ; CHECK-NEXT:    [[V1_PRE:%.*]] = load i32, ptr [[P:%.*]], align 4
  69 ; CHECK-NEXT:    br label [[HEADER:%.*]]
  70 ; CHECK:       header:
  71 ; CHECK-NEXT:    call void @hold(i32 [[V1_PRE]])
  72 ; CHECK-NEXT:    br label [[HEADER]]
  73 ;
  74 entry:
  75   br label %header
  76
  77 header:
  78   %v1 = load i32, ptr %p
  79   call void @hold(i32 %v1)
  80   br label %header
  81 }
  82
  83
  84 ; Slightly more complicated case to highlight that MemoryDependenceAnalysis
  85 ; can compute availability for internal control flow.  In this case, because
  86 ; the value is fully available across the backedge, we only need to establish
  87 ; anticipation for the preheader block (which is trivial in this case.)
  88 define i32 @test2(i1 %cnd, ptr %p) {
  89 ; CHECK-LABEL: @test2(
  90 ; CHECK-NEXT:  entry:
  91 ; CHECK-NEXT:    [[V1_PRE:%.*]] = load i32, ptr [[P:%.*]], align 4
  92 ; CHECK-NEXT:    br label [[HEADER:%.*]]
  93 ; CHECK:       header:
  94 ; CHECK-NEXT:    call void @hold(i32 [[V1_PRE]])
  95 ; CHECK-NEXT:    br i1 [[CND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
  96 ; CHECK:       bb1:
  97 ; CHECK-NEXT:    br label [[MERGE:%.*]]
  98 ; CHECK:       bb2:
  99 ; CHECK-NEXT:    br label [[MERGE]]
 100 ; CHECK:       merge:
 101 ; CHECK-NEXT:    br label [[HEADER]]
 102 ;
 103 entry:
 104   br label %header
 105
 106 header:
 107   %v1 = load i32, ptr %p
 108   call void @hold(i32 %v1)
 109   br i1 %cnd, label %bb1, label %bb2
 110
 111 bb1:
 112   br label %merge
 113
 114 bb2:
 115   br label %merge
 116
 117 merge:
 118   br label %header
 119 }
 120
 121
 122 ; TODO: at the moment, our anticipation check does not handle anything
 123 ; other than straight-line unconditional fallthrough.  This particular
 124 ; case could be solved through either a backwards anticipation walk or
 125 ; use of the "safe to speculate" status (if we annotate the param)
 126 define i32 @test3(i1 %cnd, ptr %p) {
 127 ; CHECK-LABEL: @test3(
 128 ; CHECK-NEXT:  entry:
 129 ; CHECK-NEXT:    br label [[HEADER:%.*]]
 130 ; CHECK:       header:
 131 ; CHECK-NEXT:    br i1 [[CND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 132 ; CHECK:       bb1:
 133 ; CHECK-NEXT:    br label [[MERGE:%.*]]
 134 ; CHECK:       bb2:
 135 ; CHECK-NEXT:    br label [[MERGE]]
 136 ; CHECK:       merge:
 137 ; CHECK-NEXT:    [[V1:%.*]] = load i32, ptr [[P:%.*]], align 4
 138 ; CHECK-NEXT:    call void @hold(i32 [[V1]])
 139 ; CHECK-NEXT:    br label [[HEADER]]
 140 ;
 141 entry:
 142   br label %header
 143
 144 header:
 145   br i1 %cnd, label %bb1, label %bb2
 146
 147 bb1:
 148   br label %merge
 149
 150 bb2:
 151   br label %merge
 152
 153 merge:
 154   %v1 = load i32, ptr %p
 155   call void @hold(i32 %v1)
 156   br label %header
 157 }
 158
 159 ; Highlight that we can PRE into a latch block when there are multiple
 160 ; latches only one of which clobbers an otherwise invariant value.
 161 define i32 @test4(i1 %cnd, ptr %p) {
 162 ; CHECK-LABEL: @test4(
 163 ; CHECK-NEXT:  entry:
 164 ; CHECK-NEXT:    [[V1:%.*]] = load i32, ptr [[P:%.*]], align 4
 165 ; CHECK-NEXT:    call void @hold(i32 [[V1]])
 166 ; CHECK-NEXT:    br label [[HEADER:%.*]]
 167 ; CHECK:       header:
 168 ; CHECK-NEXT:    [[V2:%.*]] = phi i32 [ [[V2_PRE:%.*]], [[BB2:%.*]] ], [ [[V2]], [[BB1:%.*]] ], [ [[V1]], [[ENTRY:%.*]] ]
 169 ; CHECK-NEXT:    call void @hold(i32 [[V2]])
 170 ; CHECK-NEXT:    br i1 [[CND:%.*]], label [[BB1]], label [[BB2]]
 171 ; CHECK:       bb1:
 172 ; CHECK-NEXT:    br label [[HEADER]]
 173 ; CHECK:       bb2:
 174 ; CHECK-NEXT:    call void @clobber()
 175 ; CHECK-NEXT:    [[V2_PRE]] = load i32, ptr [[P]], align 4
 176 ; CHECK-NEXT:    br label [[HEADER]]
 177 ;
 178 entry:
 179   %v1 = load i32, ptr %p
 180   call void @hold(i32 %v1)
 181   br label %header
 182
 183 header:
 184   %v2 = load i32, ptr %p
 185   call void @hold(i32 %v2)
 186   br i1 %cnd, label %bb1, label %bb2
 187
 188 bb1:
 189   br label %header
 190
 191 bb2:
 192
 193   call void @clobber()
 194   br label %header
 195 }
 196
 197 ; Highlight the fact that we can PRE into a single clobbering latch block
 198 ; even in loop simplify form (though multiple applications of the same
 199 ; transformation).
 200 define i32 @test5(i1 %cnd, ptr %p) {
 201 ; CHECK-LABEL: @test5(
 202 ; CHECK-NEXT:  entry:
 203 ; CHECK-NEXT:    [[V1:%.*]] = load i32, ptr [[P:%.*]], align 4
 204 ; CHECK-NEXT:    call void @hold(i32 [[V1]])
 205 ; CHECK-NEXT:    br label [[HEADER:%.*]]
 206 ; CHECK:       header:
 207 ; CHECK-NEXT:    [[V2_PRE2:%.*]] = phi i32 [ [[V2_PRE:%.*]], [[MERGE:%.*]] ], [ [[V1]], [[ENTRY:%.*]] ]
 208 ; CHECK-NEXT:    call void @hold(i32 [[V2_PRE2]])
 209 ; CHECK-NEXT:    br i1 [[CND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 210 ; CHECK:       bb1:
 211 ; CHECK-NEXT:    br label [[MERGE]]
 212 ; CHECK:       bb2:
 213 ; CHECK-NEXT:    call void @clobber()
 214 ; CHECK-NEXT:    [[V2_PRE_PRE:%.*]] = load i32, ptr [[P]], align 4
 215 ; CHECK-NEXT:    br label [[MERGE]]
 216 ; CHECK:       merge:
 217 ; CHECK-NEXT:    [[V2_PRE]] = phi i32 [ [[V2_PRE_PRE]], [[BB2]] ], [ [[V2_PRE2]], [[BB1]] ]
 218 ; CHECK-NEXT:    br label [[HEADER]]
 219 ;
 220 entry:
 221   %v1 = load i32, ptr %p
 222   call void @hold(i32 %v1)
 223   br label %header
 224
 225 header:
 226   %v2 = load i32, ptr %p
 227   call void @hold(i32 %v2)
 228   br i1 %cnd, label %bb1, label %bb2
 229
 230 bb1:
 231   br label %merge
 232
 233 bb2:
 234
 235   call void @clobber()
 236   br label %merge
 237
 238 merge:
 239   br label %header
 240 }
 241
 242 declare void @llvm.experimental.guard(i1 %cnd, ...)
 243
 244 ; These two tests highlight speculation safety when we can not establish
 245 ; anticipation (since the original load might actually not execcute)
 246 define i32 @test6a(i1 %cnd, ptr %p) {
 247 ; CHECK-LABEL: @test6a(
 248 ; CHECK-NEXT:  entry:
 249 ; CHECK-NEXT:    br label [[HEADER:%.*]]
 250 ; CHECK:       header:
 251 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[CND:%.*]]) [ "deopt"() ]
 252 ; CHECK-NEXT:    [[V1:%.*]] = load i32, ptr [[P:%.*]], align 4
 253 ; CHECK-NEXT:    call void @hold(i32 [[V1]])
 254 ; CHECK-NEXT:    br label [[HEADER]]
 255 ;
 256 entry:
 257   br label %header
 258
 259 header:
 260   call void (i1, ...) @llvm.experimental.guard(i1 %cnd) ["deopt"()]
 261   %v1 = load i32, ptr %p
 262   call void @hold(i32 %v1)
 263   br label %header
 264 }
 265
 266 define i32 @test6b(i1 %cnd, ptr dereferenceable(8) align 4 %p) nofree nosync {
 267 ; CHECK-LABEL: @test6b(
 268 ; CHECK-NEXT:  entry:
 269 ; CHECK-NEXT:    [[V1_PRE:%.*]] = load i32, ptr [[P:%.*]], align 4
 270 ; CHECK-NEXT:    br label [[HEADER:%.*]]
 271 ; CHECK:       header:
 272 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[CND:%.*]]) [ "deopt"() ]
 273 ; CHECK-NEXT:    call void @hold(i32 [[V1_PRE]])
 274 ; CHECK-NEXT:    br label [[HEADER]]
 275 ;
 276 entry:
 277   br label %header
 278
 279 header:
 280   call void (i1, ...) @llvm.experimental.guard(i1 %cnd) ["deopt"()]
 281   %v1 = load i32, ptr %p
 282   call void @hold(i32 %v1)
 283   br label %header
 284 }