llvm/test/Analysis/BasicAA/featuretest.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; This testcase tests for various features the basicaa test should be able to
   3 ; determine, as noted in the comments.
   4
   5 ; RUN: opt < %s -aa-pipeline=basic-aa -passes=gvn,instcombine,dce -S | FileCheck %s --check-prefixes=CHECK,NO_ASSUME
   6 ; RUN: opt < %s -aa-pipeline=basic-aa -passes=gvn,instcombine,dce --enable-knowledge-retention -S | FileCheck %s --check-prefixes=CHECK,USE_ASSUME
   7 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
   8
   9 @Global = external global { i32 }
  10
  11 declare void @external(ptr)
  12 declare void @llvm.assume(i1)
  13
  14 ; Array test:  Test that operations on one local array do not invalidate
  15 ; operations on another array.  Important for scientific codes.
  16 ;
  17 define i32 @different_array_test(i64 %A, i64 %B) {
  18 ; NO_ASSUME-LABEL: @different_array_test(
  19 ; NO_ASSUME-NEXT:    [[ARRAY11:%.*]] = alloca [100 x i32], align 4
  20 ; NO_ASSUME-NEXT:    [[ARRAY22:%.*]] = alloca [200 x i32], align 4
  21 ; NO_ASSUME-NEXT:    call void @llvm.assume(i1 true) [ "align"(ptr [[ARRAY11]], i32 4) ]
  22 ; NO_ASSUME-NEXT:    call void @external(ptr nonnull [[ARRAY11]])
  23 ; NO_ASSUME-NEXT:    call void @external(ptr nonnull [[ARRAY22]])
  24 ; NO_ASSUME-NEXT:    [[POINTER2:%.*]] = getelementptr i32, ptr [[ARRAY22]], i64 [[B:%.*]]
  25 ; NO_ASSUME-NEXT:    store i32 7, ptr [[POINTER2]], align 4
  26 ; NO_ASSUME-NEXT:    ret i32 0
  27 ;
  28 ; USE_ASSUME-LABEL: @different_array_test(
  29 ; USE_ASSUME-NEXT:    [[ARRAY11:%.*]] = alloca [100 x i32], align 4
  30 ; USE_ASSUME-NEXT:    [[ARRAY22:%.*]] = alloca [200 x i32], align 4
  31 ; USE_ASSUME-NEXT:    call void @external(ptr nonnull [[ARRAY11]])
  32 ; USE_ASSUME-NEXT:    call void @external(ptr nonnull [[ARRAY22]])
  33 ; USE_ASSUME-NEXT:    [[POINTER2:%.*]] = getelementptr i32, ptr [[ARRAY22]], i64 [[B:%.*]]
  34 ; USE_ASSUME-NEXT:    store i32 7, ptr [[POINTER2]], align 4
  35 ; USE_ASSUME-NEXT:    ret i32 0
  36 ;
  37   %Array1 = alloca i32, i32 100
  38   %Array2 = alloca i32, i32 200
  39   call void @llvm.assume(i1 true) ["align"(ptr %Array1, i32 4)]
  40
  41   call void @external(ptr %Array1)
  42   call void @external(ptr %Array2)
  43
  44   %pointer = getelementptr i32, ptr %Array1, i64 %A
  45   %val = load i32, ptr %pointer
  46
  47   %pointer2 = getelementptr i32, ptr %Array2, i64 %B
  48   store i32 7, ptr %pointer2
  49
  50   %REMOVE = load i32, ptr %pointer ; redundant with above load
  51   %retval = sub i32 %REMOVE, %val
  52   ret i32 %retval
  53 }
  54
  55 ; Constant index test: Constant indexes into the same array should not
  56 ; interfere with each other.  Again, important for scientific codes.
  57 ;
  58 define i32 @constant_array_index_test() {
  59 ; CHECK-LABEL: @constant_array_index_test(
  60 ; CHECK-NEXT:    [[ARRAY1:%.*]] = alloca [100 x i32], align 4
  61 ; CHECK-NEXT:    call void @external(ptr nonnull [[ARRAY1]])
  62 ; CHECK-NEXT:    [[P2:%.*]] = getelementptr inbounds i8, ptr [[ARRAY1]], i64 24
  63 ; CHECK-NEXT:    store i32 1, ptr [[P2]], align 4
  64 ; CHECK-NEXT:    ret i32 0
  65 ;
  66   %Array = alloca i32, i32 100
  67   call void @external(ptr %Array)
  68
  69   %P1 = getelementptr i32, ptr %Array, i64 7
  70   %P2 = getelementptr i32, ptr %Array, i64 6
  71
  72   %A = load i32, ptr %P1
  73   store i32 1, ptr %P2   ; Should not invalidate load
  74   %BREMOVE = load i32, ptr %P1
  75   %Val = sub i32 %A, %BREMOVE
  76   ret i32 %Val
  77 }
  78
  79 ; Test that if two pointers are spaced out by a constant getelementptr, that
  80 ; they cannot alias.
  81 define i32 @gep_distance_test(ptr %A) {
  82 ; NO_ASSUME-LABEL: @gep_distance_test(
  83 ; NO_ASSUME-NEXT:    [[B:%.*]] = getelementptr i8, ptr [[A:%.*]], i64 8
  84 ; NO_ASSUME-NEXT:    store i32 7, ptr [[B]], align 4
  85 ; NO_ASSUME-NEXT:    ret i32 0
  86 ;
  87 ; USE_ASSUME-LABEL: @gep_distance_test(
  88 ; USE_ASSUME-NEXT:    [[B:%.*]] = getelementptr i8, ptr [[A:%.*]], i64 8
  89 ; USE_ASSUME-NEXT:    store i32 7, ptr [[B]], align 4
  90 ; USE_ASSUME-NEXT:    call void @llvm.assume(i1 true) [ "dereferenceable"(ptr [[A]], i64 4), "nonnull"(ptr [[A]]), "align"(ptr [[A]], i64 4) ]
  91 ; USE_ASSUME-NEXT:    ret i32 0
  92 ;
  93   %REMOVEu = load i32, ptr %A
  94   %B = getelementptr i32, ptr %A, i64 2  ; Cannot alias A
  95   store i32 7, ptr %B
  96   %REMOVEv = load i32, ptr %A
  97   %r = sub i32 %REMOVEu, %REMOVEv
  98   ret i32 %r
  99 }
 100
 101 ; Test that if two pointers are spaced out by a constant offset, that they
 102 ; cannot alias, even if there is a variable offset between them...
 103 define i32 @gep_distance_test2(ptr %A, i64 %distance) {
 104 ; NO_ASSUME-LABEL: @gep_distance_test2(
 105 ; NO_ASSUME-NEXT:    [[B:%.*]] = getelementptr { i32, i32 }, ptr [[A:%.*]], i64 [[DISTANCE:%.*]], i32 1
 106 ; NO_ASSUME-NEXT:    store i32 7, ptr [[B]], align 4
 107 ; NO_ASSUME-NEXT:    ret i32 0
 108 ;
 109 ; USE_ASSUME-LABEL: @gep_distance_test2(
 110 ; USE_ASSUME-NEXT:    [[B:%.*]] = getelementptr { i32, i32 }, ptr [[A:%.*]], i64 [[DISTANCE:%.*]], i32 1
 111 ; USE_ASSUME-NEXT:    store i32 7, ptr [[B]], align 4
 112 ; USE_ASSUME-NEXT:    call void @llvm.assume(i1 true) [ "dereferenceable"(ptr [[A]], i64 4), "nonnull"(ptr [[A]]), "align"(ptr [[A]], i64 4) ]
 113 ; USE_ASSUME-NEXT:    ret i32 0
 114 ;
 115   %A1 = getelementptr {i32,i32}, ptr %A, i64 0, i32 0
 116   %REMOVEu = load i32, ptr %A1
 117   %B = getelementptr {i32,i32}, ptr %A, i64 %distance, i32 1
 118   store i32 7, ptr %B    ; B cannot alias A, it's at least 4 bytes away
 119   %REMOVEv = load i32, ptr %A1
 120   %r = sub i32 %REMOVEu, %REMOVEv
 121   ret i32 %r
 122 }
 123
 124 ; Test that we can do funny pointer things and that distance calc will still
 125 ; work.
 126 define i32 @gep_distance_test3(ptr %A) {
 127 ; NO_ASSUME-LABEL: @gep_distance_test3(
 128 ; NO_ASSUME-NEXT:    [[C:%.*]] = getelementptr i8, ptr [[A:%.*]], i64 4
 129 ; NO_ASSUME-NEXT:    store i8 42, ptr [[C]], align 1
 130 ; NO_ASSUME-NEXT:    ret i32 0
 131 ;
 132 ; USE_ASSUME-LABEL: @gep_distance_test3(
 133 ; USE_ASSUME-NEXT:    [[C:%.*]] = getelementptr i8, ptr [[A:%.*]], i64 4
 134 ; USE_ASSUME-NEXT:    store i8 42, ptr [[C]], align 1
 135 ; USE_ASSUME-NEXT:    call void @llvm.assume(i1 true) [ "dereferenceable"(ptr [[A]], i64 4), "nonnull"(ptr [[A]]), "align"(ptr [[A]], i64 4) ]
 136 ; USE_ASSUME-NEXT:    ret i32 0
 137 ;
 138   %X = load i32, ptr %A
 139   %C = getelementptr i8, ptr %A, i64 4
 140   store i8 42, ptr %C
 141   %Y = load i32, ptr %A
 142   %R = sub i32 %X, %Y
 143   ret i32 %R
 144 }
 145
 146 ; Test that we can disambiguate globals reached through constantexpr geps
 147 define i32 @constexpr_test() {
 148 ; CHECK-LABEL: @constexpr_test(
 149 ; CHECK-NEXT:    [[X:%.*]] = alloca i32, align 4
 150 ; CHECK-NEXT:    call void @external(ptr nonnull [[X]])
 151 ; CHECK-NEXT:    store i32 5, ptr @Global, align 4
 152 ; CHECK-NEXT:    ret i32 0
 153 ;
 154   %X = alloca i32
 155   call void @external(ptr %X)
 156
 157   %Y = load i32, ptr %X
 158   store i32 5, ptr @Global
 159   %REMOVE = load i32, ptr %X
 160   %retval = sub i32 %Y, %REMOVE
 161   ret i32 %retval
 162 }
 163
 164
 165
 166 ; PR7589
 167 ; These two index expressions are different, this cannot be CSE'd.
 168 define i16 @zext_sext_confusion(ptr %row2col, i5 %j) nounwind{
 169 ; CHECK-LABEL: @zext_sext_confusion(
 170 ; CHECK-NEXT:  entry:
 171 ; CHECK-NEXT:    [[SUM5_CAST:%.*]] = zext i5 [[J:%.*]] to i64
 172 ; CHECK-NEXT:    [[P1:%.*]] = getelementptr i16, ptr [[ROW2COL:%.*]], i64 [[SUM5_CAST]]
 173 ; CHECK-NEXT:    [[ROW2COL_LOAD_1_2:%.*]] = load i16, ptr [[P1]], align 1
 174 ; CHECK-NEXT:    [[SUM13_CAST31:%.*]] = sext i5 [[J]] to i6
 175 ; CHECK-NEXT:    [[SUM13_CAST:%.*]] = zext i6 [[SUM13_CAST31]] to i64
 176 ; CHECK-NEXT:    [[P2:%.*]] = getelementptr i16, ptr [[ROW2COL]], i64 [[SUM13_CAST]]
 177 ; CHECK-NEXT:    [[ROW2COL_LOAD_1_6:%.*]] = load i16, ptr [[P2]], align 1
 178 ; CHECK-NEXT:    [[DOTRET:%.*]] = sub i16 [[ROW2COL_LOAD_1_6]], [[ROW2COL_LOAD_1_2]]
 179 ; CHECK-NEXT:    ret i16 [[DOTRET]]
 180 ;
 181 entry:
 182   %sum5.cast = zext i5 %j to i64             ; <i64> [#uses=1]
 183   %P1 = getelementptr i16, ptr %row2col, i64 %sum5.cast
 184   %row2col.load.1.2 = load i16, ptr %P1, align 1 ; <i16> [#uses=1]
 185
 186   %sum13.cast31 = sext i5 %j to i6          ; <i6> [#uses=1]
 187   %sum13.cast = zext i6 %sum13.cast31 to i64      ; <i64> [#uses=1]
 188   %P2 = getelementptr i16, ptr %row2col, i64 %sum13.cast
 189   %row2col.load.1.6 = load i16, ptr %P2, align 1 ; <i16> [#uses=1]
 190
 191   %.ret = sub i16 %row2col.load.1.6, %row2col.load.1.2 ; <i16> [#uses=1]
 192   ret i16 %.ret
 193 }