llvm/test/Transforms/SimplifyCFG/speculate-store.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt -passes=simplifycfg -simplifycfg-require-and-preserve-domtree=1 -S < %s | FileCheck %s
   3
   4 define void @ifconvertstore(ptr %A, i32 %B, i32 %C, i32 %D) {
   5 ; CHECK-LABEL: @ifconvertstore(
   6 ; CHECK-NEXT:  entry:
   7 ; CHECK-NEXT:    store i32 [[B:%.*]], ptr [[A:%.*]], align 4
   8 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[D:%.*]], 42
   9 ; CHECK-NEXT:    [[SPEC_STORE_SELECT:%.*]] = select i1 [[CMP]], i32 [[C:%.*]], i32 [[B]], !prof [[PROF0:![0-9]+]]
  10 ; CHECK-NEXT:    store i32 [[SPEC_STORE_SELECT]], ptr [[A]], align 4
  11 ; CHECK-NEXT:    ret void
  12 ;
  13 entry:
  14 ; First store to the location.
  15   store i32 %B, ptr %A
  16   %cmp = icmp sgt i32 %D, 42
  17   br i1 %cmp, label %if.then, label %ret.end, !prof !0
  18
  19 ; Make sure we speculate stores like the following one. It is cheap compared to
  20 ; a mispredicated branch.
  21 if.then:
  22   store i32 %C, ptr %A
  23   br label %ret.end
  24
  25 ret.end:
  26   ret void
  27 }
  28
  29 ; Store to a different location.
  30
  31 define void @noifconvertstore1(ptr %A1, ptr %A2, i32 %B, i32 %C, i32 %D) {
  32 ; CHECK-LABEL: @noifconvertstore1(
  33 ; CHECK-NEXT:  entry:
  34 ; CHECK-NEXT:    store i32 [[B:%.*]], ptr [[A1:%.*]], align 4
  35 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[D:%.*]], 42
  36 ; CHECK-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[RET_END:%.*]]
  37 ; CHECK:       if.then:
  38 ; CHECK-NEXT:    store i32 [[C:%.*]], ptr [[A2:%.*]], align 4
  39 ; CHECK-NEXT:    br label [[RET_END]]
  40 ; CHECK:       ret.end:
  41 ; CHECK-NEXT:    ret void
  42 ;
  43 entry:
  44   store i32 %B, ptr %A1
  45   %cmp = icmp sgt i32 %D, 42
  46   br i1 %cmp, label %if.then, label %ret.end
  47
  48 if.then:
  49   store i32 %C, ptr %A2
  50   br label %ret.end
  51
  52 ret.end:
  53   ret void
  54 }
  55
  56 ; This function could store to our address, so we can't repeat the first store a second time.
  57 declare void @unknown_fun()
  58
  59 define void @noifconvertstore2(ptr %A, i32 %B, i32 %C, i32 %D) {
  60 ; CHECK-LABEL: @noifconvertstore2(
  61 ; CHECK-NEXT:  entry:
  62 ; CHECK-NEXT:    store i32 [[B:%.*]], ptr [[A:%.*]], align 4
  63 ; CHECK-NEXT:    call void @unknown_fun()
  64 ; CHECK-NEXT:    [[CMP6:%.*]] = icmp sgt i32 [[D:%.*]], 42
  65 ; CHECK-NEXT:    br i1 [[CMP6]], label [[IF_THEN:%.*]], label [[RET_END:%.*]]
  66 ; CHECK:       if.then:
  67 ; CHECK-NEXT:    store i32 [[C:%.*]], ptr [[A]], align 4
  68 ; CHECK-NEXT:    br label [[RET_END]]
  69 ; CHECK:       ret.end:
  70 ; CHECK-NEXT:    ret void
  71 ;
  72 entry:
  73 ; First store to the location.
  74   store i32 %B, ptr %A
  75   call void @unknown_fun()
  76   %cmp6 = icmp sgt i32 %D, 42
  77   br i1 %cmp6, label %if.then, label %ret.end
  78
  79 if.then:
  80   store i32 %C, ptr %A
  81   br label %ret.end
  82
  83 ret.end:
  84   ret void
  85 }
  86
  87 ; Make sure we don't speculate volatile stores.
  88
  89 define void @noifconvertstore_volatile(ptr %A, i32 %B, i32 %C, i32 %D) {
  90 ; CHECK-LABEL: @noifconvertstore_volatile(
  91 ; CHECK-NEXT:  entry:
  92 ; CHECK-NEXT:    store i32 [[B:%.*]], ptr [[A:%.*]], align 4
  93 ; CHECK-NEXT:    [[CMP6:%.*]] = icmp sgt i32 [[D:%.*]], 42
  94 ; CHECK-NEXT:    br i1 [[CMP6]], label [[IF_THEN:%.*]], label [[RET_END:%.*]]
  95 ; CHECK:       if.then:
  96 ; CHECK-NEXT:    store volatile i32 [[C:%.*]], ptr [[A]], align 4
  97 ; CHECK-NEXT:    br label [[RET_END]]
  98 ; CHECK:       ret.end:
  99 ; CHECK-NEXT:    ret void
 100 ;
 101 entry:
 102 ; First store to the location.
 103   store i32 %B, ptr %A
 104   %cmp6 = icmp sgt i32 %D, 42
 105   br i1 %cmp6, label %if.then, label %ret.end
 106
 107 if.then:
 108   store volatile i32 %C, ptr %A
 109   br label %ret.end
 110
 111 ret.end:
 112   ret void
 113 }
 114
 115
 116 ;; Speculate a store, preceded by a local, non-escaping load
 117 define i32 @load_before_store_noescape(i64 %i, i32 %b)  {
 118 ; CHECK-LABEL: @load_before_store_noescape(
 119 ; CHECK-NEXT:  entry:
 120 ; CHECK-NEXT:    [[A:%.*]] = alloca [2 x i32], align 8
 121 ; CHECK-NEXT:    store i64 4294967296, ptr [[A]], align 8
 122 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [2 x i32], ptr [[A]], i64 0, i64 [[I:%.*]]
 123 ; CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
 124 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP0]], [[B:%.*]]
 125 ; CHECK-NEXT:    [[SPEC_STORE_SELECT:%.*]] = select i1 [[CMP]], i32 [[B]], i32 [[TMP0]]
 126 ; CHECK-NEXT:    store i32 [[SPEC_STORE_SELECT]], ptr [[ARRAYIDX]], align 4
 127 ; CHECK-NEXT:    [[TMP1:%.*]] = load i32, ptr [[A]], align 4
 128 ; CHECK-NEXT:    [[ARRAYIDX2:%.*]] = getelementptr inbounds [2 x i32], ptr [[A]], i64 0, i64 1
 129 ; CHECK-NEXT:    [[TMP2:%.*]] = load i32, ptr [[ARRAYIDX2]], align 4
 130 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[TMP1]], [[TMP2]]
 131 ; CHECK-NEXT:    ret i32 [[ADD]]
 132 ;
 133 entry:
 134   %a = alloca [2 x i32], align 8
 135   store i64 4294967296, ptr %a, align 8
 136   %arrayidx = getelementptr inbounds [2 x i32], ptr %a, i64 0, i64 %i
 137   %0 = load i32, ptr %arrayidx, align 4
 138   %cmp = icmp slt i32 %0, %b
 139   br i1 %cmp, label %if.then, label %if.end
 140
 141 if.then:
 142   store i32 %b, ptr %arrayidx, align 4
 143   br label %if.end
 144
 145 if.end:
 146   %1 = load i32, ptr %a, align 4
 147   %arrayidx2 = getelementptr inbounds [2 x i32], ptr %a, i64 0, i64 1
 148   %2 = load i32, ptr %arrayidx2, align 4
 149   %add = add nsw i32 %1, %2
 150   ret i32 %add
 151 }
 152
 153 ;; Don't speculate a store, preceded by a local, escaping load
 154 define i32 @load_before_store_escape(i64 %i, i32 %b)  {
 155 ; CHECK-LABEL: @load_before_store_escape(
 156 ; CHECK-NEXT:  entry:
 157 ; CHECK-NEXT:    [[A:%.*]] = alloca [2 x i32], align 8
 158 ; CHECK-NEXT:    store i64 4294967296, ptr [[A]], align 8
 159 ; CHECK-NEXT:    call void @fork_some_threads(ptr [[A]])
 160 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [2 x i32], ptr [[A]], i64 0, i64 [[I:%.*]]
 161 ; CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
 162 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP0]], [[B:%.*]]
 163 ; CHECK-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 164 ; CHECK:       if.then:
 165 ; CHECK-NEXT:    store i32 [[B]], ptr [[ARRAYIDX]], align 4
 166 ; CHECK-NEXT:    br label [[IF_END]]
 167 ; CHECK:       if.end:
 168 ; CHECK-NEXT:    [[TMP1:%.*]] = load i32, ptr [[A]], align 4
 169 ; CHECK-NEXT:    [[ARRAYIDX2:%.*]] = getelementptr inbounds [2 x i32], ptr [[A]], i64 0, i64 1
 170 ; CHECK-NEXT:    [[TMP2:%.*]] = load i32, ptr [[ARRAYIDX2]], align 4
 171 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[TMP1]], [[TMP2]]
 172 ; CHECK-NEXT:    call void @join_some_threads()
 173 ; CHECK-NEXT:    ret i32 [[ADD]]
 174 ;
 175 entry:
 176   %a = alloca [2 x i32], align 8
 177   store i64 4294967296, ptr %a, align 8
 178   call void @fork_some_threads(ptr %a)
 179   %arrayidx = getelementptr inbounds [2 x i32], ptr %a, i64 0, i64 %i
 180   %0 = load i32, ptr %arrayidx, align 4
 181   %cmp = icmp slt i32 %0, %b
 182   br i1 %cmp, label %if.then, label %if.end
 183
 184 if.then:
 185   store i32 %b, ptr %arrayidx, align 4
 186   br label %if.end
 187
 188 if.end:
 189   %1 = load i32, ptr %a, align 4
 190   %arrayidx2 = getelementptr inbounds [2 x i32], ptr %a, i64 0, i64 1
 191   %2 = load i32, ptr %arrayidx2, align 4
 192   %add = add nsw i32 %1, %2
 193   call void @join_some_threads()
 194   ret i32 %add
 195 }
 196
 197 declare void @fork_some_threads(ptr);
 198 declare void @join_some_threads();
 199
 200 ; Don't speculate if it's not the only instruction in the block (not counting
 201 ; the terminator)
 202 define i32 @not_alone_in_block(i64 %i, i32 %b)  {
 203 ; CHECK-LABEL: @not_alone_in_block(
 204 ; CHECK-NEXT:  entry:
 205 ; CHECK-NEXT:    [[A:%.*]] = alloca [2 x i32], align 8
 206 ; CHECK-NEXT:    store i64 4294967296, ptr [[A]], align 8
 207 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [2 x i32], ptr [[A]], i64 0, i64 [[I:%.*]]
 208 ; CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
 209 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP0]], [[B:%.*]]
 210 ; CHECK-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 211 ; CHECK:       if.then:
 212 ; CHECK-NEXT:    store i32 [[B]], ptr [[ARRAYIDX]], align 4
 213 ; CHECK-NEXT:    store i32 [[B]], ptr [[A]], align 4
 214 ; CHECK-NEXT:    br label [[IF_END]]
 215 ; CHECK:       if.end:
 216 ; CHECK-NEXT:    [[TMP1:%.*]] = load i32, ptr [[A]], align 4
 217 ; CHECK-NEXT:    [[ARRAYIDX2:%.*]] = getelementptr inbounds [2 x i32], ptr [[A]], i64 0, i64 1
 218 ; CHECK-NEXT:    [[TMP2:%.*]] = load i32, ptr [[ARRAYIDX2]], align 4
 219 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[TMP1]], [[TMP2]]
 220 ; CHECK-NEXT:    ret i32 [[ADD]]
 221 ;
 222 entry:
 223   %a = alloca [2 x i32], align 8
 224   store i64 4294967296, ptr %a, align 8
 225   %arrayidx = getelementptr inbounds [2 x i32], ptr %a, i64 0, i64 %i
 226   %0 = load i32, ptr %arrayidx, align 4
 227   %cmp = icmp slt i32 %0, %b
 228   br i1 %cmp, label %if.then, label %if.end
 229
 230 if.then:
 231   store i32 %b, ptr %arrayidx, align 4
 232   store i32 %b, ptr %a, align 4
 233   br label %if.end
 234
 235 if.end:
 236   %1 = load i32, ptr %a, align 4
 237   %arrayidx2 = getelementptr inbounds [2 x i32], ptr %a, i64 0, i64 1
 238   %2 = load i32, ptr %arrayidx2, align 4
 239   %add = add nsw i32 %1, %2
 240   ret i32 %add
 241 }
 242
 243 define void @wrong_align_store(ptr %A, i32 %B, i32 %C, i32 %D) {
 244 ; CHECK-LABEL: @wrong_align_store(
 245 ; CHECK-NEXT:  entry:
 246 ; CHECK-NEXT:    store i32 [[B:%.*]], ptr [[A:%.*]], align 4
 247 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[D:%.*]], 42
 248 ; CHECK-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[RET_END:%.*]]
 249 ; CHECK:       if.then:
 250 ; CHECK-NEXT:    store i32 [[C:%.*]], ptr [[A]], align 8
 251 ; CHECK-NEXT:    br label [[RET_END]]
 252 ; CHECK:       ret.end:
 253 ; CHECK-NEXT:    ret void
 254 ;
 255 entry:
 256   store i32 %B, ptr %A, align 4
 257   %cmp = icmp sgt i32 %D, 42
 258   br i1 %cmp, label %if.then, label %ret.end
 259
 260 if.then:
 261   store i32 %C, ptr %A, align 8
 262   br label %ret.end
 263
 264 ret.end:
 265   ret void
 266 }
 267
 268 define void @wrong_align_load(i32 %C, i32 %D) {
 269 ; CHECK-LABEL: @wrong_align_load(
 270 ; CHECK-NEXT:  entry:
 271 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 272 ; CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[A]], align 4
 273 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[D:%.*]], 42
 274 ; CHECK-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[RET_END:%.*]]
 275 ; CHECK:       if.then:
 276 ; CHECK-NEXT:    store i32 [[C:%.*]], ptr [[A]], align 8
 277 ; CHECK-NEXT:    br label [[RET_END]]
 278 ; CHECK:       ret.end:
 279 ; CHECK-NEXT:    ret void
 280 ;
 281 entry:
 282   %A = alloca i32, align 4
 283   load i32, ptr %A, align 4
 284   %cmp = icmp sgt i32 %D, 42
 285   br i1 %cmp, label %if.then, label %ret.end
 286
 287 if.then:
 288   store i32 %C, ptr %A, align 8
 289   br label %ret.end
 290
 291 ret.end:
 292   ret void
 293 }
 294
 295 ; CHECK: !0 = !{!"branch_weights", i32 3, i32 5}
 296 !0 = !{!"branch_weights", i32 3, i32 5}
 297