This enables more runtests to be executed on s390x. Doing so
uncovered a two back-end bugs, which are fixed as well:
- The result of cls was always off by one.
- The result of popcnt.i16 has uninitialized high bits.
In addition, I found a bug in the load-op-store.clif test case:
v3 = heap_addr.i64 heap0, v1, 4
v4 = iconst.i64 42
store.i32 v4, v3
This was clearly intended to perform a 32-bit store, but
actually performs a 64-bit store (it seems the type annotation
of the store opcode is ignored, and the type of the operand
is used instead). That bug did not show any noticable symptoms
on little-endian architectures, but broke on big-endian.
341 lines
5.4 KiB
Plaintext
341 lines
5.4 KiB
Plaintext
test interpret
|
|
test run
|
|
target aarch64
|
|
target s390x
|
|
target x86_64
|
|
|
|
function %bint_b1_i8_true() -> i8 {
|
|
block0:
|
|
v0 = bconst.b1 true
|
|
v1 = bint.i8 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b1_i8_true() == 1
|
|
|
|
function %bint_b1_i8_false() -> i8 {
|
|
block0:
|
|
v0 = bconst.b1 false
|
|
v1 = bint.i8 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b1_i8_false() == 0
|
|
|
|
function %bint_b1_i16_true() -> i16 {
|
|
block0:
|
|
v0 = bconst.b1 true
|
|
v1 = bint.i16 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b1_i16_true() == 1
|
|
|
|
function %bint_b1_i16_false() -> i16 {
|
|
block0:
|
|
v0 = bconst.b1 false
|
|
v1 = bint.i16 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b1_i16_fals() == 0
|
|
|
|
function %bint_b1_i32_true() -> i32 {
|
|
block0:
|
|
v0 = bconst.b1 true
|
|
v1 = bint.i32 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b1_i32_true() == 1
|
|
|
|
function %bint_b1_i32_false() -> i32 {
|
|
block0:
|
|
v0 = bconst.b1 false
|
|
v1 = bint.i32 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b1_i32_fals() == 0
|
|
|
|
function %bint_b1_i64_true() -> i64 {
|
|
block0:
|
|
v0 = bconst.b1 true
|
|
v1 = bint.i64 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b1_i64_true() == 1
|
|
|
|
function %bint_b1_i64_false() -> i64 {
|
|
block0:
|
|
v0 = bconst.b1 false
|
|
v1 = bint.i64 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b1_i64_fals() == 0
|
|
|
|
|
|
|
|
|
|
function %bint_b8_i8_true() -> i8 {
|
|
block0:
|
|
v0 = bconst.b8 true
|
|
v1 = bint.i8 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b8_i8_true() == 1
|
|
|
|
function %bint_b8_i8_false() -> i8 {
|
|
block0:
|
|
v0 = bconst.b8 false
|
|
v1 = bint.i8 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b8_i8_false() == 0
|
|
|
|
function %bint_b8_i16_true() -> i16 {
|
|
block0:
|
|
v0 = bconst.b8 true
|
|
v1 = bint.i16 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b8_i16_true() == 1
|
|
|
|
function %bint_b8_i16_false() -> i16 {
|
|
block0:
|
|
v0 = bconst.b8 false
|
|
v1 = bint.i16 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b8_i16_fals() == 0
|
|
|
|
function %bint_b8_i32_true() -> i32 {
|
|
block0:
|
|
v0 = bconst.b8 true
|
|
v1 = bint.i32 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b8_i32_true() == 1
|
|
|
|
function %bint_b8_i32_false() -> i32 {
|
|
block0:
|
|
v0 = bconst.b8 false
|
|
v1 = bint.i32 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b8_i32_fals() == 0
|
|
|
|
function %bint_b8_i64_true() -> i64 {
|
|
block0:
|
|
v0 = bconst.b8 true
|
|
v1 = bint.i64 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b8_i64_true() == 1
|
|
|
|
function %bint_b8_i64_false() -> i64 {
|
|
block0:
|
|
v0 = bconst.b8 false
|
|
v1 = bint.i64 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b8_i64_fals() == 0
|
|
|
|
|
|
|
|
|
|
|
|
function %bint_b16_i8_true() -> i8 {
|
|
block0:
|
|
v0 = bconst.b16 true
|
|
v1 = bint.i8 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b16_i8_true() == 1
|
|
|
|
function %bint_b16_i8_false() -> i8 {
|
|
block0:
|
|
v0 = bconst.b16 false
|
|
v1 = bint.i8 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b16_i8_fals() == 0
|
|
|
|
function %bint_b16_i16_true() -> i16 {
|
|
block0:
|
|
v0 = bconst.b16 true
|
|
v1 = bint.i16 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b16_i16_tru() == 1
|
|
|
|
function %bint_b16_i16_false() -> i16 {
|
|
block0:
|
|
v0 = bconst.b16 false
|
|
v1 = bint.i16 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b16_i16_fal() == 0
|
|
|
|
function %bint_b16_i32_true() -> i32 {
|
|
block0:
|
|
v0 = bconst.b16 true
|
|
v1 = bint.i32 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b16_i32_tru() == 1
|
|
|
|
function %bint_b16_i32_false() -> i32 {
|
|
block0:
|
|
v0 = bconst.b16 false
|
|
v1 = bint.i32 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b16_i32_fal() == 0
|
|
|
|
function %bint_b16_i64_true() -> i64 {
|
|
block0:
|
|
v0 = bconst.b16 true
|
|
v1 = bint.i64 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b16_i64_tru() == 1
|
|
|
|
function %bint_b16_i64_false() -> i64 {
|
|
block0:
|
|
v0 = bconst.b16 false
|
|
v1 = bint.i64 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b16_i64_fal() == 0
|
|
|
|
|
|
|
|
|
|
function %bint_b32_i8_true() -> i8 {
|
|
block0:
|
|
v0 = bconst.b32 true
|
|
v1 = bint.i8 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b32_i8_true() == 1
|
|
|
|
function %bint_b32_i8_false() -> i8 {
|
|
block0:
|
|
v0 = bconst.b32 false
|
|
v1 = bint.i8 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b32_i8_fals() == 0
|
|
|
|
function %bint_b32_i16_true() -> i16 {
|
|
block0:
|
|
v0 = bconst.b32 true
|
|
v1 = bint.i16 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b32_i16_tru() == 1
|
|
|
|
function %bint_b32_i16_false() -> i16 {
|
|
block0:
|
|
v0 = bconst.b32 false
|
|
v1 = bint.i16 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b32_i16_fal() == 0
|
|
|
|
function %bint_b32_i32_true() -> i32 {
|
|
block0:
|
|
v0 = bconst.b32 true
|
|
v1 = bint.i32 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b32_i32_tru() == 1
|
|
|
|
function %bint_b32_i32_false() -> i32 {
|
|
block0:
|
|
v0 = bconst.b32 false
|
|
v1 = bint.i32 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b32_i32_fal() == 0
|
|
|
|
function %bint_b32_i64_true() -> i64 {
|
|
block0:
|
|
v0 = bconst.b32 true
|
|
v1 = bint.i64 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b32_i64_tru() == 1
|
|
|
|
function %bint_b32_i64_false() -> i64 {
|
|
block0:
|
|
v0 = bconst.b32 false
|
|
v1 = bint.i64 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b32_i64_fal() == 0
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function %bint_b64_i8_true() -> i8 {
|
|
block0:
|
|
v0 = bconst.b64 true
|
|
v1 = bint.i8 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b64_i8_true() == 1
|
|
|
|
function %bint_b64_i8_false() -> i8 {
|
|
block0:
|
|
v0 = bconst.b64 false
|
|
v1 = bint.i8 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b64_i8_fals() == 0
|
|
|
|
function %bint_b64_i16_true() -> i16 {
|
|
block0:
|
|
v0 = bconst.b64 true
|
|
v1 = bint.i16 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b64_i16_tru() == 1
|
|
|
|
function %bint_b64_i16_false() -> i16 {
|
|
block0:
|
|
v0 = bconst.b64 false
|
|
v1 = bint.i16 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b64_i16_fal() == 0
|
|
|
|
function %bint_b64_i32_true() -> i32 {
|
|
block0:
|
|
v0 = bconst.b64 true
|
|
v1 = bint.i32 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b64_i32_tru() == 1
|
|
|
|
function %bint_b64_i32_false() -> i32 {
|
|
block0:
|
|
v0 = bconst.b64 false
|
|
v1 = bint.i32 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b64_i32_fal() == 0
|
|
|
|
function %bint_b64_i64_true() -> i64 {
|
|
block0:
|
|
v0 = bconst.b64 true
|
|
v1 = bint.i64 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b64_i64_tru() == 1
|
|
|
|
function %bint_b64_i64_false() -> i64 {
|
|
block0:
|
|
v0 = bconst.b64 false
|
|
v1 = bint.i64 v0
|
|
return v1
|
|
}
|
|
; run: %bint_b64_i64_fal() == 0
|