llvm/test/Analysis/LoopAccessAnalysis/pointer-phis.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 %s1 = type { [32000 x double], [32000 x double], [32000 x double] }
   5
   6 define i32 @load_with_pointer_phi_no_runtime_checks(ptr %data) {
   7 ; CHECK-LABEL: 'load_with_pointer_phi_no_runtime_checks'
   8 ; CHECK-NEXT:    loop.header:
   9 ; CHECK-NEXT:      Memory dependences are safe
  10 ; CHECK-NEXT:      Dependences:
  11 ; CHECK-NEXT:      Run-time memory checks:
  12 ; CHECK-NEXT:      Grouped accesses:
  13 ; CHECK-EMPTY:
  14 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
  15 ; CHECK-NEXT:      SCEV assumptions:
  16 ; CHECK-EMPTY:
  17 ; CHECK-NEXT:      Expressions re-written:
  18 ;
  19 entry:
  20   br label %loop.header
  21
  22 loop.header:                                        ; preds = %loop.latch, %entry
  23   %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop.latch ]
  24   %iv.next = add nuw nsw i64 %iv, 1
  25   %cmp5 = icmp ult i64 %iv, 15999
  26   %arrayidx = getelementptr inbounds %s1, ptr %data, i64 0, i32 0, i64 %iv
  27   br i1 %cmp5, label %if.then, label %if.else
  28
  29 if.then:                                          ; preds = %loop.header
  30   %gep.1 = getelementptr inbounds %s1, ptr %data, i64 0, i32 1, i64 %iv
  31   br label %loop.latch
  32
  33 if.else:                                          ; preds = %loop.header
  34   %gep.2 = getelementptr inbounds %s1, ptr %data, i64 0, i32 2, i64 %iv
  35   br label %loop.latch
  36
  37 loop.latch:                                          ; preds = %if.else, %if.then
  38   %gep.2.sink = phi ptr [ %gep.2, %if.else ], [ %gep.1, %if.then ]
  39   %v8 = load double, ptr %gep.2.sink, align 8
  40   %mul16 = fmul double 3.0, %v8
  41   store double %mul16, ptr %arrayidx, align 8
  42   %exitcond.not = icmp eq i64 %iv.next, 32000
  43   br i1 %exitcond.not, label %exit, label %loop.header
  44
  45 exit:                                             ; preds = %loop.latch
  46   ret i32 10
  47 }
  48
  49 define i32 @store_with_pointer_phi_no_runtime_checks(ptr %data) {
  50 ; CHECK-LABEL: 'store_with_pointer_phi_no_runtime_checks'
  51 ; CHECK-NEXT:    loop.header:
  52 ; CHECK-NEXT:      Memory dependences are safe
  53 ; CHECK-NEXT:      Dependences:
  54 ; CHECK-NEXT:      Run-time memory checks:
  55 ; CHECK-NEXT:      Grouped accesses:
  56 ; CHECK-EMPTY:
  57 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
  58 ; CHECK-NEXT:      SCEV assumptions:
  59 ; CHECK-EMPTY:
  60 ; CHECK-NEXT:      Expressions re-written:
  61 ;
  62 entry:
  63   br label %loop.header
  64
  65 loop.header:                                        ; preds = %loop.latch, %entry
  66   %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop.latch ]
  67   %iv.next = add nuw nsw i64 %iv, 1
  68   %cmp5 = icmp ult i64 %iv, 15999
  69   %arrayidx = getelementptr inbounds %s1, ptr %data, i64 0, i32 0, i64 %iv
  70   br i1 %cmp5, label %if.then, label %if.else
  71
  72 if.then:                                          ; preds = %loop.header
  73   %gep.1 = getelementptr inbounds %s1, ptr %data, i64 0, i32 1, i64 %iv
  74   br label %loop.latch
  75
  76 if.else:                                          ; preds = %loop.header
  77   %gep.2 = getelementptr inbounds %s1, ptr %data, i64 0, i32 2, i64 %iv
  78   br label %loop.latch
  79
  80 loop.latch:                                          ; preds = %if.else, %if.then
  81   %gep.2.sink = phi ptr [ %gep.2, %if.else ], [ %gep.1, %if.then ]
  82   %v8 = load double, ptr %arrayidx, align 8
  83   %mul16 = fmul double 3.0, %v8
  84   store double %mul16, ptr %gep.2.sink, align 8
  85   %exitcond.not = icmp eq i64 %iv.next, 32000
  86   br i1 %exitcond.not, label %exit, label %loop.header
  87
  88 exit:                                             ; preds = %loop.latch
  89   ret i32 10
  90 }
  91
  92 define i32 @store_with_pointer_phi_runtime_checks(ptr %A, ptr %B, ptr %C) {
  93 ; CHECK-LABEL: 'store_with_pointer_phi_runtime_checks'
  94 ; CHECK-NEXT:    loop.header:
  95 ; CHECK-NEXT:      Memory dependences are safe with run-time checks
  96 ; CHECK-NEXT:      Dependences:
  97 ; CHECK-NEXT:      Run-time memory checks:
  98 ; CHECK-NEXT:      Check 0:
  99 ; CHECK-NEXT:        Comparing group ([[GRP1:0x[0-9a-f]+]]):
 100 ; CHECK-NEXT:          %gep.1 = getelementptr inbounds double, ptr %B, i64 %iv
 101 ; CHECK-NEXT:        Against group ([[GRP2:0x[0-9a-f]+]]):
 102 ; CHECK-NEXT:          %gep.2 = getelementptr inbounds double, ptr %C, i64 %iv
 103 ; CHECK-NEXT:      Check 1:
 104 ; CHECK-NEXT:        Comparing group ([[GRP1]]):
 105 ; CHECK-NEXT:          %gep.1 = getelementptr inbounds double, ptr %B, i64 %iv
 106 ; CHECK-NEXT:        Against group ([[GRP3:0x[0-9a-f]+]]):
 107 ; CHECK-NEXT:          %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
 108 ; CHECK-NEXT:      Check 2:
 109 ; CHECK-NEXT:        Comparing group ([[GRP2]]):
 110 ; CHECK-NEXT:          %gep.2 = getelementptr inbounds double, ptr %C, i64 %iv
 111 ; CHECK-NEXT:        Against group ([[GRP3]]):
 112 ; CHECK-NEXT:          %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
 113 ; CHECK-NEXT:      Grouped accesses:
 114 ; CHECK-NEXT:        Group [[GRP1]]:
 115 ; CHECK-NEXT:          (Low: %B High: (256000 + %B))
 116 ; CHECK-NEXT:            Member: {%B,+,8}<nw><%loop.header>
 117 ; CHECK-NEXT:        Group [[GRP2]]:
 118 ; CHECK-NEXT:          (Low: %C High: (256000 + %C))
 119 ; CHECK-NEXT:            Member: {%C,+,8}<nw><%loop.header>
 120 ; CHECK-NEXT:        Group [[GRP3]]:
 121 ; CHECK-NEXT:          (Low: %A High: (256000 + %A))
 122 ; CHECK-NEXT:            Member: {%A,+,8}<nw><%loop.header>
 123 ; CHECK-EMPTY:
 124 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 125 ; CHECK-NEXT:      SCEV assumptions:
 126 ; CHECK-EMPTY:
 127 ; CHECK-NEXT:      Expressions re-written:
 128 ;
 129 entry:
 130   br label %loop.header
 131
 132 loop.header:                                        ; preds = %loop.latch, %entry
 133   %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop.latch ]
 134   %iv.next = add nuw nsw i64 %iv, 1
 135   %cmp5 = icmp ult i64 %iv, 15999
 136   %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
 137   br i1 %cmp5, label %if.then, label %if.else
 138
 139 if.then:                                          ; preds = %loop.header
 140   %gep.1 = getelementptr inbounds double, ptr %B, i64 %iv
 141   br label %loop.latch
 142
 143 if.else:                                          ; preds = %loop.header
 144   %gep.2 = getelementptr inbounds double, ptr %C, i64 %iv
 145   br label %loop.latch
 146
 147 loop.latch:                                          ; preds = %if.else, %if.then
 148   %gep.2.sink = phi ptr [ %gep.2, %if.else ], [ %gep.1, %if.then ]
 149   %v8 = load double, ptr %arrayidx, align 8
 150   %mul16 = fmul double 3.0, %v8
 151   store double %mul16, ptr %gep.2.sink, align 8
 152   %exitcond.not = icmp eq i64 %iv.next, 32000
 153   br i1 %exitcond.not, label %exit, label %loop.header
 154
 155 exit:                                             ; preds = %loop.latch
 156   ret i32 10
 157 }
 158
 159 define i32 @load_with_pointer_phi_outside_loop(ptr %A, ptr %B, ptr %C, i1 %c.0, i1 %c.1) {
 160 ; CHECK-LABEL: 'load_with_pointer_phi_outside_loop'
 161 ; CHECK-NEXT:    loop.header:
 162 ; 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
 163 ; CHECK-NEXT:  Unknown data dependence.
 164 ; CHECK-NEXT:      Dependences:
 165 ; CHECK-NEXT:        Unknown:
 166 ; CHECK-NEXT:            %v8 = load double, ptr %ptr, align 8 ->
 167 ; CHECK-NEXT:            store double %mul16, ptr %arrayidx, align 8
 168 ; CHECK-EMPTY:
 169 ; CHECK-NEXT:      Run-time memory checks:
 170 ; CHECK-NEXT:      Grouped accesses:
 171 ; CHECK-EMPTY:
 172 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 173 ; CHECK-NEXT:      SCEV assumptions:
 174 ; CHECK-EMPTY:
 175 ; CHECK-NEXT:      Expressions re-written:
 176 ;
 177 entry:
 178   br i1 %c.0, label %if.then, label %if.else
 179
 180 if.then:
 181   br label %loop.ph
 182
 183 if.else:
 184   %ptr.select = select i1 %c.1, ptr %C, ptr %B
 185   br label %loop.ph
 186
 187 loop.ph:
 188   %ptr = phi ptr [ %A, %if.then ], [ %ptr.select, %if.else ]
 189   br label %loop.header
 190
 191 loop.header:                                        ; preds = %loop.latch, %entry
 192   %iv = phi i64 [ 0, %loop.ph ], [ %iv.next, %loop.header ]
 193   %iv.next = add nuw nsw i64 %iv, 1
 194   %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
 195   %v8 = load double, ptr %ptr, align 8
 196   %mul16 = fmul double 3.0, %v8
 197   store double %mul16, ptr %arrayidx, align 8
 198   %exitcond.not = icmp eq i64 %iv.next, 32000
 199   br i1 %exitcond.not, label %exit, label %loop.header
 200
 201 exit:                                             ; preds = %loop.latch
 202   ret i32 10
 203 }
 204
 205 define i32 @store_with_pointer_phi_outside_loop(ptr %A, ptr %B, ptr %C, i1 %c.0, i1 %c.1) {
 206 ; CHECK-LABEL: 'store_with_pointer_phi_outside_loop'
 207 ; CHECK-NEXT:    loop.header:
 208 ; 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
 209 ; CHECK-NEXT:  Unknown data dependence.
 210 ; CHECK-NEXT:      Dependences:
 211 ; CHECK-NEXT:        Unknown:
 212 ; CHECK-NEXT:            %v8 = load double, ptr %arrayidx, align 8 ->
 213 ; CHECK-NEXT:            store double %mul16, ptr %ptr, align 8
 214 ; CHECK-EMPTY:
 215 ; CHECK-NEXT:      Run-time memory checks:
 216 ; CHECK-NEXT:      Grouped accesses:
 217 ; CHECK-EMPTY:
 218 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 219 ; CHECK-NEXT:      SCEV assumptions:
 220 ; CHECK-EMPTY:
 221 ; CHECK-NEXT:      Expressions re-written:
 222 ;
 223 entry:
 224   br i1 %c.0, label %if.then, label %if.else
 225
 226 if.then:
 227   br label %loop.ph
 228
 229 if.else:
 230   %ptr.select = select i1 %c.1, ptr %C, ptr %B
 231   br label %loop.ph
 232
 233 loop.ph:
 234   %ptr = phi ptr [ %A, %if.then ], [ %ptr.select, %if.else ]
 235   br label %loop.header
 236
 237 loop.header:                                        ; preds = %loop.latch, %entry
 238   %iv = phi i64 [ 0, %loop.ph ], [ %iv.next, %loop.header ]
 239   %iv.next = add nuw nsw i64 %iv, 1
 240   %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
 241   %v8 = load double, ptr %arrayidx, align 8
 242   %mul16 = fmul double 3.0, %v8
 243   store double %mul16, ptr %ptr, align 8
 244   %exitcond.not = icmp eq i64 %iv.next, 32000
 245   br i1 %exitcond.not, label %exit, label %loop.header
 246
 247 exit:                                             ; preds = %loop.latch
 248   ret i32 10
 249 }
 250
 251 define i32 @store_with_pointer_phi_incoming_phi(ptr %A, ptr %B, ptr %C, i1 %c.0, i1 %c.1) {
 252 ; CHECK-LABEL: 'store_with_pointer_phi_incoming_phi'
 253 ; CHECK-NEXT:    loop.header:
 254 ; 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
 255 ; CHECK-NEXT:  Unknown data dependence.
 256 ; CHECK-NEXT:      Dependences:
 257 ; CHECK-NEXT:        Unknown:
 258 ; CHECK-NEXT:            %v8 = load double, ptr %arrayidx, align 8 ->
 259 ; CHECK-NEXT:            store double %mul16, ptr %ptr.2, align 8
 260 ; CHECK-EMPTY:
 261 ; CHECK-NEXT:      Run-time memory checks:
 262 ; CHECK-NEXT:      Check 0:
 263 ; CHECK-NEXT:        Comparing group ([[GRP4:0x[0-9a-f]+]]):
 264 ; CHECK-NEXT:        ptr %C
 265 ; CHECK-NEXT:        Against group ([[GRP5:0x[0-9a-f]+]]):
 266 ; CHECK-NEXT:        ptr %B
 267 ; CHECK-NEXT:      Check 1:
 268 ; CHECK-NEXT:        Comparing group ([[GRP4]]):
 269 ; CHECK-NEXT:        ptr %C
 270 ; CHECK-NEXT:        Against group ([[GRP6:0x[0-9a-f]+]]):
 271 ; CHECK-NEXT:          %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
 272 ; CHECK-NEXT:        ptr %A
 273 ; CHECK-NEXT:      Check 2:
 274 ; CHECK-NEXT:        Comparing group ([[GRP5]]):
 275 ; CHECK-NEXT:        ptr %B
 276 ; CHECK-NEXT:        Against group ([[GRP6]]):
 277 ; CHECK-NEXT:          %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
 278 ; CHECK-NEXT:        ptr %A
 279 ; CHECK-NEXT:      Grouped accesses:
 280 ; CHECK-NEXT:        Group [[GRP4]]:
 281 ; CHECK-NEXT:          (Low: %C High: (8 + %C))
 282 ; CHECK-NEXT:            Member: %C
 283 ; CHECK-NEXT:        Group [[GRP5]]:
 284 ; CHECK-NEXT:          (Low: %B High: (8 + %B))
 285 ; CHECK-NEXT:            Member: %B
 286 ; CHECK-NEXT:        Group [[GRP6]]:
 287 ; CHECK-NEXT:          (Low: %A High: (256000 + %A))
 288 ; CHECK-NEXT:            Member: {%A,+,8}<nuw><%loop.header>
 289 ; CHECK-NEXT:            Member: %A
 290 ; CHECK-EMPTY:
 291 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 292 ; CHECK-NEXT:      SCEV assumptions:
 293 ; CHECK-EMPTY:
 294 ; CHECK-NEXT:      Expressions re-written:
 295 ;
 296 ; CHECK-EMPTY
 297 entry:
 298   br label %loop.header
 299
 300 loop.header:                                        ; preds = %loop.latch, %entry
 301   %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop.latch ]
 302   %iv.next = add nuw nsw i64 %iv, 1
 303   %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
 304   %v8 = load double, ptr %arrayidx, align 8
 305   %mul16 = fmul double 3.0, %v8
 306   br i1 %c.0, label %loop.then, label %loop.latch
 307
 308 loop.then:
 309   br i1 %c.0, label %loop.then.2, label %loop.else.2
 310
 311 loop.then.2:
 312   br label %merge.2
 313
 314 loop.else.2:
 315   br label %merge.2
 316
 317
 318 merge.2:
 319   %ptr = phi ptr [ %A, %loop.then.2 ], [ %B, %loop.else.2 ]
 320   br label %loop.latch
 321
 322
 323 loop.latch:
 324   %ptr.2 = phi ptr [ %ptr, %merge.2], [ %C, %loop.header ]
 325   store double %mul16, ptr %ptr.2, align 8
 326   %exitcond.not = icmp eq i64 %iv.next, 32000
 327   br i1 %exitcond.not, label %exit, label %loop.header
 328
 329 exit:                                             ; preds = %loop.latch
 330   ret i32 10
 331 }
 332
 333 ; Test cases with pointer phis forming a cycle.
 334 define i32 @store_with_pointer_phi_incoming_phi_irreducible_cycle(ptr %A, ptr %B, ptr %C, i1 %c.0, i1 %c.1) {
 335 ; CHECK-LABEL: 'store_with_pointer_phi_incoming_phi_irreducible_cycle'
 336 ; CHECK-NEXT:    loop.header:
 337 ; 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
 338 ; CHECK-NEXT:  Unknown data dependence.
 339 ; CHECK-NEXT:      Dependences:
 340 ; CHECK-NEXT:        Unknown:
 341 ; CHECK-NEXT:            %v8 = load double, ptr %arrayidx, align 8 ->
 342 ; CHECK-NEXT:            store double %mul16, ptr %ptr.3, align 8
 343 ; CHECK-EMPTY:
 344 ; CHECK-NEXT:      Run-time memory checks:
 345 ; CHECK-NEXT:      Check 0:
 346 ; CHECK-NEXT:        Comparing group ([[GRP7:0x[0-9a-f]+]]):
 347 ; CHECK-NEXT:        ptr %C
 348 ; CHECK-NEXT:        Against group ([[GRP8:0x[0-9a-f]+]]):
 349 ; CHECK-NEXT:        ptr %B
 350 ; CHECK-NEXT:      Check 1:
 351 ; CHECK-NEXT:        Comparing group ([[GRP7]]):
 352 ; CHECK-NEXT:        ptr %C
 353 ; CHECK-NEXT:        Against group ([[GRP9:0x[0-9a-f]+]]):
 354 ; CHECK-NEXT:          %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
 355 ; CHECK-NEXT:        ptr %A
 356 ; CHECK-NEXT:      Check 2:
 357 ; CHECK-NEXT:        Comparing group ([[GRP8]]):
 358 ; CHECK-NEXT:        ptr %B
 359 ; CHECK-NEXT:        Against group ([[GRP9]]):
 360 ; CHECK-NEXT:          %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
 361 ; CHECK-NEXT:        ptr %A
 362 ; CHECK-NEXT:      Grouped accesses:
 363 ; CHECK-NEXT:        Group [[GRP7]]:
 364 ; CHECK-NEXT:          (Low: %C High: (8 + %C))
 365 ; CHECK-NEXT:            Member: %C
 366 ; CHECK-NEXT:        Group [[GRP8]]:
 367 ; CHECK-NEXT:          (Low: %B High: (8 + %B))
 368 ; CHECK-NEXT:            Member: %B
 369 ; CHECK-NEXT:        Group [[GRP9]]:
 370 ; CHECK-NEXT:          (Low: %A High: (256000 + %A))
 371 ; CHECK-NEXT:            Member: {%A,+,8}<nuw><%loop.header>
 372 ; CHECK-NEXT:            Member: %A
 373 ; CHECK-EMPTY:
 374 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 375 ; CHECK-NEXT:      SCEV assumptions:
 376 ; CHECK-EMPTY:
 377 ; CHECK-NEXT:      Expressions re-written:
 378 ;
 379 ; CHECK-EMPTY
 380 entry:
 381   br label %loop.header
 382
 383 loop.header:                                        ; preds = %loop.latch, %entry
 384   %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop.latch ]
 385   %iv.next = add nuw nsw i64 %iv, 1
 386   %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
 387   %v8 = load double, ptr %arrayidx, align 8
 388   %mul16 = fmul double 3.0, %v8
 389   br i1 %c.0, label %loop.then, label %loop.latch
 390
 391 loop.then:
 392   br i1 %c.0, label %BB.A, label %BB.B
 393
 394 BB.A:
 395   %ptr = phi ptr [ %A, %loop.then ], [ %ptr.2, %BB.B ]
 396   br label %BB.B
 397
 398 BB.B:
 399   %ptr.2 = phi ptr [ %ptr, %BB.A ], [ %B, %loop.then ]
 400   br i1 %c.1, label %loop.latch, label %BB.A
 401
 402 loop.latch:
 403   %ptr.3 = phi ptr [ %ptr.2, %BB.B ], [ %C, %loop.header ]
 404   store double %mul16, ptr %ptr.3, align 8
 405   %exitcond.not = icmp eq i64 %iv.next, 32000
 406   br i1 %exitcond.not, label %exit, label %loop.header
 407
 408 exit:                                             ; preds = %loop.latch
 409   ret i32 10
 410 }
 411
 412 define i32 @store_with_pointer_phi_outside_loop_select(ptr %A, ptr %B, ptr %C, i1 %c.0, i1 %c.1) {
 413 ; CHECK-LABEL: 'store_with_pointer_phi_outside_loop_select'
 414 ; CHECK-NEXT:    loop.header:
 415 ; 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
 416 ; CHECK-NEXT:  Unknown data dependence.
 417 ; CHECK-NEXT:      Dependences:
 418 ; CHECK-NEXT:        Unknown:
 419 ; CHECK-NEXT:            %v8 = load double, ptr %arrayidx, align 8 ->
 420 ; CHECK-NEXT:            store double %mul16, ptr %ptr, align 8
 421 ; CHECK-EMPTY:
 422 ; CHECK-NEXT:      Run-time memory checks:
 423 ; CHECK-NEXT:      Grouped accesses:
 424 ; CHECK-EMPTY:
 425 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 426 ; CHECK-NEXT:      SCEV assumptions:
 427 ; CHECK-EMPTY:
 428 ; CHECK-NEXT:      Expressions re-written:
 429 ;
 430 entry:
 431   br i1 %c.0, label %if.then, label %if.else
 432
 433 if.then:
 434   br label %loop.ph
 435
 436 if.else:
 437   %ptr.select = select i1 %c.1, ptr %C, ptr %B
 438   br label %loop.ph
 439
 440 loop.ph:
 441   %ptr = phi ptr [ %A, %if.then ], [ %ptr.select, %if.else ]
 442   br label %loop.header
 443
 444 loop.header:                                        ; preds = %loop.latch, %entry
 445   %iv = phi i64 [ 0, %loop.ph ], [ %iv.next, %loop.header ]
 446   %iv.next = add nuw nsw i64 %iv, 1
 447   %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
 448   %v8 = load double, ptr %arrayidx, align 8
 449   %mul16 = fmul double 3.0, %v8
 450   store double %mul16, ptr %ptr, align 8
 451   %exitcond.not = icmp eq i64 %iv.next, 32000
 452   br i1 %exitcond.not, label %exit, label %loop.header
 453
 454 exit:                                             ; preds = %loop.latch
 455   ret i32 10
 456 }
 457
 458 define i32 @store_with_pointer_phi_in_same_bb_use_other_phi(ptr %A, ptr %B, ptr %C, ptr %D, i1 %c.0, i1 %c.1) {
 459 ; CHECK-LABEL: 'store_with_pointer_phi_in_same_bb_use_other_phi'
 460 ; CHECK-NEXT:    loop.header:
 461 ; CHECK-NEXT:      Report: cannot identify array bounds
 462 ; CHECK-NEXT:      Dependences:
 463 ; CHECK-NEXT:      Run-time memory checks:
 464 ; CHECK-NEXT:      Grouped accesses:
 465 ; CHECK-EMPTY:
 466 ; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
 467 ; CHECK-NEXT:      SCEV assumptions:
 468 ; CHECK-EMPTY:
 469 ; CHECK-NEXT:      Expressions re-written:
 470 ;
 471 entry:
 472   br label %loop.header
 473
 474 loop.header:                                        ; preds = %loop.latch, %entry
 475   %ptr.0 = phi ptr [ %C, %entry ], [ %D, %loop.header ]
 476   %ptr.1 = phi ptr [ %B, %entry ], [ %ptr.0, %loop.header ]
 477   %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop.header ]
 478   %iv.next = add nuw nsw i64 %iv, 1
 479   %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
 480   %v8 = load double, ptr %arrayidx, align 8
 481   %mul16 = fmul double 3.0, %v8
 482   store double %mul16, ptr %ptr.1, align 8
 483   %exitcond.not = icmp eq i64 %iv.next, 32000
 484   br i1 %exitcond.not, label %exit, label %loop.header
 485
 486 exit:                                             ; preds = %loop.latch
 487   ret i32 10
 488 }
 489
 490 define void @phi_load_store_memdep_check(i1 %c, ptr %A, ptr %B, ptr %C) {
 491 ; CHECK-LABEL: 'phi_load_store_memdep_check'
 492 ; CHECK-NEXT:    for.body:
 493 ; 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
 494 ; CHECK-NEXT:  Unknown data dependence.
 495 ; CHECK-NEXT:      Dependences:
 496 ; CHECK-NEXT:        Unknown:
 497 ; CHECK-NEXT:            %lv3 = load i16, ptr %c.sink, align 2 ->
 498 ; CHECK-NEXT:            store i16 %add, ptr %c.sink, align 1
 499 ; CHECK-EMPTY:
 500 ; CHECK-NEXT:        Unknown:
 501 ; CHECK-NEXT:            %lv3 = load i16, ptr %c.sink, align 2 ->
 502 ; CHECK-NEXT:            store i16 %add, ptr %c.sink, align 1
 503 ; CHECK-EMPTY:
 504 ; CHECK-NEXT:        Unknown:
 505 ; CHECK-NEXT:            %lv = load i16, ptr %A, align 1 ->
 506 ; CHECK-NEXT:            store i16 %lv, ptr %A, align 1
 507 ; CHECK-EMPTY:
 508 ; CHECK-NEXT:        Unknown:
 509 ; CHECK-NEXT:            store i16 %lv, ptr %A, align 1 ->
 510 ; CHECK-NEXT:            %lv2 = load i16, ptr %A, align 1
 511 ; CHECK-EMPTY:
 512 ; CHECK-NEXT:      Run-time memory checks:
 513 ; CHECK-NEXT:      Check 0:
 514 ; CHECK-NEXT:        Comparing group ([[GRP10:0x[0-9a-f]+]]):
 515 ; CHECK-NEXT:        ptr %A
 516 ; CHECK-NEXT:        ptr %A
 517 ; CHECK-NEXT:        Against group ([[GRP11:0x[0-9a-f]+]]):
 518 ; CHECK-NEXT:        ptr %C
 519 ; CHECK-NEXT:        ptr %C
 520 ; CHECK-NEXT:      Check 1:
 521 ; CHECK-NEXT:        Comparing group ([[GRP10]]):
 522 ; CHECK-NEXT:        ptr %A
 523 ; CHECK-NEXT:        ptr %A
 524 ; CHECK-NEXT:        Against group ([[GRP12:0x[0-9a-f]+]]):
 525 ; CHECK-NEXT:        ptr %B
 526 ; CHECK-NEXT:        ptr %B
 527 ; CHECK-NEXT:      Check 2:
 528 ; CHECK-NEXT:        Comparing group ([[GRP11]]):
 529 ; CHECK-NEXT:        ptr %C
 530 ; CHECK-NEXT:        ptr %C
 531 ; CHECK-NEXT:        Against group ([[GRP12]]):
 532 ; CHECK-NEXT:        ptr %B
 533 ; CHECK-NEXT:        ptr %B
 534 ; CHECK-NEXT:      Grouped accesses:
 535 ; CHECK-NEXT:        Group [[GRP10]]:
 536 ; CHECK-NEXT:          (Low: %A High: (2 + %A))
 537 ; CHECK-NEXT:            Member: %A
 538 ; CHECK-NEXT:            Member: %A
 539 ; CHECK-NEXT:        Group [[GRP11]]:
 540 ; CHECK-NEXT:          (Low: %C High: (2 + %C))
 541 ; CHECK-NEXT:            Member: %C
 542 ; CHECK-NEXT:            Member: %C
 543 ; CHECK-NEXT:        Group [[GRP12]]:
 544 ; CHECK-NEXT:          (Low: %B High: (2 + %B))
 545 ; CHECK-NEXT:            Member: %B
 546 ; CHECK-NEXT:            Member: %B
 547 ; CHECK-EMPTY:
 548 ; CHECK-NEXT:      Non vectorizable stores to invariant address were found in loop.
 549 ; CHECK-NEXT:      SCEV assumptions:
 550 ; CHECK-EMPTY:
 551 ; CHECK-NEXT:      Expressions re-written:
 552 ;
 553 entry:
 554   br label %for.body
 555
 556 for.body:                                         ; preds = %if.end, %entry
 557   %iv = phi i16 [ 0, %entry ], [ %iv.next, %if.end ]
 558   %lv = load i16, ptr %A, align 1
 559   store i16 %lv, ptr %A, align 1
 560   br i1 %c, label %if.then, label %if.end
 561
 562 if.then:                                          ; preds = %for.body
 563   %lv2 = load i16, ptr %A, align 1
 564   br label %if.end
 565
 566 if.end:                                           ; preds = %if.then, %for.body
 567   %c.sink = phi ptr [ %B, %if.then ], [ %C, %for.body ]
 568   %lv3 = load i16, ptr %c.sink
 569   %add = add i16 %lv3, 10
 570   store i16 %add, ptr %c.sink, align 1
 571   %iv.next = add nuw nsw i16 %iv, 1
 572   %tobool.not = icmp eq i16 %iv.next, 1000
 573   br i1 %tobool.not, label %for.end.loopexit, label %for.body
 574
 575 for.end.loopexit:                                 ; preds = %if.end
 576   ret void
 577 }