; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
;; Simple case: a zext nneg can be replaced with a sext. Make sure BasicAA
;; understands that.
define void @t1(i32 %a, i32 %b) {
; CHECK-LABEL: Function: t1
; CHECK: NoAlias: float* %gep1, float* %gep2
%1 = alloca [8 x float], align 4
%or1 = or i32 %a, 1
%2 = sext i32 %or1 to i64
%gep1 = getelementptr inbounds float, ptr %1, i64 %2
%shl1 = shl i32 %b, 1
%3 = zext nneg i32 %shl1 to i64
%gep2 = getelementptr inbounds float, ptr %1, i64 %3
load float, ptr %gep1
load float, ptr %gep2
ret void
}
;; A (zext nneg (sext V)) is equivalent to a (zext (sext V)) as long as the
;; total number of zext+sext bits is the same for both.
define void @t2(i8 %a, i8 %b) {
; CHECK-LABEL: Function: t2
; CHECK: NoAlias: float* %gep1, float* %gep2
%1 = alloca [8 x float], align 4
%or1 = or i8 %a, 1
%2 = sext i8 %or1 to i32
%3 = zext i32 %2 to i64
%gep1 = getelementptr inbounds float, ptr %1, i64 %3
%shl1 = shl i8 %b, 1
%4 = sext i8 %shl1 to i16
%5 = zext nneg i16 %4 to i64
%gep2 = getelementptr inbounds float, ptr %1, i64 %5
load float, ptr %gep1
load float, ptr %gep2
ret void
}
;; Here the %a and %b are knowably non-equal. In this cases we can distribute
;; the zext, preserving the nneg flag, through the shl because it has a nsw flag
define void @t3(i8 %v) {
; CHECK-LABEL: Function: t3
; CHECK: NoAlias: <2 x float>* %gep1, <2 x float>* %gep2
%a = or i8 %v, 1
%b = and i8 %v, 2
%1 = alloca [8 x float], align 4
%or1 = shl nuw nsw i8 %a, 1
%2 = zext nneg i8 %or1 to i64
%gep1 = getelementptr inbounds float, ptr %1, i64 %2
%m = mul nsw nuw i8 %b, 2
%3 = sext i8 %m to i16
%4 = zext i16 %3 to i64
%gep2 = getelementptr inbounds float, ptr %1, i64 %4
load <2 x float>, ptr %gep1
load <2 x float>, ptr %gep2
ret void
}
;; This is the same as above, but this time the shl does not have the nsw flag.
;; the nneg cannot be kept on the zext.
define void @t4(i8 %v) {
; CHECK-LABEL: Function: t4
; CHECK: MayAlias: <2 x float>* %gep1, <2 x float>* %gep2
%a = or i8 %v, 1
%b = and i8 %v, 2
%1 = alloca [8 x float], align 4
%or1 = shl nuw i8 %a, 1
%2 = zext nneg i8 %or1 to i64
%gep1 = getelementptr inbounds float, ptr %1, i64 %2
%m = mul nsw nuw i8 %b, 2
%3 = sext i8 %m to i16
%4 = zext i16 %3 to i64
%gep2 = getelementptr inbounds float, ptr %1, i64 %4
load <2 x float>, ptr %gep1
load <2 x float>, ptr %gep2
ret void
}
;; Verify a zext nneg and a zext are understood as the same
define void @t5(ptr %p, i16 %i) {
; CHECK-LABEL: Function: t5
; CHECK: NoAlias: i32* %pi, i32* %pi.next
%i1 = zext nneg i16 %i to i32
%pi = getelementptr i32, ptr %p, i32 %i1
%i.next = add i16 %i, 1
%i.next2 = zext i16 %i.next to i32
%pi.next = getelementptr i32, ptr %p, i32 %i.next2
load i32, ptr %pi
load i32, ptr %pi.next
ret void
}
;; This is not very idiomatic, but still possible, verify the nneg is propagated
;; outward. and that no alias is correctly identified.
define void @t6(i8 %a) {
; CHECK-LABEL: Function: t6
; CHECK: NoAlias: float* %gep1, float* %gep2
%1 = alloca [8 x float], align 4
%a.add = add i8 %a, 1
%2 = zext nneg i8 %a.add to i16
%3 = sext i16 %2 to i32
%4 = zext i32 %3 to i64
%gep1 = getelementptr inbounds float, ptr %1, i64 %4
%5 = sext i8 %a to i64
%gep2 = getelementptr inbounds float, ptr %1, i64 %5
load float, ptr %gep1
load float, ptr %gep2
ret void
}
;; This is even less idiomatic, but still possible, verify the nneg is not
;; propagated inward. and that may alias is correctly identified.
define void @t7(i8 %a) {
; CHECK-LABEL: Function: t7
; CHECK: MayAlias: float* %gep1, float* %gep2
%1 = alloca [8 x float], align 4
%a.add = add i8 %a, 1
%2 = zext i8 %a.add to i16
%3 = sext i16 %2 to i32
%4 = zext nneg i32 %3 to i64
%gep1 = getelementptr inbounds float, ptr %1, i64 %4
%5 = sext i8 %a to i64
%gep2 = getelementptr inbounds float, ptr %1, i64 %5
load float, ptr %gep1
load float, ptr %gep2
ret void
}
;; Verify the nneg survives an implicit trunc of fewer bits then the zext.
define void @t8(i8 %a) {
; CHECK-LABEL: Function: t8
; CHECK: NoAlias: float* %gep1, float* %gep2
%1 = alloca [8 x float], align 4
%a.add = add i8 %a, 1
%2 = zext nneg i8 %a.add to i128
%gep1 = getelementptr inbounds float, ptr %1, i128 %2
%3 = sext i8 %a to i64
%gep2 = getelementptr inbounds float, ptr %1, i64 %3
load float, ptr %gep1
load float, ptr %gep2
ret void
}
;; Ensure that the nneg is never propagated past this trunc and that these
;; casted values are understood as non-equal.
define void @t9(i8 %a) {
; CHECK-LABEL: Function: t9
; CHECK: MayAlias: float* %gep1, float* %gep2
%1 = alloca [8 x float], align 4
%a.add = add i8 %a, 1
%2 = zext i8 %a.add to i16
%3 = trunc i16 %2 to i1
%4 = zext nneg i1 %3 to i64
%gep1 = getelementptr inbounds float, ptr %1, i64 %4
%5 = sext i8 %a to i64
%gep2 = getelementptr inbounds float, ptr %1, i64 %5
load float, ptr %gep1
load float, ptr %gep2
ret void
}
Codebase Browser
llvm