Page MenuHomePhabricator
Differential D54532 Diff 174800 llvm/trunk/test/Transforms/InstSimplify/saturating-add-sub.ll

Changeset View

Standalone View

View Options

llvm/trunk/test/Transforms/InstSimplify/saturating-add-sub.ll

Show All 10 Lines
declare i8 @llvm.usub.sat.i8(i8, i8) declare i8 @llvm.usub.sat.i8(i8, i8)
declare i8 @llvm.ssub.sat.i8(i8, i8) declare i8 @llvm.ssub.sat.i8(i8, i8)
declare <2 x i8> @llvm.usub.sat.v2i8(<2 x i8>, <2 x i8>) declare <2 x i8> @llvm.usub.sat.v2i8(<2 x i8>, <2 x i8>)
declare <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8>, <2 x i8>) declare <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8>, <2 x i8>)
define i8 @uadd_scalar_0(i8 %a) { define i8 @uadd_scalar_0(i8 %a) {
; CHECK-LABEL: @uadd_scalar_0( ; CHECK-LABEL: @uadd_scalar_0(
; CHECK-NEXT: [[X1:%.*]] = call i8 @llvm.uadd.sat.i8(i8 [[A:%.*]], i8 0) ; CHECK-NEXT: ret i8 [[A:%.*]]
; CHECK-NEXT: ret i8 [[X1]]
; ;
%x1 = call i8 @llvm.uadd.sat.i8(i8 %a, i8 0) %x1 = call i8 @llvm.uadd.sat.i8(i8 %a, i8 0)
ret i8 %x1 ret i8 %x1
} }
define <2 x i8> @uadd_vector_0(<2 x i8> %a) { define <2 x i8> @uadd_vector_0(<2 x i8> %a) {
; CHECK-LABEL: @uadd_vector_0( ; CHECK-LABEL: @uadd_vector_0(
; CHECK-NEXT: [[X1V:%.*]] = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> zeroinitializer) ; CHECK-NEXT: ret <2 x i8> [[A:%.*]]
; CHECK-NEXT: ret <2 x i8> [[X1V]]
; ;
%x1v = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %a, <2 x i8> zeroinitializer) %x1v = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %a, <2 x i8> zeroinitializer)
ret <2 x i8> %x1v ret <2 x i8> %x1v
} }
define i3 @uadd_scalar_0_commute(i3 %a) { define i3 @uadd_scalar_0_commute(i3 %a) {
; CHECK-LABEL: @uadd_scalar_0_commute( ; CHECK-LABEL: @uadd_scalar_0_commute(
; CHECK-NEXT: [[X2:%.*]] = call i3 @llvm.uadd.sat.i3(i3 0, i3 [[A:%.*]]) ; CHECK-NEXT: ret i3 [[A:%.*]]
; CHECK-NEXT: ret i3 [[X2]]
; ;
%x2 = call i3 @llvm.uadd.sat.i3(i3 0, i3 %a) %x2 = call i3 @llvm.uadd.sat.i3(i3 0, i3 %a)
ret i3 %x2 ret i3 %x2
} }
define <2 x i8> @uadd_vector_0_commute(<2 x i8> %a) { define <2 x i8> @uadd_vector_0_commute(<2 x i8> %a) {
; CHECK-LABEL: @uadd_vector_0_commute( ; CHECK-LABEL: @uadd_vector_0_commute(
; CHECK-NEXT: [[X2V:%.*]] = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> <i8 0, i8 undef>, <2 x i8> [[A:%.*]]) ; CHECK-NEXT: ret <2 x i8> [[A:%.*]]
; CHECK-NEXT: ret <2 x i8> [[X2V]]
; ;
%x2v = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> <i8 0, i8 undef>, <2 x i8> %a) %x2v = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> <i8 0, i8 undef>, <2 x i8> %a)
ret <2 x i8> %x2v ret <2 x i8> %x2v
} }
define i8 @uadd_scalar_maxval(i8 %a) { define i8 @uadd_scalar_maxval(i8 %a) {
; CHECK-LABEL: @uadd_scalar_maxval( ; CHECK-LABEL: @uadd_scalar_maxval(
; CHECK-NEXT: [[X3:%.*]] = call i8 @llvm.uadd.sat.i8(i8 [[A:%.*]], i8 -1) ; CHECK-NEXT: ret i8 -1
; CHECK-NEXT: ret i8 [[X3]]
; ;
%x3 = call i8 @llvm.uadd.sat.i8(i8 %a, i8 255) %x3 = call i8 @llvm.uadd.sat.i8(i8 %a, i8 255)
ret i8 %x3 ret i8 %x3
} }
define <2 x i9> @uadd_vector_maxval(<2 x i9> %a) { define <2 x i9> @uadd_vector_maxval(<2 x i9> %a) {
; CHECK-LABEL: @uadd_vector_maxval( ; CHECK-LABEL: @uadd_vector_maxval(
; CHECK-NEXT: [[X3V:%.*]] = call <2 x i9> @llvm.uadd.sat.v2i9(<2 x i9> [[A:%.*]], <2 x i9> <i9 -1, i9 -1>) ; CHECK-NEXT: ret <2 x i9> <i9 -1, i9 -1>
; CHECK-NEXT: ret <2 x i9> [[X3V]]
; ;
%x3v = call <2 x i9> @llvm.uadd.sat.v2i9(<2 x i9> %a, <2 x i9> <i9 511, i9 511>) %x3v = call <2 x i9> @llvm.uadd.sat.v2i9(<2 x i9> %a, <2 x i9> <i9 511, i9 511>)
ret <2 x i9> %x3v ret <2 x i9> %x3v
} }
define i3 @uadd_scalar_maxval_commute(i3 %a) { define i3 @uadd_scalar_maxval_commute(i3 %a) {
; CHECK-LABEL: @uadd_scalar_maxval_commute( ; CHECK-LABEL: @uadd_scalar_maxval_commute(
; CHECK-NEXT: [[X4:%.*]] = call i3 @llvm.uadd.sat.i3(i3 -1, i3 [[A:%.*]]) ; CHECK-NEXT: ret i3 -1
; CHECK-NEXT: ret i3 [[X4]]
; ;
%x4 = call i3 @llvm.uadd.sat.i3(i3 7, i3 %a) %x4 = call i3 @llvm.uadd.sat.i3(i3 7, i3 %a)
ret i3 %x4 ret i3 %x4
} }
define <2 x i8> @uadd_vector_maxval_commute(<2 x i8> %a) { define <2 x i8> @uadd_vector_maxval_commute(<2 x i8> %a) {
; CHECK-LABEL: @uadd_vector_maxval_commute( ; CHECK-LABEL: @uadd_vector_maxval_commute(
; CHECK-NEXT: [[X4V:%.*]] = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> <i8 -1, i8 -1>, <2 x i8> [[A:%.*]]) ; CHECK-NEXT: ret <2 x i8> <i8 -1, i8 -1>
; CHECK-NEXT: ret <2 x i8> [[X4V]]
; ;
%x4v = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> <i8 255, i8 255>, <2 x i8> %a) %x4v = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> <i8 255, i8 255>, <2 x i8> %a)
ret <2 x i8> %x4v ret <2 x i8> %x4v
} }
define i8 @uadd_scalar_undef(i8 %a) { define i8 @uadd_scalar_undef(i8 %a) {
; CHECK-LABEL: @uadd_scalar_undef( ; CHECK-LABEL: @uadd_scalar_undef(
; CHECK-NEXT: [[X5:%.*]] = call i8 @llvm.uadd.sat.i8(i8 [[A:%.*]], i8 undef) ; CHECK-NEXT: ret i8 -1
; CHECK-NEXT: ret i8 [[X5]]
; ;
%x5 = call i8 @llvm.uadd.sat.i8(i8 %a, i8 undef) %x5 = call i8 @llvm.uadd.sat.i8(i8 %a, i8 undef)
ret i8 %x5 ret i8 %x5
} }
define <2 x i8> @uadd_vector_undef(<2 x i8> %a) { define <2 x i8> @uadd_vector_undef(<2 x i8> %a) {
; CHECK-LABEL: @uadd_vector_undef( ; CHECK-LABEL: @uadd_vector_undef(
; CHECK-NEXT: [[X5V:%.*]] = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> undef) ; CHECK-NEXT: ret <2 x i8> <i8 -1, i8 -1>
; CHECK-NEXT: ret <2 x i8> [[X5V]]
; ;
%x5v = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 undef, i8 undef>) %x5v = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 undef, i8 undef>)
ret <2 x i8> %x5v ret <2 x i8> %x5v
} }
define i8 @uadd_scalar_undef_commute(i8 %a) { define i8 @uadd_scalar_undef_commute(i8 %a) {
; CHECK-LABEL: @uadd_scalar_undef_commute( ; CHECK-LABEL: @uadd_scalar_undef_commute(
; CHECK-NEXT: [[X6:%.*]] = call i8 @llvm.uadd.sat.i8(i8 undef, i8 [[A:%.*]]) ; CHECK-NEXT: ret i8 -1
; CHECK-NEXT: ret i8 [[X6]]
; ;
%x6 = call i8 @llvm.uadd.sat.i8(i8 undef, i8 %a) %x6 = call i8 @llvm.uadd.sat.i8(i8 undef, i8 %a)
ret i8 %x6 ret i8 %x6
} }
define <2 x i8> @uadd_vector_undef_commute(<2 x i8> %a) { define <2 x i8> @uadd_vector_undef_commute(<2 x i8> %a) {
; CHECK-LABEL: @uadd_vector_undef_commute( ; CHECK-LABEL: @uadd_vector_undef_commute(
; CHECK-NEXT: [[X5V:%.*]] = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> undef, <2 x i8> [[A:%.*]]) ; CHECK-NEXT: ret <2 x i8> <i8 -1, i8 -1>
; CHECK-NEXT: ret <2 x i8> [[X5V]]
; ;
%x5v = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> undef, <2 x i8> %a) %x5v = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> undef, <2 x i8> %a)
ret <2 x i8> %x5v ret <2 x i8> %x5v
} }
define i8 @sadd_scalar_0(i8 %a) { define i8 @sadd_scalar_0(i8 %a) {
; CHECK-LABEL: @sadd_scalar_0( ; CHECK-LABEL: @sadd_scalar_0(
; CHECK-NEXT: [[Y1:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[A:%.*]], i8 0) ; CHECK-NEXT: ret i8 [[A:%.*]]
; CHECK-NEXT: ret i8 [[Y1]]
; ;
%y1 = call i8 @llvm.sadd.sat.i8(i8 %a, i8 0) %y1 = call i8 @llvm.sadd.sat.i8(i8 %a, i8 0)
ret i8 %y1 ret i8 %y1
} }
define <2 x i8> @sadd_vector_0(<2 x i8> %a) { define <2 x i8> @sadd_vector_0(<2 x i8> %a) {
; CHECK-LABEL: @sadd_vector_0( ; CHECK-LABEL: @sadd_vector_0(
; CHECK-NEXT: [[Y1V:%.*]] = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> <i8 undef, i8 0>) ; CHECK-NEXT: ret <2 x i8> [[A:%.*]]
; CHECK-NEXT: ret <2 x i8> [[Y1V]]
; ;
%y1v = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 undef, i8 0>) %y1v = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 undef, i8 0>)
ret <2 x i8> %y1v ret <2 x i8> %y1v
} }
define i8 @sadd_scalar_0_commute(i8 %a) { define i8 @sadd_scalar_0_commute(i8 %a) {
; CHECK-LABEL: @sadd_scalar_0_commute( ; CHECK-LABEL: @sadd_scalar_0_commute(
; CHECK-NEXT: [[Y2:%.*]] = call i8 @llvm.sadd.sat.i8(i8 0, i8 [[A:%.*]]) ; CHECK-NEXT: ret i8 [[A:%.*]]
; CHECK-NEXT: ret i8 [[Y2]]
; ;
%y2 = call i8 @llvm.sadd.sat.i8(i8 0, i8 %a) %y2 = call i8 @llvm.sadd.sat.i8(i8 0, i8 %a)
ret i8 %y2 ret i8 %y2
} }
define <2 x i8> @sadd_vector_0_commute(<2 x i8> %a) { define <2 x i8> @sadd_vector_0_commute(<2 x i8> %a) {
; CHECK-LABEL: @sadd_vector_0_commute( ; CHECK-LABEL: @sadd_vector_0_commute(
; CHECK-NEXT: [[Y2V:%.*]] = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> zeroinitializer, <2 x i8> [[A:%.*]]) ; CHECK-NEXT: ret <2 x i8> [[A:%.*]]
; CHECK-NEXT: ret <2 x i8> [[Y2V]]
; ;
%y2v = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> zeroinitializer, <2 x i8> %a) %y2v = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> zeroinitializer, <2 x i8> %a)
ret <2 x i8> %y2v ret <2 x i8> %y2v
} }
define i8 @sadd_scalar_maxval(i8 %a) { define i8 @sadd_scalar_maxval(i8 %a) {
; CHECK-LABEL: @sadd_scalar_maxval( ; CHECK-LABEL: @sadd_scalar_maxval(
; CHECK-NEXT: [[Y3:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[A:%.*]], i8 127) ; CHECK-NEXT: [[Y3:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[A:%.*]], i8 127)
Show All 27 Lines
; CHECK-NEXT: ret <2 x i8> [[Y4V]] ; CHECK-NEXT: ret <2 x i8> [[Y4V]]
; ;
%y4v = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> <i8 undef, i8 127>, <2 x i8> %a) %y4v = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> <i8 undef, i8 127>, <2 x i8> %a)
ret <2 x i8> %y4v ret <2 x i8> %y4v
} }
define i8 @sadd_scalar_undef(i8 %a) { define i8 @sadd_scalar_undef(i8 %a) {
; CHECK-LABEL: @sadd_scalar_undef( ; CHECK-LABEL: @sadd_scalar_undef(
; CHECK-NEXT: [[Y5:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[A:%.*]], i8 undef) ; CHECK-NEXT: ret i8 -1
; CHECK-NEXT: ret i8 [[Y5]]
; ;
%y5 = call i8 @llvm.sadd.sat.i8(i8 %a, i8 undef) %y5 = call i8 @llvm.sadd.sat.i8(i8 %a, i8 undef)
ret i8 %y5 ret i8 %y5
} }
define <2 x i8> @sadd_vector_undef(<2 x i8> %a) { define <2 x i8> @sadd_vector_undef(<2 x i8> %a) {
; CHECK-LABEL: @sadd_vector_undef( ; CHECK-LABEL: @sadd_vector_undef(
; CHECK-NEXT: [[Y5V:%.*]] = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> undef) ; CHECK-NEXT: ret <2 x i8> <i8 -1, i8 -1>
; CHECK-NEXT: ret <2 x i8> [[Y5V]]
; ;
%y5v = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> %a, <2 x i8> undef) %y5v = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> %a, <2 x i8> undef)
ret <2 x i8> %y5v ret <2 x i8> %y5v
} }
define i8 @sadd_scalar_undef_commute(i8 %a) { define i8 @sadd_scalar_undef_commute(i8 %a) {
; CHECK-LABEL: @sadd_scalar_undef_commute( ; CHECK-LABEL: @sadd_scalar_undef_commute(
; CHECK-NEXT: [[Y6:%.*]] = call i8 @llvm.sadd.sat.i8(i8 undef, i8 [[A:%.*]]) ; CHECK-NEXT: ret i8 -1
; CHECK-NEXT: ret i8 [[Y6]]
; ;
%y6 = call i8 @llvm.sadd.sat.i8(i8 undef, i8 %a) %y6 = call i8 @llvm.sadd.sat.i8(i8 undef, i8 %a)
ret i8 %y6 ret i8 %y6
} }
define <2 x i8> @sadd_vector_undef_commute(<2 x i8> %a) { define <2 x i8> @sadd_vector_undef_commute(<2 x i8> %a) {
; CHECK-LABEL: @sadd_vector_undef_commute( ; CHECK-LABEL: @sadd_vector_undef_commute(
; CHECK-NEXT: [[Y6V:%.*]] = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> undef, <2 x i8> [[A:%.*]]) ; CHECK-NEXT: ret <2 x i8> <i8 -1, i8 -1>
; CHECK-NEXT: ret <2 x i8> [[Y6V]]
; ;
%y6v = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> undef, <2 x i8> %a) %y6v = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> undef, <2 x i8> %a)
ret <2 x i8> %y6v ret <2 x i8> %y6v
} }
define i8 @usub_scalar_0(i8 %a) { define i8 @usub_scalar_0(i8 %a) {
; CHECK-LABEL: @usub_scalar_0( ; CHECK-LABEL: @usub_scalar_0(
; CHECK-NEXT: [[X1:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[A:%.*]], i8 0) ; CHECK-NEXT: ret i8 [[A:%.*]]
; CHECK-NEXT: ret i8 [[X1]]
; ;
%x1 = call i8 @llvm.usub.sat.i8(i8 %a, i8 0) %x1 = call i8 @llvm.usub.sat.i8(i8 %a, i8 0)
ret i8 %x1 ret i8 %x1
} }
define <2 x i8> @usub_vector_0(<2 x i8> %a) { define <2 x i8> @usub_vector_0(<2 x i8> %a) {
; CHECK-LABEL: @usub_vector_0( ; CHECK-LABEL: @usub_vector_0(
; CHECK-NEXT: [[X1V:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> zeroinitializer) ; CHECK-NEXT: ret <2 x i8> [[A:%.*]]
; CHECK-NEXT: ret <2 x i8> [[X1V]]
; ;
%x1v = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 0, i8 0>) %x1v = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 0, i8 0>)
ret <2 x i8> %x1v ret <2 x i8> %x1v
} }
define i8 @usub_scalar_0_commute(i8 %a) { define i8 @usub_scalar_0_commute(i8 %a) {
; CHECK-LABEL: @usub_scalar_0_commute( ; CHECK-LABEL: @usub_scalar_0_commute(
; CHECK-NEXT: [[X2:%.*]] = call i8 @llvm.usub.sat.i8(i8 0, i8 [[A:%.*]]) ; CHECK-NEXT: ret i8 0
; CHECK-NEXT: ret i8 [[X2]]
; ;
%x2 = call i8 @llvm.usub.sat.i8(i8 0, i8 %a) %x2 = call i8 @llvm.usub.sat.i8(i8 0, i8 %a)
ret i8 %x2 ret i8 %x2
} }
define <2 x i8> @usub_vector_0_commute(<2 x i8> %a) { define <2 x i8> @usub_vector_0_commute(<2 x i8> %a) {
; CHECK-LABEL: @usub_vector_0_commute( ; CHECK-LABEL: @usub_vector_0_commute(
; CHECK-NEXT: [[X2V:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> zeroinitializer, <2 x i8> [[A:%.*]]) ; CHECK-NEXT: ret <2 x i8> zeroinitializer
; CHECK-NEXT: ret <2 x i8> [[X2V]]
; ;
%x2v = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> <i8 0, i8 0>, <2 x i8> %a) %x2v = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> <i8 0, i8 0>, <2 x i8> %a)
ret <2 x i8> %x2v ret <2 x i8> %x2v
} }
define i8 @usub_scalar_maxval(i8 %a) { define i8 @usub_scalar_maxval(i8 %a) {
; CHECK-LABEL: @usub_scalar_maxval( ; CHECK-LABEL: @usub_scalar_maxval(
; CHECK-NEXT: [[X3:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[A:%.*]], i8 -1) ; CHECK-NEXT: ret i8 0
; CHECK-NEXT: ret i8 [[X3]]
; ;
%x3 = call i8 @llvm.usub.sat.i8(i8 %a, i8 255) %x3 = call i8 @llvm.usub.sat.i8(i8 %a, i8 255)
ret i8 %x3 ret i8 %x3
} }
define <2 x i8> @usub_vector_maxval(<2 x i8> %a) { define <2 x i8> @usub_vector_maxval(<2 x i8> %a) {
; CHECK-LABEL: @usub_vector_maxval( ; CHECK-LABEL: @usub_vector_maxval(
; CHECK-NEXT: [[X3V:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> <i8 -1, i8 -1>) ; CHECK-NEXT: ret <2 x i8> zeroinitializer
; CHECK-NEXT: ret <2 x i8> [[X3V]]
; ;
%x3v = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 255, i8 255>) %x3v = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 255, i8 255>)
ret <2 x i8> %x3v ret <2 x i8> %x3v
} }
define i8 @usub_scalar_undef(i8 %a) { define i8 @usub_scalar_undef(i8 %a) {
; CHECK-LABEL: @usub_scalar_undef( ; CHECK-LABEL: @usub_scalar_undef(
; CHECK-NEXT: [[X4:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[A:%.*]], i8 undef) ; CHECK-NEXT: ret i8 0
; CHECK-NEXT: ret i8 [[X4]]
; ;
%x4 = call i8 @llvm.usub.sat.i8(i8 %a, i8 undef) %x4 = call i8 @llvm.usub.sat.i8(i8 %a, i8 undef)
ret i8 %x4 ret i8 %x4
} }
define <2 x i8> @usub_vector_undef(<2 x i8> %a) { define <2 x i8> @usub_vector_undef(<2 x i8> %a) {
; CHECK-LABEL: @usub_vector_undef( ; CHECK-LABEL: @usub_vector_undef(
; CHECK-NEXT: [[X4V:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> <i8 0, i8 undef>) ; CHECK-NEXT: ret <2 x i8> zeroinitializer
; CHECK-NEXT: ret <2 x i8> [[X4V]]
; ;
%x4v = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 0, i8 undef>) %x4v = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 undef, i8 undef>)
ret <2 x i8> %x4v ret <2 x i8> %x4v
} }
define i8 @usub_scalar_undef_commute(i8 %a) { define i8 @usub_scalar_undef_commute(i8 %a) {
; CHECK-LABEL: @usub_scalar_undef_commute( ; CHECK-LABEL: @usub_scalar_undef_commute(
; CHECK-NEXT: [[X5:%.*]] = call i8 @llvm.usub.sat.i8(i8 undef, i8 [[A:%.*]]) ; CHECK-NEXT: ret i8 0
; CHECK-NEXT: ret i8 [[X5]]
; ;
%x5 = call i8 @llvm.usub.sat.i8(i8 undef, i8 %a) %x5 = call i8 @llvm.usub.sat.i8(i8 undef, i8 %a)
ret i8 %x5 ret i8 %x5
} }
define <2 x i8> @usub_vector_undef_commute(<2 x i8> %a) { define <2 x i8> @usub_vector_undef_commute(<2 x i8> %a) {
; CHECK-LABEL: @usub_vector_undef_commute( ; CHECK-LABEL: @usub_vector_undef_commute(
; CHECK-NEXT: [[X5V:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> undef) ; CHECK-NEXT: ret <2 x i8> zeroinitializer
; CHECK-NEXT: ret <2 x i8> [[X5V]]
; ;
%x5v = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 undef, i8 undef>) %x5v = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> <i8 undef, i8 undef>, <2 x i8> %a)
ret <2 x i8> %x5v ret <2 x i8> %x5v
} }
define i8 @usub_scalar_same(i8 %a) { define i8 @usub_scalar_same(i8 %a) {
; CHECK-LABEL: @usub_scalar_same( ; CHECK-LABEL: @usub_scalar_same(
; CHECK-NEXT: [[X6:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[A:%.*]], i8 [[A]]) ; CHECK-NEXT: ret i8 0
; CHECK-NEXT: ret i8 [[X6]]
; ;
%x6 = call i8 @llvm.usub.sat.i8(i8 %a, i8 %a) %x6 = call i8 @llvm.usub.sat.i8(i8 %a, i8 %a)
ret i8 %x6 ret i8 %x6
} }
define <2 x i8> @usub_vector_same(<2 x i8> %a) { define <2 x i8> @usub_vector_same(<2 x i8> %a) {
; CHECK-LABEL: @usub_vector_same( ; CHECK-LABEL: @usub_vector_same(
; CHECK-NEXT: [[X6V:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> [[A]]) ; CHECK-NEXT: ret <2 x i8> zeroinitializer
; CHECK-NEXT: ret <2 x i8> [[X6V]]
; ;
%x6v = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a, <2 x i8> %a) %x6v = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %a, <2 x i8> %a)
ret <2 x i8> %x6v ret <2 x i8> %x6v
} }
define i8 @ssub_scalar_0(i8 %a) { define i8 @ssub_scalar_0(i8 %a) {
; CHECK-LABEL: @ssub_scalar_0( ; CHECK-LABEL: @ssub_scalar_0(
; CHECK-NEXT: [[Y1:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[A:%.*]], i8 0) ; CHECK-NEXT: ret i8 [[A:%.*]]
; CHECK-NEXT: ret i8 [[Y1]]
; ;
%y1 = call i8 @llvm.ssub.sat.i8(i8 %a, i8 0) %y1 = call i8 @llvm.ssub.sat.i8(i8 %a, i8 0)
ret i8 %y1 ret i8 %y1
} }
define <2 x i8> @ssub_vector_0(<2 x i8> %a) { define <2 x i8> @ssub_vector_0(<2 x i8> %a) {
; CHECK-LABEL: @ssub_vector_0( ; CHECK-LABEL: @ssub_vector_0(
; CHECK-NEXT: [[Y1V:%.*]] = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> zeroinitializer) ; CHECK-NEXT: ret <2 x i8> [[A:%.*]]
; CHECK-NEXT: ret <2 x i8> [[Y1V]]
; ;
%y1v = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 0, i8 0>) %y1v = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 0, i8 0>)
ret <2 x i8> %y1v ret <2 x i8> %y1v
} }
define i8 @ssub_scalar_0_commute(i8 %a) { define i8 @ssub_scalar_0_commute(i8 %a) {
; CHECK-LABEL: @ssub_scalar_0_commute( ; CHECK-LABEL: @ssub_scalar_0_commute(
; CHECK-NEXT: [[Y2:%.*]] = call i8 @llvm.ssub.sat.i8(i8 0, i8 [[A:%.*]]) ; CHECK-NEXT: [[Y2:%.*]] = call i8 @llvm.ssub.sat.i8(i8 0, i8 [[A:%.*]])
Show All 27 Lines
; CHECK-NEXT: ret <2 x i8> [[Y3V]] ; CHECK-NEXT: ret <2 x i8> [[Y3V]]
; ;
%y3v = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 127, i8 127>) %y3v = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %a, <2 x i8> <i8 127, i8 127>)
ret <2 x i8> %y3v ret <2 x i8> %y3v
} }
define i8 @ssub_scalar_undef(i8 %a) { define i8 @ssub_scalar_undef(i8 %a) {
; CHECK-LABEL: @ssub_scalar_undef( ; CHECK-LABEL: @ssub_scalar_undef(
; CHECK-NEXT: [[Y4:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[A:%.*]], i8 undef) ; CHECK-NEXT: ret i8 0
; CHECK-NEXT: ret i8 [[Y4]]
; ;
%y4 = call i8 @llvm.ssub.sat.i8(i8 %a, i8 undef) %y4 = call i8 @llvm.ssub.sat.i8(i8 %a, i8 undef)
ret i8 %y4 ret i8 %y4
} }
define <2 x i8> @ssub_vector_undef(<2 x i8> %a) { define <2 x i8> @ssub_vector_undef(<2 x i8> %a) {
; CHECK-LABEL: @ssub_vector_undef( ; CHECK-LABEL: @ssub_vector_undef(
; CHECK-NEXT: [[Y4V:%.*]] = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> undef) ; CHECK-NEXT: ret <2 x i8> zeroinitializer
; CHECK-NEXT: ret <2 x i8> [[Y4V]]
; ;
%y4v = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %a, <2 x i8> undef) %y4v = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %a, <2 x i8> undef)
ret <2 x i8> %y4v ret <2 x i8> %y4v
} }
define i8 @ssub_scalar_undef_commute(i8 %a) { define i8 @ssub_scalar_undef_commute(i8 %a) {
; CHECK-LABEL: @ssub_scalar_undef_commute( ; CHECK-LABEL: @ssub_scalar_undef_commute(
; CHECK-NEXT: [[Y5:%.*]] = call i8 @llvm.ssub.sat.i8(i8 undef, i8 [[A:%.*]]) ; CHECK-NEXT: ret i8 0
; CHECK-NEXT: ret i8 [[Y5]]
; ;
%y5 = call i8 @llvm.ssub.sat.i8(i8 undef, i8 %a) %y5 = call i8 @llvm.ssub.sat.i8(i8 undef, i8 %a)
ret i8 %y5 ret i8 %y5
} }
define <2 x i8> @ssub_vector_undef_commute(<2 x i8> %a) { define <2 x i8> @ssub_vector_undef_commute(<2 x i8> %a) {
; CHECK-LABEL: @ssub_vector_undef_commute( ; CHECK-LABEL: @ssub_vector_undef_commute(
; CHECK-NEXT: [[Y5V:%.*]] = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> undef, <2 x i8> [[A:%.*]]) ; CHECK-NEXT: ret <2 x i8> zeroinitializer
; CHECK-NEXT: ret <2 x i8> [[Y5V]]
; ;
%y5v = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> <i8 undef, i8 undef>, <2 x i8> %a) %y5v = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> <i8 undef, i8 undef>, <2 x i8> %a)
ret <2 x i8> %y5v ret <2 x i8> %y5v
} }
define i8 @ssub_scalar_same(i8 %a) { define i8 @ssub_scalar_same(i8 %a) {
; CHECK-LABEL: @ssub_scalar_same( ; CHECK-LABEL: @ssub_scalar_same(
; CHECK-NEXT: [[Y6:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[A:%.*]], i8 [[A]]) ; CHECK-NEXT: ret i8 0
; CHECK-NEXT: ret i8 [[Y6]]
; ;
%y6 = call i8 @llvm.ssub.sat.i8(i8 %a, i8 %a) %y6 = call i8 @llvm.ssub.sat.i8(i8 %a, i8 %a)
ret i8 %y6 ret i8 %y6
} }
define <2 x i8> @ssub_vector_same(<2 x i8> %a) { define <2 x i8> @ssub_vector_same(<2 x i8> %a) {
; CHECK-LABEL: @ssub_vector_same( ; CHECK-LABEL: @ssub_vector_same(
; CHECK-NEXT: [[Y6V:%.*]] = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> [[A:%.*]], <2 x i8> [[A]]) ; CHECK-NEXT: ret <2 x i8> zeroinitializer
; CHECK-NEXT: ret <2 x i8> [[Y6V]]
; ;
%y6v = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %a, <2 x i8> %a) %y6v = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %a, <2 x i8> %a)
ret <2 x i8> %y6v ret <2 x i8> %y6v
} }