159 lines
3.1 KiB
Plaintext
159 lines
3.1 KiB
Plaintext
test interpret
|
|
test run
|
|
target x86_64
|
|
target aarch64
|
|
target s390x
|
|
target riscv64
|
|
|
|
function %bmask_i64_i64(i64) -> i64 {
|
|
block0(v0: i64):
|
|
v1 = bmask.i64 v0
|
|
return v1
|
|
}
|
|
; run: %bmask_i64_i64(1) == -1
|
|
; run: %bmask_i64_i64(0) == 0
|
|
|
|
function %bmask_i64_i32(i64) -> i32 {
|
|
block0(v0: i64):
|
|
v1 = bmask.i32 v0
|
|
return v1
|
|
}
|
|
; run: %bmask_i64_i32(1) == -1
|
|
; run: %bmask_i64_i32(0) == 0
|
|
|
|
function %bmask_i64_i16(i64) -> i16 {
|
|
block0(v0: i64):
|
|
v1 = bmask.i16 v0
|
|
return v1
|
|
}
|
|
; run: %bmask_i64_i16(1) == -1
|
|
; run: %bmask_i64_i16(0) == 0
|
|
|
|
function %bmask_i64_i8(i64) -> i8 {
|
|
block0(v0: i64):
|
|
v1 = bmask.i8 v0
|
|
return v1
|
|
}
|
|
; run: %bmask_i64_i8(1) == -1
|
|
; run: %bmask_i64_i8(0) == 0
|
|
|
|
function %bmask_i32_i64(i32) -> i64 {
|
|
block0(v0: i32):
|
|
v1 = bmask.i64 v0
|
|
return v1
|
|
}
|
|
; run: %bmask_i32_i64(1) == -1
|
|
; run: %bmask_i32_i64(0) == 0
|
|
|
|
function %bmask_i32_i32(i32) -> i32 {
|
|
block0(v0: i32):
|
|
v1 = bmask.i32 v0
|
|
return v1
|
|
}
|
|
; run: %bmask_i32_i32(1) == -1
|
|
; run: %bmask_i32_i32(0) == 0
|
|
|
|
function %bmask_i32_i16(i32) -> i16 {
|
|
block0(v0: i32):
|
|
v1 = bmask.i16 v0
|
|
return v1
|
|
}
|
|
; run: %bmask_i32_i16(1) == -1
|
|
; run: %bmask_i32_i16(0) == 0
|
|
|
|
function %bmask_i32_i8(i32) -> i8 {
|
|
block0(v0: i32):
|
|
v1 = bmask.i8 v0
|
|
return v1
|
|
}
|
|
; run: %bmask_i32_i8(1) == -1
|
|
; run: %bmask_i32_i8(0) == 0
|
|
|
|
function %bmask_i16_i64(i16) -> i64 {
|
|
block0(v0: i16):
|
|
v1 = bmask.i64 v0
|
|
return v1
|
|
}
|
|
; run: %bmask_i16_i64(1) == -1
|
|
; run: %bmask_i16_i64(0) == 0
|
|
|
|
function %bmask_i16_i32(i16) -> i32 {
|
|
block0(v0: i16):
|
|
v1 = bmask.i32 v0
|
|
return v1
|
|
}
|
|
; run: %bmask_i16_i32(1) == -1
|
|
; run: %bmask_i16_i32(0) == 0
|
|
|
|
function %bmask_i16_i16(i16) -> i16 {
|
|
block0(v0: i16):
|
|
v1 = bmask.i16 v0
|
|
return v1
|
|
}
|
|
; run: %bmask_i16_i16(1) == -1
|
|
; run: %bmask_i16_i16(0) == 0
|
|
|
|
function %bmask_i16_i8(i16) -> i8 {
|
|
block0(v0: i16):
|
|
v1 = bmask.i8 v0
|
|
return v1
|
|
}
|
|
; run: %bmask_i16_i8(1) == -1
|
|
; run: %bmask_i16_i8(0) == 0
|
|
|
|
function %bmask_i8_i64(i8) -> i64 {
|
|
block0(v0: i8):
|
|
v1 = bmask.i64 v0
|
|
return v1
|
|
}
|
|
; run: %bmask_i8_i64(1) == -1
|
|
; run: %bmask_i8_i64(0) == 0
|
|
|
|
function %bmask_i8_i32(i8) -> i32 {
|
|
block0(v0: i8):
|
|
v1 = bmask.i32 v0
|
|
return v1
|
|
}
|
|
; run: %bmask_i8_i32(1) == -1
|
|
; run: %bmask_i8_i32(0) == 0
|
|
|
|
function %bmask_i8_i16(i8) -> i16 {
|
|
block0(v0: i8):
|
|
v1 = bmask.i16 v0
|
|
return v1
|
|
}
|
|
; run: %bmask_i8_i16(1) == -1
|
|
; run: %bmask_i8_i16(0) == 0
|
|
|
|
function %bmask_i8_i8(i8) -> i8 {
|
|
block0(v0: i8):
|
|
v1 = bmask.i8 v0
|
|
return v1
|
|
}
|
|
; run: %bmask_i8_i8(1) == -1
|
|
; run: %bmask_i8_i8(0) == 0
|
|
|
|
|
|
; This is a regression test for AArch64, where the high bits weren't
|
|
; correctly being masked off for smaller types
|
|
function %bmask_masks_small_types() -> i8 {
|
|
block0:
|
|
v0 = iconst.i8 120
|
|
v1 = iconst.i8 7
|
|
v2 = ishl.i8 v0, v1
|
|
v3 = bmask.i8 v2
|
|
return v3
|
|
}
|
|
; run: %bmask_masks_small_types() == 0
|
|
|
|
; Similar to the above, this issue happened due to us always using a 64 bit
|
|
; comparison, even on a 32 bit type. This is triggered by ireduce since it
|
|
; doesn't actually produce any instructions, but is just a "type cast".
|
|
function %bmask_uses_32bit_cmp(i64) -> i8 {
|
|
block0(v0: i64):
|
|
v1 = ireduce.i32 v0
|
|
v2 = bmask.i8 v1
|
|
return v2
|
|
}
|
|
; run: %bmask_uses_32bit_cmp(0x2520B6E9_00000000) == 0
|