test/Analysis/LoopAccessAnalysis/stride-access-dependence.ll

   1 ; RUN: opt -loop-accesses -analyze < %s | FileCheck %s
   2 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
   3
   4 target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
   5
   6 ; Following cases are no dependence.
   7
   8 ; void nodep_Read_Write(int *A) {
   9 ;   int *B = A + 1;
  10 ;   for (unsigned i = 0; i < 1024; i+=3)
  11 ;     B[i] = A[i] + 1;
  12 ; }
  13
  14 ; CHECK: function 'nodep_Read_Write':
  15 ; CHECK-NEXT:   for.body:
  16 ; CHECK-NEXT:     Memory dependences are safe
  17 ; CHECK-NEXT:     Dependences:
  18 ; CHECK-NEXT:     Run-time memory checks:
  19
  20 define void @nodep_Read_Write(i32* nocapture %A) {
  21 entry:
  22   %add.ptr = getelementptr inbounds i32, i32* %A, i64 1
  23   br label %for.body
  24
  25 for.cond.cleanup:                                 ; preds = %for.body
  26   ret void
  27
  28 for.body:                                         ; preds = %entry, %for.body
  29   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
  30   %arrayidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
  31   %0 = load i32, i32* %arrayidx, align 4
  32   %add = add nsw i32 %0, 1
  33   %arrayidx2 = getelementptr inbounds i32, i32* %add.ptr, i64 %indvars.iv
  34   store i32 %add, i32* %arrayidx2, align 4
  35   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 3
  36   %cmp = icmp ult i64 %indvars.iv.next, 1024
  37   br i1 %cmp, label %for.body, label %for.cond.cleanup
  38 }
  39
  40 ; int nodep_Write_Read(int *A) {
  41 ;   int sum = 0;
  42 ;   for (unsigned i = 0; i < 1024; i+=4) {
  43 ;     A[i] = i;
  44 ;     sum += A[i+3];
  45 ;   }
  46 ;
  47 ;   return sum;
  48 ; }
  49
  50 ; CHECK: function 'nodep_Write_Read':
  51 ; CHECK-NEXT:   for.body:
  52 ; CHECK-NEXT:     Memory dependences are safe
  53 ; CHECK-NEXT:     Dependences:
  54 ; CHECK-NEXT:     Run-time memory checks:
  55
  56 define i32 @nodep_Write_Read(i32* nocapture %A) {
  57 entry:
  58   br label %for.body
  59
  60 for.cond.cleanup:                                 ; preds = %for.body
  61   ret i32 %add3
  62
  63 for.body:                                         ; preds = %entry, %for.body
  64   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
  65   %sum.013 = phi i32 [ 0, %entry ], [ %add3, %for.body ]
  66   %arrayidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
  67   %0 = trunc i64 %indvars.iv to i32
  68   store i32 %0, i32* %arrayidx, align 4
  69   %1 = or i64 %indvars.iv, 3
  70   %arrayidx2 = getelementptr inbounds i32, i32* %A, i64 %1
  71   %2 = load i32, i32* %arrayidx2, align 4
  72   %add3 = add nsw i32 %2, %sum.013
  73   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 4
  74   %cmp = icmp ult i64 %indvars.iv.next, 1024
  75   br i1 %cmp, label %for.body, label %for.cond.cleanup
  76 }
  77
  78 ; void nodep_Write_Write(int *A) {
  79 ;   for (unsigned i = 0; i < 1024; i+=2) {
  80 ;     A[i] = i;
  81 ;     A[i+1] = i+1;
  82 ;   }
  83 ; }
  84
  85 ; CHECK: function 'nodep_Write_Write':
  86 ; CHECK-NEXT:   for.body:
  87 ; CHECK-NEXT:     Memory dependences are safe
  88 ; CHECK-NEXT:     Dependences:
  89 ; CHECK-NEXT:     Run-time memory checks:
  90
  91 define void @nodep_Write_Write(i32* nocapture %A) {
  92 entry:
  93   br label %for.body
  94
  95 for.cond.cleanup:                                 ; preds = %for.body
  96   ret void
  97
  98 for.body:                                         ; preds = %entry, %for.body
  99   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
 100   %arrayidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
 101   %0 = trunc i64 %indvars.iv to i32
 102   store i32 %0, i32* %arrayidx, align 4
 103   %1 = or i64 %indvars.iv, 1
 104   %arrayidx3 = getelementptr inbounds i32, i32* %A, i64 %1
 105   %2 = trunc i64 %1 to i32
 106   store i32 %2, i32* %arrayidx3, align 4
 107   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2
 108   %cmp = icmp ult i64 %indvars.iv.next, 1024
 109   br i1 %cmp, label %for.body, label %for.cond.cleanup
 110 }
 111
 112 ; Following cases are unsafe depdences and are not vectorizable.
 113
 114 ; void unsafe_Read_Write(int *A) {
 115 ;   for (unsigned i = 0; i < 1024; i+=3)
 116 ;     A[i+3] = A[i] + 1;
 117 ; }
 118
 119 ; CHECK: function 'unsafe_Read_Write':
 120 ; CHECK-NEXT:   for.body:
 121 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
 122 ; CHECK-NEXT:     Dependences:
 123 ; CHECK-NEXT:      Backward:
 124 ; CHECK-NEXT:           %0 = load i32, i32* %arrayidx, align 4 ->
 125 ; CHECK-NEXT:           store i32 %add, i32* %arrayidx3, align 4
 126
 127 define void @unsafe_Read_Write(i32* nocapture %A) {
 128 entry:
 129   br label %for.body
 130
 131 for.cond.cleanup:                                 ; preds = %for.body
 132   ret void
 133
 134 for.body:                                         ; preds = %entry, %for.body
 135   %i.010 = phi i32 [ 0, %entry ], [ %add1, %for.body ]
 136   %idxprom = zext i32 %i.010 to i64
 137   %arrayidx = getelementptr inbounds i32, i32* %A, i64 %idxprom
 138   %0 = load i32, i32* %arrayidx, align 4
 139   %add = add nsw i32 %0, 1
 140   %add1 = add i32 %i.010, 3
 141   %idxprom2 = zext i32 %add1 to i64
 142   %arrayidx3 = getelementptr inbounds i32, i32* %A, i64 %idxprom2
 143   store i32 %add, i32* %arrayidx3, align 4
 144   %cmp = icmp ult i32 %add1, 1024
 145   br i1 %cmp, label %for.body, label %for.cond.cleanup
 146 }
 147
 148 ; int unsafe_Write_Read(int *A) {
 149 ;   int sum = 0;
 150 ;   for (unsigned i = 0; i < 1024; i+=4) {
 151 ;     A[i] = i;
 152 ;     sum += A[i+4];
 153 ;   }
 154 ;
 155 ;   return sum;
 156 ; }
 157
 158 ; CHECK: function 'unsafe_Write_Read':
 159 ; CHECK-NEXT:   for.body:
 160 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
 161 ; CHECK-NEXT:     Dependences:
 162 ; CHECK-NEXT:      Backward:
 163 ; CHECK-NEXT:           store i32 %0, i32* %arrayidx, align 4 ->
 164 ; CHECK-NEXT:           %1 = load i32, i32* %arrayidx2, align 4
 165
 166 define i32 @unsafe_Write_Read(i32* nocapture %A) {
 167 entry:
 168   br label %for.body
 169
 170 for.cond.cleanup:                                 ; preds = %for.body
 171   ret i32 %add3
 172
 173 for.body:                                         ; preds = %entry, %for.body
 174   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
 175   %sum.013 = phi i32 [ 0, %entry ], [ %add3, %for.body ]
 176   %arrayidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
 177   %0 = trunc i64 %indvars.iv to i32
 178   store i32 %0, i32* %arrayidx, align 4
 179   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 4
 180   %arrayidx2 = getelementptr inbounds i32, i32* %A, i64 %indvars.iv.next
 181   %1 = load i32, i32* %arrayidx2, align 4
 182   %add3 = add nsw i32 %1, %sum.013
 183   %cmp = icmp ult i64 %indvars.iv.next, 1024
 184   br i1 %cmp, label %for.body, label %for.cond.cleanup
 185 }
 186
 187 ; void unsafe_Write_Write(int *A) {
 188 ;   for (unsigned i = 0; i < 1024; i+=2) {
 189 ;     A[i] = i;
 190 ;     A[i+2] = i+1;
 191 ;   }
 192 ; }
 193
 194 ; CHECK: function 'unsafe_Write_Write':
 195 ; CHECK-NEXT:   for.body:
 196 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
 197 ; CHECK-NEXT:     Dependences:
 198 ; CHECK-NEXT:      Backward:
 199 ; CHECK-NEXT:           store i32 %0, i32* %arrayidx, align 4 ->
 200 ; CHECK-NEXT:           store i32 %2, i32* %arrayidx3, align 4
 201
 202 define void @unsafe_Write_Write(i32* nocapture %A) {
 203 entry:
 204   br label %for.body
 205
 206 for.cond.cleanup:                                 ; preds = %for.body
 207   ret void
 208
 209 for.body:                                         ; preds = %entry, %for.body
 210   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
 211   %arrayidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
 212   %0 = trunc i64 %indvars.iv to i32
 213   store i32 %0, i32* %arrayidx, align 4
 214   %1 = or i64 %indvars.iv, 1
 215   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2
 216   %arrayidx3 = getelementptr inbounds i32, i32* %A, i64 %indvars.iv.next
 217   %2 = trunc i64 %1 to i32
 218   store i32 %2, i32* %arrayidx3, align 4
 219   %cmp = icmp ult i64 %indvars.iv.next, 1024
 220   br i1 %cmp, label %for.body, label %for.cond.cleanup
 221 }
 222
 223 ; Following cases check that strided accesses can be vectorized.
 224
 225 ; void vectorizable_Read_Write(int *A) {
 226 ;   int *B = A + 4;
 227 ;   for (unsigned i = 0; i < 1024; i+=2)
 228 ;     B[i] = A[i] + 1;
 229 ; }
 230
 231 ; CHECK: function 'vectorizable_Read_Write':
 232 ; CHECK-NEXT:   for.body:
 233 ; CHECK-NEXT:     Memory dependences are safe
 234 ; CHECK-NEXT:     Dependences:
 235 ; CHECK-NEXT:       BackwardVectorizable:
 236 ; CHECK-NEXT:           %0 = load i32, i32* %arrayidx, align 4 ->
 237 ; CHECK-NEXT:           store i32 %add, i32* %arrayidx2, align 4
 238
 239 define void @vectorizable_Read_Write(i32* nocapture %A) {
 240 entry:
 241   %add.ptr = getelementptr inbounds i32, i32* %A, i64 4
 242   br label %for.body
 243
 244 for.cond.cleanup:                                 ; preds = %for.body
 245   ret void
 246
 247 for.body:                                         ; preds = %entry, %for.body
 248   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
 249   %arrayidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
 250   %0 = load i32, i32* %arrayidx, align 4
 251   %add = add nsw i32 %0, 1
 252   %arrayidx2 = getelementptr inbounds i32, i32* %add.ptr, i64 %indvars.iv
 253   store i32 %add, i32* %arrayidx2, align 4
 254   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2
 255   %cmp = icmp ult i64 %indvars.iv.next, 1024
 256   br i1 %cmp, label %for.body, label %for.cond.cleanup
 257 }
 258
 259 ; int vectorizable_Write_Read(int *A) {
 260 ;   int *B = A + 4;
 261 ;   int sum = 0;
 262 ;   for (unsigned i = 0; i < 1024; i+=2) {
 263 ;     A[i] = i;
 264 ;     sum += B[i];
 265 ;   }
 266 ;
 267 ;   return sum;
 268 ; }
 269
 270 ; CHECK: function 'vectorizable_Write_Read':
 271 ; CHECK-NEXT:   for.body:
 272 ; CHECK-NEXT:     Memory dependences are safe
 273 ; CHECK-NEXT:     Dependences:
 274 ; CHECK-NEXT:       BackwardVectorizable:
 275 ; CHECK-NEXT:           store i32 %0, i32* %arrayidx, align 4 ->
 276 ; CHECK-NEXT:           %1 = load i32, i32* %arrayidx2, align 4
 277
 278 define i32 @vectorizable_Write_Read(i32* nocapture %A) {
 279 entry:
 280   %add.ptr = getelementptr inbounds i32, i32* %A, i64 4
 281   br label %for.body
 282
 283 for.cond.cleanup:                                 ; preds = %for.body
 284   ret i32 %add
 285
 286 for.body:                                         ; preds = %entry, %for.body
 287   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
 288   %sum.013 = phi i32 [ 0, %entry ], [ %add, %for.body ]
 289   %arrayidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
 290   %0 = trunc i64 %indvars.iv to i32
 291   store i32 %0, i32* %arrayidx, align 4
 292   %arrayidx2 = getelementptr inbounds i32, i32* %add.ptr, i64 %indvars.iv
 293   %1 = load i32, i32* %arrayidx2, align 4
 294   %add = add nsw i32 %1, %sum.013
 295   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2
 296   %cmp = icmp ult i64 %indvars.iv.next, 1024
 297   br i1 %cmp, label %for.body, label %for.cond.cleanup
 298 }
 299
 300 ; void vectorizable_Write_Write(int *A) {
 301 ;   int *B = A + 4;
 302 ;   for (unsigned i = 0; i < 1024; i+=2) {
 303 ;     A[i] = i;
 304 ;     B[i] = i+1;
 305 ;   }
 306 ; }
 307
 308 ; CHECK: function 'vectorizable_Write_Write':
 309 ; CHECK-NEXT:   for.body:
 310 ; CHECK-NEXT:     Memory dependences are safe
 311 ; CHECK-NEXT:     Dependences:
 312 ; CHECK-NEXT:       BackwardVectorizable:
 313 ; CHECK-NEXT:           store i32 %0, i32* %arrayidx, align 4 ->
 314 ; CHECK-NEXT:           store i32 %2, i32* %arrayidx2, align 4
 315
 316 define void @vectorizable_Write_Write(i32* nocapture %A) {
 317 entry:
 318   %add.ptr = getelementptr inbounds i32, i32* %A, i64 4
 319   br label %for.body
 320
 321 for.cond.cleanup:                                 ; preds = %for.body
 322   ret void
 323
 324 for.body:                                         ; preds = %entry, %for.body
 325   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
 326   %arrayidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
 327   %0 = trunc i64 %indvars.iv to i32
 328   store i32 %0, i32* %arrayidx, align 4
 329   %1 = or i64 %indvars.iv, 1
 330   %arrayidx2 = getelementptr inbounds i32, i32* %add.ptr, i64 %indvars.iv
 331   %2 = trunc i64 %1 to i32
 332   store i32 %2, i32* %arrayidx2, align 4
 333   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2
 334   %cmp = icmp ult i64 %indvars.iv.next, 1024
 335   br i1 %cmp, label %for.body, label %for.cond.cleanup
 336 }
 337
 338 ; void vectorizable_unscaled_Read_Write(int *A) {
 339 ;   int *B = (int *)((char *)A + 14);
 340 ;   for (unsigned i = 0; i < 1024; i+=2)
 341 ;     B[i] = A[i] + 1;
 342 ; }
 343
 344 ; FIXME: This case looks like previous case @vectorizable_Read_Write. It sould
 345 ; be vectorizable.
 346
 347 ; CHECK: function 'vectorizable_unscaled_Read_Write':
 348 ; CHECK-NEXT:   for.body:
 349 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
 350 ; CHECK-NEXT:     Dependences:
 351 ; CHECK-NEXT:       BackwardVectorizableButPreventsForwarding:
 352 ; CHECK-NEXT:           %2 = load i32, i32* %arrayidx, align 4 ->
 353 ; CHECK-NEXT:           store i32 %add, i32* %arrayidx2, align 4
 354
 355 define void @vectorizable_unscaled_Read_Write(i32* nocapture %A) {
 356 entry:
 357   %0 = bitcast i32* %A to i8*
 358   %add.ptr = getelementptr inbounds i8, i8* %0, i64 14
 359   %1 = bitcast i8* %add.ptr to i32*
 360   br label %for.body
 361
 362 for.cond.cleanup:                                 ; preds = %for.body
 363   ret void
 364
 365 for.body:                                         ; preds = %entry, %for.body
 366   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
 367   %arrayidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
 368   %2 = load i32, i32* %arrayidx, align 4
 369   %add = add nsw i32 %2, 1
 370   %arrayidx2 = getelementptr inbounds i32, i32* %1, i64 %indvars.iv
 371   store i32 %add, i32* %arrayidx2, align 4
 372   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2
 373   %cmp = icmp ult i64 %indvars.iv.next, 1024
 374   br i1 %cmp, label %for.body, label %for.cond.cleanup
 375 }
 376
 377 ; int vectorizable_unscaled_Write_Read(int *A) {
 378 ;   int *B = (int *)((char *)A + 17);
 379 ;   int sum = 0;
 380 ;   for (unsigned i = 0; i < 1024; i+=2) {
 381 ;     A[i] = i;
 382 ;     sum += B[i];
 383 ;   }
 384 ;
 385 ;   return sum;
 386 ; }
 387
 388 ; CHECK: function 'vectorizable_unscaled_Write_Read':
 389 ; CHECK-NEXT:   for.body:
 390 ; CHECK-NEXT:     Memory dependences are safe
 391 ; CHECK-NEXT:     Dependences:
 392 ; CHECK-NEXT:       BackwardVectorizable:
 393 ; CHECK-NEXT:           store i32 %2, i32* %arrayidx, align 4 ->
 394 ; CHECK-NEXT:           %3 = load i32, i32* %arrayidx2, align 4
 395
 396 define i32 @vectorizable_unscaled_Write_Read(i32* nocapture %A) {
 397 entry:
 398   %0 = bitcast i32* %A to i8*
 399   %add.ptr = getelementptr inbounds i8, i8* %0, i64 17
 400   %1 = bitcast i8* %add.ptr to i32*
 401   br label %for.body
 402
 403 for.cond.cleanup:                                 ; preds = %for.body
 404   ret i32 %add
 405
 406 for.body:                                         ; preds = %entry, %for.body
 407   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
 408   %sum.013 = phi i32 [ 0, %entry ], [ %add, %for.body ]
 409   %arrayidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
 410   %2 = trunc i64 %indvars.iv to i32
 411   store i32 %2, i32* %arrayidx, align 4
 412   %arrayidx2 = getelementptr inbounds i32, i32* %1, i64 %indvars.iv
 413   %3 = load i32, i32* %arrayidx2, align 4
 414   %add = add nsw i32 %3, %sum.013
 415   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2
 416   %cmp = icmp ult i64 %indvars.iv.next, 1024
 417   br i1 %cmp, label %for.body, label %for.cond.cleanup
 418 }
 419
 420 ; void unsafe_unscaled_Read_Write(int *A) {
 421 ;   int *B = (int *)((char *)A + 11);
 422 ;   for (unsigned i = 0; i < 1024; i+=2)
 423 ;     B[i] = A[i] + 1;
 424 ; }
 425
 426 ; CHECK: function 'unsafe_unscaled_Read_Write':
 427 ; CHECK-NEXT:   for.body:
 428 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
 429 ; CHECK-NEXT:     Dependences:
 430 ; CHECK-NEXT:       Backward:
 431 ; CHECK-NEXT:           %2 = load i32, i32* %arrayidx, align 4 ->
 432 ; CHECK-NEXT:           store i32 %add, i32* %arrayidx2, align 4
 433
 434 define void @unsafe_unscaled_Read_Write(i32* nocapture %A) {
 435 entry:
 436   %0 = bitcast i32* %A to i8*
 437   %add.ptr = getelementptr inbounds i8, i8* %0, i64 11
 438   %1 = bitcast i8* %add.ptr to i32*
 439   br label %for.body
 440
 441 for.cond.cleanup:                                 ; preds = %for.body
 442   ret void
 443
 444 for.body:                                         ; preds = %entry, %for.body
 445   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
 446   %arrayidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
 447   %2 = load i32, i32* %arrayidx, align 4
 448   %add = add nsw i32 %2, 1
 449   %arrayidx2 = getelementptr inbounds i32, i32* %1, i64 %indvars.iv
 450   store i32 %add, i32* %arrayidx2, align 4
 451   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2
 452   %cmp = icmp ult i64 %indvars.iv.next, 1024
 453   br i1 %cmp, label %for.body, label %for.cond.cleanup
 454 }
 455
 456 ; CHECK: function 'unsafe_unscaled_Read_Write2':
 457 ; CHECK-NEXT:   for.body:
 458 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
 459 ; CHECK-NEXT:     Dependences:
 460 ; CHECK-NEXT:       Backward:
 461 ; CHECK-NEXT:           %2 = load i32, i32* %arrayidx, align 4 ->
 462 ; CHECK-NEXT:           store i32 %add, i32* %arrayidx2, align 4
 463
 464 ; void unsafe_unscaled_Read_Write2(int *A) {
 465 ;   int *B = (int *)((char *)A + 1);
 466 ;   for (unsigned i = 0; i < 1024; i+=2)
 467 ;     B[i] = A[i] + 1;
 468 ; }
 469
 470 define void @unsafe_unscaled_Read_Write2(i32* nocapture %A) {
 471 entry:
 472   %0 = bitcast i32* %A to i8*
 473   %add.ptr = getelementptr inbounds i8, i8* %0, i64 1
 474   %1 = bitcast i8* %add.ptr to i32*
 475   br label %for.body
 476
 477 for.cond.cleanup:                                 ; preds = %for.body
 478   ret void
 479
 480 for.body:                                         ; preds = %entry, %for.body
 481   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
 482   %arrayidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
 483   %2 = load i32, i32* %arrayidx, align 4
 484   %add = add nsw i32 %2, 1
 485   %arrayidx2 = getelementptr inbounds i32, i32* %1, i64 %indvars.iv
 486   store i32 %add, i32* %arrayidx2, align 4
 487   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2
 488   %cmp = icmp ult i64 %indvars.iv.next, 1024
 489   br i1 %cmp, label %for.body, label %for.cond.cleanup
 490 }
 491
 492 ; Following case checks that interleaved stores have dependences with another
 493 ; store and can not pass dependence check.
 494
 495 ; void interleaved_stores(int *A) {
 496 ;   int *B = (int *) ((char *)A + 1);
 497 ;   for(int i = 0; i < 1024; i+=2) {
 498 ;     B[i]   = i;                // (1)
 499 ;     A[i+1] = i + 1;            // (2)
 500 ;     B[i+1] = i + 1;            // (3)
 501 ;   }
 502 ; }
 503 ;
 504 ; The access (2) has overlaps with (1) and (3).
 505
 506 ; CHECK: function 'interleaved_stores':
 507 ; CHECK-NEXT:   for.body:
 508 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
 509 ; CHECK-NEXT:     Dependences:
 510 ; CHECK-NEXT:       Backward:
 511 ; CHECK-NEXT:           store i32 %4, i32* %arrayidx5, align 4 ->
 512 ; CHECK-NEXT:           store i32 %4, i32* %arrayidx9, align 4
 513 ; CHECK:       Backward:
 514 ; CHECK-NEXT:           store i32 %2, i32* %arrayidx2, align 4 ->
 515 ; CHECK-NEXT:           store i32 %4, i32* %arrayidx5, align 4
 516
 517 define void @interleaved_stores(i32* nocapture %A) {
 518 entry:
 519   %0 = bitcast i32* %A to i8*
 520   %incdec.ptr = getelementptr inbounds i8, i8* %0, i64 1
 521   %1 = bitcast i8* %incdec.ptr to i32*
 522   br label %for.body
 523
 524 for.cond.cleanup:                                 ; preds = %for.body
 525   ret void
 526
 527 for.body:                                         ; preds = %entry, %for.body
 528   %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
 529   %2 = trunc i64 %indvars.iv to i32
 530   %arrayidx2 = getelementptr inbounds i32, i32* %1, i64 %indvars.iv
 531   store i32 %2, i32* %arrayidx2, align 4
 532   %3 = or i64 %indvars.iv, 1
 533   %arrayidx5 = getelementptr inbounds i32, i32* %A, i64 %3
 534   %4 = trunc i64 %3 to i32
 535   store i32 %4, i32* %arrayidx5, align 4
 536   %arrayidx9 = getelementptr inbounds i32, i32* %1, i64 %3
 537   store i32 %4, i32* %arrayidx9, align 4
 538   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2
 539   %cmp = icmp slt i64 %indvars.iv.next, 1024
 540   br i1 %cmp, label %for.body, label %for.cond.cleanup
 541 }