186 lines · plain
1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py2; This testcase tests for various features the basicaa test should be able to3; 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_ASSUME6; RUN: opt < %s -aa-pipeline=basic-aa -passes=gvn,instcombine,dce --enable-knowledge-retention -S | FileCheck %s --check-prefixes=CHECK,USE_ASSUME7target 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 11declare void @external(ptr)12declare void @llvm.assume(i1)13 14; Array test: Test that operations on one local array do not invalidate15; operations on another array. Important for scientific codes.16;17define i32 @different_array_test(i64 %A, i64 %B) {18; CHECK-LABEL: @different_array_test(19; CHECK-NEXT: [[ARRAY11:%.*]] = alloca [100 x i32], align 420; CHECK-NEXT: [[ARRAY22:%.*]] = alloca [200 x i32], align 421; CHECK-NEXT: call void @external(ptr nonnull [[ARRAY11]])22; CHECK-NEXT: call void @external(ptr nonnull [[ARRAY22]])23; CHECK-NEXT: [[POINTER2:%.*]] = getelementptr i32, ptr [[ARRAY22]], i64 [[B:%.*]]24; CHECK-NEXT: store i32 7, ptr [[POINTER2]], align 425; CHECK-NEXT: ret i32 026;27 %Array1 = alloca i32, i32 10028 %Array2 = alloca i32, i32 20029 call void @llvm.assume(i1 true) ["align"(ptr %Array1, i32 4)]30 31 call void @external(ptr %Array1)32 call void @external(ptr %Array2)33 34 %pointer = getelementptr i32, ptr %Array1, i64 %A35 %val = load i32, ptr %pointer36 37 %pointer2 = getelementptr i32, ptr %Array2, i64 %B38 store i32 7, ptr %pointer239 40 %REMOVE = load i32, ptr %pointer ; redundant with above load41 %retval = sub i32 %REMOVE, %val42 ret i32 %retval43}44 45; Constant index test: Constant indexes into the same array should not46; interfere with each other. Again, important for scientific codes.47;48define i32 @constant_array_index_test() {49; CHECK-LABEL: @constant_array_index_test(50; CHECK-NEXT: [[ARRAY1:%.*]] = alloca [100 x i32], align 451; CHECK-NEXT: call void @external(ptr nonnull [[ARRAY1]])52; CHECK-NEXT: [[P2:%.*]] = getelementptr inbounds nuw i8, ptr [[ARRAY1]], i64 2453; CHECK-NEXT: store i32 1, ptr [[P2]], align 454; CHECK-NEXT: ret i32 055;56 %Array = alloca i32, i32 10057 call void @external(ptr %Array)58 59 %P1 = getelementptr i32, ptr %Array, i64 760 %P2 = getelementptr i32, ptr %Array, i64 661 62 %A = load i32, ptr %P163 store i32 1, ptr %P2 ; Should not invalidate load64 %BREMOVE = load i32, ptr %P165 %Val = sub i32 %A, %BREMOVE66 ret i32 %Val67}68 69; Test that if two pointers are spaced out by a constant getelementptr, that70; they cannot alias.71define i32 @gep_distance_test(ptr %A) {72; NO_ASSUME-LABEL: @gep_distance_test(73; NO_ASSUME-NEXT: [[B:%.*]] = getelementptr i8, ptr [[A:%.*]], i64 874; NO_ASSUME-NEXT: store i32 7, ptr [[B]], align 475; NO_ASSUME-NEXT: ret i32 076;77; USE_ASSUME-LABEL: @gep_distance_test(78; USE_ASSUME-NEXT: [[B:%.*]] = getelementptr i8, ptr [[A:%.*]], i64 879; USE_ASSUME-NEXT: store i32 7, ptr [[B]], align 480; USE_ASSUME-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(ptr [[A]], i64 4), "nonnull"(ptr [[A]]), "align"(ptr [[A]], i64 4) ]81; USE_ASSUME-NEXT: ret i32 082;83 %REMOVEu = load i32, ptr %A84 %B = getelementptr i32, ptr %A, i64 2 ; Cannot alias A85 store i32 7, ptr %B86 %REMOVEv = load i32, ptr %A87 %r = sub i32 %REMOVEu, %REMOVEv88 ret i32 %r89}90 91; Test that if two pointers are spaced out by a constant offset, that they92; cannot alias, even if there is a variable offset between them...93define i32 @gep_distance_test2(ptr %A, i64 %distance) {94; NO_ASSUME-LABEL: @gep_distance_test2(95; NO_ASSUME-NEXT: [[B_SPLIT:%.*]] = getelementptr { i32, i32 }, ptr [[A:%.*]], i64 [[DISTANCE:%.*]]96; NO_ASSUME-NEXT: [[B:%.*]] = getelementptr i8, ptr [[B_SPLIT]], i64 497; NO_ASSUME-NEXT: store i32 7, ptr [[B]], align 498; NO_ASSUME-NEXT: ret i32 099;100; USE_ASSUME-LABEL: @gep_distance_test2(101; USE_ASSUME-NEXT: [[B_SPLIT:%.*]] = getelementptr { i32, i32 }, ptr [[A:%.*]], i64 [[DISTANCE:%.*]]102; USE_ASSUME-NEXT: [[B:%.*]] = getelementptr i8, ptr [[B_SPLIT]], i64 4103; USE_ASSUME-NEXT: store i32 7, ptr [[B]], align 4104; USE_ASSUME-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(ptr [[A]], i64 4), "nonnull"(ptr [[A]]), "align"(ptr [[A]], i64 4) ]105; USE_ASSUME-NEXT: ret i32 0106;107 %A1 = getelementptr {i32,i32}, ptr %A, i64 0, i32 0108 %REMOVEu = load i32, ptr %A1109 %B = getelementptr {i32,i32}, ptr %A, i64 %distance, i32 1110 store i32 7, ptr %B ; B cannot alias A, it's at least 4 bytes away111 %REMOVEv = load i32, ptr %A1112 %r = sub i32 %REMOVEu, %REMOVEv113 ret i32 %r114}115 116; Test that we can do funny pointer things and that distance calc will still117; work.118define i32 @gep_distance_test3(ptr %A) {119; NO_ASSUME-LABEL: @gep_distance_test3(120; NO_ASSUME-NEXT: [[C:%.*]] = getelementptr i8, ptr [[A:%.*]], i64 4121; NO_ASSUME-NEXT: store i8 42, ptr [[C]], align 1122; NO_ASSUME-NEXT: ret i32 0123;124; USE_ASSUME-LABEL: @gep_distance_test3(125; USE_ASSUME-NEXT: [[C:%.*]] = getelementptr i8, ptr [[A:%.*]], i64 4126; USE_ASSUME-NEXT: store i8 42, ptr [[C]], align 1127; USE_ASSUME-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(ptr [[A]], i64 4), "nonnull"(ptr [[A]]), "align"(ptr [[A]], i64 4) ]128; USE_ASSUME-NEXT: ret i32 0129;130 %X = load i32, ptr %A131 %C = getelementptr i8, ptr %A, i64 4132 store i8 42, ptr %C133 %Y = load i32, ptr %A134 %R = sub i32 %X, %Y135 ret i32 %R136}137 138; Test that we can disambiguate globals reached through constantexpr geps139define i32 @constexpr_test() {140; CHECK-LABEL: @constexpr_test(141; CHECK-NEXT: [[X:%.*]] = alloca i32, align 4142; CHECK-NEXT: call void @external(ptr nonnull [[X]])143; CHECK-NEXT: store i32 5, ptr @Global, align 4144; CHECK-NEXT: ret i32 0145;146 %X = alloca i32147 call void @external(ptr %X)148 149 %Y = load i32, ptr %X150 store i32 5, ptr @Global151 %REMOVE = load i32, ptr %X152 %retval = sub i32 %Y, %REMOVE153 ret i32 %retval154}155 156 157 158; PR7589159; These two index expressions are different, this cannot be CSE'd.160define i16 @zext_sext_confusion(ptr %row2col, i5 %j) nounwind{161; CHECK-LABEL: @zext_sext_confusion(162; CHECK-NEXT: entry:163; CHECK-NEXT: [[SUM5_CAST:%.*]] = zext i5 [[J:%.*]] to i64164; CHECK-NEXT: [[P1:%.*]] = getelementptr i16, ptr [[ROW2COL:%.*]], i64 [[SUM5_CAST]]165; CHECK-NEXT: [[ROW2COL_LOAD_1_2:%.*]] = load i16, ptr [[P1]], align 1166; CHECK-NEXT: [[SUM13_CAST31:%.*]] = sext i5 [[J]] to i6167; CHECK-NEXT: [[SUM13_CAST:%.*]] = zext i6 [[SUM13_CAST31]] to i64168; CHECK-NEXT: [[P2:%.*]] = getelementptr i16, ptr [[ROW2COL]], i64 [[SUM13_CAST]]169; CHECK-NEXT: [[ROW2COL_LOAD_1_6:%.*]] = load i16, ptr [[P2]], align 1170; CHECK-NEXT: [[DOTRET:%.*]] = sub i16 [[ROW2COL_LOAD_1_6]], [[ROW2COL_LOAD_1_2]]171; CHECK-NEXT: ret i16 [[DOTRET]]172;173entry:174 %sum5.cast = zext i5 %j to i64 ; <i64> [#uses=1]175 %P1 = getelementptr i16, ptr %row2col, i64 %sum5.cast176 %row2col.load.1.2 = load i16, ptr %P1, align 1 ; <i16> [#uses=1]177 178 %sum13.cast31 = sext i5 %j to i6 ; <i6> [#uses=1]179 %sum13.cast = zext i6 %sum13.cast31 to i64 ; <i64> [#uses=1]180 %P2 = getelementptr i16, ptr %row2col, i64 %sum13.cast181 %row2col.load.1.6 = load i16, ptr %P2, align 1 ; <i16> [#uses=1]182 183 %.ret = sub i16 %row2col.load.1.6, %row2col.load.1.2 ; <i16> [#uses=1]184 ret i16 %.ret185}186