llvm/test/Transforms/DeadStoreElimination/multiblock-loops.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
   3
   4 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
   5 declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) nounwind
   6
   7 define void @test13(i32* noalias %P) {
   8 ; CHECK-LABEL: @test13(
   9 ; CHECK-NEXT:  entry:
  10 ; CHECK-NEXT:    br label [[FOR:%.*]]
  11 ; CHECK:       for:
  12 ; CHECK-NEXT:    store i32 0, i32* [[P:%.*]], align 4
  13 ; CHECK-NEXT:    br i1 false, label [[FOR]], label [[END:%.*]]
  14 ; CHECK:       end:
  15 ; CHECK-NEXT:    ret void
  16 ;
  17 entry:
  18   br label %for
  19 for:
  20   store i32 0, i32* %P
  21   br i1 false, label %for, label %end
  22 end:
  23   ret void
  24 }
  25
  26
  27 define void @test14(i32* noalias %P) {
  28 ; CHECK-LABEL: @test14(
  29 ; CHECK-NEXT:  entry:
  30 ; CHECK-NEXT:    br label [[FOR:%.*]]
  31 ; CHECK:       for:
  32 ; CHECK-NEXT:    store i32 0, i32* [[P:%.*]], align 4
  33 ; CHECK-NEXT:    br i1 false, label [[FOR]], label [[END:%.*]]
  34 ; CHECK:       end:
  35 ; CHECK-NEXT:    ret void
  36 ;
  37 entry:
  38   store i32 1, i32* %P
  39   br label %for
  40 for:
  41   store i32 0, i32* %P
  42   br i1 false, label %for, label %end
  43 end:
  44   ret void
  45 }
  46
  47 define void @test18(i32* noalias %P) {
  48 ; CHECK-LABEL: @test18(
  49 ; CHECK-NEXT:  entry:
  50 ; CHECK-NEXT:    [[P2:%.*]] = bitcast i32* [[P:%.*]] to i8*
  51 ; CHECK-NEXT:    store i32 0, i32* [[P]], align 4
  52 ; CHECK-NEXT:    br label [[FOR:%.*]]
  53 ; CHECK:       for:
  54 ; CHECK-NEXT:    store i8 1, i8* [[P2]], align 1
  55 ; CHECK-NEXT:    [[X:%.*]] = load i32, i32* [[P]], align 4
  56 ; CHECK-NEXT:    store i8 2, i8* [[P2]], align 1
  57 ; CHECK-NEXT:    br i1 false, label [[FOR]], label [[END:%.*]]
  58 ; CHECK:       end:
  59 ; CHECK-NEXT:    ret void
  60 ;
  61 entry:
  62   %P2 = bitcast i32* %P to i8*
  63   store i32 0, i32* %P
  64   br label %for
  65 for:
  66   store i8 1, i8* %P2
  67   %x = load i32, i32* %P
  68   store i8 2, i8* %P2
  69   br i1 false, label %for, label %end
  70 end:
  71   ret void
  72 }
  73
  74 define void @test21(i32* noalias %P) {
  75 ; CHECK-LABEL: @test21(
  76 ; CHECK-NEXT:  entry:
  77 ; CHECK-NEXT:    [[ARRAYIDX0:%.*]] = getelementptr inbounds i32, i32* [[P:%.*]], i64 1
  78 ; CHECK-NEXT:    [[P3:%.*]] = bitcast i32* [[ARRAYIDX0]] to i8*
  79 ; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[P3]], i64 4
  80 ; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* align 4 [[TMP0]], i8 0, i64 24, i1 false)
  81 ; CHECK-NEXT:    br label [[FOR:%.*]]
  82 ; CHECK:       for:
  83 ; CHECK-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr inbounds i32, i32* [[P]], i64 1
  84 ; CHECK-NEXT:    store i32 1, i32* [[ARRAYIDX1]], align 4
  85 ; CHECK-NEXT:    br i1 false, label [[FOR]], label [[END:%.*]]
  86 ; CHECK:       end:
  87 ; CHECK-NEXT:    ret void
  88 ;
  89 entry:
  90   %arrayidx0 = getelementptr inbounds i32, i32* %P, i64 1
  91   %p3 = bitcast i32* %arrayidx0 to i8*
  92   call void @llvm.memset.p0i8.i64(i8* %p3, i8 0, i64 28, i32 4, i1 false)
  93   br label %for
  94 for:
  95   %arrayidx1 = getelementptr inbounds i32, i32* %P, i64 1
  96   store i32 1, i32* %arrayidx1, align 4
  97   br i1 false, label %for, label %end
  98 end:
  99   ret void
 100 }
 101
 102 define void @test_loop(i32 %N, i32* noalias nocapture readonly %A, i32* noalias nocapture readonly %x, i32* noalias nocapture %b) local_unnamed_addr {
 103 ; CHECK-LABEL: @test_loop(
 104 ; CHECK-NEXT:  entry:
 105 ; CHECK-NEXT:    [[CMP27:%.*]] = icmp sgt i32 [[N:%.*]], 0
 106 ; CHECK-NEXT:    br i1 [[CMP27]], label [[FOR_BODY4_LR_PH_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]]
 107 ; CHECK:       for.body4.lr.ph.preheader:
 108 ; CHECK-NEXT:    br label [[FOR_BODY4_LR_PH:%.*]]
 109 ; CHECK:       for.cond.cleanup:
 110 ; CHECK-NEXT:    ret void
 111 ; CHECK:       for.body4.lr.ph:
 112 ; CHECK-NEXT:    [[I_028:%.*]] = phi i32 [ [[INC11:%.*]], [[FOR_COND_CLEANUP3:%.*]] ], [ 0, [[FOR_BODY4_LR_PH_PREHEADER]] ]
 113 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[B:%.*]], i32 [[I_028]]
 114 ; CHECK-NEXT:    [[MUL:%.*]] = mul nsw i32 [[I_028]], [[N]]
 115 ; CHECK-NEXT:    br label [[FOR_BODY4:%.*]]
 116 ; CHECK:       for.body4:
 117 ; CHECK-NEXT:    [[TMP0:%.*]] = phi i32 [ 0, [[FOR_BODY4_LR_PH]] ], [ [[ADD9:%.*]], [[FOR_BODY4]] ]
 118 ; CHECK-NEXT:    [[J_026:%.*]] = phi i32 [ 0, [[FOR_BODY4_LR_PH]] ], [ [[INC:%.*]], [[FOR_BODY4]] ]
 119 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[J_026]], [[MUL]]
 120 ; CHECK-NEXT:    [[ARRAYIDX5:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[ADD]]
 121 ; CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[ARRAYIDX5]], align 4
 122 ; CHECK-NEXT:    [[ARRAYIDX6:%.*]] = getelementptr inbounds i32, i32* [[X:%.*]], i32 [[J_026]]
 123 ; CHECK-NEXT:    [[TMP2:%.*]] = load i32, i32* [[ARRAYIDX6]], align 4
 124 ; CHECK-NEXT:    [[MUL7:%.*]] = mul nsw i32 [[TMP2]], [[TMP1]]
 125 ; CHECK-NEXT:    [[ADD9]] = add nsw i32 [[MUL7]], [[TMP0]]
 126 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[J_026]], 1
 127 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], [[N]]
 128 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP3]], label [[FOR_BODY4]]
 129 ; CHECK:       for.cond.cleanup3:
 130 ; CHECK-NEXT:    store i32 [[ADD9]], i32* [[ARRAYIDX]], align 4
 131 ; CHECK-NEXT:    [[INC11]] = add nuw nsw i32 [[I_028]], 1
 132 ; CHECK-NEXT:    [[EXITCOND29:%.*]] = icmp eq i32 [[INC11]], [[N]]
 133 ; CHECK-NEXT:    br i1 [[EXITCOND29]], label [[FOR_COND_CLEANUP]], label [[FOR_BODY4_LR_PH]]
 134 ;
 135 entry:
 136   %cmp27 = icmp sgt i32 %N, 0
 137   br i1 %cmp27, label %for.body4.lr.ph.preheader, label %for.cond.cleanup
 138
 139 for.body4.lr.ph.preheader:                        ; preds = %entry
 140   br label %for.body4.lr.ph
 141
 142 for.cond.cleanup:                                 ; preds = %for.cond.cleanup3, %entry
 143   ret void
 144
 145 for.body4.lr.ph:                                  ; preds = %for.body4.lr.ph.preheader, %for.cond.cleanup3
 146   %i.028 = phi i32 [ %inc11, %for.cond.cleanup3 ], [ 0, %for.body4.lr.ph.preheader ]
 147   %arrayidx = getelementptr inbounds i32, i32* %b, i32 %i.028
 148   store i32 0, i32* %arrayidx, align 4
 149   %mul = mul nsw i32 %i.028, %N
 150   br label %for.body4
 151
 152 for.body4:                                        ; preds = %for.body4, %for.body4.lr.ph
 153   %0 = phi i32 [ 0, %for.body4.lr.ph ], [ %add9, %for.body4 ]
 154   %j.026 = phi i32 [ 0, %for.body4.lr.ph ], [ %inc, %for.body4 ]
 155   %add = add nsw i32 %j.026, %mul
 156   %arrayidx5 = getelementptr inbounds i32, i32* %A, i32 %add
 157   %1 = load i32, i32* %arrayidx5, align 4
 158   %arrayidx6 = getelementptr inbounds i32, i32* %x, i32 %j.026
 159   %2 = load i32, i32* %arrayidx6, align 4
 160   %mul7 = mul nsw i32 %2, %1
 161   %add9 = add nsw i32 %mul7, %0
 162   %inc = add nuw nsw i32 %j.026, 1
 163   %exitcond = icmp eq i32 %inc, %N
 164   br i1 %exitcond, label %for.cond.cleanup3, label %for.body4
 165
 166 for.cond.cleanup3:                                ; preds = %for.body4
 167   store i32 %add9, i32* %arrayidx, align 4
 168   %inc11 = add nuw nsw i32 %i.028, 1
 169   %exitcond29 = icmp eq i32 %inc11, %N
 170   br i1 %exitcond29, label %for.cond.cleanup, label %for.body4.lr.ph
 171 }
 172
 173 define i32 @test_if(i1 %c, i32* %p, i32 %i) {
 174 ; CHECK-LABEL: @test_if(
 175 ; CHECK-NEXT:  entry:
 176 ; CHECK-NEXT:    br label [[BB1:%.*]]
 177 ; CHECK:       bb1:
 178 ; CHECK-NEXT:    [[PH:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[BB3:%.*]] ]
 179 ; CHECK-NEXT:    [[INC]] = add i32 [[PH]], 1
 180 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds i32, i32* [[P:%.*]], i32 [[PH]]
 181 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB2:%.*]], label [[BB3]]
 182 ; CHECK:       bb2:
 183 ; CHECK-NEXT:    br label [[BB3]]
 184 ; CHECK:       bb3:
 185 ; CHECK-NEXT:    store i32 2, i32* [[GEP]], align 4
 186 ; CHECK-NEXT:    [[C1:%.*]] = icmp slt i32 [[PH]], 10
 187 ; CHECK-NEXT:    br i1 [[C1]], label [[BB1]], label [[EXIT:%.*]]
 188 ; CHECK:       exit:
 189 ; CHECK-NEXT:    ret i32 0
 190 ;
 191 entry:
 192   br label %bb1
 193 bb1:
 194   %ph = phi i32 [ 0, %entry ], [ %inc, %bb3 ]
 195   %inc = add i32 %ph, 1
 196   %gep = getelementptr inbounds i32, i32* %p, i32 %ph
 197   store i32 %i, i32* %gep, align 4
 198   br i1 %c, label %bb2, label %bb3
 199 bb2:
 200   br label %bb3
 201 bb3:
 202   store i32 2, i32* %gep, align 4
 203   %c1 = icmp slt i32 %ph, 10
 204   br i1 %c1, label %bb1, label %exit
 205 exit:
 206   ret i32 0
 207 }
 208
 209 define i32 @test_if2(i1 %c, i32* %p, i32 %i) {
 210 ; CHECK-LABEL: @test_if2(
 211 ; CHECK-NEXT:  entry:
 212 ; CHECK-NEXT:    br label [[BB1:%.*]]
 213 ; CHECK:       bb1:
 214 ; CHECK-NEXT:    [[PH:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[BB2:%.*]] ], [ [[INC]], [[BB3:%.*]] ]
 215 ; CHECK-NEXT:    [[INC]] = add i32 [[PH]], 1
 216 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds i32, i32* [[P:%.*]], i32 [[PH]]
 217 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB2]], label [[BB3]]
 218 ; CHECK:       bb2:
 219 ; CHECK-NEXT:    store i32 2, i32* [[GEP]], align 4
 220 ; CHECK-NEXT:    [[C1:%.*]] = icmp slt i32 [[PH]], 10
 221 ; CHECK-NEXT:    br i1 [[C1]], label [[BB1]], label [[EXIT:%.*]]
 222 ; CHECK:       bb3:
 223 ; CHECK-NEXT:    store i32 3, i32* [[GEP]], align 4
 224 ; CHECK-NEXT:    [[C2:%.*]] = icmp slt i32 [[PH]], 5
 225 ; CHECK-NEXT:    br i1 [[C2]], label [[BB1]], label [[EXIT]]
 226 ; CHECK:       exit:
 227 ; CHECK-NEXT:    ret i32 0
 228 ;
 229 entry:
 230   br label %bb1
 231 bb1:
 232   %ph = phi i32 [ 0, %entry ], [ %inc, %bb2 ], [ %inc, %bb3 ]
 233   %inc = add i32 %ph, 1
 234   %gep = getelementptr inbounds i32, i32* %p, i32 %ph
 235   store i32 %i, i32* %gep, align 4
 236   br i1 %c, label %bb2, label %bb3
 237 bb2:
 238   store i32 2, i32* %gep, align 4
 239   %c1 = icmp slt i32 %ph, 10
 240   br i1 %c1, label %bb1, label %exit
 241 bb3:
 242   store i32 3, i32* %gep, align 4
 243   %c2 = icmp slt i32 %ph, 5
 244   br i1 %c2, label %bb1, label %exit
 245 exit:
 246   ret i32 0
 247 }
 248
 249 define i32 @test_if3(i1 %c, i32* %p, i32 %i) {
 250 ; CHECK-LABEL: @test_if3(
 251 ; CHECK-NEXT:  entry:
 252 ; CHECK-NEXT:    br label [[BB1:%.*]]
 253 ; CHECK:       bb1:
 254 ; CHECK-NEXT:    [[PH:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[BB3:%.*]] ]
 255 ; CHECK-NEXT:    [[INC]] = add i32 [[PH]], 1
 256 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds i32, i32* [[P:%.*]], i32 [[PH]]
 257 ; CHECK-NEXT:    store i32 [[I:%.*]], i32* [[GEP]], align 4
 258 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB2:%.*]], label [[BB3]]
 259 ; CHECK:       bb2:
 260 ; CHECK-NEXT:    store i32 2, i32* [[GEP]], align 4
 261 ; CHECK-NEXT:    br label [[BB3]]
 262 ; CHECK:       bb3:
 263 ; CHECK-NEXT:    [[C1:%.*]] = icmp slt i32 [[PH]], 10
 264 ; CHECK-NEXT:    br i1 [[C1]], label [[BB1]], label [[EXIT:%.*]]
 265 ; CHECK:       exit:
 266 ; CHECK-NEXT:    ret i32 0
 267 ;
 268 entry:
 269   br label %bb1
 270 bb1:
 271   %ph = phi i32 [ 0, %entry ], [ %inc, %bb3 ]
 272   %inc = add i32 %ph, 1
 273   %gep = getelementptr inbounds i32, i32* %p, i32 %ph
 274   store i32 %i, i32* %gep, align 4
 275   br i1 %c, label %bb2, label %bb3
 276 bb2:
 277   store i32 2, i32* %gep, align 4
 278   br label %bb3
 279 bb3:
 280   %c1 = icmp slt i32 %ph, 10
 281   br i1 %c1, label %bb1, label %exit
 282 exit:
 283   ret i32 0
 284 }
 285
 286 define i32 @test_if4(i1 %c, i32* %p, i32 %i) {
 287 ; CHECK-LABEL: @test_if4(
 288 ; CHECK-NEXT:  entry:
 289 ; CHECK-NEXT:    br label [[BB1:%.*]]
 290 ; CHECK:       bb1:
 291 ; CHECK-NEXT:    [[PH:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[BB1]] ], [ [[INC]], [[BB2:%.*]] ]
 292 ; CHECK-NEXT:    [[INC]] = add i32 [[PH]], 1
 293 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds i32, i32* [[P:%.*]], i32 [[PH]]
 294 ; CHECK-NEXT:    store i32 [[I:%.*]], i32* [[GEP]], align 4
 295 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB2]], label [[BB1]]
 296 ; CHECK:       bb2:
 297 ; CHECK-NEXT:    store i32 2, i32* [[GEP]], align 4
 298 ; CHECK-NEXT:    [[C1:%.*]] = icmp slt i32 [[PH]], 10
 299 ; CHECK-NEXT:    br i1 [[C1]], label [[BB1]], label [[EXIT:%.*]]
 300 ; CHECK:       exit:
 301 ; CHECK-NEXT:    ret i32 0
 302 ;
 303 entry:
 304   br label %bb1
 305 bb1:
 306   %ph = phi i32 [ 0, %entry ], [ %inc, %bb1 ], [ %inc, %bb2 ]
 307   %inc = add i32 %ph, 1
 308   %gep = getelementptr inbounds i32, i32* %p, i32 %ph
 309   store i32 %i, i32* %gep, align 4
 310   br i1 %c, label %bb2, label %bb1
 311 bb2:
 312   store i32 2, i32* %gep, align 4
 313   %c1 = icmp slt i32 %ph, 10
 314   br i1 %c1, label %bb1, label %exit
 315 exit:
 316   ret i32 0
 317 }
 318
 319 declare void @clobber()
 320 define i32 @test_self(i1 %c, i32* %p, i32 %i) {
 321 ; CHECK-LABEL: @test_self(
 322 ; CHECK-NEXT:  entry:
 323 ; CHECK-NEXT:    br label [[BB1:%.*]]
 324 ; CHECK:       bb1:
 325 ; CHECK-NEXT:    [[PH:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[BB1]] ], [ [[INC]], [[BB2:%.*]] ]
 326 ; CHECK-NEXT:    [[INC]] = add i32 [[PH]], 1
 327 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds i32, i32* [[P:%.*]], i32 [[PH]]
 328 ; CHECK-NEXT:    store i32 1, i32* [[GEP]], align 4
 329 ; CHECK-NEXT:    call void @clobber()
 330 ; CHECK-NEXT:    store i32 2, i32* [[GEP]], align 4
 331 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB2]], label [[BB1]]
 332 ; CHECK:       bb2:
 333 ; CHECK-NEXT:    store i32 3, i32* [[GEP]], align 4
 334 ; CHECK-NEXT:    [[C1:%.*]] = icmp slt i32 [[PH]], 10
 335 ; CHECK-NEXT:    br i1 [[C1]], label [[BB1]], label [[EXIT:%.*]]
 336 ; CHECK:       exit:
 337 ; CHECK-NEXT:    ret i32 0
 338 ;
 339 entry:
 340   br label %bb1
 341 bb1:
 342   %ph = phi i32 [ 0, %entry ], [ %inc, %bb1 ], [ %inc, %bb2 ]
 343   %inc = add i32 %ph, 1
 344   %gep = getelementptr inbounds i32, i32* %p, i32 %ph
 345   store i32 1, i32* %gep, align 4
 346   call void @clobber()
 347   store i32 2, i32* %gep, align 4
 348   br i1 %c, label %bb2, label %bb1
 349 bb2:
 350   store i32 3, i32* %gep, align 4
 351   %c1 = icmp slt i32 %ph, 10
 352   br i1 %c1, label %bb1, label %exit
 353 exit:
 354   ret i32 0
 355 }
 356
 357 define i32 @test_selfalloca(i1 %c, i32 %i) {
 358 ; CHECK-LABEL: @test_selfalloca(
 359 ; CHECK-NEXT:  entry:
 360 ; CHECK-NEXT:    [[P:%.*]] = alloca i32, align 4
 361 ; CHECK-NEXT:    br label [[BB1:%.*]]
 362 ; CHECK:       bb1:
 363 ; CHECK-NEXT:    [[PH:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[BB1]] ], [ [[INC]], [[BB2:%.*]] ]
 364 ; CHECK-NEXT:    [[INC]] = add i32 [[PH]], 1
 365 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds i32, i32* [[P]], i32 [[PH]]
 366 ; CHECK-NEXT:    call void @clobber()
 367 ; CHECK-NEXT:    store i32 2, i32* [[GEP]], align 4
 368 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB2]], label [[BB1]]
 369 ; CHECK:       bb2:
 370 ; CHECK-NEXT:    store i32 3, i32* [[GEP]], align 4
 371 ; CHECK-NEXT:    [[C1:%.*]] = icmp slt i32 [[PH]], 10
 372 ; CHECK-NEXT:    br i1 [[C1]], label [[BB1]], label [[EXIT:%.*]]
 373 ; CHECK:       exit:
 374 ; CHECK-NEXT:    [[PG:%.*]] = getelementptr inbounds i32, i32* [[P]], i32 [[I:%.*]]
 375 ; CHECK-NEXT:    [[L:%.*]] = load i32, i32* [[PG]], align 4
 376 ; CHECK-NEXT:    ret i32 [[L]]
 377 ;
 378 entry:
 379   %p = alloca i32, align 4
 380   br label %bb1
 381 bb1:
 382   %ph = phi i32 [ 0, %entry ], [ %inc, %bb1 ], [ %inc, %bb2 ]
 383   %inc = add i32 %ph, 1
 384   %gep = getelementptr inbounds i32, i32* %p, i32 %ph
 385   store i32 1, i32* %gep, align 4
 386   call void @clobber()
 387   store i32 2, i32* %gep, align 4
 388   br i1 %c, label %bb2, label %bb1
 389 bb2:
 390   store i32 3, i32* %gep, align 4
 391   %c1 = icmp slt i32 %ph, 10
 392   br i1 %c1, label %bb1, label %exit
 393 exit:
 394   %pg = getelementptr inbounds i32, i32* %p, i32 %i
 395   %l = load i32, i32* %pg
 396   ret i32 %l
 397 }
 398
 399 declare i1 @cond() readnone
 400
 401 ; TODO: We can eliminate the store in for.header, but we currently hit a MemoryPhi.
 402 define void @loop_multiple_def_uses(i32* noalias %P) {
 403 ; CHECK-LABEL: @loop_multiple_def_uses(
 404 ; CHECK-NEXT:  entry:
 405 ; CHECK-NEXT:    br label [[FOR_HEADER:%.*]]
 406 ; CHECK:       for.header:
 407 ; CHECK-NEXT:    store i32 1, i32* [[P:%.*]], align 4
 408 ; CHECK-NEXT:    [[C1:%.*]] = call i1 @cond()
 409 ; CHECK-NEXT:    br i1 [[C1]], label [[FOR_BODY:%.*]], label [[END:%.*]]
 410 ; CHECK:       for.body:
 411 ; CHECK-NEXT:    store i32 2, i32* [[P]], align 4
 412 ; CHECK-NEXT:    [[LV:%.*]] = load i32, i32* [[P]], align 4
 413 ; CHECK-NEXT:    br label [[FOR_HEADER]]
 414 ; CHECK:       end:
 415 ; CHECK-NEXT:    store i32 3, i32* [[P]], align 4
 416 ; CHECK-NEXT:    ret void
 417 ;
 418 entry:
 419   br label %for.header
 420
 421 for.header:
 422   store i32 1, i32* %P, align 4
 423   %c1 = call i1 @cond()
 424   br i1 %c1, label %for.body, label %end
 425
 426 for.body:
 427   store i32 2, i32* %P, align 4
 428   %lv = load i32, i32* %P
 429   br label %for.header
 430
 431 end:
 432   store i32 3, i32* %P, align 4
 433   ret void
 434 }
 435
 436 ; We cannot eliminate the store in for.header, as it is only partially
 437 ; overwritten in for.body and read afterwards.
 438 define void @loop_multiple_def_uses_partial_write(i32* noalias %p) {
 439 ; CHECK-LABEL: @loop_multiple_def_uses_partial_write(
 440 ; CHECK-NEXT:  entry:
 441 ; CHECK-NEXT:    br label [[FOR_HEADER:%.*]]
 442 ; CHECK:       for.header:
 443 ; CHECK-NEXT:    store i32 1239491, i32* [[P:%.*]], align 4
 444 ; CHECK-NEXT:    [[C1:%.*]] = call i1 @cond()
 445 ; CHECK-NEXT:    br i1 [[C1]], label [[FOR_BODY:%.*]], label [[END:%.*]]
 446 ; CHECK:       for.body:
 447 ; CHECK-NEXT:    [[C:%.*]] = bitcast i32* [[P]] to i8*
 448 ; CHECK-NEXT:    store i8 1, i8* [[C]], align 4
 449 ; CHECK-NEXT:    [[LV:%.*]] = load i32, i32* [[P]], align 4
 450 ; CHECK-NEXT:    br label [[FOR_HEADER]]
 451 ; CHECK:       end:
 452 ; CHECK-NEXT:    store i32 3, i32* [[P]], align 4
 453 ; CHECK-NEXT:    ret void
 454 ;
 455 entry:
 456   br label %for.header
 457
 458 for.header:
 459   store i32 1239491, i32* %p, align 4
 460   %c1 = call i1 @cond()
 461   br i1 %c1, label %for.body, label %end
 462
 463 for.body:
 464   %c = bitcast i32* %p to i8*
 465   store i8 1, i8* %c, align 4
 466   %lv = load i32, i32* %p
 467   br label %for.header
 468
 469 end:
 470   store i32 3, i32* %p, align 4
 471   ret void
 472 }
 473
 474 ; We cannot eliminate the store in for.header, as the location is not overwritten
 475 ; in for.body and read afterwards.
 476 define void @loop_multiple_def_uses_mayalias_write(i32* %p, i32* %q) {
 477 ; CHECK-LABEL: @loop_multiple_def_uses_mayalias_write(
 478 ; CHECK-NEXT:  entry:
 479 ; CHECK-NEXT:    br label [[FOR_HEADER:%.*]]
 480 ; CHECK:       for.header:
 481 ; CHECK-NEXT:    store i32 1239491, i32* [[P:%.*]], align 4
 482 ; CHECK-NEXT:    [[C1:%.*]] = call i1 @cond()
 483 ; CHECK-NEXT:    br i1 [[C1]], label [[FOR_BODY:%.*]], label [[END:%.*]]
 484 ; CHECK:       for.body:
 485 ; CHECK-NEXT:    store i32 1, i32* [[Q:%.*]], align 4
 486 ; CHECK-NEXT:    [[LV:%.*]] = load i32, i32* [[P]], align 4
 487 ; CHECK-NEXT:    br label [[FOR_HEADER]]
 488 ; CHECK:       end:
 489 ; CHECK-NEXT:    store i32 3, i32* [[P]], align 4
 490 ; CHECK-NEXT:    ret void
 491 ;
 492 entry:
 493   br label %for.header
 494
 495 for.header:
 496   store i32 1239491, i32* %p, align 4
 497   %c1 = call i1 @cond()
 498   br i1 %c1, label %for.body, label %end
 499
 500 for.body:
 501   store i32 1, i32* %q, align 4
 502   %lv = load i32, i32* %p
 503   br label %for.header
 504
 505 end:
 506   store i32 3, i32* %p, align 4
 507   ret void
 508 }
 509
 510 %struct.hoge = type { i32, i32 }
 511
 512 @global = external local_unnamed_addr global %struct.hoge*, align 8
 513
 514 define void @widget(i8* %tmp) {
 515 ; CHECK-LABEL: @widget(
 516 ; CHECK-NEXT:  bb:
 517 ; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 [[TMP:%.*]], i8* nonnull align 16 undef, i64 64, i1 false)
 518 ; CHECK-NEXT:    br label [[BB1:%.*]]
 519 ; CHECK:       bb1:
 520 ; CHECK-NEXT:    [[TMP2:%.*]] = load %struct.hoge*, %struct.hoge** @global, align 8
 521 ; CHECK-NEXT:    [[TMP3:%.*]] = getelementptr inbounds [[STRUCT_HOGE:%.*]], %struct.hoge* [[TMP2]], i64 undef, i32 1
 522 ; CHECK-NEXT:    store i32 0, i32* [[TMP3]], align 4
 523 ; CHECK-NEXT:    [[TMP4:%.*]] = load %struct.hoge*, %struct.hoge** @global, align 8
 524 ; CHECK-NEXT:    [[TMP5:%.*]] = getelementptr inbounds [[STRUCT_HOGE]], %struct.hoge* [[TMP4]], i64 undef, i32 1
 525 ; CHECK-NEXT:    store i32 10, i32* [[TMP5]], align 4
 526 ; CHECK-NEXT:    br label [[BB1]]
 527 ;
 528 bb:
 529   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %tmp, i8* nonnull align 16 undef, i64 64, i1 false)
 530   br label %bb1
 531
 532 bb1:                                              ; preds = %bb1, %bb
 533   %tmp2 = load %struct.hoge*, %struct.hoge** @global, align 8
 534   %tmp3 = getelementptr inbounds %struct.hoge, %struct.hoge* %tmp2, i64 undef, i32 1
 535   store i32 0, i32* %tmp3, align 4
 536   %tmp4 = load %struct.hoge*, %struct.hoge** @global, align 8
 537   %tmp5 = getelementptr inbounds %struct.hoge, %struct.hoge* %tmp4, i64 undef, i32 1
 538   store i32 10, i32* %tmp5, align 4
 539   br label %bb1
 540 }
 541
 542 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i64, i1 immarg)
 543
 544 @x = global [10 x i16] zeroinitializer, align 1
 545
 546 ; Make sure we do not eliminate the store in %do.body, because it writes to
 547 ; multiple locations in the loop and the store in %if.end10 only stores to
 548 ; the last one.
 549 define i16 @test_loop_carried_dep() {
 550 ; CHECK-LABEL: @test_loop_carried_dep(
 551 ; CHECK-NEXT:  entry:
 552 ; CHECK-NEXT:    br label [[DO_BODY:%.*]]
 553 ; CHECK:       do.body:
 554 ; CHECK-NEXT:    [[I_0:%.*]] = phi i16 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[IF_END:%.*]] ]
 555 ; CHECK-NEXT:    [[ARRAYIDX2:%.*]] = getelementptr inbounds [10 x i16], [10 x i16]* @x, i16 0, i16 [[I_0]]
 556 ; CHECK-NEXT:    store i16 2, i16* [[ARRAYIDX2]], align 1
 557 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i16 [[I_0]], 4
 558 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[IF_END10:%.*]], label [[IF_END]]
 559 ; CHECK:       if.end:
 560 ; CHECK-NEXT:    [[INC]] = add nuw nsw i16 [[I_0]], 1
 561 ; CHECK-NEXT:    br label [[DO_BODY]]
 562 ; CHECK:       if.end10:
 563 ; CHECK-NEXT:    store i16 1, i16* [[ARRAYIDX2]], align 1
 564 ; CHECK-NEXT:    ret i16 0
 565 ;
 566 entry:
 567   br label %do.body
 568
 569 do.body:                                          ; preds = %if.end, %entry
 570   %i.0 = phi i16 [ 0, %entry ], [ %inc, %if.end ]
 571   %arrayidx2 = getelementptr inbounds [10 x i16], [10 x i16]* @x, i16 0, i16 %i.0
 572   store i16 2, i16* %arrayidx2, align 1
 573   %exitcond = icmp eq i16 %i.0, 4
 574   br i1 %exitcond, label %if.end10, label %if.end
 575
 576 if.end:                                           ; preds = %do.body
 577   %inc = add nuw nsw i16 %i.0, 1
 578   br label %do.body
 579
 580 if.end10:                                         ; preds = %do.body
 581   store i16 1, i16* %arrayidx2, align 1
 582   ret i16 0
 583 }
 584
 585 ; Similar to above, but with an irreducible loop. The stores should not be removed.
 586 define i16 @irreducible(i1 %c) {
 587 ; CHECK-LABEL: @irreducible(
 588 ; CHECK-NEXT:  entry:
 589 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[A:%.*]], label [[B:%.*]]
 590 ; CHECK:       A:
 591 ; CHECK-NEXT:    [[I_0:%.*]] = phi i16 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[B]] ]
 592 ; CHECK-NEXT:    [[ARRAYIDX2:%.*]] = getelementptr inbounds [10 x i16], [10 x i16]* @x, i16 0, i16 [[I_0]]
 593 ; CHECK-NEXT:    br label [[B]]
 594 ; CHECK:       B:
 595 ; CHECK-NEXT:    [[J_0:%.*]] = phi i16 [ 0, [[ENTRY]] ], [ [[I_0]], [[A]] ]
 596 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [10 x i16], [10 x i16]* @x, i16 0, i16 [[J_0]]
 597 ; CHECK-NEXT:    store i16 2, i16* [[ARRAYIDX]], align 1
 598 ; CHECK-NEXT:    [[INC]] = add nuw nsw i16 [[J_0]], 1
 599 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i16 [[J_0]], 4
 600 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[EXIT:%.*]], label [[A]]
 601 ; CHECK:       exit:
 602 ; CHECK-NEXT:    store i16 1, i16* [[ARRAYIDX]], align 1
 603 ; CHECK-NEXT:    ret i16 0
 604 ;
 605 entry:
 606   br i1 %c, label %A, label %B
 607
 608 A:
 609   %i.0 = phi i16 [ 0, %entry ], [ %inc, %B ]
 610   %arrayidx2 = getelementptr inbounds [10 x i16], [10 x i16]* @x, i16 0, i16 %i.0
 611   br label %B
 612
 613 B:
 614   %j.0 = phi i16 [ 0, %entry ], [ %i.0, %A ]
 615   %arrayidx = getelementptr inbounds [10 x i16], [10 x i16]* @x, i16 0, i16 %j.0
 616   store i16 2, i16* %arrayidx, align 1
 617   %inc = add nuw nsw i16 %j.0, 1
 618   %exitcond = icmp eq i16 %j.0, 4
 619   br i1 %exitcond, label %exit, label %A
 620
 621 exit:
 622   store i16 1, i16* %arrayidx, align 1
 623   ret i16 0
 624 }
 625
 626 ; An irreducible loop inside another loop.
 627 define i16 @irreducible_nested() {
 628 ; CHECK-LABEL: @irreducible_nested(
 629 ; CHECK-NEXT:  entry:
 630 ; CHECK-NEXT:    br label [[OUTER:%.*]]
 631 ; CHECK:       outer:
 632 ; CHECK-NEXT:    [[X:%.*]] = phi i16 [ 0, [[ENTRY:%.*]] ], [ [[INCX:%.*]], [[OUTERL:%.*]] ]
 633 ; CHECK-NEXT:    [[C:%.*]] = icmp sgt i16 [[X]], 2
 634 ; CHECK-NEXT:    br i1 [[C]], label [[A:%.*]], label [[B:%.*]]
 635 ; CHECK:       A:
 636 ; CHECK-NEXT:    [[I_0:%.*]] = phi i16 [ 0, [[OUTER]] ], [ [[INC:%.*]], [[B]] ]
 637 ; CHECK-NEXT:    [[ARRAYIDX2:%.*]] = getelementptr inbounds [10 x i16], [10 x i16]* @x, i16 0, i16 [[I_0]]
 638 ; CHECK-NEXT:    br label [[B]]
 639 ; CHECK:       B:
 640 ; CHECK-NEXT:    [[J_0:%.*]] = phi i16 [ 0, [[OUTER]] ], [ [[I_0]], [[A]] ]
 641 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [10 x i16], [10 x i16]* @x, i16 0, i16 [[J_0]]
 642 ; CHECK-NEXT:    store i16 2, i16* [[ARRAYIDX]], align 1
 643 ; CHECK-NEXT:    [[INC]] = add nuw nsw i16 [[J_0]], 1
 644 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i16 [[J_0]], 4
 645 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[OUTERL]], label [[A]]
 646 ; CHECK:       outerl:
 647 ; CHECK-NEXT:    store i16 1, i16* [[ARRAYIDX]], align 1
 648 ; CHECK-NEXT:    [[INCX]] = add nuw nsw i16 [[X]], 1
 649 ; CHECK-NEXT:    [[EXITCONDX:%.*]] = icmp eq i16 [[X]], 4
 650 ; CHECK-NEXT:    br i1 [[EXITCONDX]], label [[END:%.*]], label [[OUTER]]
 651 ; CHECK:       end:
 652 ; CHECK-NEXT:    ret i16 0
 653 ;
 654 entry:
 655   br label %outer
 656
 657 outer:
 658   %x = phi i16 [ 0, %entry ], [ %incx, %outerl ]
 659   %c = icmp sgt i16 %x, 2
 660   br i1 %c, label %A, label %B
 661
 662 A:
 663   %i.0 = phi i16 [ 0, %outer ], [ %inc, %B ]
 664   %arrayidx2 = getelementptr inbounds [10 x i16], [10 x i16]* @x, i16 0, i16 %i.0
 665   br label %B
 666
 667 B:
 668   %j.0 = phi i16 [ 0, %outer ], [ %i.0, %A ]
 669   %arrayidx = getelementptr inbounds [10 x i16], [10 x i16]* @x, i16 0, i16 %j.0
 670   store i16 2, i16* %arrayidx, align 1
 671   %inc = add nuw nsw i16 %j.0, 1
 672   %exitcond = icmp eq i16 %j.0, 4
 673   br i1 %exitcond, label %outerl, label %A
 674
 675 outerl:
 676   store i16 1, i16* %arrayidx, align 1
 677   %incx = add nuw nsw i16 %x, 1
 678   %exitcondx = icmp eq i16 %x, 4
 679   br i1 %exitcondx, label %end, label %outer
 680
 681 end:
 682   ret i16 0
 683 }
 684
 685 define i16 @multi_overwrite(i1 %cond) {
 686 ; CHECK-LABEL: @multi_overwrite(
 687 ; CHECK-NEXT:  entry:
 688 ; CHECK-NEXT:    br label [[DO_BODY:%.*]]
 689 ; CHECK:       do.body:
 690 ; CHECK-NEXT:    [[I_0:%.*]] = phi i16 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[IF_END2:%.*]] ]
 691 ; CHECK-NEXT:    [[ARRAYIDX2:%.*]] = getelementptr inbounds [10 x i16], [10 x i16]* @x, i16 0, i16 [[I_0]]
 692 ; CHECK-NEXT:    store i16 2, i16* [[ARRAYIDX2]], align 1
 693 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i16 [[I_0]], 4
 694 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[EXIT:%.*]], label [[IF_END:%.*]]
 695 ; CHECK:       if.end:
 696 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[DO_STORE:%.*]], label [[IF_END2]]
 697 ; CHECK:       do.store:
 698 ; CHECK-NEXT:    store i16 3, i16* [[ARRAYIDX2]], align 1
 699 ; CHECK-NEXT:    br label [[IF_END2]]
 700 ; CHECK:       if.end2:
 701 ; CHECK-NEXT:    [[INC]] = add nuw nsw i16 [[I_0]], 1
 702 ; CHECK-NEXT:    br label [[DO_BODY]]
 703 ; CHECK:       exit:
 704 ; CHECK-NEXT:    store i16 1, i16* [[ARRAYIDX2]], align 1
 705 ; CHECK-NEXT:    ret i16 0
 706 ;
 707 entry:
 708   br label %do.body
 709
 710 do.body:
 711   %i.0 = phi i16 [ 0, %entry ], [ %inc, %if.end2 ]
 712   %arrayidx2 = getelementptr inbounds [10 x i16], [10 x i16]* @x, i16 0, i16 %i.0
 713   store i16 2, i16* %arrayidx2, align 1
 714   %exitcond = icmp eq i16 %i.0, 4
 715   br i1 %exitcond, label %exit, label %if.end
 716
 717 if.end:
 718   br i1 %cond, label %do.store, label %if.end2
 719
 720 do.store:
 721   store i16 3, i16* %arrayidx2, align 1
 722   br label %if.end2
 723
 724 if.end2:
 725   %inc = add nuw nsw i16 %i.0, 1
 726   br label %do.body
 727
 728 exit:
 729   store i16 1, i16* %arrayidx2, align 1
 730   ret i16 0
 731 }
 732
 733 define void @test(i8* noalias %data1, i8* %data2, i16* %data3, i32 %i1)
 734 ; CHECK-LABEL: @test(
 735 ; CHECK-NEXT:    [[C:%.*]] = icmp eq i32 [[I1:%.*]], 0
 736 ; CHECK-NEXT:    br label [[PH0:%.*]]
 737 ; CHECK:       ph0:
 738 ; CHECK-NEXT:    br label [[HEADER0:%.*]]
 739 ; CHECK:       header0:
 740 ; CHECK-NEXT:    [[P1:%.*]] = phi i32 [ 0, [[PH0]] ], [ [[PN1:%.*]], [[END1:%.*]] ]
 741 ; CHECK-NEXT:    [[PN1]] = add i32 [[P1]], 1
 742 ; CHECK-NEXT:    [[PC1:%.*]] = icmp slt i32 [[PN1]], 5
 743 ; CHECK-NEXT:    [[V2:%.*]] = getelementptr [10 x i16], [10 x i16]* @x, i32 0, i32 [[P1]]
 744 ; CHECK-NEXT:    store i16 1, i16* [[V2]], align 2
 745 ; CHECK-NEXT:    br i1 [[C]], label [[THEN1:%.*]], label [[ELSE1:%.*]]
 746 ; CHECK:       then1:
 747 ; CHECK-NEXT:    store i16 2, i16* [[V2]], align 2
 748 ; CHECK-NEXT:    br label [[END1]]
 749 ; CHECK:       else1:
 750 ; CHECK-NEXT:    br label [[END1]]
 751 ; CHECK:       end1:
 752 ; CHECK-NEXT:    br i1 [[PC1]], label [[HEADER0]], label [[END0:%.*]]
 753 ; CHECK:       end0:
 754 ; CHECK-NEXT:    br label [[HEADER2:%.*]]
 755 ; CHECK:       header2:
 756 ; CHECK-NEXT:    [[P3:%.*]] = phi i32 [ 0, [[END0]] ], [ [[PN3:%.*]], [[HEADER2]] ]
 757 ; CHECK-NEXT:    [[PN3]] = add i32 [[P3]], 1
 758 ; CHECK-NEXT:    [[PC3:%.*]] = icmp slt i32 [[PN3]], 5
 759 ; CHECK-NEXT:    store i16 4, i16* [[V2]], align 2
 760 ; CHECK-NEXT:    br i1 [[PC3]], label [[HEADER2]], label [[END2:%.*]]
 761 ; CHECK:       end2:
 762 ; CHECK-NEXT:    ret void
 763 ;
 764 {
 765   %c = icmp eq i32 %i1, 0
 766   br label %ph0
 767 ph0:
 768   br label %header0
 769 header0:
 770   %p1 = phi i32 [0, %ph0], [%pn1, %end1]
 771   %pn1 = add i32 %p1, 1
 772   %pc1 = icmp slt i32 %pn1, 5
 773   %v2 = getelementptr [10 x i16], [10 x i16]* @x, i32 0, i32 %p1
 774   store i16 1, i16* %v2
 775   br i1 %c, label %then1, label %else1
 776 then1:
 777   store i16 2, i16* %v2
 778   br label %end1
 779 else1:
 780   br label %end1
 781 end1:
 782   br i1 %pc1, label %header0, label %end0
 783 end0:
 784   br label %header2
 785 header2:
 786   %p3 = phi i32 [0, %end0], [%pn3, %header2]
 787   %pn3 = add i32 %p3, 1
 788   %pc3 = icmp slt i32 %pn3, 5
 789   store i16 4, i16* %v2
 790   br i1 %pc3, label %header2, label %end2
 791 end2:
 792   ret void
 793 }
 794
 795 ; Similar to above, but with multiple partial overlaps
 796 define i16 @partial_override_fromloop(i1 %c, i32 %i) {
 797 ; CHECK-LABEL: @partial_override_fromloop(
 798 ; CHECK-NEXT:  entry:
 799 ; CHECK-NEXT:    br label [[DO_BODY:%.*]]
 800 ; CHECK:       do.body:
 801 ; CHECK-NEXT:    [[I_0:%.*]] = phi i16 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[IF_END2:%.*]] ]
 802 ; CHECK-NEXT:    [[ARRAYIDX2:%.*]] = getelementptr inbounds [10 x i16], [10 x i16]* @x, i16 0, i16 [[I_0]]
 803 ; CHECK-NEXT:    store i16 2, i16* [[ARRAYIDX2]], align 1
 804 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i16 [[I_0]], 4
 805 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[EXIT:%.*]], label [[IF_END:%.*]]
 806 ; CHECK:       if.end:
 807 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[DO_STORE:%.*]], label [[IF_END2]]
 808 ; CHECK:       do.store:
 809 ; CHECK-NEXT:    store i16 3, i16* [[ARRAYIDX2]], align 1
 810 ; CHECK-NEXT:    br label [[IF_END2]]
 811 ; CHECK:       if.end2:
 812 ; CHECK-NEXT:    [[INC]] = add nuw nsw i16 [[I_0]], 1
 813 ; CHECK-NEXT:    br label [[DO_BODY]]
 814 ; CHECK:       exit:
 815 ; CHECK-NEXT:    [[BC:%.*]] = bitcast i16* [[ARRAYIDX2]] to i8*
 816 ; CHECK-NEXT:    [[BC2:%.*]] = getelementptr inbounds i8, i8* [[BC]], i32 1
 817 ; CHECK-NEXT:    store i8 10, i8* [[BC]], align 1
 818 ; CHECK-NEXT:    store i8 11, i8* [[BC2]], align 1
 819 ; CHECK-NEXT:    ret i16 0
 820 ;
 821 entry:
 822   br label %do.body
 823
 824 do.body:
 825   %i.0 = phi i16 [ 0, %entry ], [ %inc, %if.end2 ]
 826   %arrayidx2 = getelementptr inbounds [10 x i16], [10 x i16]* @x, i16 0, i16 %i.0
 827   store i16 2, i16* %arrayidx2, align 1
 828   %exitcond = icmp eq i16 %i.0, 4
 829   br i1 %exitcond, label %exit, label %if.end
 830
 831 if.end:
 832   br i1 %c, label %do.store, label %if.end2
 833
 834 do.store:
 835   store i16 3, i16* %arrayidx2, align 1
 836   br label %if.end2
 837
 838 if.end2:
 839   %inc = add nuw nsw i16 %i.0, 1
 840   br label %do.body
 841
 842 exit:
 843   %bc = bitcast i16* %arrayidx2 to i8*
 844   %bc2 = getelementptr inbounds i8, i8* %bc, i32 1
 845   store i8 10, i8* %bc, align 1
 846   store i8 11, i8* %bc2, align 1
 847   ret i16 0
 848 }
 849
 850
 851 define i16 @partial_override_overloop(i1 %c, i32 %i) {
 852 ; CHECK-LABEL: @partial_override_overloop(
 853 ; CHECK-NEXT:  entry:
 854 ; CHECK-NEXT:    br label [[FIRST:%.*]]
 855 ; CHECK:       first:
 856 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [10 x i16], [10 x i16]* @x, i16 0, i32 [[I:%.*]]
 857 ; CHECK-NEXT:    store i16 1, i16* [[ARRAYIDX]], align 1
 858 ; CHECK-NEXT:    br label [[DO_BODY:%.*]]
 859 ; CHECK:       do.body:
 860 ; CHECK-NEXT:    [[I_0:%.*]] = phi i16 [ 0, [[FIRST]] ], [ [[INC:%.*]], [[DO_BODY]] ]
 861 ; CHECK-NEXT:    [[ARRAYIDX2:%.*]] = getelementptr inbounds [10 x i16], [10 x i16]* @x, i16 0, i16 [[I_0]]
 862 ; CHECK-NEXT:    store i16 2, i16* [[ARRAYIDX2]], align 1
 863 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i16 [[I_0]], 4
 864 ; CHECK-NEXT:    [[INC]] = add nuw nsw i16 [[I_0]], 1
 865 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[EXIT:%.*]], label [[DO_BODY]]
 866 ; CHECK:       exit:
 867 ; CHECK-NEXT:    [[BC:%.*]] = bitcast i16* [[ARRAYIDX]] to i8*
 868 ; CHECK-NEXT:    [[BC2:%.*]] = getelementptr inbounds i8, i8* [[BC]], i32 1
 869 ; CHECK-NEXT:    store i8 10, i8* [[BC]], align 1
 870 ; CHECK-NEXT:    store i8 11, i8* [[BC2]], align 1
 871 ; CHECK-NEXT:    ret i16 0
 872 ;
 873 entry:
 874   ; Branch to first so MemoryLoc is not in the entry block.
 875   br label %first
 876
 877 first:
 878   %arrayidx = getelementptr inbounds [10 x i16], [10 x i16]* @x, i16 0, i32 %i
 879   store i16 1, i16* %arrayidx, align 1
 880   br label %do.body
 881
 882 do.body:
 883   %i.0 = phi i16 [ 0, %first ], [ %inc, %do.body ]
 884   %arrayidx2 = getelementptr inbounds [10 x i16], [10 x i16]* @x, i16 0, i16 %i.0
 885   store i16 2, i16* %arrayidx2, align 1
 886   %exitcond = icmp eq i16 %i.0, 4
 887   %inc = add nuw nsw i16 %i.0, 1
 888   br i1 %exitcond, label %exit, label %do.body
 889
 890 exit:
 891   %bc = bitcast i16* %arrayidx to i8*
 892   %bc2 = getelementptr inbounds i8, i8* %bc, i32 1
 893   store i8 10, i8* %bc, align 1
 894   store i8 11, i8* %bc2, align 1
 895   ret i16 0
 896 }
 897
 898 define i16 @partial_override_multi(i1 %c, i32 %i) {
 899 ; CHECK-LABEL: @partial_override_multi(
 900 ; CHECK-NEXT:  entry:
 901 ; CHECK-NEXT:    br label [[DO_BODY:%.*]]
 902 ; CHECK:       do.body:
 903 ; CHECK-NEXT:    [[I_0:%.*]] = phi i16 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[DO_BODY]] ]
 904 ; CHECK-NEXT:    [[ARRAYIDX2:%.*]] = getelementptr inbounds [10 x i16], [10 x i16]* @x, i16 0, i16 [[I_0]]
 905 ; CHECK-NEXT:    store i16 10, i16* [[ARRAYIDX2]], align 1
 906 ; CHECK-NEXT:    [[BC:%.*]] = bitcast i16* [[ARRAYIDX2]] to i8*
 907 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i16 [[I_0]], 4
 908 ; CHECK-NEXT:    [[INC]] = add nuw nsw i16 [[I_0]], 1
 909 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[EXIT:%.*]], label [[DO_BODY]]
 910 ; CHECK:       exit:
 911 ; CHECK-NEXT:    [[BC2:%.*]] = getelementptr inbounds i8, i8* [[BC]], i32 1
 912 ; CHECK-NEXT:    store i8 11, i8* [[BC2]], align 1
 913 ; CHECK-NEXT:    ret i16 0
 914 ;
 915 entry:
 916   br label %do.body
 917
 918 do.body:
 919   %i.0 = phi i16 [ 0, %entry ], [ %inc, %do.body ]
 920   %arrayidx2 = getelementptr inbounds [10 x i16], [10 x i16]* @x, i16 0, i16 %i.0
 921   store i16 2, i16* %arrayidx2, align 1
 922   %bc = bitcast i16* %arrayidx2 to i8*
 923   store i8 10, i8* %bc, align 1
 924   %exitcond = icmp eq i16 %i.0, 4
 925   %inc = add nuw nsw i16 %i.0, 1
 926   br i1 %exitcond, label %exit, label %do.body
 927
 928 exit:
 929   %bc2 = getelementptr inbounds i8, i8* %bc, i32 1
 930   store i8 11, i8* %bc2, align 1
 931   ret i16 0
 932 }
 933
 934 define void @InitializeMasks(i64* %p) {
 935 ; CHECK-LABEL: @InitializeMasks(
 936 ; CHECK-NEXT:  entry:
 937 ; CHECK-NEXT:    br label [[FOR_BODY98:%.*]]
 938 ; CHECK:       for.body98:
 939 ; CHECK-NEXT:    [[INDVARS_IV377:%.*]] = phi i64 [ 8, [[ENTRY:%.*]] ], [ [[INC2:%.*]], [[FOR_INC140:%.*]] ], [ [[INC1:%.*]], [[FOR_INC140_THREAD:%.*]] ]
 940 ; CHECK-NEXT:    [[ARRAYIDX106:%.*]] = getelementptr inbounds i64, i64* [[P:%.*]], i64 [[INDVARS_IV377]]
 941 ; CHECK-NEXT:    store i64 1, i64* [[ARRAYIDX106]], align 8
 942 ; CHECK-NEXT:    [[CMP107:%.*]] = icmp ugt i64 [[INDVARS_IV377]], 15
 943 ; CHECK-NEXT:    br i1 [[CMP107]], label [[IF_END:%.*]], label [[IF_END_THREAD:%.*]]
 944 ; CHECK:       if.end.thread:
 945 ; CHECK-NEXT:    br label [[FOR_INC140_THREAD]]
 946 ; CHECK:       if.end:
 947 ; CHECK-NEXT:    store i64 2, i64* [[ARRAYIDX106]], align 8
 948 ; CHECK-NEXT:    [[CMP127:%.*]] = icmp ult i64 [[INDVARS_IV377]], 48
 949 ; CHECK-NEXT:    br i1 [[CMP127]], label [[FOR_INC140_THREAD]], label [[FOR_INC140]]
 950 ; CHECK:       for.inc140.thread:
 951 ; CHECK-NEXT:    [[INC1]] = add i64 [[INDVARS_IV377]], 1
 952 ; CHECK-NEXT:    br label [[FOR_BODY98]]
 953 ; CHECK:       for.inc140:
 954 ; CHECK-NEXT:    [[INC2]] = add i64 [[INDVARS_IV377]], 1
 955 ; CHECK-NEXT:    [[EXITCOND384_NOT:%.*]] = icmp eq i64 [[INDVARS_IV377]], 56
 956 ; CHECK-NEXT:    br i1 [[EXITCOND384_NOT]], label [[FOR_INC177:%.*]], label [[FOR_BODY98]]
 957 ; CHECK:       for.inc177:
 958 ; CHECK-NEXT:    ret void
 959 ;
 960 entry:
 961   br label %for.body98
 962
 963 for.body98:                                       ; preds = %for.inc140, %for.inc140.thread, %entry
 964   %indvars.iv377 = phi i64 [ 8, %entry ], [ %inc2, %for.inc140 ], [ %inc1, %for.inc140.thread ]
 965   %arrayidx106 = getelementptr inbounds i64, i64* %p, i64 %indvars.iv377
 966   store i64 1, i64* %arrayidx106, align 8
 967   %cmp107 = icmp ugt i64 %indvars.iv377, 15
 968   br i1 %cmp107, label %if.end, label %if.end.thread
 969
 970 if.end.thread:                                    ; preds = %for.body98
 971   br label %for.inc140.thread
 972
 973 if.end:                                           ; preds = %for.body98
 974   store i64 2, i64* %arrayidx106, align 8
 975   %cmp127 = icmp ult i64 %indvars.iv377, 48
 976   br i1 %cmp127, label %for.inc140.thread, label %for.inc140
 977
 978 for.inc140.thread:                                ; preds = %if.end, %if.end.thread
 979   %inc1 = add i64 %indvars.iv377, 1
 980   br label %for.body98
 981
 982 for.inc140:                                       ; preds = %if.end
 983   %inc2 = add i64 %indvars.iv377, 1
 984   %exitcond384.not = icmp eq i64 %indvars.iv377, 56
 985   br i1 %exitcond384.not, label %for.inc177, label %for.body98
 986
 987 for.inc177:                                       ; preds = %for.inc140
 988   ret void
 989 }