define i8 @smax_smax_smax(i8 %x, i8 %y) {
; CHECK-LABEL: @smax_smax_smax(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x)
define i8 @smax_smax_smin(i8 %x, i8 %y) {
; CHECK-LABEL: @smax_smax_smin(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x)
define i8 @smax_smax_umax(i8 %x, i8 %y) {
; CHECK-LABEL: @smax_smax_umax(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x)
define i8 @smax_smax_umin(i8 %x, i8 %y) {
; CHECK-LABEL: @smax_smax_umin(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x)
define i8 @smax_smin_smax(i8 %x, i8 %y) {
; CHECK-LABEL: @smax_smin_smax(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x)
define i8 @smax_smin_smin(i8 %x, i8 %y) {
; CHECK-LABEL: @smax_smin_smin(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x)
define i8 @smax_smin_umax(i8 %x, i8 %y) {
; CHECK-LABEL: @smax_smin_umax(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x)
define i8 @smax_smin_umin(i8 %x, i8 %y) {
; CHECK-LABEL: @smax_smin_umin(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x)
define i8 @smax_umax_smax(i8 %x, i8 %y) {
; CHECK-LABEL: @smax_umax_smax(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x)
define i8 @smax_umax_smin(i8 %x, i8 %y) {
; CHECK-LABEL: @smax_umax_smin(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x)
ret i8 %r
}
+; This could simplify (commuted min/max op).
+
define i8 @smax_umax_umax(i8 %x, i8 %y) {
; CHECK-LABEL: @smax_umax_umax(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
ret i8 %r
}
+; This could combine - smax(x,y) - but does not simplify.
+
define i8 @smax_umax_umin(i8 %x, i8 %y) {
; CHECK-LABEL: @smax_umax_umin(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
define i8 @smax_umin_smax(i8 %x, i8 %y) {
; CHECK-LABEL: @smax_umin_smax(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x)
define i8 @smax_umin_smin(i8 %x, i8 %y) {
; CHECK-LABEL: @smax_umin_smin(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x)
ret i8 %r
}
+; This could combine - smax(x,y) - but does not simplify.
+
define i8 @smax_umin_umax(i8 %x, i8 %y) {
; CHECK-LABEL: @smax_umin_umax(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
ret i8 %r
}
+; This could simplify (commuted min/max op).
+
define i8 @smax_umin_umin(i8 %x, i8 %y) {
; CHECK-LABEL: @smax_umin_umin(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
define i8 @smin_smax_smax(i8 %x, i8 %y) {
; CHECK-LABEL: @smin_smax_smax(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x)
define i8 @smin_smax_smin(i8 %x, i8 %y) {
; CHECK-LABEL: @smin_smax_smin(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x)
define i8 @smin_smax_umax(i8 %x, i8 %y) {
; CHECK-LABEL: @smin_smax_umax(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x)
define i8 @smin_smax_umin(i8 %x, i8 %y) {
; CHECK-LABEL: @smin_smax_umin(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x)
define i8 @smin_smin_smax(i8 %x, i8 %y) {
; CHECK-LABEL: @smin_smin_smax(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x)
define i8 @smin_smin_smin(i8 %x, i8 %y) {
; CHECK-LABEL: @smin_smin_smin(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x)
define i8 @smin_smin_umax(i8 %x, i8 %y) {
; CHECK-LABEL: @smin_smin_umax(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x)
define i8 @smin_smin_umin(i8 %x, i8 %y) {
; CHECK-LABEL: @smin_smin_umin(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x)
define i8 @smin_umax_smax(i8 %x, i8 %y) {
; CHECK-LABEL: @smin_umax_smax(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x)
define i8 @smin_umax_smin(i8 %x, i8 %y) {
; CHECK-LABEL: @smin_umax_smin(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x)
ret i8 %r
}
+; This could simplify (commuted min/max op).
+
define i8 @smin_umax_umax(i8 %x, i8 %y) {
; CHECK-LABEL: @smin_umax_umax(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
ret i8 %r
}
+; This could combine - smin(x,y) - but does not simplify.
+
define i8 @smin_umax_umin(i8 %x, i8 %y) {
; CHECK-LABEL: @smin_umax_umin(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
define i8 @smin_umin_smax(i8 %x, i8 %y) {
; CHECK-LABEL: @smin_umin_smax(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x)
define i8 @smin_umin_smin(i8 %x, i8 %y) {
; CHECK-LABEL: @smin_umin_smin(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x)
ret i8 %r
}
+; This could combine - smin(x,y) - but does not simplify.
+
define i8 @smin_umin_umax(i8 %x, i8 %y) {
; CHECK-LABEL: @smin_umin_umax(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
ret i8 %r
}
+; This could simplify (commuted min/max op).
+
define i8 @smin_umin_umin(i8 %x, i8 %y) {
; CHECK-LABEL: @smin_umin_umin(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
ret i8 %r
}
+; This could simplify (commuted min/max op).
+
define i8 @umax_smax_smax(i8 %x, i8 %y) {
; CHECK-LABEL: @umax_smax_smax(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
ret i8 %r
}
+; This could combine - umax(x,y) - but does not simplify.
+
define i8 @umax_smax_smin(i8 %x, i8 %y) {
; CHECK-LABEL: @umax_smax_smin(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
define i8 @umax_smax_umax(i8 %x, i8 %y) {
; CHECK-LABEL: @umax_smax_umax(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x)
define i8 @umax_smax_umin(i8 %x, i8 %y) {
; CHECK-LABEL: @umax_smax_umin(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x)
ret i8 %r
}
+; This could combine - umax(x,y) - but does not simplify.
+
define i8 @umax_smin_smax(i8 %x, i8 %y) {
; CHECK-LABEL: @umax_smin_smax(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
ret i8 %r
}
+; This could simplify (commuted min/max op).
+
define i8 @umax_smin_smin(i8 %x, i8 %y) {
; CHECK-LABEL: @umax_smin_smin(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
define i8 @umax_smin_umax(i8 %x, i8 %y) {
; CHECK-LABEL: @umax_smin_umax(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x)
define i8 @umax_smin_umin(i8 %x, i8 %y) {
; CHECK-LABEL: @umax_smin_umin(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x)
define i8 @umax_umax_smax(i8 %x, i8 %y) {
; CHECK-LABEL: @umax_umax_smax(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x)
define i8 @umax_umax_smin(i8 %x, i8 %y) {
; CHECK-LABEL: @umax_umax_smin(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x)
define i8 @umax_umax_umax(i8 %x, i8 %y) {
; CHECK-LABEL: @umax_umax_umax(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x)
define i8 @umax_umax_umin(i8 %x, i8 %y) {
; CHECK-LABEL: @umax_umax_umin(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x)
define i8 @umax_umin_smax(i8 %x, i8 %y) {
; CHECK-LABEL: @umax_umin_smax(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x)
define i8 @umax_umin_smin(i8 %x, i8 %y) {
; CHECK-LABEL: @umax_umin_smin(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x)
define i8 @umax_umin_umax(i8 %x, i8 %y) {
; CHECK-LABEL: @umax_umin_umax(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x)
define i8 @umax_umin_umin(i8 %x, i8 %y) {
; CHECK-LABEL: @umax_umin_umin(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umax.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x)
ret i8 %r
}
+; This could simplify (commuted min/max op).
+
define i8 @umin_smax_smax(i8 %x, i8 %y) {
; CHECK-LABEL: @umin_smax_smax(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
ret i8 %r
}
+; This could combine - umin(x,y) - but does not simplify.
+
define i8 @umin_smax_smin(i8 %x, i8 %y) {
; CHECK-LABEL: @umin_smax_smin(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
define i8 @umin_smax_umax(i8 %x, i8 %y) {
; CHECK-LABEL: @umin_smax_umax(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x)
define i8 @umin_smax_umin(i8 %x, i8 %y) {
; CHECK-LABEL: @umin_smax_umin(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x)
ret i8 %r
}
+; This could combine - umin(x,y) - but does not simplify.
+
define i8 @umin_smin_smax(i8 %x, i8 %y) {
; CHECK-LABEL: @umin_smin_smax(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
ret i8 %r
}
+; This could simplify (commuted min/max op).
+
define i8 @umin_smin_smin(i8 %x, i8 %y) {
; CHECK-LABEL: @umin_smin_smin(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
define i8 @umin_smin_umax(i8 %x, i8 %y) {
; CHECK-LABEL: @umin_smin_umax(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x)
define i8 @umin_smin_umin(i8 %x, i8 %y) {
; CHECK-LABEL: @umin_smin_umin(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x)
define i8 @umin_umax_smax(i8 %x, i8 %y) {
; CHECK-LABEL: @umin_umax_smax(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x)
define i8 @umin_umax_smin(i8 %x, i8 %y) {
; CHECK-LABEL: @umin_umax_smin(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x)
define i8 @umin_umax_umax(i8 %x, i8 %y) {
; CHECK-LABEL: @umin_umax_umax(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x)
define i8 @umin_umax_umin(i8 %x, i8 %y) {
; CHECK-LABEL: @umin_umax_umin(
-; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y:%.*]], i8 [[X:%.*]])
+; CHECK-NEXT: ret i8 [[M2]]
;
%m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x)
define i8 @umin_umin_smax(i8 %x, i8 %y) {
; CHECK-LABEL: @umin_umin_smax(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x)
define i8 @umin_umin_smin(i8 %x, i8 %y) {
; CHECK-LABEL: @umin_umin_smin(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x)
define i8 @umin_umin_umax(i8 %x, i8 %y) {
; CHECK-LABEL: @umin_umin_umax(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x)
define i8 @umin_umin_umin(i8 %x, i8 %y) {
; CHECK-LABEL: @umin_umin_umin(
; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[X]])
-; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umin.i8(i8 [[M1]], i8 [[M2]])
-; CHECK-NEXT: ret i8 [[R]]
+; CHECK-NEXT: ret i8 [[M1]]
;
%m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y)
%m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x)