llvm/test/Analysis/LoopAccessAnalysis/invariant-dependence-before.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 3
   2 ; RUN: opt -passes='print<access-info>' -disable-output %s 2>&1 | FileCheck %s
   3
   4 define void @test_invar_dependence_before_positive_strided_access_1(ptr %a) {
   5 ; CHECK-LABEL: 'test_invar_dependence_before_positive_strided_access_1'
   6 ; CHECK-NEXT:    loop:
   7 ; CHECK-NEXT:      Memory dependences are safe
   8 ; CHECK-NEXT:      Dependences:
   9 ; CHECK-NEXT:      Run-time memory checks:
  10 ; CHECK-NEXT:      Grouped accesses:
  11 ; CHECK-EMPTY:
  12 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
  13 ; CHECK-NEXT:      SCEV assumptions:
  14 ; CHECK-EMPTY:
  15 ; CHECK-NEXT:      Expressions re-written:
  16 ;
  17 entry:
  18   %gep.off = getelementptr i8, ptr %a, i32 4
  19   br label %loop
  20
  21 loop:
  22   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
  23   %gep = getelementptr i32, ptr %gep.off, i32 %iv
  24   %l = load i32, ptr %a
  25   store i32 %l, ptr %gep
  26   %iv.next = add i32 %iv, 1
  27   %ec = icmp eq i32 %iv.next, 100
  28   br i1 %ec, label %exit, label %loop
  29
  30 exit:
  31   ret void
  32 }
  33
  34 define void @test_invar_dependence_before_positive_strided_access_2(ptr %a) {
  35 ; CHECK-LABEL: 'test_invar_dependence_before_positive_strided_access_2'
  36 ; CHECK-NEXT:    loop:
  37 ; CHECK-NEXT:      Memory dependences are safe
  38 ; CHECK-NEXT:      Dependences:
  39 ; CHECK-NEXT:      Run-time memory checks:
  40 ; CHECK-NEXT:      Grouped accesses:
  41 ; CHECK-EMPTY:
  42 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
  43 ; CHECK-NEXT:      SCEV assumptions:
  44 ; CHECK-EMPTY:
  45 ; CHECK-NEXT:      Expressions re-written:
  46 ;
  47 entry:
  48   %gep.off = getelementptr i8, ptr %a, i32 4
  49   br label %loop
  50
  51 loop:
  52   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
  53   %gep = getelementptr i32, ptr %gep.off, i32 %iv
  54   %l = load i32, ptr %gep
  55   store i32 %l, ptr %a
  56   %iv.next = add i32 %iv, 1
  57   %ec = icmp eq i32 %iv.next, 100
  58   br i1 %ec, label %exit, label %loop
  59
  60 exit:
  61   ret void
  62 }
  63
  64 define void @test_invar_dependence_not_before_positive_strided_access_1(ptr %a) {
  65 ; CHECK-LABEL: 'test_invar_dependence_not_before_positive_strided_access_1'
  66 ; CHECK-NEXT:    loop:
  67 ; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
  68 ; CHECK-NEXT:  Unknown data dependence.
  69 ; CHECK-NEXT:      Dependences:
  70 ; CHECK-NEXT:        Unknown:
  71 ; CHECK-NEXT:            %l = load i32, ptr %a, align 4 ->
  72 ; CHECK-NEXT:            store i32 %l, ptr %gep, align 4
  73 ; CHECK-EMPTY:
  74 ; CHECK-NEXT:      Run-time memory checks:
  75 ; CHECK-NEXT:      Grouped accesses:
  76 ; CHECK-EMPTY:
  77 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
  78 ; CHECK-NEXT:      SCEV assumptions:
  79 ; CHECK-EMPTY:
  80 ; CHECK-NEXT:      Expressions re-written:
  81 ;
  82 entry:
  83   %gep.off = getelementptr i8, ptr %a, i32 3
  84   br label %loop
  85
  86 loop:
  87   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
  88   %gep = getelementptr i32, ptr %gep.off, i32 %iv
  89   %l = load i32, ptr %a
  90   store i32 %l, ptr %gep
  91   %iv.next = add i32 %iv, 1
  92   %ec = icmp eq i32 %iv.next, 100
  93   br i1 %ec, label %exit, label %loop
  94
  95 exit:
  96   ret void
  97 }
  98
  99 define void @test_invar_dependence_not_before_positive_strided_access_2(ptr %a) {
 100 ; CHECK-LABEL: 'test_invar_dependence_not_before_positive_strided_access_2'
 101 ; CHECK-NEXT:    loop:
 102 ; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
 103 ; CHECK-NEXT:  Unknown data dependence.
 104 ; CHECK-NEXT:      Dependences:
 105 ; CHECK-NEXT:        Unknown:
 106 ; CHECK-NEXT:            %l = load i32, ptr %gep, align 4 ->
 107 ; CHECK-NEXT:            store i32 %l, ptr %a, align 4
 108 ; CHECK-EMPTY:
 109 ; CHECK-NEXT:      Run-time memory checks:
 110 ; CHECK-NEXT:      Grouped accesses:
 111 ; CHECK-EMPTY:
 112 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 113 ; CHECK-NEXT:      SCEV assumptions:
 114 ; CHECK-EMPTY:
 115 ; CHECK-NEXT:      Expressions re-written:
 116 ;
 117 entry:
 118   %gep.off = getelementptr i8, ptr %a, i32 3
 119   br label %loop
 120
 121 loop:
 122   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 123   %gep = getelementptr i32, ptr %gep.off, i32 %iv
 124   %l = load i32, ptr %gep
 125   store i32 %l, ptr %a
 126   %iv.next = add i32 %iv, 1
 127   %ec = icmp eq i32 %iv.next, 100
 128   br i1 %ec, label %exit, label %loop
 129
 130 exit:
 131   ret void
 132 }
 133
 134 define void @test_invar_dependence_before_positive_strided_access_1_different_access_sizes(ptr %a) {
 135 ; CHECK-LABEL: 'test_invar_dependence_before_positive_strided_access_1_different_access_sizes'
 136 ; CHECK-NEXT:    loop:
 137 ; CHECK-NEXT:      Memory dependences are safe
 138 ; CHECK-NEXT:      Dependences:
 139 ; CHECK-NEXT:      Run-time memory checks:
 140 ; CHECK-NEXT:      Grouped accesses:
 141 ; CHECK-EMPTY:
 142 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 143 ; CHECK-NEXT:      SCEV assumptions:
 144 ; CHECK-EMPTY:
 145 ; CHECK-NEXT:      Expressions re-written:
 146 ;
 147 entry:
 148   %gep.off = getelementptr i8, ptr %a, i32 4
 149   br label %loop
 150
 151 loop:
 152   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 153   %gep = getelementptr i32, ptr %gep.off, i32 %iv
 154   %l = load i32, ptr %a
 155   %t = trunc i32 %l to i8
 156   store i8 %t, ptr %gep
 157   %iv.next = add i32 %iv, 1
 158   %ec = icmp eq i32 %iv.next, 100
 159   br i1 %ec, label %exit, label %loop
 160
 161 exit:
 162   ret void
 163 }
 164
 165 define void @test_invar_dependence_not_before_positive_strided_access_1_different_access_sizes(ptr %a) {
 166 ; CHECK-LABEL: 'test_invar_dependence_not_before_positive_strided_access_1_different_access_sizes'
 167 ; CHECK-NEXT:    loop:
 168 ; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
 169 ; CHECK-NEXT:  Unknown data dependence.
 170 ; CHECK-NEXT:      Dependences:
 171 ; CHECK-NEXT:        Unknown:
 172 ; CHECK-NEXT:            %l = load i64, ptr %a, align 4 ->
 173 ; CHECK-NEXT:            store i32 %t, ptr %gep, align 4
 174 ; CHECK-EMPTY:
 175 ; CHECK-NEXT:      Run-time memory checks:
 176 ; CHECK-NEXT:      Grouped accesses:
 177 ; CHECK-EMPTY:
 178 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 179 ; CHECK-NEXT:      SCEV assumptions:
 180 ; CHECK-EMPTY:
 181 ; CHECK-NEXT:      Expressions re-written:
 182 ;
 183 entry:
 184   %gep.off = getelementptr i8, ptr %a, i32 4
 185   br label %loop
 186
 187 loop:
 188   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 189   %gep = getelementptr i32, ptr %gep.off, i32 %iv
 190   %l = load i64, ptr %a
 191   %t = trunc i64 %l to i32
 192   store i32 %t, ptr %gep
 193   %iv.next = add i32 %iv, 1
 194   %ec = icmp eq i32 %iv.next, 100
 195   br i1 %ec, label %exit, label %loop
 196
 197 exit:
 198   ret void
 199 }
 200
 201 define void @test_invar_dependence_before_negative_strided_access_1(ptr %a) {
 202 ; CHECK-LABEL: 'test_invar_dependence_before_negative_strided_access_1'
 203 ; CHECK-NEXT:    loop:
 204 ; CHECK-NEXT:      Memory dependences are safe
 205 ; CHECK-NEXT:      Dependences:
 206 ; CHECK-NEXT:      Run-time memory checks:
 207 ; CHECK-NEXT:      Grouped accesses:
 208 ; CHECK-EMPTY:
 209 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 210 ; CHECK-NEXT:      SCEV assumptions:
 211 ; CHECK-EMPTY:
 212 ; CHECK-NEXT:      Expressions re-written:
 213 ;
 214 entry:
 215   %gep.off = getelementptr i32, ptr %a, i32 100
 216   br label %loop
 217
 218 loop:
 219   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 220   %gep = getelementptr i32, ptr %gep.off, i32 %iv
 221   %l = load i32, ptr %a
 222   store i32 %l, ptr %gep
 223   %iv.next = sub i32 %iv, 1
 224   %ec = icmp eq i32 %iv.next, -100
 225   br i1 %ec, label %exit, label %loop
 226
 227 exit:
 228   ret void
 229 }
 230
 231 define void @test_invar_dependence_before_negative_strided_access_2(ptr %a) {
 232 ; CHECK-LABEL: 'test_invar_dependence_before_negative_strided_access_2'
 233 ; CHECK-NEXT:    loop:
 234 ; CHECK-NEXT:      Memory dependences are safe
 235 ; CHECK-NEXT:      Dependences:
 236 ; CHECK-NEXT:      Run-time memory checks:
 237 ; CHECK-NEXT:      Grouped accesses:
 238 ; CHECK-EMPTY:
 239 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 240 ; CHECK-NEXT:      SCEV assumptions:
 241 ; CHECK-EMPTY:
 242 ; CHECK-NEXT:      Expressions re-written:
 243 ;
 244 entry:
 245   %gep.off = getelementptr i32, ptr %a, i32 100
 246   br label %loop
 247
 248 loop:
 249   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 250   %gep = getelementptr i32, ptr %gep.off, i32 %iv
 251   %l = load i32, ptr %gep
 252   store i32 %l, ptr %a
 253   %iv.next = sub i32 %iv, 1
 254   %ec = icmp eq i32 %iv.next, -100
 255   br i1 %ec, label %exit, label %loop
 256
 257 exit:
 258   ret void
 259 }
 260
 261
 262 define void @test_invar_dependence_not_before_negative_strided_access_1(ptr %a) {
 263 ; CHECK-LABEL: 'test_invar_dependence_not_before_negative_strided_access_1'
 264 ; CHECK-NEXT:    loop:
 265 ; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
 266 ; CHECK-NEXT:  Unknown data dependence.
 267 ; CHECK-NEXT:      Dependences:
 268 ; CHECK-NEXT:        Unknown:
 269 ; CHECK-NEXT:            %l = load i32, ptr %a, align 4 ->
 270 ; CHECK-NEXT:            store i32 %l, ptr %gep, align 4
 271 ; CHECK-EMPTY:
 272 ; CHECK-NEXT:      Run-time memory checks:
 273 ; CHECK-NEXT:      Grouped accesses:
 274 ; CHECK-EMPTY:
 275 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 276 ; CHECK-NEXT:      SCEV assumptions:
 277 ; CHECK-EMPTY:
 278 ; CHECK-NEXT:      Expressions re-written:
 279 ;
 280 entry:
 281   %gep.off = getelementptr i32, ptr %a, i32 99
 282   br label %loop
 283
 284 loop:
 285   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 286   %gep = getelementptr i32, ptr %gep.off, i32 %iv
 287   %l = load i32, ptr %a
 288   store i32 %l, ptr %gep
 289   %iv.next = sub i32 %iv, 1
 290   %ec = icmp eq i32 %iv.next, -100
 291   br i1 %ec, label %exit, label %loop
 292
 293 exit:
 294   ret void
 295 }
 296
 297 define void @test_invar_dependence_not_before_negative_strided_access_2(ptr %a) {
 298 ; CHECK-LABEL: 'test_invar_dependence_not_before_negative_strided_access_2'
 299 ; CHECK-NEXT:    loop:
 300 ; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
 301 ; CHECK-NEXT:  Unknown data dependence.
 302 ; CHECK-NEXT:      Dependences:
 303 ; CHECK-NEXT:        Unknown:
 304 ; CHECK-NEXT:            %l = load i32, ptr %gep, align 4 ->
 305 ; CHECK-NEXT:            store i32 %l, ptr %a, align 4
 306 ; CHECK-EMPTY:
 307 ; CHECK-NEXT:      Run-time memory checks:
 308 ; CHECK-NEXT:      Grouped accesses:
 309 ; CHECK-EMPTY:
 310 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 311 ; CHECK-NEXT:      SCEV assumptions:
 312 ; CHECK-EMPTY:
 313 ; CHECK-NEXT:      Expressions re-written:
 314 ;
 315 entry:
 316   %gep.off = getelementptr i32, ptr %a, i32 99
 317   br label %loop
 318
 319 loop:
 320   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 321   %gep = getelementptr i32, ptr %gep.off, i32 %iv
 322   %l = load i32, ptr %gep
 323   store i32 %l, ptr %a
 324   %iv.next = sub i32 %iv, 1
 325   %ec = icmp eq i32 %iv.next, -100
 326   br i1 %ec, label %exit, label %loop
 327
 328 exit:
 329   ret void
 330 }
 331
 332 define void @test_both_invar_before_1(ptr %a) {
 333 ; CHECK-LABEL: 'test_both_invar_before_1'
 334 ; CHECK-NEXT:    loop:
 335 ; CHECK-NEXT:      Memory dependences are safe
 336 ; CHECK-NEXT:      Dependences:
 337 ; CHECK-NEXT:      Run-time memory checks:
 338 ; CHECK-NEXT:      Grouped accesses:
 339 ; CHECK-EMPTY:
 340 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 341 ; CHECK-NEXT:      SCEV assumptions:
 342 ; CHECK-EMPTY:
 343 ; CHECK-NEXT:      Expressions re-written:
 344 ;
 345 entry:
 346   %gep.off = getelementptr i8, ptr %a, i32 4
 347   br label %loop
 348
 349 loop:
 350   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 351   %l = load i32, ptr %a
 352   store i32 %l, ptr %gep.off
 353   %iv.next = add i32 %iv, 1
 354   %ec = icmp eq i32 %iv.next, 100
 355   br i1 %ec, label %exit, label %loop
 356
 357 exit:
 358   ret void
 359 }
 360
 361 define void @test_both_invar_before_2(ptr %a) {
 362 ; CHECK-LABEL: 'test_both_invar_before_2'
 363 ; CHECK-NEXT:    loop:
 364 ; CHECK-NEXT:      Memory dependences are safe
 365 ; CHECK-NEXT:      Dependences:
 366 ; CHECK-NEXT:      Run-time memory checks:
 367 ; CHECK-NEXT:      Grouped accesses:
 368 ; CHECK-EMPTY:
 369 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 370 ; CHECK-NEXT:      SCEV assumptions:
 371 ; CHECK-EMPTY:
 372 ; CHECK-NEXT:      Expressions re-written:
 373 ;
 374 entry:
 375   %gep.off = getelementptr i8, ptr %a, i32 4
 376   br label %loop
 377
 378 loop:
 379   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 380   %l = load i32, ptr %gep.off
 381   store i32 %l, ptr %a
 382   %iv.next = add i32 %iv, 1
 383   %ec = icmp eq i32 %iv.next, 100
 384   br i1 %ec, label %exit, label %loop
 385
 386 exit:
 387   ret void
 388 }
 389
 390 define void @test_both_invar_not_before_1(ptr %a) {
 391 ; CHECK-LABEL: 'test_both_invar_not_before_1'
 392 ; CHECK-NEXT:    loop:
 393 ; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
 394 ; CHECK-NEXT:  Unknown data dependence.
 395 ; CHECK-NEXT:      Dependences:
 396 ; CHECK-NEXT:        Unknown:
 397 ; CHECK-NEXT:            %l = load i32, ptr %a, align 4 ->
 398 ; CHECK-NEXT:            store i32 %l, ptr %gep.off, align 4
 399 ; CHECK-EMPTY:
 400 ; CHECK-NEXT:      Run-time memory checks:
 401 ; CHECK-NEXT:      Grouped accesses:
 402 ; CHECK-EMPTY:
 403 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 404 ; CHECK-NEXT:      SCEV assumptions:
 405 ; CHECK-EMPTY:
 406 ; CHECK-NEXT:      Expressions re-written:
 407 ;
 408 entry:
 409   %gep.off = getelementptr i8, ptr %a, i32 3
 410   br label %loop
 411
 412 loop:
 413   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 414   %l = load i32, ptr %a
 415   store i32 %l, ptr %gep.off
 416   %iv.next = add i32 %iv, 1
 417   %ec = icmp eq i32 %iv.next, 100
 418   br i1 %ec, label %exit, label %loop
 419
 420 exit:
 421   ret void
 422 }
 423
 424 define void @test_both_invar_not_before_2(ptr %a) {
 425 ; CHECK-LABEL: 'test_both_invar_not_before_2'
 426 ; CHECK-NEXT:    loop:
 427 ; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
 428 ; CHECK-NEXT:  Unknown data dependence.
 429 ; CHECK-NEXT:      Dependences:
 430 ; CHECK-NEXT:        Unknown:
 431 ; CHECK-NEXT:            %l = load i32, ptr %gep.off, align 4 ->
 432 ; CHECK-NEXT:            store i32 %l, ptr %a, align 4
 433 ; CHECK-EMPTY:
 434 ; CHECK-NEXT:      Run-time memory checks:
 435 ; CHECK-NEXT:      Grouped accesses:
 436 ; CHECK-EMPTY:
 437 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 438 ; CHECK-NEXT:      SCEV assumptions:
 439 ; CHECK-EMPTY:
 440 ; CHECK-NEXT:      Expressions re-written:
 441 ;
 442 entry:
 443   %gep.off = getelementptr i8, ptr %a, i32 3
 444   br label %loop
 445
 446 loop:
 447   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 448   %l = load i32, ptr %gep.off
 449   store i32 %l, ptr %a
 450   %iv.next = add i32 %iv, 1
 451   %ec = icmp eq i32 %iv.next, 100
 452   br i1 %ec, label %exit, label %loop
 453
 454 exit:
 455   ret void
 456 }
 457
 458 define void @test_invar_dependence_before_via_loop_guard_positive_strided_access_1(ptr %a, i32 %off) {
 459 ; CHECK-LABEL: 'test_invar_dependence_before_via_loop_guard_positive_strided_access_1'
 460 ; CHECK-NEXT:    loop:
 461 ; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
 462 ; CHECK-NEXT:  Unknown data dependence.
 463 ; CHECK-NEXT:      Dependences:
 464 ; CHECK-NEXT:        Unknown:
 465 ; CHECK-NEXT:            %l = load i32, ptr %a, align 4 ->
 466 ; CHECK-NEXT:            store i32 %l, ptr %gep, align 4
 467 ; CHECK-EMPTY:
 468 ; CHECK-NEXT:      Run-time memory checks:
 469 ; CHECK-NEXT:      Grouped accesses:
 470 ; CHECK-EMPTY:
 471 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 472 ; CHECK-NEXT:      SCEV assumptions:
 473 ; CHECK-EMPTY:
 474 ; CHECK-NEXT:      Expressions re-written:
 475 ;
 476 entry:
 477   %gep.off = getelementptr i8, ptr %a, i32 %off
 478   %c = icmp sge i32 %off, 4
 479   br i1 %c, label %loop, label %exit
 480
 481 loop:
 482   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 483   %gep = getelementptr i32, ptr %gep.off, i32 %iv
 484   %l = load i32, ptr %a
 485   store i32 %l, ptr %gep
 486   %iv.next = add i32 %iv, 1
 487   %ec = icmp eq i32 %iv.next, 100
 488   br i1 %ec, label %exit, label %loop
 489
 490 exit:
 491   ret void
 492 }
 493
 494 define void @test_invar_dependence_before_via_loop_guard_positive_strided_access_2(ptr %a, i32 %off) {
 495 ; CHECK-LABEL: 'test_invar_dependence_before_via_loop_guard_positive_strided_access_2'
 496 ; CHECK-NEXT:    loop:
 497 ; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
 498 ; CHECK-NEXT:  Unknown data dependence.
 499 ; CHECK-NEXT:      Dependences:
 500 ; CHECK-NEXT:        Unknown:
 501 ; CHECK-NEXT:            %l = load i32, ptr %gep, align 4 ->
 502 ; CHECK-NEXT:            store i32 %l, ptr %a, align 4
 503 ; CHECK-EMPTY:
 504 ; CHECK-NEXT:      Run-time memory checks:
 505 ; CHECK-NEXT:      Grouped accesses:
 506 ; CHECK-EMPTY:
 507 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 508 ; CHECK-NEXT:      SCEV assumptions:
 509 ; CHECK-EMPTY:
 510 ; CHECK-NEXT:      Expressions re-written:
 511 ;
 512 entry:
 513   %gep.off = getelementptr i8, ptr %a, i32 %off
 514   %c = icmp sge i32 %off, 4
 515   br i1 %c, label %loop, label %exit
 516
 517 loop:
 518   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 519   %gep = getelementptr i32, ptr %gep.off, i32 %iv
 520   %l = load i32, ptr %gep
 521   store i32 %l, ptr %a
 522   %iv.next = add i32 %iv, 1
 523   %ec = icmp eq i32 %iv.next, 100
 524   br i1 %ec, label %exit, label %loop
 525
 526 exit:
 527   ret void
 528 }
 529 define void @test_invar_dependence_not_before_via_loop_guard_positive_strided_access_1(ptr %a, i32 %off) {
 530 ; CHECK-LABEL: 'test_invar_dependence_not_before_via_loop_guard_positive_strided_access_1'
 531 ; CHECK-NEXT:    loop:
 532 ; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
 533 ; CHECK-NEXT:  Unknown data dependence.
 534 ; CHECK-NEXT:      Dependences:
 535 ; CHECK-NEXT:        Unknown:
 536 ; CHECK-NEXT:            %l = load i32, ptr %a, align 4 ->
 537 ; CHECK-NEXT:            store i32 %l, ptr %gep, align 4
 538 ; CHECK-EMPTY:
 539 ; CHECK-NEXT:      Run-time memory checks:
 540 ; CHECK-NEXT:      Grouped accesses:
 541 ; CHECK-EMPTY:
 542 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 543 ; CHECK-NEXT:      SCEV assumptions:
 544 ; CHECK-EMPTY:
 545 ; CHECK-NEXT:      Expressions re-written:
 546 ;
 547 entry:
 548   %gep.off = getelementptr i8, ptr %a, i32 %off
 549   %c = icmp sge i32 %off, 3
 550   br i1 %c, label %loop, label %exit
 551
 552 loop:
 553   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 554   %gep = getelementptr i32, ptr %gep.off, i32 %iv
 555   %l = load i32, ptr %a
 556   store i32 %l, ptr %gep
 557   %iv.next = add i32 %iv, 1
 558   %ec = icmp eq i32 %iv.next, 100
 559   br i1 %ec, label %exit, label %loop
 560
 561 exit:
 562   ret void
 563 }
 564
 565 define void @test_invar_dependence_not_before_via_loop_guard_positive_strided_access_2(ptr %a, i32 %off) {
 566 ; CHECK-LABEL: 'test_invar_dependence_not_before_via_loop_guard_positive_strided_access_2'
 567 ; CHECK-NEXT:    loop:
 568 ; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
 569 ; CHECK-NEXT:  Unknown data dependence.
 570 ; CHECK-NEXT:      Dependences:
 571 ; CHECK-NEXT:        Unknown:
 572 ; CHECK-NEXT:            %l = load i32, ptr %gep, align 4 ->
 573 ; CHECK-NEXT:            store i32 %l, ptr %a, align 4
 574 ; CHECK-EMPTY:
 575 ; CHECK-NEXT:      Run-time memory checks:
 576 ; CHECK-NEXT:      Grouped accesses:
 577 ; CHECK-EMPTY:
 578 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 579 ; CHECK-NEXT:      SCEV assumptions:
 580 ; CHECK-EMPTY:
 581 ; CHECK-NEXT:      Expressions re-written:
 582 ;
 583 entry:
 584   %gep.off = getelementptr i8, ptr %a, i32 %off
 585   %c = icmp sge i32 %off, 3
 586   br i1 %c, label %loop, label %exit
 587
 588 loop:
 589   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 590   %gep = getelementptr i32, ptr %gep.off, i32 %iv
 591   %l = load i32, ptr %gep
 592   store i32 %l, ptr %a
 593   %iv.next = add i32 %iv, 1
 594   %ec = icmp eq i32 %iv.next, 100
 595   br i1 %ec, label %exit, label %loop
 596
 597 exit:
 598   ret void
 599 }
 600
 601 define void @test_invar_dependence_before_positive_strided_access_via_loop_guard_1(ptr %a, i32 %off) {
 602 ; CHECK-LABEL: 'test_invar_dependence_before_positive_strided_access_via_loop_guard_1'
 603 ; CHECK-NEXT:    loop:
 604 ; CHECK-NEXT:      Report: could not determine number of loop iterations
 605 ; CHECK-NEXT:      Dependences:
 606 ; CHECK-NEXT:      Run-time memory checks:
 607 ; CHECK-NEXT:      Grouped accesses:
 608 ; CHECK-EMPTY:
 609 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 610 ; CHECK-NEXT:      SCEV assumptions:
 611 ; CHECK-EMPTY:
 612 ; CHECK-NEXT:      Expressions re-written:
 613 ;
 614 entry:
 615   %gep.off = getelementptr i8, ptr %a, i32 4
 616   %c = icmp sge i32 %off, 0
 617   br i1 %c, label %loop, label %exit
 618
 619 loop:
 620   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 621   %gep = getelementptr i32, ptr %gep.off, i32 %iv
 622   %l = load i32, ptr %gep
 623   store i32 %l, ptr %a
 624   %iv.next = add i32 %iv, %off
 625   %ec = icmp eq i32 %iv.next, 100
 626   br i1 %ec, label %exit, label %loop
 627
 628 exit:
 629   ret void
 630 }
 631
 632 define void @test_invar_dependence_before_positive_strided_access_via_loop_guard_2(ptr %a, i32 %off) {
 633 ; CHECK-LABEL: 'test_invar_dependence_before_positive_strided_access_via_loop_guard_2'
 634 ; CHECK-NEXT:    loop:
 635 ; CHECK-NEXT:      Report: could not determine number of loop iterations
 636 ; CHECK-NEXT:      Dependences:
 637 ; CHECK-NEXT:      Run-time memory checks:
 638 ; CHECK-NEXT:      Grouped accesses:
 639 ; CHECK-EMPTY:
 640 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 641 ; CHECK-NEXT:      SCEV assumptions:
 642 ; CHECK-EMPTY:
 643 ; CHECK-NEXT:      Expressions re-written:
 644 ;
 645 entry:
 646   %gep.off = getelementptr i8, ptr %a, i32 4
 647   %c = icmp sge i32 %off, 0
 648   br i1 %c, label %loop, label %exit
 649
 650 loop:
 651   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 652   %gep = getelementptr i32, ptr %gep.off, i32 %iv
 653   %l = load i32, ptr %a
 654   store i32 %l, ptr %gep
 655   %iv.next = add i32 %iv, %off
 656   %ec = icmp eq i32 %iv.next, 100
 657   br i1 %ec, label %exit, label %loop
 658
 659 exit:
 660   ret void
 661 }
 662
 663 define void @test_invar_dependence_not_known_beforepositive_strided_access_not_known_via_loop_guard_1(ptr %a, i32 %off) {
 664 ; CHECK-LABEL: 'test_invar_dependence_not_known_beforepositive_strided_access_not_known_via_loop_guard_1'
 665 ; CHECK-NEXT:    loop:
 666 ; CHECK-NEXT:      Report: could not determine number of loop iterations
 667 ; CHECK-NEXT:      Dependences:
 668 ; CHECK-NEXT:      Run-time memory checks:
 669 ; CHECK-NEXT:      Grouped accesses:
 670 ; CHECK-EMPTY:
 671 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 672 ; CHECK-NEXT:      SCEV assumptions:
 673 ; CHECK-EMPTY:
 674 ; CHECK-NEXT:      Expressions re-written:
 675 ;
 676 entry:
 677   %gep.off = getelementptr i8, ptr %a, i32 4
 678   br label %loop
 679
 680 loop:
 681   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 682   %gep = getelementptr i32, ptr %gep.off, i32 %iv
 683   %l = load i32, ptr %a
 684   store i32 %l, ptr %gep
 685   %iv.next = add i32 %iv, %off
 686   %ec = icmp eq i32 %iv.next, 100
 687   br i1 %ec, label %exit, label %loop
 688
 689 exit:
 690   ret void
 691 }
 692
 693 define void @test_invar_dependence_not_known_beforepositive_strided_access_not_known_via_loop_guard_2(ptr %a, i32 %off) {
 694 ; CHECK-LABEL: 'test_invar_dependence_not_known_beforepositive_strided_access_not_known_via_loop_guard_2'
 695 ; CHECK-NEXT:    loop:
 696 ; CHECK-NEXT:      Report: could not determine number of loop iterations
 697 ; CHECK-NEXT:      Dependences:
 698 ; CHECK-NEXT:      Run-time memory checks:
 699 ; CHECK-NEXT:      Grouped accesses:
 700 ; CHECK-EMPTY:
 701 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 702 ; CHECK-NEXT:      SCEV assumptions:
 703 ; CHECK-EMPTY:
 704 ; CHECK-NEXT:      Expressions re-written:
 705 ;
 706 entry:
 707   %gep.off = getelementptr i8, ptr %a, i32 4
 708   br label %loop
 709
 710 loop:
 711   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 712   %gep = getelementptr i32, ptr %gep.off, i32 %iv
 713   %l = load i32, ptr %gep
 714   store i32 %l, ptr %a
 715   %iv.next = add i32 %iv, %off
 716   %ec = icmp eq i32 %iv.next, 100
 717   br i1 %ec, label %exit, label %loop
 718
 719 exit:
 720   ret void
 721 }
 722
 723 define void @test_invar_vector_dependence_before_positive_strided_access_1(ptr %a) {
 724 ; CHECK-LABEL: 'test_invar_vector_dependence_before_positive_strided_access_1'
 725 ; CHECK-NEXT:    loop:
 726 ; CHECK-NEXT:      Memory dependences are safe
 727 ; CHECK-NEXT:      Dependences:
 728 ; CHECK-NEXT:      Run-time memory checks:
 729 ; CHECK-NEXT:      Grouped accesses:
 730 ; CHECK-EMPTY:
 731 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 732 ; CHECK-NEXT:      SCEV assumptions:
 733 ; CHECK-EMPTY:
 734 ; CHECK-NEXT:      Expressions re-written:
 735 ;
 736 entry:
 737   %gep.off = getelementptr i8, ptr %a, i32 4
 738   br label %loop
 739
 740 loop:
 741   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 742   %gep = getelementptr i32, ptr %gep.off, i32 %iv
 743   %l = load <4 x i8>, ptr %a
 744   store i32 0, ptr %gep
 745   %iv.next = add i32 %iv, 1
 746   %ec = icmp eq i32 %iv.next, 100
 747   br i1 %ec, label %exit, label %loop
 748
 749 exit:
 750   ret void
 751 }
 752
 753 define void @test_invar_scalable_dependence_before_positive_strided_access_1(ptr %a) {
 754 ; CHECK-LABEL: 'test_invar_scalable_dependence_before_positive_strided_access_1'
 755 ; CHECK-NEXT:    loop:
 756 ; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
 757 ; CHECK-NEXT:  Unknown data dependence.
 758 ; CHECK-NEXT:      Dependences:
 759 ; CHECK-NEXT:        Unknown:
 760 ; CHECK-NEXT:            %l = load <vscale x 4 x i8>, ptr %a, align 4 ->
 761 ; CHECK-NEXT:            store i32 0, ptr %gep, align 4
 762 ; CHECK-EMPTY:
 763 ; CHECK-NEXT:      Run-time memory checks:
 764 ; CHECK-NEXT:      Grouped accesses:
 765 ; CHECK-EMPTY:
 766 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 767 ; CHECK-NEXT:      SCEV assumptions:
 768 ; CHECK-EMPTY:
 769 ; CHECK-NEXT:      Expressions re-written:
 770 ;
 771 entry:
 772   %gep.off = getelementptr i8, ptr %a, i32 4
 773   br label %loop
 774
 775 loop:
 776   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
 777   %gep = getelementptr i32, ptr %gep.off, i32 %iv
 778   %l = load <vscale x 4 x i8>, ptr %a
 779   store i32 0, ptr %gep
 780   %iv.next = add i32 %iv, 1
 781   %ec = icmp eq i32 %iv.next, 100
 782   br i1 %ec, label %exit, label %loop
 783
 784 exit:
 785   ret void
 786 }