cranelift: Fix shifts and implement rotates in interpreter (#4519)
* cranelift: Fix shifts and implement rotates in interpreter * x64: Implement `rotl`/`rotr` for some small type combinations
This commit is contained in:
Afonso Bordado
@@ -1,3 +1,4 @@
|
||||
test interpret
|
||||
test run
|
||||
set enable_llvm_abi_extensions=true
|
||||
target aarch64
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
test interpret
|
||||
test run
|
||||
target aarch64
|
||||
target s390x
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
test interpret
|
||||
test run
|
||||
set enable_llvm_abi_extensions=true
|
||||
target aarch64
|
||||
|
||||
243
cranelift/filetests/filetests/runtests/rotl.clif
Normal file
243
cranelift/filetests/filetests/runtests/rotl.clif
Normal file
@@ -0,0 +1,243 @@
|
||||
test interpret
|
||||
test run
|
||||
target aarch64
|
||||
target x86_64
|
||||
target s390x
|
||||
|
||||
|
||||
function %rotl_i64_i64(i64, i64) -> i64 {
|
||||
block0(v0: i64, v1: i64):
|
||||
v2 = rotl.i64 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotl_i64_i64(0xe0000000_00000000, 0) == 0xe0000000_00000000
|
||||
; run: %rotl_i64_i64(0xe0000000_00000000, 1) == 0xc0000000_00000001
|
||||
; run: %rotl_i64_i64(0xe000000f_0000000f, 0) == 0xe000000f_0000000f
|
||||
; run: %rotl_i64_i64(0xe000000f_0000000f, 4) == 0x000000f0_000000fe
|
||||
; run: %rotl_i64_i64(0xe0000000_00000004, 64) == 0xe0000000_00000004
|
||||
; run: %rotl_i64_i64(0xe0000000_00000004, 65) == 0xc0000000_00000009
|
||||
; run: %rotl_i64_i64(0xe0000000_00000004, 66) == 0x80000000_00000013
|
||||
; run: %rotl_i64_i64(0xe0000000_00000004, 257) == 0xc0000000_00000009
|
||||
|
||||
function %rotl_i64_i32(i64, i32) -> i64 {
|
||||
block0(v0: i64, v1: i32):
|
||||
v2 = rotl.i64 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotl_i64_i32(0xe0000000_00000000, 0) == 0xe0000000_00000000
|
||||
; run: %rotl_i64_i32(0xe0000000_00000000, 1) == 0xc0000000_00000001
|
||||
; run: %rotl_i64_i32(0xe000000f_0000000f, 0) == 0xe000000f_0000000f
|
||||
; run: %rotl_i64_i32(0xe000000f_0000000f, 4) == 0x000000f0_000000fe
|
||||
; run: %rotl_i64_i32(0xe0000000_00000004, 64) == 0xe0000000_00000004
|
||||
; run: %rotl_i64_i32(0xe0000000_00000004, 65) == 0xc0000000_00000009
|
||||
; run: %rotl_i64_i32(0xe0000000_00000004, 66) == 0x80000000_00000013
|
||||
; run: %rotl_i64_i32(0xe0000000_00000004, 257) == 0xc0000000_00000009
|
||||
|
||||
function %rotl_i64_i16(i64, i16) -> i64 {
|
||||
block0(v0: i64, v1: i16):
|
||||
v2 = rotl.i64 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotl_i64_i16(0xe0000000_00000000, 0) == 0xe0000000_00000000
|
||||
; run: %rotl_i64_i16(0xe0000000_00000000, 1) == 0xc0000000_00000001
|
||||
; run: %rotl_i64_i16(0xe000000f_0000000f, 0) == 0xe000000f_0000000f
|
||||
; run: %rotl_i64_i16(0xe000000f_0000000f, 4) == 0x000000f0_000000fe
|
||||
; run: %rotl_i64_i16(0xe0000000_00000004, 64) == 0xe0000000_00000004
|
||||
; run: %rotl_i64_i16(0xe0000000_00000004, 65) == 0xc0000000_00000009
|
||||
; run: %rotl_i64_i16(0xe0000000_00000004, 66) == 0x80000000_00000013
|
||||
; run: %rotl_i64_i16(0xe0000000_00000004, 257) == 0xc0000000_00000009
|
||||
|
||||
function %rotl_i64_i8(i64, i8) -> i64 {
|
||||
block0(v0: i64, v1: i8):
|
||||
v2 = rotl.i64 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotl_i64_i8(0xe0000000_00000000, 0) == 0xe0000000_00000000
|
||||
; run: %rotl_i64_i8(0xe0000000_00000000, 1) == 0xc0000000_00000001
|
||||
; run: %rotl_i64_i8(0xe000000f_0000000f, 0) == 0xe000000f_0000000f
|
||||
; run: %rotl_i64_i8(0xe000000f_0000000f, 4) == 0x000000f0_000000fe
|
||||
; run: %rotl_i64_i8(0xe0000000_00000004, 64) == 0xe0000000_00000004
|
||||
; run: %rotl_i64_i8(0xe0000000_00000004, 65) == 0xc0000000_00000009
|
||||
; run: %rotl_i64_i8(0xe0000000_00000004, 66) == 0x80000000_00000013
|
||||
|
||||
|
||||
function %rotl_i32_i64(i32, i64) -> i32 {
|
||||
block0(v0: i32, v1: i64):
|
||||
v2 = rotl.i32 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotl_i32_i64(0xe0000000, 0) == 0xe0000000
|
||||
; run: %rotl_i32_i64(0xe0000000, 1) == 0xc0000001
|
||||
; run: %rotl_i32_i64(0xe00f000f, 0) == 0xe00f000f
|
||||
; run: %rotl_i32_i64(0xe00f000f, 4) == 0x00f000fe
|
||||
; run: %rotl_i32_i64(0xe0000004, 64) == 0xe0000004
|
||||
; run: %rotl_i32_i64(0xe0000004, 65) == 0xc0000009
|
||||
; run: %rotl_i32_i64(0xe0000004, 66) == 0x80000013
|
||||
; run: %rotl_i32_i64(0xe0000004, 257) == 0xc0000009
|
||||
|
||||
function %rotl_i32_i32(i32, i32) -> i32 {
|
||||
block0(v0: i32, v1: i32):
|
||||
v2 = rotl.i32 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotl_i32_i32(0xe0000000, 0) == 0xe0000000
|
||||
; run: %rotl_i32_i32(0xe0000000, 1) == 0xc0000001
|
||||
; run: %rotl_i32_i32(0xe00f000f, 0) == 0xe00f000f
|
||||
; run: %rotl_i32_i32(0xe00f000f, 4) == 0x00f000fe
|
||||
; run: %rotl_i32_i32(0xe0000004, 64) == 0xe0000004
|
||||
; run: %rotl_i32_i32(0xe0000004, 65) == 0xc0000009
|
||||
; run: %rotl_i32_i32(0xe0000004, 66) == 0x80000013
|
||||
; run: %rotl_i32_i32(0xe0000004, 257) == 0xc0000009
|
||||
|
||||
function %rotl_i32_i16(i32, i16) -> i32 {
|
||||
block0(v0: i32, v1: i16):
|
||||
v2 = rotl.i32 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotl_i32_i16(0xe0000000, 0) == 0xe0000000
|
||||
; run: %rotl_i32_i16(0xe0000000, 1) == 0xc0000001
|
||||
; run: %rotl_i32_i16(0xe00f000f, 0) == 0xe00f000f
|
||||
; run: %rotl_i32_i16(0xe00f000f, 4) == 0x00f000fe
|
||||
; run: %rotl_i32_i16(0xe0000004, 64) == 0xe0000004
|
||||
; run: %rotl_i32_i16(0xe0000004, 65) == 0xc0000009
|
||||
; run: %rotl_i32_i16(0xe0000004, 66) == 0x80000013
|
||||
; run: %rotl_i32_i16(0xe0000004, 257) == 0xc0000009
|
||||
|
||||
function %rotl_i32_i8(i32, i8) -> i32 {
|
||||
block0(v0: i32, v1: i8):
|
||||
v2 = rotl.i32 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotl_i32_i8(0xe0000000, 0) == 0xe0000000
|
||||
; run: %rotl_i32_i8(0xe0000000, 1) == 0xc0000001
|
||||
; run: %rotl_i32_i8(0xe00f000f, 0) == 0xe00f000f
|
||||
; run: %rotl_i32_i8(0xe00f000f, 4) == 0x00f000fe
|
||||
; run: %rotl_i32_i8(0xe0000004, 64) == 0xe0000004
|
||||
; run: %rotl_i32_i8(0xe0000004, 65) == 0xc0000009
|
||||
; run: %rotl_i32_i8(0xe0000004, 66) == 0x80000013
|
||||
|
||||
|
||||
function %rotl_i16_i64(i16, i64) -> i16 {
|
||||
block0(v0: i16, v1: i64):
|
||||
v2 = rotl.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotl_i16_i64(0xe000, 0) == 0xe000
|
||||
; run: %rotl_i16_i64(0xe000, 1) == 0xc001
|
||||
; run: %rotl_i16_i64(0xef0f, 0) == 0xef0f
|
||||
; run: %rotl_i16_i64(0xef0f, 4) == 0xf0fe
|
||||
; run: %rotl_i16_i64(0xe004, 64) == 0xe004
|
||||
; run: %rotl_i16_i64(0xe004, 65) == 0xc009
|
||||
; run: %rotl_i16_i64(0xe004, 66) == 0x8013
|
||||
; run: %rotl_i16_i64(0xe004, 257) == 0xc009
|
||||
|
||||
function %rotl_i16_i32(i16, i32) -> i16 {
|
||||
block0(v0: i16, v1: i32):
|
||||
v2 = rotl.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotl_i16_i32(0xe000, 0) == 0xe000
|
||||
; run: %rotl_i16_i32(0xe000, 1) == 0xc001
|
||||
; run: %rotl_i16_i32(0xef0f, 0) == 0xef0f
|
||||
; run: %rotl_i16_i32(0xef0f, 4) == 0xf0fe
|
||||
; run: %rotl_i16_i32(0xe004, 64) == 0xe004
|
||||
; run: %rotl_i16_i32(0xe004, 65) == 0xc009
|
||||
; run: %rotl_i16_i32(0xe004, 66) == 0x8013
|
||||
; run: %rotl_i16_i32(0xe004, 257) == 0xc009
|
||||
|
||||
function %rotl_i16_i16(i16, i16) -> i16 {
|
||||
block0(v0: i16, v1: i16):
|
||||
v2 = rotl.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotl_i16_i16(0xe000, 0) == 0xe000
|
||||
; run: %rotl_i16_i16(0xe000, 1) == 0xc001
|
||||
; run: %rotl_i16_i16(0xef0f, 0) == 0xef0f
|
||||
; run: %rotl_i16_i16(0xef0f, 4) == 0xf0fe
|
||||
; run: %rotl_i16_i16(0xe004, 64) == 0xe004
|
||||
; run: %rotl_i16_i16(0xe004, 65) == 0xc009
|
||||
; run: %rotl_i16_i16(0xe004, 66) == 0x8013
|
||||
; run: %rotl_i16_i16(0xe004, 257) == 0xc009
|
||||
|
||||
function %rotl_i16_i8(i16, i8) -> i16 {
|
||||
block0(v0: i16, v1: i8):
|
||||
v2 = rotl.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotl_i16_i8(0xe000, 0) == 0xe000
|
||||
; run: %rotl_i16_i8(0xe000, 1) == 0xc001
|
||||
; run: %rotl_i16_i8(0xef0f, 0) == 0xef0f
|
||||
; run: %rotl_i16_i8(0xef0f, 4) == 0xf0fe
|
||||
; run: %rotl_i16_i8(0xe004, 64) == 0xe004
|
||||
; run: %rotl_i16_i8(0xe004, 65) == 0xc009
|
||||
; run: %rotl_i16_i8(0xe004, 66) == 0x8013
|
||||
|
||||
|
||||
function %rotl_i8_i64(i8, i64) -> i8 {
|
||||
block0(v0: i8, v1: i64):
|
||||
v2 = rotl.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotl_i8_i64(0xe0, 0) == 0xe0
|
||||
; run: %rotl_i8_i64(0xe0, 1) == 0xc1
|
||||
; run: %rotl_i8_i64(0xef, 0) == 0xef
|
||||
; run: %rotl_i8_i64(0xef, 4) == 0xfe
|
||||
; run: %rotl_i8_i64(0xe4, 64) == 0xe4
|
||||
; run: %rotl_i8_i64(0xe4, 65) == 0xc9
|
||||
; run: %rotl_i8_i64(0xe4, 66) == 0x93
|
||||
; run: %rotl_i8_i64(0xe4, 257) == 0xc9
|
||||
|
||||
function %rotl_i8_i32(i8, i32) -> i8 {
|
||||
block0(v0: i8, v1: i32):
|
||||
v2 = rotl.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotl_i8_i32(0xe0, 0) == 0xe0
|
||||
; run: %rotl_i8_i32(0xe0, 1) == 0xc1
|
||||
; run: %rotl_i8_i32(0xef, 0) == 0xef
|
||||
; run: %rotl_i8_i32(0xef, 4) == 0xfe
|
||||
; run: %rotl_i8_i32(0xe4, 64) == 0xe4
|
||||
; run: %rotl_i8_i32(0xe4, 65) == 0xc9
|
||||
; run: %rotl_i8_i32(0xe4, 66) == 0x93
|
||||
; run: %rotl_i8_i32(0xe4, 257) == 0xc9
|
||||
|
||||
function %rotl_i8_i16(i8, i16) -> i8 {
|
||||
block0(v0: i8, v1: i16):
|
||||
v2 = rotl.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotl_i8_i16(0xe0, 0) == 0xe0
|
||||
; run: %rotl_i8_i16(0xe0, 1) == 0xc1
|
||||
; run: %rotl_i8_i16(0xef, 0) == 0xef
|
||||
; run: %rotl_i8_i16(0xef, 4) == 0xfe
|
||||
; run: %rotl_i8_i16(0xe4, 64) == 0xe4
|
||||
; run: %rotl_i8_i16(0xe4, 65) == 0xc9
|
||||
; run: %rotl_i8_i16(0xe4, 66) == 0x93
|
||||
; run: %rotl_i8_i16(0xe4, 257) == 0xc9
|
||||
|
||||
function %rotl_i8_i8(i8, i8) -> i8 {
|
||||
block0(v0: i8, v1: i8):
|
||||
v2 = rotl.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotl_i8_i8(0xe0, 0) == 0xe0
|
||||
; run: %rotl_i8_i8(0xe0, 1) == 0xc1
|
||||
; run: %rotl_i8_i8(0xef, 0) == 0xef
|
||||
; run: %rotl_i8_i8(0xef, 4) == 0xfe
|
||||
; run: %rotl_i8_i8(0xe4, 64) == 0xe4
|
||||
; run: %rotl_i8_i8(0xe4, 65) == 0xc9
|
||||
; run: %rotl_i8_i8(0xe4, 66) == 0x93
|
||||
|
||||
|
||||
|
||||
;; This is a regression test for rotates on x64
|
||||
;; See: https://github.com/bytecodealliance/wasmtime/pull/3610
|
||||
function %rotl_i8_const_37(i8) -> i8 {
|
||||
block0(v0: i8):
|
||||
v1 = iconst.i8 37
|
||||
v2 = rotl.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotl_i8_const_37(0x00) == 0x00
|
||||
; run: %rotl_i8_const_37(0x01) == 0x20
|
||||
; run: %rotl_i8_const_37(0x12) == 0x42
|
||||
243
cranelift/filetests/filetests/runtests/rotr.clif
Normal file
243
cranelift/filetests/filetests/runtests/rotr.clif
Normal file
@@ -0,0 +1,243 @@
|
||||
test interpret
|
||||
test run
|
||||
target aarch64
|
||||
target x86_64
|
||||
target s390x
|
||||
|
||||
|
||||
function %rotr_i64_i64(i64, i64) -> i64 {
|
||||
block0(v0: i64, v1: i64):
|
||||
v2 = rotr.i64 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotr_i64_i64(0xe0000000_00000000, 0) == 0xe0000000_00000000
|
||||
; run: %rotr_i64_i64(0xe0000000_00000000, 1) == 0x70000000_00000000
|
||||
; run: %rotr_i64_i64(0xe000000f_0000000f, 0) == 0xe000000f_0000000f
|
||||
; run: %rotr_i64_i64(0xe000000f_0000000f, 4) == 0xfe000000_f0000000
|
||||
; run: %rotr_i64_i64(0xe0000000_00000004, 64) == 0xe0000000_00000004
|
||||
; run: %rotr_i64_i64(0xe0000000_00000004, 65) == 0x70000000_00000002
|
||||
; run: %rotr_i64_i64(0xe0000000_00000004, 66) == 0x38000000_00000001
|
||||
; run: %rotr_i64_i64(0xe0000000_00000004, 257) == 0x70000000_00000002
|
||||
|
||||
function %rotr_i64_i32(i64, i32) -> i64 {
|
||||
block0(v0: i64, v1: i32):
|
||||
v2 = rotr.i64 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotr_i64_i32(0xe0000000_00000000, 0) == 0xe0000000_00000000
|
||||
; run: %rotr_i64_i32(0xe0000000_00000000, 1) == 0x70000000_00000000
|
||||
; run: %rotr_i64_i32(0xe000000f_0000000f, 0) == 0xe000000f_0000000f
|
||||
; run: %rotr_i64_i32(0xe000000f_0000000f, 4) == 0xfe000000_f0000000
|
||||
; run: %rotr_i64_i32(0xe0000000_00000004, 64) == 0xe0000000_00000004
|
||||
; run: %rotr_i64_i32(0xe0000000_00000004, 65) == 0x70000000_00000002
|
||||
; run: %rotr_i64_i32(0xe0000000_00000004, 66) == 0x38000000_00000001
|
||||
; run: %rotr_i64_i32(0xe0000000_00000004, 257) == 0x70000000_00000002
|
||||
|
||||
function %rotr_i64_i16(i64, i16) -> i64 {
|
||||
block0(v0: i64, v1: i16):
|
||||
v2 = rotr.i64 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotr_i64_i16(0xe0000000_00000000, 0) == 0xe0000000_00000000
|
||||
; run: %rotr_i64_i16(0xe0000000_00000000, 1) == 0x70000000_00000000
|
||||
; run: %rotr_i64_i16(0xe000000f_0000000f, 0) == 0xe000000f_0000000f
|
||||
; run: %rotr_i64_i16(0xe000000f_0000000f, 4) == 0xfe000000_f0000000
|
||||
; run: %rotr_i64_i16(0xe0000000_00000004, 64) == 0xe0000000_00000004
|
||||
; run: %rotr_i64_i16(0xe0000000_00000004, 65) == 0x70000000_00000002
|
||||
; run: %rotr_i64_i16(0xe0000000_00000004, 66) == 0x38000000_00000001
|
||||
; run: %rotr_i64_i16(0xe0000000_00000004, 257) == 0x70000000_00000002
|
||||
|
||||
function %rotr_i64_i8(i64, i8) -> i64 {
|
||||
block0(v0: i64, v1: i8):
|
||||
v2 = rotr.i64 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotr_i64_i8(0xe0000000_00000000, 0) == 0xe0000000_00000000
|
||||
; run: %rotr_i64_i8(0xe0000000_00000000, 1) == 0x70000000_00000000
|
||||
; run: %rotr_i64_i8(0xe000000f_0000000f, 0) == 0xe000000f_0000000f
|
||||
; run: %rotr_i64_i8(0xe000000f_0000000f, 4) == 0xfe000000_f0000000
|
||||
; run: %rotr_i64_i8(0xe0000000_00000004, 64) == 0xe0000000_00000004
|
||||
; run: %rotr_i64_i8(0xe0000000_00000004, 65) == 0x70000000_00000002
|
||||
; run: %rotr_i64_i8(0xe0000000_00000004, 66) == 0x38000000_00000001
|
||||
|
||||
|
||||
function %rotr_i32_i64(i32, i64) -> i32 {
|
||||
block0(v0: i32, v1: i64):
|
||||
v2 = rotr.i32 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotr_i32_i64(0xe0000000, 0) == 0xe0000000
|
||||
; run: %rotr_i32_i64(0xe0000000, 1) == 0x70000000
|
||||
; run: %rotr_i32_i64(0xe00f000f, 0) == 0xe00f000f
|
||||
; run: %rotr_i32_i64(0xe00f000f, 4) == 0xfe00f000
|
||||
; run: %rotr_i32_i64(0xe0000004, 64) == 0xe0000004
|
||||
; run: %rotr_i32_i64(0xe0000004, 65) == 0x70000002
|
||||
; run: %rotr_i32_i64(0xe0000004, 66) == 0x38000001
|
||||
; run: %rotr_i32_i64(0xe0000004, 257) == 0x70000002
|
||||
|
||||
function %rotr_i32_i32(i32, i32) -> i32 {
|
||||
block0(v0: i32, v1: i32):
|
||||
v2 = rotr.i32 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotr_i32_i32(0xe0000000, 0) == 0xe0000000
|
||||
; run: %rotr_i32_i32(0xe0000000, 1) == 0x70000000
|
||||
; run: %rotr_i32_i32(0xe00f000f, 0) == 0xe00f000f
|
||||
; run: %rotr_i32_i32(0xe00f000f, 4) == 0xfe00f000
|
||||
; run: %rotr_i32_i32(0xe0000004, 64) == 0xe0000004
|
||||
; run: %rotr_i32_i32(0xe0000004, 65) == 0x70000002
|
||||
; run: %rotr_i32_i32(0xe0000004, 66) == 0x38000001
|
||||
; run: %rotr_i32_i32(0xe0000004, 257) == 0x70000002
|
||||
|
||||
function %rotr_i32_i16(i32, i16) -> i32 {
|
||||
block0(v0: i32, v1: i16):
|
||||
v2 = rotr.i32 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotr_i32_i16(0xe0000000, 0) == 0xe0000000
|
||||
; run: %rotr_i32_i16(0xe0000000, 1) == 0x70000000
|
||||
; run: %rotr_i32_i16(0xe00f000f, 0) == 0xe00f000f
|
||||
; run: %rotr_i32_i16(0xe00f000f, 4) == 0xfe00f000
|
||||
; run: %rotr_i32_i16(0xe0000004, 64) == 0xe0000004
|
||||
; run: %rotr_i32_i16(0xe0000004, 65) == 0x70000002
|
||||
; run: %rotr_i32_i16(0xe0000004, 66) == 0x38000001
|
||||
; run: %rotr_i32_i16(0xe0000004, 257) == 0x70000002
|
||||
|
||||
function %rotr_i32_i8(i32, i8) -> i32 {
|
||||
block0(v0: i32, v1: i8):
|
||||
v2 = rotr.i32 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotr_i32_i8(0xe0000000, 0) == 0xe0000000
|
||||
; run: %rotr_i32_i8(0xe0000000, 1) == 0x70000000
|
||||
; run: %rotr_i32_i8(0xe00f000f, 0) == 0xe00f000f
|
||||
; run: %rotr_i32_i8(0xe00f000f, 4) == 0xfe00f000
|
||||
; run: %rotr_i32_i8(0xe0000004, 64) == 0xe0000004
|
||||
; run: %rotr_i32_i8(0xe0000004, 65) == 0x70000002
|
||||
; run: %rotr_i32_i8(0xe0000004, 66) == 0x38000001
|
||||
|
||||
|
||||
function %rotr_i16_i64(i16, i64) -> i16 {
|
||||
block0(v0: i16, v1: i64):
|
||||
v2 = rotr.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotr_i16_i64(0xe000, 0) == 0xe000
|
||||
; run: %rotr_i16_i64(0xe000, 1) == 0x7000
|
||||
; run: %rotr_i16_i64(0xef0f, 0) == 0xef0f
|
||||
; run: %rotr_i16_i64(0xef0f, 4) == 0xfef0
|
||||
; run: %rotr_i16_i64(0xe004, 64) == 0xe004
|
||||
; run: %rotr_i16_i64(0xe004, 65) == 0x7002
|
||||
; run: %rotr_i16_i64(0xe004, 66) == 0x3801
|
||||
; run: %rotr_i16_i64(0xe004, 257) == 0x7002
|
||||
|
||||
function %rotr_i16_i32(i16, i32) -> i16 {
|
||||
block0(v0: i16, v1: i32):
|
||||
v2 = rotr.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotr_i16_i32(0xe000, 0) == 0xe000
|
||||
; run: %rotr_i16_i32(0xe000, 1) == 0x7000
|
||||
; run: %rotr_i16_i32(0xef0f, 0) == 0xef0f
|
||||
; run: %rotr_i16_i32(0xef0f, 4) == 0xfef0
|
||||
; run: %rotr_i16_i32(0xe004, 64) == 0xe004
|
||||
; run: %rotr_i16_i32(0xe004, 65) == 0x7002
|
||||
; run: %rotr_i16_i32(0xe004, 66) == 0x3801
|
||||
; run: %rotr_i16_i32(0xe004, 257) == 0x7002
|
||||
|
||||
function %rotr_i16_i16(i16, i16) -> i16 {
|
||||
block0(v0: i16, v1: i16):
|
||||
v2 = rotr.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotr_i16_i16(0xe000, 0) == 0xe000
|
||||
; run: %rotr_i16_i16(0xe000, 1) == 0x7000
|
||||
; run: %rotr_i16_i16(0xef0f, 0) == 0xef0f
|
||||
; run: %rotr_i16_i16(0xef0f, 4) == 0xfef0
|
||||
; run: %rotr_i16_i16(0xe004, 64) == 0xe004
|
||||
; run: %rotr_i16_i16(0xe004, 65) == 0x7002
|
||||
; run: %rotr_i16_i16(0xe004, 66) == 0x3801
|
||||
; run: %rotr_i16_i16(0xe004, 257) == 0x7002
|
||||
|
||||
function %rotr_i16_i8(i16, i8) -> i16 {
|
||||
block0(v0: i16, v1: i8):
|
||||
v2 = rotr.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotr_i16_i8(0xe000, 0) == 0xe000
|
||||
; run: %rotr_i16_i8(0xe000, 1) == 0x7000
|
||||
; run: %rotr_i16_i8(0xef0f, 0) == 0xef0f
|
||||
; run: %rotr_i16_i8(0xef0f, 4) == 0xfef0
|
||||
; run: %rotr_i16_i8(0xe004, 64) == 0xe004
|
||||
; run: %rotr_i16_i8(0xe004, 65) == 0x7002
|
||||
; run: %rotr_i16_i8(0xe004, 66) == 0x3801
|
||||
|
||||
|
||||
function %rotr_i8_i64(i8, i64) -> i8 {
|
||||
block0(v0: i8, v1: i64):
|
||||
v2 = rotr.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotr_i8_i64(0xe0, 0) == 0xe0
|
||||
; run: %rotr_i8_i64(0xe0, 1) == 0x70
|
||||
; run: %rotr_i8_i64(0xef, 0) == 0xef
|
||||
; run: %rotr_i8_i64(0xef, 4) == 0xfe
|
||||
; run: %rotr_i8_i64(0xe0, 64) == 0xe0
|
||||
; run: %rotr_i8_i64(0xe0, 65) == 0x70
|
||||
; run: %rotr_i8_i64(0xe0, 66) == 0x38
|
||||
; run: %rotr_i8_i64(0xe0, 257) == 0x70
|
||||
|
||||
function %rotr_i8_i32(i8, i32) -> i8 {
|
||||
block0(v0: i8, v1: i32):
|
||||
v2 = rotr.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotr_i8_i32(0xe0, 0) == 0xe0
|
||||
; run: %rotr_i8_i32(0xe0, 1) == 0x70
|
||||
; run: %rotr_i8_i32(0xef, 0) == 0xef
|
||||
; run: %rotr_i8_i32(0xef, 4) == 0xfe
|
||||
; run: %rotr_i8_i32(0xe0, 64) == 0xe0
|
||||
; run: %rotr_i8_i32(0xe0, 65) == 0x70
|
||||
; run: %rotr_i8_i32(0xe0, 66) == 0x38
|
||||
; run: %rotr_i8_i32(0xe0, 257) == 0x70
|
||||
|
||||
function %rotr_i8_i16(i8, i16) -> i8 {
|
||||
block0(v0: i8, v1: i16):
|
||||
v2 = rotr.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotr_i8_i16(0xe0, 0) == 0xe0
|
||||
; run: %rotr_i8_i16(0xe0, 1) == 0x70
|
||||
; run: %rotr_i8_i16(0xef, 0) == 0xef
|
||||
; run: %rotr_i8_i16(0xef, 4) == 0xfe
|
||||
; run: %rotr_i8_i16(0xe0, 64) == 0xe0
|
||||
; run: %rotr_i8_i16(0xe0, 65) == 0x70
|
||||
; run: %rotr_i8_i16(0xe0, 66) == 0x38
|
||||
; run: %rotr_i8_i16(0xe0, 257) == 0x70
|
||||
|
||||
function %rotr_i8_i8(i8, i8) -> i8 {
|
||||
block0(v0: i8, v1: i8):
|
||||
v2 = rotr.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotr_i8_i8(0xe0, 0) == 0xe0
|
||||
; run: %rotr_i8_i8(0xe0, 1) == 0x70
|
||||
; run: %rotr_i8_i8(0xef, 0) == 0xef
|
||||
; run: %rotr_i8_i8(0xef, 4) == 0xfe
|
||||
; run: %rotr_i8_i8(0xe0, 64) == 0xe0
|
||||
; run: %rotr_i8_i8(0xe0, 65) == 0x70
|
||||
; run: %rotr_i8_i8(0xe0, 66) == 0x38
|
||||
|
||||
|
||||
|
||||
;; This is a regression test for rotates on x64
|
||||
;; See: https://github.com/bytecodealliance/wasmtime/pull/3610
|
||||
function %rotr_i8_const_37(i8) -> i8 {
|
||||
block0(v0: i8):
|
||||
v1 = iconst.i8 37
|
||||
v2 = rotr.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %rotr_i8_const_37(0x00) == 0x00
|
||||
; run: %rotr_i8_const_37(0x01) == 0x08
|
||||
; run: %rotr_i8_const_37(0x12) == 0x90
|
||||
@@ -1,3 +1,4 @@
|
||||
test interpret
|
||||
test run
|
||||
target aarch64
|
||||
target x86_64
|
||||
@@ -110,6 +111,113 @@ block0(v0: i32, v1: i8):
|
||||
; run: %ishl_i32_i8(0x00000004, 34) == 0x00000010
|
||||
|
||||
|
||||
function %ishl_i16_i64(i16, i64) -> i16 {
|
||||
block0(v0: i16, v1: i64):
|
||||
v2 = ishl.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %ishl_i16_i64(0x0000, 0) == 0x0000
|
||||
; run: %ishl_i16_i64(0x0000, 1) == 0x0000
|
||||
; run: %ishl_i16_i64(0x000f, 0) == 0x000f
|
||||
; run: %ishl_i16_i64(0x000f, 4) == 0x00f0
|
||||
; run: %ishl_i16_i64(0x0004, 32) == 0x0004
|
||||
; run: %ishl_i16_i64(0x0004, 33) == 0x0008
|
||||
; run: %ishl_i16_i64(0x0004, 34) == 0x0010
|
||||
|
||||
function %ishl_i16_i32(i16, i32) -> i16 {
|
||||
block0(v0: i16, v1: i32):
|
||||
v2 = ishl.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %ishl_i16_i32(0x0000, 0) == 0x0000
|
||||
; run: %ishl_i16_i32(0x0000, 1) == 0x0000
|
||||
; run: %ishl_i16_i32(0x000f, 0) == 0x000f
|
||||
; run: %ishl_i16_i32(0x000f, 4) == 0x00f0
|
||||
; run: %ishl_i16_i32(0x0004, 32) == 0x0004
|
||||
; run: %ishl_i16_i32(0x0004, 33) == 0x0008
|
||||
; run: %ishl_i16_i32(0x0004, 34) == 0x0010
|
||||
|
||||
function %ishl_i16_i16(i16, i16) -> i16 {
|
||||
block0(v0: i16, v1: i16):
|
||||
v2 = ishl.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %ishl_i16_i16(0x0000, 0) == 0x0000
|
||||
; run: %ishl_i16_i16(0x0000, 1) == 0x0000
|
||||
; run: %ishl_i16_i16(0x000f, 0) == 0x000f
|
||||
; run: %ishl_i16_i16(0x000f, 4) == 0x00f0
|
||||
; run: %ishl_i16_i16(0x0004, 32) == 0x0004
|
||||
; run: %ishl_i16_i16(0x0004, 33) == 0x0008
|
||||
; run: %ishl_i16_i16(0x0004, 34) == 0x0010
|
||||
|
||||
function %ishl_i16_i8(i16, i8) -> i16 {
|
||||
block0(v0: i16, v1: i8):
|
||||
v2 = ishl.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %ishl_i16_i8(0x0000, 0) == 0x0000
|
||||
; run: %ishl_i16_i8(0x0000, 1) == 0x0000
|
||||
; run: %ishl_i16_i8(0x000f, 0) == 0x000f
|
||||
; run: %ishl_i16_i8(0x000f, 4) == 0x00f0
|
||||
; run: %ishl_i16_i8(0x0004, 32) == 0x0004
|
||||
; run: %ishl_i16_i8(0x0004, 33) == 0x0008
|
||||
; run: %ishl_i16_i8(0x0004, 34) == 0x0010
|
||||
|
||||
|
||||
function %ishl_i8_i64(i8, i64) -> i8 {
|
||||
block0(v0: i8, v1: i64):
|
||||
v2 = ishl.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %ishl_i8_i64(0x00, 0) == 0x00
|
||||
; run: %ishl_i8_i64(0x00, 1) == 0x00
|
||||
; run: %ishl_i8_i64(0x0f, 0) == 0x0f
|
||||
; run: %ishl_i8_i64(0x0f, 4) == 0xf0
|
||||
; run: %ishl_i8_i64(0x04, 32) == 0x04
|
||||
; run: %ishl_i8_i64(0x04, 33) == 0x08
|
||||
; run: %ishl_i8_i64(0x04, 34) == 0x10
|
||||
|
||||
function %ishl_i8_i32(i8, i32) -> i8 {
|
||||
block0(v0: i8, v1: i32):
|
||||
v2 = ishl.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %ishl_i8_i32(0x00, 0) == 0x00
|
||||
; run: %ishl_i8_i32(0x00, 1) == 0x00
|
||||
; run: %ishl_i8_i32(0x0f, 0) == 0x0f
|
||||
; run: %ishl_i8_i32(0x0f, 4) == 0xf0
|
||||
; run: %ishl_i8_i32(0x04, 32) == 0x04
|
||||
; run: %ishl_i8_i32(0x04, 33) == 0x08
|
||||
; run: %ishl_i8_i32(0x04, 34) == 0x10
|
||||
|
||||
function %ishl_i8_i16(i8, i16) -> i8 {
|
||||
block0(v0: i8, v1: i16):
|
||||
v2 = ishl.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %ishl_i8_i16(0x00, 0) == 0x00
|
||||
; run: %ishl_i8_i16(0x00, 1) == 0x00
|
||||
; run: %ishl_i8_i16(0x0f, 0) == 0x0f
|
||||
; run: %ishl_i8_i16(0x0f, 4) == 0xf0
|
||||
; run: %ishl_i8_i16(0x04, 32) == 0x04
|
||||
; run: %ishl_i8_i16(0x04, 33) == 0x08
|
||||
; run: %ishl_i8_i16(0x04, 34) == 0x10
|
||||
|
||||
function %ishl_i8_i8(i8, i8) -> i8 {
|
||||
block0(v0: i8, v1: i8):
|
||||
v2 = ishl.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %ishl_i8_i8(0x00, 0) == 0x00
|
||||
; run: %ishl_i8_i8(0x00, 1) == 0x00
|
||||
; run: %ishl_i8_i8(0x0f, 0) == 0x0f
|
||||
; run: %ishl_i8_i8(0x0f, 4) == 0xf0
|
||||
; run: %ishl_i8_i8(0x04, 32) == 0x04
|
||||
; run: %ishl_i8_i8(0x04, 33) == 0x08
|
||||
; run: %ishl_i8_i8(0x04, 34) == 0x10
|
||||
|
||||
|
||||
|
||||
function %ushr_i64_i64(i64, i64) -> i64 {
|
||||
block0(v0: i64, v1: i64):
|
||||
v2 = ushr.i64 v0, v1
|
||||
@@ -215,6 +323,113 @@ block0(v0: i32, v1: i8):
|
||||
; run: %ushr_i32_i8(0x40000000, 34) == 0x10000000
|
||||
|
||||
|
||||
function %ushr_i16_i64(i16, i64) -> i16 {
|
||||
block0(v0: i16, v1: i64):
|
||||
v2 = ushr.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %ushr_i16_i64(0x1000, 0) == 0x1000
|
||||
; run: %ushr_i16_i64(0x1000, 1) == 0x0800
|
||||
; run: %ushr_i16_i64(0xf000, 0) == 0xf000
|
||||
; run: %ushr_i16_i64(0xf000, 4) == 0x0f00
|
||||
; run: %ushr_i16_i64(0x4000, 32) == 0x4000
|
||||
; run: %ushr_i16_i64(0x4000, 33) == 0x2000
|
||||
; run: %ushr_i16_i64(0x4000, 34) == 0x1000
|
||||
|
||||
function %ushr_i16_i32(i16, i32) -> i16 {
|
||||
block0(v0: i16, v1: i32):
|
||||
v2 = ushr.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %ushr_i16_i32(0x1000, 0) == 0x1000
|
||||
; run: %ushr_i16_i32(0x1000, 1) == 0x0800
|
||||
; run: %ushr_i16_i32(0xf000, 0) == 0xf000
|
||||
; run: %ushr_i16_i32(0xf000, 4) == 0x0f00
|
||||
; run: %ushr_i16_i32(0x4000, 32) == 0x4000
|
||||
; run: %ushr_i16_i32(0x4000, 33) == 0x2000
|
||||
; run: %ushr_i16_i32(0x4000, 34) == 0x1000
|
||||
|
||||
function %ushr_i16_i16(i16, i16) -> i16 {
|
||||
block0(v0: i16, v1: i16):
|
||||
v2 = ushr.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %ushr_i16_i16(0x1000, 0) == 0x1000
|
||||
; run: %ushr_i16_i16(0x1000, 1) == 0x0800
|
||||
; run: %ushr_i16_i16(0xf000, 0) == 0xf000
|
||||
; run: %ushr_i16_i16(0xf000, 4) == 0x0f00
|
||||
; run: %ushr_i16_i16(0x4000, 32) == 0x4000
|
||||
; run: %ushr_i16_i16(0x4000, 33) == 0x2000
|
||||
; run: %ushr_i16_i16(0x4000, 34) == 0x1000
|
||||
|
||||
function %ushr_i16_i8(i16, i8) -> i16 {
|
||||
block0(v0: i16, v1: i8):
|
||||
v2 = ushr.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %ushr_i16_i8(0x1000, 0) == 0x1000
|
||||
; run: %ushr_i16_i8(0x1000, 1) == 0x0800
|
||||
; run: %ushr_i16_i8(0xf000, 0) == 0xf000
|
||||
; run: %ushr_i16_i8(0xf000, 4) == 0x0f00
|
||||
; run: %ushr_i16_i8(0x4000, 32) == 0x4000
|
||||
; run: %ushr_i16_i8(0x4000, 33) == 0x2000
|
||||
; run: %ushr_i16_i8(0x4000, 34) == 0x1000
|
||||
|
||||
|
||||
function %ushr_i8_i64(i8, i64) -> i8 {
|
||||
block0(v0: i8, v1: i64):
|
||||
v2 = ushr.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %ushr_i8_i64(0x10, 0) == 0x10
|
||||
; run: %ushr_i8_i64(0x10, 1) == 0x08
|
||||
; run: %ushr_i8_i64(0xf0, 0) == 0xf0
|
||||
; run: %ushr_i8_i64(0xf0, 4) == 0x0f
|
||||
; run: %ushr_i8_i64(0x40, 32) == 0x40
|
||||
; run: %ushr_i8_i64(0x40, 33) == 0x20
|
||||
; run: %ushr_i8_i64(0x40, 34) == 0x10
|
||||
|
||||
function %ushr_i8_i32(i8, i32) -> i8 {
|
||||
block0(v0: i8, v1: i32):
|
||||
v2 = ushr.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %ushr_i8_i32(0x10, 0) == 0x10
|
||||
; run: %ushr_i8_i32(0x10, 1) == 0x08
|
||||
; run: %ushr_i8_i32(0xf0, 0) == 0xf0
|
||||
; run: %ushr_i8_i32(0xf0, 4) == 0x0f
|
||||
; run: %ushr_i8_i32(0x40, 32) == 0x40
|
||||
; run: %ushr_i8_i32(0x40, 33) == 0x20
|
||||
; run: %ushr_i8_i32(0x40, 34) == 0x10
|
||||
|
||||
function %ushr_i8_i16(i8, i16) -> i8 {
|
||||
block0(v0: i8, v1: i16):
|
||||
v2 = ushr.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %ushr_i8_i16(0x10, 0) == 0x10
|
||||
; run: %ushr_i8_i16(0x10, 1) == 0x08
|
||||
; run: %ushr_i8_i16(0xf0, 0) == 0xf0
|
||||
; run: %ushr_i8_i16(0xf0, 4) == 0x0f
|
||||
; run: %ushr_i8_i16(0x40, 32) == 0x40
|
||||
; run: %ushr_i8_i16(0x40, 33) == 0x20
|
||||
; run: %ushr_i8_i16(0x40, 34) == 0x10
|
||||
|
||||
function %ushr_i8_i8(i8, i8) -> i8 {
|
||||
block0(v0: i8, v1: i8):
|
||||
v2 = ushr.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %ushr_i8_i8(0x10, 0) == 0x10
|
||||
; run: %ushr_i8_i8(0x10, 1) == 0x08
|
||||
; run: %ushr_i8_i8(0xf0, 0) == 0xf0
|
||||
; run: %ushr_i8_i8(0xf0, 4) == 0x0f
|
||||
; run: %ushr_i8_i8(0x40, 32) == 0x40
|
||||
; run: %ushr_i8_i8(0x40, 33) == 0x20
|
||||
; run: %ushr_i8_i8(0x40, 34) == 0x10
|
||||
|
||||
|
||||
|
||||
function %sshr_i64_i64(i64, i64) -> i64 {
|
||||
block0(v0: i64, v1: i64):
|
||||
v2 = sshr.i64 v0, v1
|
||||
@@ -319,24 +534,108 @@ block0(v0: i32, v1: i8):
|
||||
; run: %sshr_i32_i8(0x40000000, 33) == 0x20000000
|
||||
; run: %sshr_i32_i8(0x40000000, 34) == 0x10000000
|
||||
|
||||
function %rotl_i8_const_37(i8) -> i8 {
|
||||
block0(v0: i8):
|
||||
v1 = iconst.i8 37
|
||||
v2 = rotl.i8 v0, v1
|
||||
return v2
|
||||
|
||||
function %sshr_i16_i64(i16, i64) -> i16 {
|
||||
block0(v0: i16, v1: i64):
|
||||
v2 = sshr.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %sshr_i16_i64(0x8000, 0) == 0x8000
|
||||
; run: %sshr_i16_i64(0x8000, 1) == 0xC000
|
||||
; run: %sshr_i16_i64(0xf000, 0) == 0xf000
|
||||
; run: %sshr_i16_i64(0xf000, 4) == 0xff00
|
||||
; run: %sshr_i16_i64(0x4000, 32) == 0x4000
|
||||
; run: %sshr_i16_i64(0x4000, 33) == 0x2000
|
||||
; run: %sshr_i16_i64(0x4000, 34) == 0x1000
|
||||
|
||||
; run: %rotl_i8_const_37(0x00) == 0x00
|
||||
; run: %rotl_i8_const_37(0x01) == 0x20
|
||||
; run: %rotl_i8_const_37(0x12) == 0x42
|
||||
|
||||
function %rotr_i8_const_37(i8) -> i8 {
|
||||
block0(v0: i8):
|
||||
v1 = iconst.i8 37
|
||||
v2 = rotr.i8 v0, v1
|
||||
return v2
|
||||
function %sshr_i16_i32(i16, i32) -> i16 {
|
||||
block0(v0: i16, v1: i32):
|
||||
v2 = sshr.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %sshr_i16_i32(0x8000, 0) == 0x8000
|
||||
; run: %sshr_i16_i32(0x8000, 1) == 0xC000
|
||||
; run: %sshr_i16_i32(0xf000, 0) == 0xf000
|
||||
; run: %sshr_i16_i32(0xf000, 4) == 0xff00
|
||||
; run: %sshr_i16_i32(0x4000, 32) == 0x4000
|
||||
; run: %sshr_i16_i32(0x4000, 33) == 0x2000
|
||||
; run: %sshr_i16_i32(0x4000, 34) == 0x1000
|
||||
|
||||
; run: %rotr_i8_const_37(0x00) == 0x00
|
||||
; run: %rotr_i8_const_37(0x01) == 0x08
|
||||
; run: %rotr_i8_const_37(0x12) == 0x90
|
||||
function %sshr_i16_i16(i16, i16) -> i16 {
|
||||
block0(v0: i16, v1: i16):
|
||||
v2 = sshr.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %sshr_i16_i16(0x8000, 0) == 0x8000
|
||||
; run: %sshr_i16_i16(0x8000, 1) == 0xC000
|
||||
; run: %sshr_i16_i16(0xf000, 0) == 0xf000
|
||||
; run: %sshr_i16_i16(0xf000, 4) == 0xff00
|
||||
; run: %sshr_i16_i16(0x4000, 32) == 0x4000
|
||||
; run: %sshr_i16_i16(0x4000, 33) == 0x2000
|
||||
; run: %sshr_i16_i16(0x4000, 34) == 0x1000
|
||||
|
||||
function %sshr_i16_i8(i16, i8) -> i16 {
|
||||
block0(v0: i16, v1: i8):
|
||||
v2 = sshr.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %sshr_i16_i8(0x8000, 0) == 0x8000
|
||||
; run: %sshr_i16_i8(0x8000, 1) == 0xC000
|
||||
; run: %sshr_i16_i8(0xf000, 0) == 0xf000
|
||||
; run: %sshr_i16_i8(0xf000, 4) == 0xff00
|
||||
; run: %sshr_i16_i8(0x4000, 32) == 0x4000
|
||||
; run: %sshr_i16_i8(0x4000, 33) == 0x2000
|
||||
; run: %sshr_i16_i8(0x4000, 34) == 0x1000
|
||||
|
||||
|
||||
function %sshr_i8_i64(i8, i64) -> i8 {
|
||||
block0(v0: i8, v1: i64):
|
||||
v2 = sshr.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %sshr_i8_i64(0x80, 0) == 0x80
|
||||
; run: %sshr_i8_i64(0x80, 1) == 0xC0
|
||||
; run: %sshr_i8_i64(0xf0, 0) == 0xf0
|
||||
; run: %sshr_i8_i64(0xf0, 4) == 0xff
|
||||
; run: %sshr_i8_i64(0x40, 32) == 0x40
|
||||
; run: %sshr_i8_i64(0x40, 33) == 0x20
|
||||
; run: %sshr_i8_i64(0x40, 34) == 0x10
|
||||
|
||||
function %sshr_i8_i32(i8, i32) -> i8 {
|
||||
block0(v0: i8, v1: i32):
|
||||
v2 = sshr.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %sshr_i8_i32(0x80, 0) == 0x80
|
||||
; run: %sshr_i8_i32(0x80, 1) == 0xC0
|
||||
; run: %sshr_i8_i32(0xf0, 0) == 0xf0
|
||||
; run: %sshr_i8_i32(0xf0, 4) == 0xff
|
||||
; run: %sshr_i8_i32(0x40, 32) == 0x40
|
||||
; run: %sshr_i8_i32(0x40, 33) == 0x20
|
||||
; run: %sshr_i8_i32(0x40, 34) == 0x10
|
||||
|
||||
function %sshr_i8_i16(i8, i16) -> i8 {
|
||||
block0(v0: i8, v1: i16):
|
||||
v2 = sshr.i8 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %sshr_i8_i16(0x80, 0) == 0x80
|
||||
; run: %sshr_i8_i16(0x80, 1) == 0xC0
|
||||
; run: %sshr_i8_i16(0xf0, 0) == 0xf0
|
||||
; run: %sshr_i8_i16(0xf0, 4) == 0xff
|
||||
; run: %sshr_i8_i16(0x40, 32) == 0x40
|
||||
; run: %sshr_i8_i16(0x40, 33) == 0x20
|
||||
; run: %sshr_i8_i16(0x40, 34) == 0x10
|
||||
|
||||
function %sshr_i8_i8(i16, i8) -> i16 {
|
||||
block0(v0: i16, v1: i8):
|
||||
v2 = sshr.i16 v0, v1
|
||||
return v2
|
||||
}
|
||||
; run: %sshr_i8_i8(0x80, 0) == 0x80
|
||||
; run: %sshr_i8_i8(0x80, 1) == 0x40
|
||||
; run: %sshr_i8_i8(0xf0, 0) == 0xf0
|
||||
; run: %sshr_i8_i8(0xf0, 4) == 0x0f
|
||||
; run: %sshr_i8_i8(0x40, 32) == 0x40
|
||||
; run: %sshr_i8_i8(0x40, 33) == 0x20
|
||||
; run: %sshr_i8_i8(0x40, 34) == 0x10
|
||||
|
||||
Reference in New Issue
Block a user