llvm/test/Analysis/ScalarEvolution/no-wrap-symbolic-becount.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
   2 ; RUN: opt < %s -disable-output -scalar-evolution-use-expensive-range-sharpening -passes='print<scalar-evolution>' 2>&1 | FileCheck %s
   3
   4 define i32 @test_01(i32 %start, i32* %p, i32* %q) {
   5 ; CHECK-LABEL: 'test_01'
   6 ; CHECK-NEXT:  Classifying expressions for: @test_01
   7 ; CHECK-NEXT:    %0 = zext i32 %start to i64
   8 ; CHECK-NEXT:    --> (zext i32 %start to i64) U: [0,4294967296) S: [0,4294967296)
   9 ; CHECK-NEXT:    %indvars.iv = phi i64 [ %indvars.iv.next, %backedge ], [ %0, %entry ]
  10 ; CHECK-NEXT:    --> {(zext i32 %start to i64),+,-1}<nsw><%loop> U: [0,4294967296) S: [0,4294967296) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
  11 ; CHECK-NEXT:    %iv = phi i32 [ %start, %entry ], [ %iv.next, %backedge ]
  12 ; CHECK-NEXT:    --> {%start,+,-1}<%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
  13 ; CHECK-NEXT:    %iv.next = add i32 %iv, -1
  14 ; CHECK-NEXT:    --> {(-1 + %start),+,-1}<%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
  15 ; CHECK-NEXT:    %index = zext i32 %iv.next to i64
  16 ; CHECK-NEXT:    --> (zext i32 {(-1 + %start),+,-1}<%loop> to i64) U: [0,4294967296) S: [0,4294967296) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
  17 ; CHECK-NEXT:    %store.addr = getelementptr i32, i32* %p, i64 %index
  18 ; CHECK-NEXT:    --> ((4 * (zext i32 {(-1 + %start),+,-1}<%loop> to i64))<nuw><nsw> + %p) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
  19 ; CHECK-NEXT:    %load.addr = getelementptr i32, i32* %q, i64 %index
  20 ; CHECK-NEXT:    --> ((4 * (zext i32 {(-1 + %start),+,-1}<%loop> to i64))<nuw><nsw> + %q) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
  21 ; CHECK-NEXT:    %stop = load i32, i32* %load.addr, align 4
  22 ; CHECK-NEXT:    --> %stop U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
  23 ; CHECK-NEXT:    %indvars.iv.next = add nsw i64 %indvars.iv, -1
  24 ; CHECK-NEXT:    --> {(-1 + (zext i32 %start to i64))<nsw>,+,-1}<nsw><%loop> U: [-4294967296,4294967295) S: [-1,4294967295) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
  25 ; CHECK-NEXT:  Determining loop execution counts for: @test_01
  26 ; CHECK-NEXT:  Loop %loop: <multiple exits> Unpredictable backedge-taken count.
  27 ; CHECK-NEXT:    exit count for loop: (zext i32 %start to i64)
  28 ; CHECK-NEXT:    exit count for backedge: ***COULDNOTCOMPUTE***
  29 ; CHECK-NEXT:  Loop %loop: max backedge-taken count is 4294967295
  30 ; CHECK-NEXT:  Loop %loop: Unpredictable predicated backedge-taken count.
  31 ;
  32 entry:
  33   %0 = zext i32 %start to i64
  34   br label %loop
  35
  36 loop:                                             ; preds = %backedge, %entry
  37   %indvars.iv = phi i64 [ %indvars.iv.next, %backedge ], [ %0, %entry ]
  38   %iv = phi i32 [ %start, %entry ], [ %iv.next, %backedge ]
  39   %cond = icmp eq i64 %indvars.iv, 0
  40   br i1 %cond, label %exit, label %backedge
  41
  42 backedge:                                         ; preds = %loop
  43   %iv.next = add i32 %iv, -1
  44   %index = zext i32 %iv.next to i64
  45   %store.addr = getelementptr i32, i32* %p, i64 %index
  46   store i32 1, i32* %store.addr, align 4
  47   %load.addr = getelementptr i32, i32* %q, i64 %index
  48   %stop = load i32, i32* %load.addr, align 4
  49   %loop.cond = icmp eq i32 %stop, 0
  50   %indvars.iv.next = add nsw i64 %indvars.iv, -1
  51   br i1 %loop.cond, label %loop, label %failure
  52
  53 exit:                                             ; preds = %loop
  54   ret i32 0
  55
  56 failure:                                          ; preds = %backedge
  57   unreachable
  58 }
  59
  60 ; Check that we do not mess up with wrapping ranges.
  61 define i32 @test_02(i32 %start, i32* %p, i32* %q) {
  62 ; CHECK-LABEL: 'test_02'
  63 ; CHECK-NEXT:  Classifying expressions for: @test_02
  64 ; CHECK-NEXT:    %zext = zext i32 %start to i64
  65 ; CHECK-NEXT:    --> (zext i32 %start to i64) U: [0,4294967296) S: [0,4294967296)
  66 ; CHECK-NEXT:    %shl = shl i64 %zext, 31
  67 ; CHECK-NEXT:    --> (2147483648 * (zext i32 %start to i64))<nuw><nsw> U: [0,9223372034707292161) S: [0,9223372034707292161)
  68 ; CHECK-NEXT:    %indvars.iv = phi i64 [ %indvars.iv.next, %loop ], [ %shl, %entry ]
  69 ; CHECK-NEXT:    --> {(2147483648 * (zext i32 %start to i64))<nuw><nsw>,+,-1}<nsw><%loop> U: [-9223372036854775808,9223372034707292161) S: [-9223372036854775808,9223372034707292161) Exits: -9223372036854775806 LoopDispositions: { %loop: Computable }
  70 ; CHECK-NEXT:    %indvars.iv.next = add nsw i64 %indvars.iv, -1
  71 ; CHECK-NEXT:    --> {(-1 + (2147483648 * (zext i32 %start to i64))<nuw><nsw>)<nsw>,+,-1}<nw><%loop> U: full-set S: full-set Exits: -9223372036854775807 LoopDispositions: { %loop: Computable }
  72 ; CHECK-NEXT:  Determining loop execution counts for: @test_02
  73 ; CHECK-NEXT:  Loop %loop: backedge-taken count is (9223372036854775806 + (2147483648 * (zext i32 %start to i64))<nuw><nsw>)<nuw>
  74 ; CHECK-NEXT:  Loop %loop: max backedge-taken count is -2147483650
  75 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is (9223372036854775806 + (2147483648 * (zext i32 %start to i64))<nuw><nsw>)<nuw>
  76 ; CHECK-NEXT:   Predicates:
  77 ; CHECK:       Loop %loop: Trip multiple is 1
  78 ;
  79 entry:
  80   %zext = zext i32 %start to i64
  81   %shl = shl i64 %zext, 31
  82   br label %loop
  83
  84 loop:                                             ; preds = %backedge, %entry
  85   %indvars.iv = phi i64 [ %indvars.iv.next, %loop ], [ %shl, %entry ]
  86   %cond = icmp eq i64 %indvars.iv, -9223372036854775806
  87   %indvars.iv.next = add nsw i64 %indvars.iv, -1
  88   br i1 %cond, label %exit, label %loop
  89
  90 exit:                                             ; preds = %loop
  91   ret i32 0
  92 }
  93
  94 define void @pointer_iv_nowrap(i8* %startptr, i8* %endptr) local_unnamed_addr {
  95 ; CHECK-LABEL: 'pointer_iv_nowrap'
  96 ; CHECK-NEXT:  Classifying expressions for: @pointer_iv_nowrap
  97 ; CHECK-NEXT:    %init = getelementptr inbounds i8, i8* %startptr, i64 2000
  98 ; CHECK-NEXT:    --> (2000 + %startptr) U: full-set S: full-set
  99 ; CHECK-NEXT:    %iv = phi i8* [ %init, %entry ], [ %iv.next, %loop ]
 100 ; CHECK-NEXT:    --> {(2000 + %startptr),+,1}<nuw><%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
 101 ; CHECK-NEXT:    %iv.next = getelementptr inbounds i8, i8* %iv, i64 1
 102 ; CHECK-NEXT:    --> {(2001 + %startptr),+,1}<nuw><%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
 103 ; CHECK-NEXT:  Determining loop execution counts for: @pointer_iv_nowrap
 104 ; CHECK-NEXT:  Loop %loop: Unpredictable backedge-taken count.
 105 ; CHECK-NEXT:  Loop %loop: Unpredictable max backedge-taken count.
 106 ; CHECK-NEXT:  Loop %loop: Unpredictable predicated backedge-taken count.
 107 ;
 108 entry:
 109   %init = getelementptr inbounds i8, i8* %startptr, i64 2000
 110   br label %loop
 111
 112 loop:
 113   %iv = phi i8* [ %init, %entry ], [ %iv.next, %loop ]
 114   %iv.next = getelementptr inbounds i8, i8* %iv, i64 1
 115   %ec = icmp ugt i8* %iv.next, %endptr
 116   br i1 %ec, label %end, label %loop
 117
 118 end:
 119   ret void
 120 }
 121
 122 define void @pointer_iv_nowrap_guard(i32* %startptr, i32* %endptr) local_unnamed_addr {
 123 ; CHECK-LABEL: 'pointer_iv_nowrap_guard'
 124 ; CHECK-NEXT:  Classifying expressions for: @pointer_iv_nowrap_guard
 125 ; CHECK-NEXT:    %init = getelementptr inbounds i32, i32* %startptr, i64 2000
 126 ; CHECK-NEXT:    --> (8000 + %startptr) U: full-set S: full-set
 127 ; CHECK-NEXT:    %iv = phi i32* [ %init, %entry ], [ %iv.next, %loop ]
 128 ; CHECK-NEXT:    --> {(8000 + %startptr),+,4}<nuw><%loop> U: full-set S: full-set Exits: (8000 + (4 * ((-8001 + (-1 * (ptrtoint i32* %startptr to i64)) + ((8004 + (ptrtoint i32* %startptr to i64)) umax (ptrtoint i32* %endptr to i64))) /u 4))<nuw> + %startptr) LoopDispositions: { %loop: Computable }
 129 ; CHECK-NEXT:    %iv.next = getelementptr inbounds i32, i32* %iv, i64 1
 130 ; CHECK-NEXT:    --> {(8004 + %startptr),+,4}<nuw><%loop> U: full-set S: full-set Exits: (8004 + (4 * ((-8001 + (-1 * (ptrtoint i32* %startptr to i64)) + ((8004 + (ptrtoint i32* %startptr to i64)) umax (ptrtoint i32* %endptr to i64))) /u 4))<nuw> + %startptr) LoopDispositions: { %loop: Computable }
 131 ; CHECK-NEXT:  Determining loop execution counts for: @pointer_iv_nowrap_guard
 132 ; CHECK-NEXT:  Loop %loop: backedge-taken count is ((-8001 + (-1 * (ptrtoint i32* %startptr to i64)) + ((8004 + (ptrtoint i32* %startptr to i64)) umax (ptrtoint i32* %endptr to i64))) /u 4)
 133 ; CHECK-NEXT:  Loop %loop: max backedge-taken count is 4611686018427387903
 134 ; CHECK-NEXT:  Loop %loop: Predicated backedge-taken count is ((-8001 + (-1 * (ptrtoint i32* %startptr to i64)) + ((8004 + (ptrtoint i32* %startptr to i64)) umax (ptrtoint i32* %endptr to i64))) /u 4)
 135 ; CHECK-NEXT:   Predicates:
 136 ; CHECK:       Loop %loop: Trip multiple is 1
 137 ;
 138 entry:
 139   %init = getelementptr inbounds i32, i32* %startptr, i64 2000
 140   %cmp2 = icmp ult i32* %init, %endptr
 141   br i1 %cmp2, label %loop, label %end
 142
 143 loop:
 144   %iv = phi i32* [ %init, %entry ], [ %iv.next, %loop ]
 145   %iv.next = getelementptr inbounds i32, i32* %iv, i64 1
 146   %ec = icmp uge i32* %iv.next, %endptr
 147   br i1 %ec, label %end, label %loop
 148
 149 end:
 150   ret void
 151 }