llvm/test/Analysis/DependenceAnalysis/Propagating.ll

   1 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
   2 ; RUN: | FileCheck %s
   3
   4 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
   5 target triple = "x86_64-apple-macosx10.6.0"
   6
   7
   8 ;;  for (long int i = 0; i < 100; i++)
   9 ;;    for (long int j = 0; j < 100; j++) {
  10 ;;      A[i + 1][i + j] = i;
  11 ;;      *B++ = A[i][i + j];
  12
  13 define void @prop0(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
  14 entry:
  15   br label %for.cond1.preheader
  16
  17 ; CHECK-LABEL: prop0
  18 ; CHECK: da analyze - none!
  19 ; CHECK: da analyze - flow [< >]!
  20 ; CHECK: da analyze - confused!
  21 ; CHECK: da analyze - none!
  22 ; CHECK: da analyze - confused!
  23 ; CHECK: da analyze - none!
  24
  25 for.cond1.preheader:                              ; preds = %entry, %for.inc9
  26   %B.addr.04 = phi ptr [ %B, %entry ], [ %scevgep, %for.inc9 ]
  27   %i.03 = phi i64 [ 0, %entry ], [ %inc10, %for.inc9 ]
  28   br label %for.body3
  29
  30 for.body3:                                        ; preds = %for.cond1.preheader, %for.body3
  31   %j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
  32   %B.addr.11 = phi ptr [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
  33   %conv = trunc i64 %i.03 to i32
  34   %add = add nsw i64 %i.03, %j.02
  35   %add4 = add nsw i64 %i.03, 1
  36   %arrayidx5 = getelementptr inbounds [100 x i32], ptr %A, i64 %add4, i64 %add
  37   store i32 %conv, ptr %arrayidx5, align 4
  38   %add6 = add nsw i64 %i.03, %j.02
  39   %arrayidx8 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.03, i64 %add6
  40   %0 = load i32, ptr %arrayidx8, align 4
  41   %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.11, i64 1
  42   store i32 %0, ptr %B.addr.11, align 4
  43   %inc = add nsw i64 %j.02, 1
  44   %exitcond = icmp ne i64 %inc, 100
  45   br i1 %exitcond, label %for.body3, label %for.inc9
  46
  47 for.inc9:                                         ; preds = %for.body3
  48   %scevgep = getelementptr i32, ptr %B.addr.04, i64 100
  49   %inc10 = add nsw i64 %i.03, 1
  50   %exitcond5 = icmp ne i64 %inc10, 100
  51   br i1 %exitcond5, label %for.cond1.preheader, label %for.end11
  52
  53 for.end11:                                        ; preds = %for.inc9
  54   ret void
  55 }
  56
  57
  58 ;;  for (long int i = 0; i < 100; i++)
  59 ;;    for (long int j = 0; j < 100; j++)
  60 ;;      for (long int k = 0; k < 100; k++) {
  61 ;;        A[j - i][i + 1][j + k] = i;
  62 ;;        *B++ = A[j - i][i][j + k];
  63
  64 define void @prop1(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
  65 entry:
  66   br label %for.cond1.preheader
  67
  68 ; CHECK-LABEL: prop1
  69 ; CHECK: da analyze - output [* * *]!
  70 ; CHECK: da analyze - flow [<> <> *]!
  71 ; CHECK: da analyze - confused!
  72 ; CHECK: da analyze - input [* * *]!
  73 ; CHECK: da analyze - confused!
  74 ; CHECK: da analyze - none!
  75
  76 for.cond1.preheader:                              ; preds = %entry, %for.inc18
  77   %B.addr.06 = phi ptr [ %B, %entry ], [ %scevgep7, %for.inc18 ]
  78   %i.05 = phi i64 [ 0, %entry ], [ %inc19, %for.inc18 ]
  79   br label %for.cond4.preheader
  80
  81 for.cond4.preheader:                              ; preds = %for.cond1.preheader, %for.inc15
  82   %B.addr.14 = phi ptr [ %B.addr.06, %for.cond1.preheader ], [ %scevgep, %for.inc15 ]
  83   %j.03 = phi i64 [ 0, %for.cond1.preheader ], [ %inc16, %for.inc15 ]
  84   br label %for.body6
  85
  86 for.body6:                                        ; preds = %for.cond4.preheader, %for.body6
  87   %k.02 = phi i64 [ 0, %for.cond4.preheader ], [ %inc, %for.body6 ]
  88   %B.addr.21 = phi ptr [ %B.addr.14, %for.cond4.preheader ], [ %incdec.ptr, %for.body6 ]
  89   %conv = trunc i64 %i.05 to i32
  90   %add = add nsw i64 %j.03, %k.02
  91   %add7 = add nsw i64 %i.05, 1
  92   %sub = sub nsw i64 %j.03, %i.05
  93   %arrayidx9 = getelementptr inbounds [100 x [100 x i32]], ptr %A, i64 %sub, i64 %add7, i64 %add
  94   store i32 %conv, ptr %arrayidx9, align 4
  95   %add10 = add nsw i64 %j.03, %k.02
  96   %sub11 = sub nsw i64 %j.03, %i.05
  97   %arrayidx14 = getelementptr inbounds [100 x [100 x i32]], ptr %A, i64 %sub11, i64 %i.05, i64 %add10
  98   %0 = load i32, ptr %arrayidx14, align 4
  99   %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.21, i64 1
 100   store i32 %0, ptr %B.addr.21, align 4
 101   %inc = add nsw i64 %k.02, 1
 102   %exitcond = icmp ne i64 %inc, 100
 103   br i1 %exitcond, label %for.body6, label %for.inc15
 104
 105 for.inc15:                                        ; preds = %for.body6
 106   %scevgep = getelementptr i32, ptr %B.addr.14, i64 100
 107   %inc16 = add nsw i64 %j.03, 1
 108   %exitcond8 = icmp ne i64 %inc16, 100
 109   br i1 %exitcond8, label %for.cond4.preheader, label %for.inc18
 110
 111 for.inc18:                                        ; preds = %for.inc15
 112   %scevgep7 = getelementptr i32, ptr %B.addr.06, i64 10000
 113   %inc19 = add nsw i64 %i.05, 1
 114   %exitcond9 = icmp ne i64 %inc19, 100
 115   br i1 %exitcond9, label %for.cond1.preheader, label %for.end20
 116
 117 for.end20:                                        ; preds = %for.inc18
 118   ret void
 119 }
 120
 121
 122 ;;  for (long int i = 0; i < 100; i++)
 123 ;;    for (long int j = 0; j ptr]!
 124 ;;    for (long int j = 0; j < 100; j++) {
 125 ;;      A[i - 1][2*i] = i;
 126 ;;      *B++ = A[i][i + j + 110];
 127
 128 define void @prop2(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
 129 entry:
 130   br label %for.cond1.preheader
 131
 132 ; CHECK-LABEL: prop2
 133 ; CHECK: da analyze - consistent output [0 S]!
 134 ; CHECK: da analyze - flow [> *]!
 135 ; CHECK: da analyze - confused!
 136 ; CHECK: da analyze - none!
 137 ; CHECK: da analyze - confused!
 138 ; CHECK: da analyze - none!
 139
 140 for.cond1.preheader:                              ; preds = %entry, %for.inc8
 141   %B.addr.04 = phi ptr [ %B, %entry ], [ %scevgep, %for.inc8 ]
 142   %i.03 = phi i64 [ 0, %entry ], [ %inc9, %for.inc8 ]
 143   br label %for.body3
 144
 145 for.body3:                                        ; preds = %for.cond1.preheader, %for.body3
 146   %j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
 147   %B.addr.11 = phi ptr [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
 148   %conv = trunc i64 %i.03 to i32
 149   %mul = shl nsw i64 %i.03, 1
 150   %sub = add nsw i64 %i.03, -1
 151   %arrayidx4 = getelementptr inbounds [100 x i32], ptr %A, i64 %sub, i64 %mul
 152   store i32 %conv, ptr %arrayidx4, align 4
 153   %add = add nsw i64 %i.03, %j.02
 154   %add5 = add nsw i64 %add, 110
 155   %arrayidx7 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.03, i64 %add5
 156   %0 = load i32, ptr %arrayidx7, align 4
 157   %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.11, i64 1
 158   store i32 %0, ptr %B.addr.11, align 4
 159   %inc = add nsw i64 %j.02, 1
 160   %exitcond = icmp ne i64 %inc, 100
 161   br i1 %exitcond, label %for.body3, label %for.inc8
 162
 163 for.inc8:                                         ; preds = %for.body3
 164   %scevgep = getelementptr i32, ptr %B.addr.04, i64 100
 165   %inc9 = add nsw i64 %i.03, 1
 166   %exitcond5 = icmp ne i64 %inc9, 100
 167   br i1 %exitcond5, label %for.cond1.preheader, label %for.end10
 168
 169 for.end10:                                        ; preds = %for.inc8
 170   ret void
 171 }
 172
 173
 174 ;;  for (long int i = 0; i < 100; i++)
 175 ;;    for (long int j = 0; j < 100; j++) {
 176 ;;      A[i][2*j + i] = i;
 177 ;;      *B++ = A[i][2*j - i + 5];
 178
 179 define void @prop3(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
 180 entry:
 181   br label %for.cond1.preheader
 182
 183 ; CHECK-LABEL: prop3
 184 ; CHECK: da analyze - output [* *]!
 185 ; CHECK: da analyze - flow [<> *]!
 186 ; CHECK: da analyze - confused!
 187 ; CHECK: da analyze - input [* *]!
 188 ; CHECK: da analyze - confused!
 189 ; CHECK: da analyze - none!
 190
 191 for.cond1.preheader:                              ; preds = %entry, %for.inc9
 192   %B.addr.04 = phi ptr [ %B, %entry ], [ %scevgep, %for.inc9 ]
 193   %i.03 = phi i64 [ 0, %entry ], [ %inc10, %for.inc9 ]
 194   br label %for.body3
 195
 196 for.body3:                                        ; preds = %for.cond1.preheader, %for.body3
 197   %j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
 198   %B.addr.11 = phi ptr [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
 199   %conv = trunc i64 %i.03 to i32
 200   %mul = shl nsw i64 %j.02, 1
 201   %add = add nsw i64 %mul, %i.03
 202   %arrayidx4 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.03, i64 %add
 203   store i32 %conv, ptr %arrayidx4, align 4
 204   %mul5 = shl nsw i64 %j.02, 1
 205   %sub = sub nsw i64 %mul5, %i.03
 206   %add6 = add nsw i64 %sub, 5
 207   %arrayidx8 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.03, i64 %add6
 208   %0 = load i32, ptr %arrayidx8, align 4
 209   %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.11, i64 1
 210   store i32 %0, ptr %B.addr.11, align 4
 211   %inc = add nsw i64 %j.02, 1
 212   %exitcond = icmp ne i64 %inc, 100
 213   br i1 %exitcond, label %for.body3, label %for.inc9
 214
 215 for.inc9:                                         ; preds = %for.body3
 216   %scevgep = getelementptr i32, ptr %B.addr.04, i64 100
 217   %inc10 = add nsw i64 %i.03, 1
 218   %exitcond5 = icmp ne i64 %inc10, 100
 219   br i1 %exitcond5, label %for.cond1.preheader, label %for.end11
 220
 221 for.end11:                                        ; preds = %for.inc9
 222   ret void
 223 }
 224
 225
 226 ;;  for (long int i = 0; i < 100; i++)
 227 ;;    for (long int j = 0; j < 100; j++) {
 228 ;;      A[i + 2][2*i + j + 1] = i;
 229 ;;      *B++ = A[i][2*i + j];
 230
 231 define void @prop4(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
 232 entry:
 233   br label %for.cond1.preheader
 234
 235 ; CHECK-LABEL: prop4
 236 ; CHECK: da analyze - none!
 237 ; CHECK: da analyze - flow [< <>]!
 238 ; CHECK: da analyze - confused!
 239 ; CHECK: da analyze - none!
 240 ; CHECK: da analyze - confused!
 241 ; CHECK: da analyze - none!
 242
 243 for.cond1.preheader:                              ; preds = %entry, %for.inc11
 244   %B.addr.04 = phi ptr [ %B, %entry ], [ %scevgep, %for.inc11 ]
 245   %i.03 = phi i64 [ 0, %entry ], [ %inc12, %for.inc11 ]
 246   br label %for.body3
 247
 248 for.body3:                                        ; preds = %for.cond1.preheader, %for.body3
 249   %j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
 250   %B.addr.11 = phi ptr [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
 251   %conv = trunc i64 %i.03 to i32
 252   %mul = shl nsw i64 %i.03, 1
 253   %add = add nsw i64 %mul, %j.02
 254   %add4 = add nsw i64 %add, 1
 255   %add5 = add nsw i64 %i.03, 2
 256   %arrayidx6 = getelementptr inbounds [100 x i32], ptr %A, i64 %add5, i64 %add4
 257   store i32 %conv, ptr %arrayidx6, align 4
 258   %mul7 = shl nsw i64 %i.03, 1
 259   %add8 = add nsw i64 %mul7, %j.02
 260   %arrayidx10 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.03, i64 %add8
 261   %0 = load i32, ptr %arrayidx10, align 4
 262   %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.11, i64 1
 263   store i32 %0, ptr %B.addr.11, align 4
 264   %inc = add nsw i64 %j.02, 1
 265   %exitcond = icmp ne i64 %inc, 100
 266   br i1 %exitcond, label %for.body3, label %for.inc11
 267
 268 for.inc11:                                        ; preds = %for.body3
 269   %scevgep = getelementptr i32, ptr %B.addr.04, i64 100
 270   %inc12 = add nsw i64 %i.03, 1
 271   %exitcond5 = icmp ne i64 %inc12, 100
 272   br i1 %exitcond5, label %for.cond1.preheader, label %for.end13
 273
 274 for.end13:                                        ; preds = %for.inc11
 275   ret void
 276 }
 277
 278
 279 ;;  for (long int i = 0; i < 100; i++)
 280 ;;    for (long int j = 0; j < 100; j++) {
 281 ;;      A[3*i - 18][22 - i][2*i + j] = i;
 282 ;;      *B++ = A[i][i][3*i + j];
 283
 284 define void @prop5(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
 285 entry:
 286   br label %for.cond1.preheader
 287
 288 ; CHECK-LABEL: prop5
 289 ; CHECK: da analyze - none!
 290 ; CHECK: da analyze - flow [* *|<]!
 291 ; CHECK: da analyze - confused!
 292 ; CHECK: da analyze - none!
 293 ; CHECK: da analyze - confused!
 294 ; CHECK: da analyze - none!
 295
 296 for.cond1.preheader:                              ; preds = %entry, %for.inc13
 297   %B.addr.04 = phi ptr [ %B, %entry ], [ %scevgep, %for.inc13 ]
 298   %i.03 = phi i64 [ 0, %entry ], [ %inc14, %for.inc13 ]
 299   br label %for.body3
 300
 301 for.body3:                                        ; preds = %for.cond1.preheader, %for.body3
 302   %j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
 303   %B.addr.11 = phi ptr [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
 304   %conv = trunc i64 %i.03 to i32
 305   %mul = shl nsw i64 %i.03, 1
 306   %add = add nsw i64 %mul, %j.02
 307   %sub = sub nsw i64 22, %i.03
 308   %mul4 = mul nsw i64 %i.03, 3
 309   %sub5 = add nsw i64 %mul4, -18
 310   %arrayidx7 = getelementptr inbounds [100 x [100 x i32]], ptr %A, i64 %sub5, i64 %sub, i64 %add
 311   store i32 %conv, ptr %arrayidx7, align 4
 312   %mul8 = mul nsw i64 %i.03, 3
 313   %add9 = add nsw i64 %mul8, %j.02
 314   %arrayidx12 = getelementptr inbounds [100 x [100 x i32]], ptr %A, i64 %i.03, i64 %i.03, i64 %add9
 315   %0 = load i32, ptr %arrayidx12, align 4
 316   %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.11, i64 1
 317   store i32 %0, ptr %B.addr.11, align 4
 318   %inc = add nsw i64 %j.02, 1
 319   %exitcond = icmp ne i64 %inc, 100
 320   br i1 %exitcond, label %for.body3, label %for.inc13
 321
 322 for.inc13:                                        ; preds = %for.body3
 323   %scevgep = getelementptr i32, ptr %B.addr.04, i64 100
 324   %inc14 = add nsw i64 %i.03, 1
 325   %exitcond5 = icmp ne i64 %inc14, 100
 326   br i1 %exitcond5, label %for.cond1.preheader, label %for.end15
 327
 328 for.end15:                                        ; preds = %for.inc13
 329   ret void
 330 }
 331
 332
 333 ;;  for (long int i = 0; i < 100; i++)
 334 ;;    for (long int j = 0; j < 100; j++) {
 335 ;;      A[i + 1][4*i + j + 2] = i;
 336 ;;      *B++ = A[2*i][8*i + j];
 337
 338 define void @prop6(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
 339 entry:
 340   br label %for.cond1.preheader
 341
 342 ; CHECK-LABEL: prop6
 343 ; CHECK: da analyze - none!
 344 ; CHECK: da analyze - flow [=> <>]!
 345 ; CHECK: da analyze - confused!
 346 ; CHECK: da analyze - none!
 347 ; CHECK: da analyze - confused!
 348 ; CHECK: da analyze - none!
 349
 350 for.cond1.preheader:                              ; preds = %entry, %for.inc12
 351   %B.addr.04 = phi ptr [ %B, %entry ], [ %scevgep, %for.inc12 ]
 352   %i.03 = phi i64 [ 0, %entry ], [ %inc13, %for.inc12 ]
 353   br label %for.body3
 354
 355 for.body3:                                        ; preds = %for.cond1.preheader, %for.body3
 356   %j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
 357   %B.addr.11 = phi ptr [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
 358   %conv = trunc i64 %i.03 to i32
 359   %mul = shl nsw i64 %i.03, 2
 360   %add = add nsw i64 %mul, %j.02
 361   %add4 = add nsw i64 %add, 2
 362   %add5 = add nsw i64 %i.03, 1
 363   %arrayidx6 = getelementptr inbounds [100 x i32], ptr %A, i64 %add5, i64 %add4
 364   store i32 %conv, ptr %arrayidx6, align 4
 365   %mul7 = shl nsw i64 %i.03, 3
 366   %add8 = add nsw i64 %mul7, %j.02
 367   %mul9 = shl nsw i64 %i.03, 1
 368   %arrayidx11 = getelementptr inbounds [100 x i32], ptr %A, i64 %mul9, i64 %add8
 369   %0 = load i32, ptr %arrayidx11, align 4
 370   %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.11, i64 1
 371   store i32 %0, ptr %B.addr.11, align 4
 372   %inc = add nsw i64 %j.02, 1
 373   %exitcond = icmp ne i64 %inc, 100
 374   br i1 %exitcond, label %for.body3, label %for.inc12
 375
 376 for.inc12:                                        ; preds = %for.body3
 377   %scevgep = getelementptr i32, ptr %B.addr.04, i64 100
 378   %inc13 = add nsw i64 %i.03, 1
 379   %exitcond5 = icmp ne i64 %inc13, 100
 380   br i1 %exitcond5, label %for.cond1.preheader, label %for.end14
 381
 382 for.end14:                                        ; preds = %for.inc12
 383   ret void
 384 }
 385
 386
 387 ;;  for (long int i = 0; i < 100; i++)
 388 ;;    for (long int j = 0; j < 100; j++) {
 389 ;;      A[2*i + 4][-5*i + j + 2] = i;
 390 ;;      *B++ = A[-2*i + 20][5*i + j];
 391
 392 define void @prop7(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
 393 entry:
 394   br label %for.cond1.preheader
 395
 396 ; CHECK-LABEL: prop7
 397 ; CHECK: da analyze - none!
 398 ; CHECK: da analyze - flow [* <>]!
 399 ; CHECK: da analyze - confused!
 400 ; CHECK: da analyze - none!
 401 ; CHECK: da analyze - confused!
 402 ; CHECK: da analyze - none!
 403
 404 for.cond1.preheader:                              ; preds = %entry, %for.inc14
 405   %B.addr.04 = phi ptr [ %B, %entry ], [ %scevgep, %for.inc14 ]
 406   %i.03 = phi i64 [ 0, %entry ], [ %inc15, %for.inc14 ]
 407   br label %for.body3
 408
 409 for.body3:                                        ; preds = %for.cond1.preheader, %for.body3
 410   %j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
 411   %B.addr.11 = phi ptr [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
 412   %conv = trunc i64 %i.03 to i32
 413   %mul = mul nsw i64 %i.03, -5
 414   %add = add nsw i64 %mul, %j.02
 415   %add4 = add nsw i64 %add, 2
 416   %mul5 = shl nsw i64 %i.03, 1
 417   %add6 = add nsw i64 %mul5, 4
 418   %arrayidx7 = getelementptr inbounds [100 x i32], ptr %A, i64 %add6, i64 %add4
 419   store i32 %conv, ptr %arrayidx7, align 4
 420   %mul8 = mul nsw i64 %i.03, 5
 421   %add9 = add nsw i64 %mul8, %j.02
 422   %mul10 = mul nsw i64 %i.03, -2
 423   %add11 = add nsw i64 %mul10, 20
 424   %arrayidx13 = getelementptr inbounds [100 x i32], ptr %A, i64 %add11, i64 %add9
 425   %0 = load i32, ptr %arrayidx13, align 4
 426   %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.11, i64 1
 427   store i32 %0, ptr %B.addr.11, align 4
 428   %inc = add nsw i64 %j.02, 1
 429   %exitcond = icmp ne i64 %inc, 100
 430   br i1 %exitcond, label %for.body3, label %for.inc14
 431
 432 for.inc14:                                        ; preds = %for.body3
 433   %scevgep = getelementptr i32, ptr %B.addr.04, i64 100
 434   %inc15 = add nsw i64 %i.03, 1
 435   %exitcond5 = icmp ne i64 %inc15, 100
 436   br i1 %exitcond5, label %for.cond1.preheader, label %for.end16
 437
 438 for.end16:                                        ; preds = %for.inc14
 439   ret void
 440 }
 441
 442
 443 ;;  for (long int i = 0; i < 100; i++)
 444 ;;    for (long int j = 0; j < 100; j++) {
 445 ;;      A[4][j + 2] = i;
 446 ;;      *B++ = A[-2*i + 4][5*i + j];
 447
 448 define void @prop8(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
 449 entry:
 450   br label %for.cond1.preheader
 451
 452 ; CHECK-LABEL: prop8
 453 ; CHECK: da analyze - consistent output [S 0]!
 454 ; CHECK: da analyze - flow [=> <]!
 455 ; CHECK: da analyze - confused!
 456 ; CHECK: da analyze - none!
 457 ; CHECK: da analyze - confused!
 458 ; CHECK: da analyze - none!
 459
 460 for.cond1.preheader:                              ; preds = %entry, %for.inc10
 461   %B.addr.04 = phi ptr [ %B, %entry ], [ %scevgep, %for.inc10 ]
 462   %i.03 = phi i64 [ 0, %entry ], [ %inc11, %for.inc10 ]
 463   br label %for.body3
 464
 465 for.body3:                                        ; preds = %for.cond1.preheader, %for.body3
 466   %j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
 467   %B.addr.11 = phi ptr [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
 468   %conv = trunc i64 %i.03 to i32
 469   %add = add nsw i64 %j.02, 2
 470   %arrayidx4 = getelementptr inbounds [100 x i32], ptr %A, i64 4, i64 %add
 471   store i32 %conv, ptr %arrayidx4, align 4
 472   %mul = mul nsw i64 %i.03, 5
 473   %add5 = add nsw i64 %mul, %j.02
 474   %mul6 = mul nsw i64 %i.03, -2
 475   %add7 = add nsw i64 %mul6, 4
 476   %arrayidx9 = getelementptr inbounds [100 x i32], ptr %A, i64 %add7, i64 %add5
 477   %0 = load i32, ptr %arrayidx9, align 4
 478   %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.11, i64 1
 479   store i32 %0, ptr %B.addr.11, align 4
 480   %inc = add nsw i64 %j.02, 1
 481   %exitcond = icmp ne i64 %inc, 100
 482   br i1 %exitcond, label %for.body3, label %for.inc10
 483
 484 for.inc10:                                        ; preds = %for.body3
 485   %scevgep = getelementptr i32, ptr %B.addr.04, i64 100
 486   %inc11 = add nsw i64 %i.03, 1
 487   %exitcond5 = icmp ne i64 %inc11, 100
 488   br i1 %exitcond5, label %for.cond1.preheader, label %for.end12
 489
 490 for.end12:                                        ; preds = %for.inc10
 491   ret void
 492 }
 493
 494
 495 ;;  for (long int i = 0; i < 100; i++)
 496 ;;    for (long int j = 0; j < 100; j++) {
 497 ;;      A[2*i + 4][5*i + j + 2] = i;
 498 ;;      *B++ = A[4][j];
 499
 500 define void @prop9(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
 501 entry:
 502   br label %for.cond1.preheader
 503
 504 ; CHECK-LABEL: prop9
 505 ; CHECK: da analyze - none!
 506 ; CHECK: da analyze - flow [<= <]!
 507 ; CHECK: da analyze - confused!
 508 ; CHECK: da analyze - consistent input [S 0]!
 509 ; CHECK: da analyze - confused!
 510 ; CHECK: da analyze - none!
 511
 512 for.cond1.preheader:                              ; preds = %entry, %for.inc10
 513   %B.addr.04 = phi ptr [ %B, %entry ], [ %scevgep, %for.inc10 ]
 514   %i.03 = phi i64 [ 0, %entry ], [ %inc11, %for.inc10 ]
 515   br label %for.body3
 516
 517 for.body3:                                        ; preds = %for.cond1.preheader, %for.body3
 518   %j.02 = phi i64 [ 0, %for.cond1.preheader ], [ %inc, %for.body3 ]
 519   %B.addr.11 = phi ptr [ %B.addr.04, %for.cond1.preheader ], [ %incdec.ptr, %for.body3 ]
 520   %conv = trunc i64 %i.03 to i32
 521   %mul = mul nsw i64 %i.03, 5
 522   %add = add nsw i64 %mul, %j.02
 523   %add4 = add nsw i64 %add, 2
 524   %mul5 = shl nsw i64 %i.03, 1
 525   %add6 = add nsw i64 %mul5, 4
 526   %arrayidx7 = getelementptr inbounds [100 x i32], ptr %A, i64 %add6, i64 %add4
 527   store i32 %conv, ptr %arrayidx7, align 4
 528   %arrayidx9 = getelementptr inbounds [100 x i32], ptr %A, i64 4, i64 %j.02
 529   %0 = load i32, ptr %arrayidx9, align 4
 530   %incdec.ptr = getelementptr inbounds i32, ptr %B.addr.11, i64 1
 531   store i32 %0, ptr %B.addr.11, align 4
 532   %inc = add nsw i64 %j.02, 1
 533   %exitcond = icmp ne i64 %inc, 100
 534   br i1 %exitcond, label %for.body3, label %for.inc10
 535
 536 for.inc10:                                        ; preds = %for.body3
 537   %scevgep = getelementptr i32, ptr %B.addr.04, i64 100
 538   %inc11 = add nsw i64 %i.03, 1
 539   %exitcond5 = icmp ne i64 %inc11, 100
 540   br i1 %exitcond5, label %for.cond1.preheader, label %for.end12
 541
 542 for.end12:                                        ; preds = %for.inc10
 543   ret void
 544 }