fe992c2627
* Cranelift: aarch64: lower umin.i64 and friends * fuzzgen: Enable integer-min/max for aarch64
153 lines
4.7 KiB
Plaintext
153 lines
4.7 KiB
Plaintext
test interpret
|
|
test run
|
|
target aarch64
|
|
; target s390x
|
|
target x86_64
|
|
target riscv64
|
|
|
|
|
|
; sort three signed i8s with smin and smax only
|
|
function %isort3(i8, i8, i8) -> i8, i8, i8 {
|
|
block0(v0: i8, v1: i8, v2: i8):
|
|
v3 = smin.i8 v0, v1
|
|
v4 = smin.i8 v1, v2
|
|
v5 = smin.i8 v2, v0
|
|
v6 = smin.i8 v3, v4 ; low
|
|
v7 = smax.i8 v0, v1
|
|
v8 = smax.i8 v1, v2
|
|
v9 = smax.i8 v7, v8 ; high
|
|
v10 = smax.i8 v3, v4
|
|
v11 = smax.i8 v10, v5 ; mid = max of min of all pairs
|
|
return v6, v11, v9
|
|
}
|
|
; run: %isort3(1, 2, 3) == [1, 2, 3]
|
|
; run: %isort3(1, 3, 2) == [1, 2, 3]
|
|
; run: %isort3(2, 1, 3) == [1, 2, 3]
|
|
; run: %isort3(2, 3, 1) == [1, 2, 3]
|
|
; run: %isort3(3, 1, 2) == [1, 2, 3]
|
|
; run: %isort3(3, 2, 1) == [1, 2, 3]
|
|
; run: %isort3(-1, 0, 1) == [-1, 0, 1]
|
|
; run: %isort3(-1, 1, 1) == [-1, 1, 1]
|
|
; run: %isort3(-2, 1, 0) == [-2, 0, 1]
|
|
; run: %isort3(0, 0, 0) == [0, 0, 0]
|
|
; run: %isort3(5, 4, 4) == [4, 4, 5]
|
|
|
|
|
|
function %smin_max_i8(i8, i8) -> i8, i8 {
|
|
block0(v0: i8, v1: i8):
|
|
v2 = smin.i8 v0, v1
|
|
v3 = smax.i8 v0, v1
|
|
return v2, v3
|
|
}
|
|
; run: %smin_max_i8(127, -128) == [-128, 127]
|
|
; run: %smin_max_i8(-128, 127) == [-128, 127]
|
|
; run: %smin_max_i8(-1, 0) == [-1, 0]
|
|
; run: %smin_max_i8(1, -1) == [-1, 1]
|
|
; run: %smin_max_i8(1, 2) == [1, 2]
|
|
; run: %smin_max_i8(2, 1) == [1, 2]
|
|
; run: %smin_max_i8(2, 2) == [2, 2]
|
|
; run: %smin_max_i8(0x7f, 0x80) == [0x80, 0x7f]
|
|
|
|
function %smin_max_i16(i16, i16) -> i16, i16 {
|
|
block0(v0: i16, v1: i16):
|
|
v2 = smin.i16 v0, v1
|
|
v3 = smax.i16 v0, v1
|
|
return v2, v3
|
|
}
|
|
; run: %smin_max_i16(32767, -32768) == [-32768, 32767]
|
|
; run: %smin_max_i16(-32768, 32767) == [-32768, 32767]
|
|
; run: %smin_max_i16(-1, 0) == [-1, 0]
|
|
; run: %smin_max_i16(1, -1) == [-1, 1]
|
|
; run: %smin_max_i16(1, 2) == [1, 2]
|
|
; run: %smin_max_i16(2, 1) == [1, 2]
|
|
; run: %smin_max_i16(2, 2) == [2, 2]
|
|
; run: %smin_max_i16(0x7f, 0x80) == [0x7f, 0x80]
|
|
; run: %smin_max_i16(0x7fff, 0x8000) == [0x8000, 0x7fff]
|
|
|
|
function %smin_max_i32(i32, i32) -> i32, i32 {
|
|
block0(v0: i32, v1: i32):
|
|
v2 = smin.i32 v0, v1
|
|
v3 = smax.i32 v0, v1
|
|
return v2, v3
|
|
}
|
|
; run: %smin_max_i32(-1, 0) == [-1, 0]
|
|
; run: %smin_max_i32(1, -1) == [-1, 1]
|
|
; run: %smin_max_i32(1, 2) == [1, 2]
|
|
; run: %smin_max_i32(2, 1) == [1, 2]
|
|
; run: %smin_max_i32(0x7f, 0x80) == [0x7f, 0x80]
|
|
; run: %smin_max_i32(0x7fff, 0x8000) == [0x7fff, 0x8000]
|
|
; run: %smin_max_i32(0x7fffffff, 0x80000000) == [0x80000000, 0x7fffffff]
|
|
|
|
function %smin_max_i64(i64, i64) -> i64, i64 {
|
|
block0(v0: i64, v1: i64):
|
|
v2 = smin.i64 v0, v1
|
|
v3 = smax.i64 v0, v1
|
|
return v2, v3
|
|
}
|
|
; run: %smin_max_i64(-1, 0) == [-1, 0]
|
|
; run: %smin_max_i64(1, -1) == [-1, 1]
|
|
; run: %smin_max_i64(1, 2) == [1, 2]
|
|
; run: %smin_max_i64(2, 1) == [1, 2]
|
|
; run: %smin_max_i64(0x7f, 0x80) == [0x7f, 0x80]
|
|
; run: %smin_max_i64(0x7fff, 0x8000) == [0x7fff, 0x8000]
|
|
; run: %smin_max_i64(0x7fffffff, 0x80000000) == [0x7fffffff, 0x80000000]
|
|
; run: %smin_max_i64(0x7fffffffffffffff, 0x8000000000000000) == [0x8000000000000000, 0x7fffffffffffffff]
|
|
|
|
function %umin_max_i8(i8, i8) -> i8, i8 {
|
|
block0(v0: i8, v1: i8):
|
|
v2 = umin.i8 v0, v1
|
|
v3 = umax.i8 v0, v1
|
|
return v2, v3
|
|
}
|
|
; run: %umin_max_i8(1, 2) == [1, 2]
|
|
; run: %umin_max_i8(2, 1) == [1, 2]
|
|
; run: %umin_max_i8(0x7f, 0x80) == [0x7f, 0x80]
|
|
|
|
function %umin_max_i16(i16, i16) -> i16, i16 {
|
|
block0(v0: i16, v1: i16):
|
|
v2 = umin.i16 v0, v1
|
|
v3 = umax.i16 v0, v1
|
|
return v2, v3
|
|
}
|
|
; run: %umin_max_i16(1, 2) == [1, 2]
|
|
; run: %umin_max_i16(2, 1) == [1, 2]
|
|
; run: %umin_max_i16(0x7f, 0x80) == [0x7f, 0x80]
|
|
; run: %umin_max_i16(0x7fff, 0x8000) == [0x7fff, 0x8000]
|
|
|
|
function %umin_max_i32(i32, i32) -> i32, i32 {
|
|
block0(v0: i32, v1: i32):
|
|
v2 = umin.i32 v0, v1
|
|
v3 = umax.i32 v0, v1
|
|
return v2, v3
|
|
}
|
|
; run: %umin_max_i32(1, 2) == [1, 2]
|
|
; run: %umin_max_i32(2, 1) == [1, 2]
|
|
; run: %umin_max_i32(0x7fff, 0x8000) == [0x7fff, 0x8000]
|
|
; run: %umin_max_i32(0x7fffffff, 0x80000000) == [0x7fffffff, 0x80000000]
|
|
|
|
function %umin_max_i64(i64, i64) -> i64, i64 {
|
|
block0(v0: i64, v1: i64):
|
|
v2 = umin.i64 v0, v1
|
|
v3 = umax.i64 v0, v1
|
|
return v2, v3
|
|
}
|
|
; run: %umin_max_i64(1, 2) == [1, 2]
|
|
; run: %umin_max_i64(2, 1) == [1, 2]
|
|
; run: %umin_max_i64(0x7fffffff, 0x80000000) == [0x7fffffff, 0x80000000]
|
|
; run: %umin_max_i64(0x7fffffffffffffff, 0x8000000000000000) == [0x7fffffffffffffff, 0x8000000000000000]
|
|
|
|
; make sure that upper/uninitialized parts of operand registers do not leak
|
|
; inside of the comparison
|
|
function %umin_max_i32_trunc_to_i8(i32, i32) -> i8, i8 {
|
|
block0(v0: i32, v1: i32):
|
|
v2 = ireduce.i8 v0
|
|
v3 = ireduce.i8 v1
|
|
v4 = umin.i8 v2, v3
|
|
v5 = umax.i8 v2, v3
|
|
return v4, v5
|
|
}
|
|
; run: %umin_max_i32_trunc_to_i8(1, 2) == [1, 2]
|
|
; run: %umin_max_i32_trunc_to_i8(0xBB01, 0xAA02) == [1, 2]
|
|
; run: %umin_max_i32_trunc_to_i8(0xBB02, 0xABCD0001) == [1, 2]
|
|
; run: %umin_max_i32_trunc_to_i8(0x1234567f, 0x12345680) == [0x7f, 0x80]
|