T0b1/wasmtime
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #3351 from afonso360/parser-i128

Browse Source 
cranelift: Add support for parsing i128 data values
This commit is contained in:
Chris Fallin
2021-09-21 10:04:27 -07:00
committed by GitHub
parent fc6328ae06 3a4ebd7727
commit ebe2af6eaa
25 changed files with 1224 additions and 1528 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
cranelift/codegen/src/data_value.rs
View File

@@ -86,6 +86,7 @@ impl DataValue {
DataValue::I16(i) => dst[..2].copy_from_slice(&i.to_ne_bytes()[..]),
DataValue::I32(i) => dst[..4].copy_from_slice(&i.to_ne_bytes()[..]),
DataValue::I64(i) => dst[..8].copy_from_slice(&i.to_ne_bytes()[..]),
DataValue::I128(i) => dst[..16].copy_from_slice(&i.to_ne_bytes()[..]),
DataValue::F32(f) => dst[..4].copy_from_slice(&f.bits().to_ne_bytes()[..]),
DataValue::F64(f) => dst[..8].copy_from_slice(&f.bits().to_ne_bytes()[..]),
DataValue::V128(v) => dst[..16].copy_from_slice(&v[..]),
@@ -104,6 +105,7 @@ impl DataValue {
types::I16 => DataValue::I16(i16::from_ne_bytes(src[..2].try_into().unwrap())),
types::I32 => DataValue::I32(i32::from_ne_bytes(src[..4].try_into().unwrap())),
types::I64 => DataValue::I64(i64::from_ne_bytes(src[..8].try_into().unwrap())),
types::I128 => DataValue::I128(i128::from_ne_bytes(src[..16].try_into().unwrap())),
types::F32 => DataValue::F32(Ieee32::with_bits(u32::from_ne_bytes(
src[..4].try_into().unwrap(),
))),

101
cranelift/filetests/filetests/runtests/i128-arithmetic.clif
View File

@@ -1,74 +1,57 @@
test interpret
test run
set enable_llvm_abi_extensions=true
target aarch64
; target s390x TODO: Not yet implemented on s390x
target x86_64 machinst
; TODO: Cleanup these tests when we have native support for i128 immediates in CLIF's parser
function %add_i128(i64, i64, i64, i64) -> i64, i64 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = iadd v4, v5
v7, v8 = isplit v6
return v7, v8
function %add_i128(i128, i128) -> i128 {
block0(v0: i128,v1: i128):
v2 = iadd v0, v1
return v2
}
; run: %add_i128(0, 0, 0, 0) == [0, 0]
; run: %add_i128(0, -1, -1, 0) == [-1, -1]
; run: %add_i128(1, 0, 0, 0) == [1, 0]
; run: %add_i128(1, 0, 1, 0) == [2, 0]
; run: %add_i128(1, 0, -1, -1) == [0, 0]
; run: %add_i128(-1, 0, 1, 0) == [0, 1]
; run: %add_i128(0, 0) == 0
; run: %add_i128(1, 0) == 1
; run: %add_i128(1, 1) == 2
; run: %add_i128(1, -1) == 0
; run: %add_i128(0xFFFFFFFF_FFFFFFFF_00000000_00000000, 0x00000000_00000000_FFFFFFFF_FFFFFFFF) == -1
; run: %add_i128(0x00000000_00000000_FFFFFFFF_FFFFFFFF, 1) == 0x00000000_00000001_00000000_00000000
; run: %add_i128(0x01234567_89ABCDEF, 0x01234567_89ABCDEF, 0xFEDCBA98_76543210, 0xFEDCBA98_76543210) == [-1, -1]
; run: %add_i128(0x06060606_06060606, 0xA00A00A0_0A00A00A, 0x30303030_30303030, 0x0BB0BB0B_B0BB0BB0) == [0x36363636_36363636, 0xABBABBAB_BABBABBA]
; run: %add_i128(0xC0FFEEEE_C0FFEEEE, 0xC0FFEEEE_C0FFEEEE, 0x1DCB1111_1DCB1111, 0x1DCB1111_1DCB1111) == [0xDECAFFFF_DECAFFFF, 0xDECAFFFF_DECAFFFF]
; run: %add_i128(0x01234567_89ABCDEF_01234567_89ABCDEF, 0xFEDCBA98_76543210_FEDCBA98_76543210) == -1
; run: %add_i128(0x06060606_06060606_A00A00A0_0A00A00A, 0x30303030_30303030_0BB0BB0B_B0BB0BB0) == 0x36363636_36363636_ABBABBAB_BABBABBA
; run: %add_i128(0xC0FFEEEE_C0FFEEEE_C0FFEEEE_C0FFEEEE, 0x1DCB1111_1DCB1111_1DCB1111_1DCB1111) == 0xDECAFFFF_DECAFFFF_DECAFFFF_DECAFFFF
function %sub_i128(i64, i64, i64, i64) -> i64, i64 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = isub v4, v5
v7, v8 = isplit v6
return v7, v8
function %sub_i128(i128, i128) -> i128 {
block0(v0: i128,v1: i128):
v2 = isub v0, v1
return v2
}
; run: %sub_i128(0, 0, 0, 0) == [0, 0]
; run: %sub_i128(1, 0, 1, 0) == [0, 0]
; run: %sub_i128(1, 0, 0, 0) == [1, 0]
; run: %sub_i128(0, 0, 1, 0) == [-1, -1]
; run: %sub_i128(0, 0, -1, -1) == [1, 0]
; run: %sub_i128(0, 0) == 0
; run: %sub_i128(1, 1) == 0
; run: %sub_i128(1, 0) == 1
; run: %sub_i128(0, 1) == -1
; run: %sub_i128(0, -1) == 1
; run: %sub_i128(-1, -1, 0xFEDCBA98_76543210, 0xFEDCBA98_76543210) == [0x01234567_89ABCDEF, 0x01234567_89ABCDEF]
; run: %sub_i128(0x36363636_36363636, 0xABBABBAB_BABBABBA, 0x30303030_30303030, 0x0BB0BB0B_B0BB0BB0) == [0x06060606_06060606, 0xA00A00A0_0A00A00A]
; run: %sub_i128(0xDECAFFFF_DECAFFFF, 0xDECAFFFF_DECAFFFF, 0x1DCB1111_1DCB1111, 0x1DCB1111_1DCB1111) == [0xC0FFEEEE_C0FFEEEE, 0xC0FFEEEE_C0FFEEEE]
; run: %sub_i128(-1, 0xFEDCBA98_76543210_FEDCBA98_76543210) == 0x01234567_89ABCDEF_01234567_89ABCDEF
; run: %sub_i128(0x36363636_36363636_ABBABBAB_BABBABBA, 0x30303030_30303030_0BB0BB0B_B0BB0BB0) == 0x06060606_06060606_A00A00A0_0A00A00A
; run: %sub_i128(0xDECAFFFF_DECAFFFF_DECAFFFF_DECAFFFF, 0x1DCB1111_1DCB1111_1DCB1111_1DCB1111) == 0xC0FFEEEE_C0FFEEEE_C0FFEEEE_C0FFEEEE
function %mul_i128(i64, i64, i64, i64) -> i64, i64 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = imul v4, v5
v7, v8 = isplit v6
return v7, v8
function %mul_i128(i128, i128) -> i128 {
block0(v0: i128,v1: i128):
v2 = imul v0, v1
return v2
}
; run: %mul_i128(0, 0, 0, 0) == [0, 0]
; run: %mul_i128(1, 0, 1, 0) == [1, 0]
; run: %mul_i128(1, 0, 0, 0) == [0, 0]
; run: %mul_i128(0, 0, 1, 0) == [0, 0]
; run: %mul_i128(2, 0, 1, 0) == [2, 0]
; run: %mul_i128(2, 0, 2, 0) == [4, 0]
; run: %mul_i128(1, 0, -1, -1) == [-1, -1]
; run: %mul_i128(2, 0, -1, -1) == [-2, -1]
; run: %mul_i128(0, 0) == 0
; run: %mul_i128(1, 1) == 1
; run: %mul_i128(1, 0) == 0
; run: %mul_i128(0, 1) == 0
; run: %mul_i128(2, 1) == 2
; run: %mul_i128(2, 2) == 4
; run: %mul_i128(1, -1) == -1
; run: %mul_i128(2, -1) == -2
; run: %mul_i128(0x01010101_01010101, 0x01010101_01010101, 13, 0) == [0x0D0D0D0D_0D0D0D0D, 0x0D0D0D0D_0D0D0D0D]
; run: %mul_i128(13, 0, 0x01010101_01010101, 0x01010101_01010101) == [0x0D0D0D0D_0D0D0D0D, 0x0D0D0D0D_0D0D0D0D]
; run: %mul_i128(0x00000000_01234567, 0x89ABCDEF_00000000, 0x00000000_FEDCBA98, 0x76543210_00000000) == [0x0121FA00_23E20B28, 0xE2946058_00000000]
; run: %mul_i128(0xC0FFEEEE_C0FFEEEE, 0xC0FFEEEE_C0FFEEEE, 0xDECAFFFF_DECAFFFF, 0xDECAFFFF_DECAFFFF) == [0xDB6B1E48_19BA1112, 0x5ECD38B5_9D1C2B7E]
; run: %mul_i128(0xC0FFEEEE_C0FFEEEE, 0xC0FFEEEE_C0FFEEEE, 0xDECAFFFF_DECAFFFF, 0xDECAFFFF_DECAFFFF) == [0xDB6B1E48_19BA1112, 0x5ECD38B5_9D1C2B7E]
; run: %mul_i128(0x01010101_01010101_01010101_01010101, 13) == 0x0D0D0D0D_0D0D0D0D_0D0D0D0D_0D0D0D0D
; run: %mul_i128(13, 0x01010101_01010101_01010101_01010101) == 0x0D0D0D0D_0D0D0D0D_0D0D0D0D_0D0D0D0D
; run: %mul_i128(0x00000000_01234567_89ABCDEF_00000000, 0x00000000_FEDCBA98_76543210_00000000) == 0x2236D88F_E5618CF0_00000000_00000000
; run: %mul_i128(0xC0FFEEEE_C0FFEEEE_C0FFEEEE_C0FFEEEE, 0xDECAFFFF_DECAFFFF_DECAFFFF_DECAFFFF) == 0x5ECD38B5_9D1C2B7E_DB6B1E48_19BA1112

14
cranelift/filetests/filetests/runtests/i128-bandnot.clif Normal file
View File

@@ -0,0 +1,14 @@
test run
target aarch64
function %band_not_i128(i128, i128) -> i128 {
block0(v0: i128, v1: i128):
v2 = band_not v0, v1
return v2
}
; run: %band_not_i128(0, 0) == 0
; run: %band_not_i128(-1, 0) == -1
; run: %band_not_i128(-1, -1) == 0
; run: %band_not_i128(-1, 0xFFFFFFFF_FFFFFFFF_00000000_00000000) == 0x00000000_00000000_FFFFFFFF_FFFFFFFF
; run: %band_not_i128(0xFEDCBA98_76543210_01234567_89ABCDEF, 0x01234567_89ABCDEF_FEDCBA98_76543210) == 0xFEDCBA98_76543210_01234567_89ABCDEF
; run: %band_not_i128(0xFEEEFFFF_FEEEFFFF_F1FFFEFE_F1FFFEFE, 0x20240000_20240000_31001010_31001010) == 0xDECAFFFF_DECAFFFF_C0FFEEEE_C0FFEEEE

8
cranelift/filetests/filetests/runtests/i128-bint.clif
View File

@@ -1,12 +1,12 @@
test run
set enable_llvm_abi_extensions=true
target aarch64
target x86_64 machinst
function %bint_b8_i128() -> i64, i64 {
function %bint_b8_i128() -> i128 {
block0:
v0 = bconst.b8 true
v1 = bint.i128 v0
v2, v3 = isplit.i128 v1
return v2, v3
return v1
}
; run: %bint_b8_i128() == [1, 0]
; run: %bint_b8_i128() == 1

24
cranelift/filetests/filetests/runtests/i128-bitops-cls.clif
View File

@@ -1,24 +0,0 @@
test run
target aarch64
; TODO: Move this test into i128-bitops-count.clif when x86_64 supports it
function %cls_i128(i64, i64) -> i64 {
block0(v0: i64, v1: i64):
v2 = iconcat v0, v1
v3 = cls v2
v4, v5 = isplit v3
v6 = iadd v4, v5
return v6
}
; run: %cls_i128(0x00000000_00000000, 0x00000000_00000000) == 127
; run: %cls_i128(0xFFFFFFFF_FFFFFFFF, 0x00000000_00000000) == 63
; run: %cls_i128(0x00000000_00000000, 0xFFFFFFFF_FFFFFFFF) == 63
; run: %cls_i128(0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == 127
; run: %cls_i128(0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF) == 0
; run: %cls_i128(0xFFFFFFFF_FFFFFFFF, 0x3FFFFFFF_FFFFFFFF) == 1
; run: %cls_i128(0x7FFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == 63
; run: %cls_i128(0x80000000_00000000, 0xC0000000_00000000) == 1
; run: %cls_i128(0x00000000_00000000, 0xC0000000_00000000) == 1
; run: %cls_i128(0x80000000_00000000, 0x80000000_00000000) == 0

93
cranelift/filetests/filetests/runtests/i128-bitops-count.clif
View File

@@ -1,63 +1,48 @@
test run
set enable_llvm_abi_extensions=true
target aarch64
; target s390x TODO: Not yet implemented on s390x
target x86_64 machinst
function %ctz_i128(i64, i64) -> i64 {
block0(v0: i64, v1: i64):
v2 = iconcat v0, v1
v3 = ctz v2
v4, v5 = isplit v3
v6 = iadd v4, v5
return v6
function %ctz_i128(i128) -> i128 {
block0(v0: i128):
v1 = ctz v0
return v1
}
; run: %ctz_i128(0x00000000_00000000, 0x00000000_00000000) == 128
; run: %ctz_i128(0xFFFFFFFF_FFFFFFFF, 0x00000000_00000000) == 0
; run: %ctz_i128(0x00000000_00000000, 0xFFFFFFFF_FFFFFFFF) == 64
; run: %ctz_i128(0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == 0
; run: %ctz_i128(0xFFFFFFFF_00000000, 0xF0000000_00000000) == 32
; run: %ctz_i128(0xF0000000_00000000, 0xFF000000_00000000) == 60
; run: %ctz_i128(0x00000001_00000000, 0x00000000_00000000) == 32
; run: %ctz_i128(0x00000000_00000000, 0x00000001_00000000) == 96
; run: %ctz_i128(0x00000000_00010000, 0x00000001_00000000) == 16
; run: %ctz_i128(0x00000000_00010000, 0x00000000_00000000) == 16
; run: %ctz_i128(0x00000000_00000000_00000000_00000000) == 128
; run: %ctz_i128(0x00000000_00000000_FFFFFFFF_FFFFFFFF) == 0
; run: %ctz_i128(0xFFFFFFFF_FFFFFFFF_00000000_00000000) == 64
; run: %ctz_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == 0
; run: %ctz_i128(0xF0000000_00000000_FFFFFFFF_00000000) == 32
; run: %ctz_i128(0xFF000000_00000000_F0000000_00000000) == 60
; run: %ctz_i128(0x00000000_00000000_00000001_00000000) == 32
; run: %ctz_i128(0x00000001_00000000_00000000_00000000) == 96
; run: %ctz_i128(0x00000001_00000000_00000000_00010000) == 16
; run: %ctz_i128(0x00000000_00000000_00000000_00010000) == 16
function %clz_i128(i64, i64) -> i64 {
block0(v0: i64, v1: i64):
v2 = iconcat v0, v1
v3 = clz v2
v4, v5 = isplit v3
v6 = iadd v4, v5
return v6
function %clz_i128(i128) -> i128 {
block0(v0: i128):
v1 = clz v0
return v1
}
; run: %clz_i128(0x00000000_00000000, 0x00000000_00000000) == 128
; run: %clz_i128(0xFFFFFFFF_FFFFFFFF, 0x00000000_00000000) == 64
; run: %clz_i128(0x00000000_00000000, 0xFFFFFFFF_FFFFFFFF) == 0
; run: %clz_i128(0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == 0
; run: %clz_i128(0xFFFFFFFF_FFFFFFFF, 0x40000000_00000000) == 1
; run: %clz_i128(0xFFFFFFFF_FFFFFFFF, 0x20000000_00000000) == 2
; run: %clz_i128(0x00000000_00000000, 0x00000000_80000000) == 32
; run: %clz_i128(0x00000000_00000000, 0x00000001_00000000) == 31
; run: %clz_i128(0x00000000_00010000, 0x00000001_00000000) == 31
; run: %clz_i128(0x00000000_00010000, 0x00000000_00000000) == 111
; run: %clz_i128(0x00000000_00000000_00000000_00000000) == 128
; run: %clz_i128(0x00000000_00000000_FFFFFFFF_FFFFFFFF) == 64
; run: %clz_i128(0xFFFFFFFF_FFFFFFFF_00000000_00000000) == 0
; run: %clz_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == 0
; run: %clz_i128(0x40000000_00000000_FFFFFFFF_FFFFFFFF) == 1
; run: %clz_i128(0x20000000_00000000_FFFFFFFF_FFFFFFFF) == 2
; run: %clz_i128(0x00000000_80000000_00000000_00000000) == 32
; run: %clz_i128(0x00000001_00000000_00000000_00000000) == 31
; run: %clz_i128(0x00000001_00000000_00000000_00010000) == 31
; run: %clz_i128(0x00000000_00000000_00000000_00010000) == 111
function %popcnt_i128(i64, i64) -> i64 {
block0(v0: i64, v1: i64):
v2 = iconcat v0, v1
v3 = popcnt v2
v4, v5 = isplit v3
v6 = iadd v4, v5
return v6
function %popcnt_i128(i128) -> i128 {
block0(v0: i128):
v1 = popcnt v0
return v1
}
; run: %popcnt_i128(0x00000000_00000000, 0x00000000_00000000) == 0
; run: %popcnt_i128(0xFFFFFFFF_FFFFFFFF, 0x00000000_00000000) == 64
; run: %popcnt_i128(0x00000000_00000000, 0xFFFFFFFF_FFFFFFFF) == 64
; run: %popcnt_i128(0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == 128
; run: %popcnt_i128(0x55555555_55555555, 0x55555555_55555555) == 64
; run: %popcnt_i128(0xC0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE) == 96
; run: %popcnt_i128(0x00000000_00000000_00000000_00000000) == 0
; run: %popcnt_i128(0x00000000_00000000_FFFFFFFF_FFFFFFFF) == 64
; run: %popcnt_i128(0xFFFFFFFF_FFFFFFFF_00000000_00000000) == 64
; run: %popcnt_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == 128
; run: %popcnt_i128(0x55555555_55555555_55555555_55555555) == 64
; run: %popcnt_i128(0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF) == 96

179
cranelift/filetests/filetests/runtests/i128-bitops.clif
View File

@@ -1,153 +1,54 @@
test run
set enable_llvm_abi_extensions=true
target aarch64
; target s390x TODO: Not yet implemented on s390x
; target x86_64 TODO: Not yet implemented on x86_64
target x86_64 machinst
; i128 tests
; TODO: Cleanup these tests when we have native support for i128 immediates in CLIF's parser
function %bnot_i128(i64, i64) -> i64, i64 {
block0(v0: i64,v1: i64):
v2 = iconcat v0, v1
v3 = bnot v2
v4, v5 = isplit v3
return v4, v5
function %bnot_i128(i128) -> i128 {
block0(v0: i128):
v1 = bnot v0
return v1
}
; run: %bnot_i128(0, 0) == [-1, -1]
; run: %bnot_i128(-1, -1) == [0, 0]
; run: %bnot_i128(-1, 0) == [0, -1]
; run: %bnot_i128(0x3F001111_3F001111, 0x21350000_21350000) == [0xC0FFEEEE_C0FFEEEE, 0xDECAFFFF_DECAFFFF]
; run: %bnot_i128(0) == -1
; run: %bnot_i128(-1) == 0
; run: %bnot_i128(0xFFFFFFFF_FFFFFFFF_00000000_00000000) == 0x00000000_00000000_FFFFFFFF_FFFFFFFF
; run: %bnot_i128(0x3F001111_3F001111_21350000_21350000) == 0xC0FFEEEE_C0FFEEEE_DECAFFFF_DECAFFFF
function %band_i128(i64, i64, i64, i64) -> i64, i64 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = band v4, v5
v7, v8 = isplit v6
return v7, v8
function %band_i128(i128, i128) -> i128 {
block0(v0: i128, v1: i128):
v2 = band v0, v1
return v2
}
; run: %band_i128(0, 0, 0, 0) == [0, 0]
; run: %band_i128(-1, -1, 0, 0) == [0, 0]
; run: %band_i128(-1, -1, -1, -1) == [-1, -1]
; run: %band_i128(-1, -1, 0, -1) == [0, -1]
; run: %band_i128(0x01234567_89ABCDEF, 0xFEDCBA98_76543210, 0xFEDCBA98_76543210, 0x01234567_89ABCDEF) == [0, 0]
; run: %band_i128(0xF1FFFEFE_F1FFFEFE, 0xFEEEFFFF_FEEEFFFF, 0xCEFFEFEF_CEFFEFEF, 0xDFDBFFFF_DFDBFFFF) == [0xC0FFEEEE_C0FFEEEE, 0xDECAFFFF_DECAFFFF]
; run: %band_i128(0, 0) == 0
; run: %band_i128(-1, 0) == 0
; run: %band_i128(-1, -1) == -1
; run: %band_i128(-1, 0x00000000_00000000_FFFFFFFF_FFFFFFFF) == 0x00000000_00000000_FFFFFFFF_FFFFFFFF
; run: %band_i128(0xFEDCBA98_76543210_01234567_89ABCDEF, 0x01234567_89ABCDEF_FEDCBA98_76543210) == 0
; run: %band_i128(0xFEEEFFFF_FEEEFFFF_F1FFFEFE_F1FFFEFE, 0xDFDBFFFF_DFDBFFFF_CEFFEFEF_CEFFEFEF) == 0xDECAFFFF_DECAFFFF_C0FFEEEE_C0FFEEEE
function %bor_i128(i64, i64, i64, i64) -> i64, i64 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = bor v4, v5
v7, v8 = isplit v6
return v7, v8
function %bor_i128(i128, i128) -> i128 {
block0(v0: i128, v1: i128):
v2 = bor v0, v1
return v2
}
; run: %bor_i128(0, 0, 0, 0) == [0, 0]
; run: %bor_i128(-1, -1, 0, 0) == [-1, -1]
; run: %bor_i128(-1, -1, -1, -1) == [-1, -1]
; run: %bor_i128(0, 0, 0, -1) == [0, -1]
; run: %bor_i128(0x01234567_89ABCDEF, 0xFEDCBA98_76543210, 0xFEDCBA98_76543210, 0x01234567_89ABCDEF) == [-1, -1]
; run: %bor_i128(0x80AAAAAA_80AAAAAA, 0x8A8AAAAA_8A8AAAAA, 0x40554444_40554444, 0x54405555_54405555) == [0xC0FFEEEE_C0FFEEEE, 0xDECAFFFF_DECAFFFF]
; run: %bor_i128(0, 0) == 0
; run: %bor_i128(-1, 0) == -1
; run: %bor_i128(-1, -1) == -1
; run: %bor_i128(0, 0x00000000_00000000_FFFFFFFF_FFFFFFFF) == 0x00000000_00000000_FFFFFFFF_FFFFFFFF
; run: %bor_i128(0xFEDCBA98_76543210_01234567_89ABCDEF, 0x01234567_89ABCDEF_FEDCBA98_76543210) == -1
; run: %bor_i128(0x8A8AAAAA_8A8AAAAA_80AAAAAA_80AAAAAA, 0x54405555_54405555_40554444_40554444) == 0xDECAFFFF_DECAFFFF_C0FFEEEE_C0FFEEEE
function %bxor_i128(i64, i64, i64, i64) -> i64, i64 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = bxor v4, v5
v7, v8 = isplit v6
return v7, v8
function %bxor_i128(i128, i128) -> i128 {
block0(v0: i128, v1: i128):
v2 = bxor v0, v1
return v2
}
; run: %bxor_i128(0, 0, 0, 0) == [0, 0]
; run: %bxor_i128(-1, -1, 0, 0) == [-1, -1]
; run: %bxor_i128(-1, -1, -1, -1) == [0, 0]
; run: %bxor_i128(-1, -1, 0, -1) == [-1, 0]
; run: %bxor_i128(0x01234567_89ABCDEF, 0xFEDCBA98_76543210, 0xFEDCBA98_76543210, 0x01234567_89ABCDEF) == [-1, -1]
; run: %bxor_i128(0x8FA50A64_8FA50A64, 0x9440A07D_9440A07D, 0x4F5AE48A_4F5AE48A, 0x4A8A5F82_4A8A5F82) == [0xC0FFEEEE_C0FFEEEE, 0xDECAFFFF_DECAFFFF]
function %band_not_i128(i64, i64, i64, i64) -> i64, i64 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = band_not v4, v5
v7, v8 = isplit v6
return v7, v8
}
; run: %band_not_i128(0, 0, 0, 0) == [0, 0]
; run: %band_not_i128(-1, -1, 0, 0) == [-1, -1]
; run: %band_not_i128(-1, -1, -1, -1) == [0, 0]
; run: %band_not_i128(-1, -1, 0, -1) == [-1, 0]
; run: %band_not_i128(0x01234567_89ABCDEF, 0xFEDCBA98_76543210, 0xFEDCBA98_76543210, 0x01234567_89ABCDEF) == [0x01234567_89ABCDEF, 0xFEDCBA98_76543210]
; run: %band_not_i128(0xF1FFFEFE_F1FFFEFE, 0xFEEEFFFF_FEEEFFFF, 0x31001010_31001010, 0x20240000_20240000) == [0xC0FFEEEE_C0FFEEEE, 0xDECAFFFF_DECAFFFF]
function %bor_not_i128(i64, i64, i64, i64) -> i64, i64 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = bor_not v4, v5
v7, v8 = isplit v6
return v7, v8
}
; run: %bor_not_i128(0, 0, 0, 0) == [-1, -1]
; run: %bor_not_i128(-1, -1, 0, 0) == [-1, -1]
; run: %bor_not_i128(-1, -1, -1, -1) == [-1, -1]
; run: %bor_not_i128(-1, 0, 0, -1) == [-1, 0]
; run: %bor_not_i128(0x01234567_89ABCDEF, 0xFEDCBA98_76543210, 0xFEDCBA98_76543210, 0x01234567_89ABCDEF) == [0x01234567_89ABCDEF, 0xFEDCBA98_76543210]
; run: %bor_not_i128(0x80AAAAAA_80AAAAAA, 0x8A8AAAAA_8A8AAAAA, 0xBFAABBBB_BFAABBBB, 0xABBFAAAA_ABBFAAAA) == [0xC0FFEEEE_C0FFEEEE, 0xDECAFFFF_DECAFFFF]
function %bxor_not_i128(i64, i64, i64, i64) -> i64, i64 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = bxor_not v4, v5
v7, v8 = isplit v6
return v7, v8
}
; run: %bxor_not_i128(0, 0, 0, 0) == [-1, -1]
; run: %bxor_not_i128(-1, -1, 0, 0) == [0, 0]
; run: %bxor_not_i128(-1, -1, -1, -1) == [-1, -1]
; run: %bxor_not_i128(-1, -1, 0, -1) == [0, -1]
; run: %bxor_not_i128(0x01234567_89ABCDEF, 0xFEDCBA98_76543210, 0xFEDCBA98_76543210, 0x01234567_89ABCDEF) == [0, 0]
; run: %bxor_not_i128(0x8FA50A64_8FA50A64, 0x9440A07D_9440A07D, 0xB0A51B75_B0A51B75, 0xB575A07D_B575A07D) == [0xC0FFEEEE_C0FFEEEE, 0xDECAFFFF_DECAFFFF]
function %bitrev_i128(i64, i64) -> i64, i64 {
block0(v0: i64, v1: i64):
v2 = iconcat v0, v1
v3 = bitrev v2
v4, v5 = isplit v3
return v4, v5
}
; run: %bitrev_i128(0, 0) == [0, 0]
; run: %bitrev_i128(-1, -1) == [-1, -1]
; run: %bitrev_i128(-1, 0) == [0, -1]
; run: %bitrev_i128(0, -1) == [-1, 0]
; run: %bitrev_i128(0x00000000_00000000, 0x80000000_00000000) == [1, 0]
; run: %bitrev_i128(0x01234567_89ABCDEF, 0xFEDCBA98_76543210) == [0x084C2A6E_195D3B7F, 0xF7B3D591_E6A2C480]
; run: %bitrev_i128(0xC0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE) == [0x7777FF03_FFFF537B, 0xFFFF537B_7777FF03]
; run: %bxor_i128(0, 0) == 0
; run: %bxor_i128(-1, 0) == -1
; run: %bxor_i128(-1, -1) == 0
; run: %bxor_i128(-1, 0xFFFFFFFF_FFFFFFFF_00000000_00000000) == 0x00000000_00000000_FFFFFFFF_FFFFFFFF
; run: %bxor_i128(0xFEDCBA98_76543210_01234567_89ABCDEF, 0x01234567_89ABCDEF_FEDCBA98_76543210) == -1
; run: %bxor_i128(0x9440A07D_9440A07D_8FA50A64_8FA50A64, 0x4A8A5F82_4A8A5F82_4F5AE48A_4F5AE48A) == 0xDECAFFFF_DECAFFFF_C0FFEEEE_C0FFEEEE

15
cranelift/filetests/filetests/runtests/i128-bitrev.clif
View File

@@ -1,4 +1,5 @@
test run
set enable_llvm_abi_extensions=true
target aarch64
target x86_64 machinst
target x86_64 legacy
@@ -46,3 +47,17 @@ block0:
return v7
}
; run
function %bitrev_i128(i128) -> i128 {
block0(v0: i128):
v1 = bitrev v0
return v1
}
; run: %bitrev_i128(0) == 0
; run: %bitrev_i128(-1) == -1
; run: %bitrev_i128(0xFFFFFFFF_FFFFFFFF_00000000_00000000) == 0x00000000_00000000_FFFFFFFF_FFFFFFFF
; run: %bitrev_i128(0x00000000_00000000_FFFFFFFF_FFFFFFFF) == 0xFFFFFFFF_FFFFFFFF_00000000_00000000
; run: %bitrev_i128(0x80000000_00000000_00000000_00000000) == 1
; run: %bitrev_i128(0xFEDCBA98_76543210_01234567_89ABCDEF) == 0xF7B3D591_E6A2C480_084C2A6E_195D3B7F
; run: %bitrev_i128(0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF) == 0xFFFF537B_7777FF03_7777FF03_FFFF537B

14
cranelift/filetests/filetests/runtests/i128-bornot.clif Normal file
View File

@@ -0,0 +1,14 @@
test run
target aarch64
function %bor_not_i128(i128, i128) -> i128 {
block0(v0: i128, v1: i128):
v2 = bor_not v0, v1
return v2
}
; run: %bor_not_i128(0, 0) == -1
; run: %bor_not_i128(-1, 0) == -1
; run: %bor_not_i128(-1, -1) == -1
; run: %bor_not_i128(0x00000000_00000000_FFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF_00000000_00000000) == 0x00000000_00000000_FFFFFFFF_FFFFFFFF
; run: %bor_not_i128(0xFEDCBA98_76543210_01234567_89ABCDEF, 0x01234567_89ABCDEF_FEDCBA98_76543210) == 0xFEDCBA98_76543210_01234567_89ABCDEF
; run: %bor_not_i128(0x8A8AAAAA_8A8AAAAA_80AAAAAA_80AAAAAA, 0xABBFAAAA_ABBFAAAA_BFAABBBB_BFAABBBB) == 0xDECAFFFF_DECAFFFF_C0FFEEEE_C0FFEEEE

48
cranelift/filetests/filetests/runtests/i128-br.clif
View File

@@ -1,45 +1,43 @@
test run
set enable_llvm_abi_extensions=true
target aarch64
; target s390x TODO: Not yet implemented on s390x
target x86_64 machinst
target x86_64 legacy
function %i128_brz(i64, i64) -> b1 {
block0(v0: i64, v1: i64):
v2 = iconcat v0, v1
brz v2, block2
function %i128_brz(i128) -> b1 {
block0(v0: i128):
brz v0, block2
jump block1
block1:
v3 = bconst.b1 false
return v3
v1 = bconst.b1 false
return v1
block2:
v4 = bconst.b1 true
return v4
v2 = bconst.b1 true
return v2
}
; run: %i128_brz(0, 0) == true
; run: %i128_brz(-1, 0) == false
; run: %i128_brz(0, -1) == false
; run: %i128_brz(-1, -1) == false
; run: %i128_brz(0) == true
; run: %i128_brz(-1) == false
; run: %i128_brz(0x00000000_00000000_FFFFFFFF_FFFFFFFF) == false
; run: %i128_brz(0xFFFFFFFF_FFFFFFFF_00000000_00000000) == false
function %i128_brnz(i64, i64) -> b1 {
block0(v0: i64, v1: i64):
v2 = iconcat v0, v1
brnz v2, block2
function %i128_brnz(i128) -> b1 {
block0(v0: i128):
brnz v0, block2
jump block1
block1:
v3 = bconst.b1 false
return v3
v1 = bconst.b1 false
return v1
block2:
v4 = bconst.b1 true
return v4
v2 = bconst.b1 true
return v2
}
; run: %i128_brnz(0, 0) == false
; run: %i128_brnz(-1, 0) == true
; run: %i128_brnz(0, -1) == true
; run: %i128_brnz(-1, -1) == true
; run: %i128_brnz(0) == false
; run: %i128_brnz(-1) == true
; run: %i128_brnz(0x00000000_00000000_FFFFFFFF_FFFFFFFF) == true
; run: %i128_brnz(0xFFFFFFFF_FFFFFFFF_00000000_00000000) == true

432
cranelift/filetests/filetests/runtests/i128-bricmp.clif
View File

@@ -1,321 +1,285 @@
test run
target aarch64
function %i128_bricmp_eq(i64, i64, i64, i64) -> b1 {
block0(v0: i64, v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
br_icmp.i128 eq v4, v5, block2
function %i128_bricmp_eq(i128, i128) -> b1 {
block0(v0: i128, v1: i128):
br_icmp.i128 eq v0, v1, block2
jump block1
block1:
v6 = bconst.b1 false
return v6
v2 = bconst.b1 false
return v2
block2:
v7 = bconst.b1 true
return v7
v3 = bconst.b1 true
return v3
}
; run: %i128_bricmp_eq(0, 0, 0, 0) == true
; run: %i128_bricmp_eq(-1, -1, -1, -1) == true
; run: %i128_bricmp_eq(-1, -1, 0, 0) == false
; run: %i128_bricmp_eq(-1, -1, 0, -1) == false
; run: %i128_bricmp_eq(-1, 0, -1, -1) == false
; run: %i128_bricmp_eq(0, -1, -1, -1) == false
; run: %i128_bricmp_eq(0xC0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE, 0xC0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE) == true
; run: %i128_bricmp_eq(0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF, 0x00000000_00000001, 0x00000000_00000001) == false
; run: %i128_bricmp_eq(0xFFFFFFFF_FFFFFFFF, 0x00000000_00000001, 0x00000000_00000001, 0x00000000_00000001) == false
; run: %i128_bricmp_eq(0, 0) == true
; run: %i128_bricmp_eq(-1, -1) == true
; run: %i128_bricmp_eq(-1, 0) == false
; run: %i128_bricmp_eq(-1, 0xFFFFFFFF_FFFFFFFF_00000000_00000000) == false
; run: %i128_bricmp_eq(0x00000000_00000000_FFFFFFFF_FFFFFFFF, -1) == false
; run: %i128_bricmp_eq(0xFFFFFFFF_FFFFFFFF_00000000_00000000, -1) == false
; run: %i128_bricmp_eq(0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF) == true
; run: %i128_bricmp_eq(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0x00000000_00000001_00000000_00000001) == false
; run: %i128_bricmp_eq(0x00000000_00000001_FFFFFFFF_FFFFFFFF, 0x00000000_00000001_00000000_00000001) == false
function %i128_bricmp_ne(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
br_icmp.i128 ne v4, v5, block2
function %i128_bricmp_ne(i128, i128) -> b1 {
block0(v0: i128,v1: i128):
br_icmp.i128 ne v0, v1, block2
jump block1
block1:
v6 = bconst.b1 false
return v6
v2 = bconst.b1 false
return v2
block2:
v7 = bconst.b1 true
return v7
v3 = bconst.b1 true
return v3
}
; run: %i128_bricmp_ne(0, 0, 0, 0) == false
; run: %i128_bricmp_ne(-1, -1, -1, -1) == false
; run: %i128_bricmp_ne(-1, -1, 0, 0) == true
; run: %i128_bricmp_ne(-1, -1, 0, -1) == true
; run: %i128_bricmp_ne(-1, 0, -1, -1) == true
; run: %i128_bricmp_ne(0, -1, -1, -1) == true
; run: %i128_bricmp_ne(0xC0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE, 0xC0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE) == false
; run: %i128_bricmp_ne(0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF, 0x00000000_00000001, 0x00000000_00000001) == true
; run: %i128_bricmp_ne(0xFFFFFFFF_FFFFFFFF, 0x00000000_00000001, 0x00000000_00000001, 0x00000000_00000001) == true
; run: %i128_bricmp_ne(0, 0) == false
; run: %i128_bricmp_ne(-1, -1) == false
; run: %i128_bricmp_ne(-1, 0) == true
; run: %i128_bricmp_ne(-1, 0xFFFFFFFF_FFFFFFFF_00000000_00000000) == true
; run: %i128_bricmp_ne(0x00000000_00000000_FFFFFFFF_FFFFFFFF, -1) == true
; run: %i128_bricmp_ne(0xFFFFFFFF_FFFFFFFF_00000000_00000000, -1) == true
; run: %i128_bricmp_ne(0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF) == false
; run: %i128_bricmp_ne(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0x00000000_00000001_00000000_00000001) == true
; run: %i128_bricmp_ne(0x00000000_00000001_FFFFFFFF_FFFFFFFF, 0x00000000_00000001_00000000_00000001) == true
function %i128_bricmp_slt(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
br_icmp.i128 slt v4, v5, block2
function %i128_bricmp_slt(i128, i128) -> b1 {
block0(v0: i128,v1: i128):
br_icmp.i128 slt v0, v1, block2
jump block1
block1:
v6 = bconst.b1 false
return v6
v2 = bconst.b1 false
return v2
block2:
v7 = bconst.b1 true
return v7
v3 = bconst.b1 true
return v3
}
; run: %i128_bricmp_slt(0, 0, 0, 0) == false
; run: %i128_bricmp_slt(1, 0, 1, 0) == false
; run: %i128_bricmp_slt(0, 0, 1, 0) == true
; run: %i128_bricmp_slt(-1, -1, 0, 0) == true
; run: %i128_bricmp_slt(0, 0, -1, -1) == false
; run: %i128_bricmp_slt(-1, -1, -1, -1) == false
; run: %i128_bricmp_slt(0xFFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == true
; run: %i128_bricmp_slt(0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE, 0x00000000_00000000, 0xDECAFFFF_DECAFFFF) == true
; run: %i128_bricmp_slt(0x00000000_00000000, 0xDECAFFFF_DECAFFFF, 0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE) == false
; run: %i128_bricmp_slt(0, 0) == false
; run: %i128_bricmp_slt(1, 1) == false
; run: %i128_bricmp_slt(0, 1) == true
; run: %i128_bricmp_slt(-1, 0) == true
; run: %i128_bricmp_slt(0, -1) == false
; run: %i128_bricmp_slt(-1, -1) == false
; run: %i128_bricmp_slt(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == true
; run: %i128_bricmp_slt(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == true
; run: %i128_bricmp_slt(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == false
function %i128_bricmp_ult(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
br_icmp.i128 ult v4, v5, block2
function %i128_bricmp_ult(i128, i128) -> b1 {
block0(v0: i128,v1: i128):
br_icmp.i128 ult v0, v1, block2
jump block1
block1:
v6 = bconst.b1 false
return v6
v2 = bconst.b1 false
return v2
block2:
v7 = bconst.b1 true
return v7
v3 = bconst.b1 true
return v3
}
; run: %i128_bricmp_ult(0, 0, 0, 0) == false
; run: %i128_bricmp_ult(1, 0, 1, 0) == false
; run: %i128_bricmp_ult(0, 0, 1, 0) == true
; run: %i128_bricmp_ult(-1, -1, 0, 0) == false
; run: %i128_bricmp_ult(0, 0, -1, -1) == true
; run: %i128_bricmp_ult(-1, -1, -1, -1) == false
; run: %i128_bricmp_ult(0xFFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == true
; run: %i128_bricmp_ult(0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE, 0x00000000_00000000, 0xDECAFFFF_DECAFFFF) == true
; run: %i128_bricmp_ult(0x00000000_00000000, 0xDECAFFFF_DECAFFFF, 0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE) == false
; run: %i128_bricmp_ult(0, 0) == false
; run: %i128_bricmp_ult(1, 1) == false
; run: %i128_bricmp_ult(0, 1) == true
; run: %i128_bricmp_ult(-1, 0) == false
; run: %i128_bricmp_ult(0, -1) == true
; run: %i128_bricmp_ult(-1, -1) == false
; run: %i128_bricmp_ult(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == true
; run: %i128_bricmp_ult(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == true
; run: %i128_bricmp_ult(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == false
function %i128_bricmp_sle(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
br_icmp.i128 sle v4, v5, block2
function %i128_bricmp_sle(i128, i128) -> b1 {
block0(v0: i128,v1: i128):
br_icmp.i128 sle v0, v1, block2
jump block1
block1:
v6 = bconst.b1 false
return v6
v2 = bconst.b1 false
return v2
block2:
v7 = bconst.b1 true
return v7
v3 = bconst.b1 true
return v3
}
; run: %i128_bricmp_sle(0, 0, 0, 0) == true
; run: %i128_bricmp_sle(1, 0, 1, 0) == true
; run: %i128_bricmp_sle(0, 0, 1, 0) == true
; run: %i128_bricmp_sle(-1, -1, 0, 0) == true
; run: %i128_bricmp_sle(0, 0, -1, -1) == false
; run: %i128_bricmp_sle(-1, -1, -1, -1) == true
; run: %i128_bricmp_sle(0xFFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == true
; run: %i128_bricmp_sle(0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE, 0x00000000_00000000, 0xDECAFFFF_DECAFFFF) == true
; run: %i128_bricmp_sle(0x00000000_00000000, 0xDECAFFFF_DECAFFFF, 0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE) == false
; run: %i128_bricmp_sle(0, 0) == true
; run: %i128_bricmp_sle(1, 1) == true
; run: %i128_bricmp_sle(0, 1) == true
; run: %i128_bricmp_sle(-1, 0) == true
; run: %i128_bricmp_sle(0, -1) == false
; run: %i128_bricmp_sle(-1, -1) == true
; run: %i128_bricmp_sle(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == true
; run: %i128_bricmp_sle(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == true
; run: %i128_bricmp_sle(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == false
function %i128_bricmp_ule(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
br_icmp.i128 ule v4, v5, block2
function %i128_bricmp_ule(i128, i128) -> b1 {
block0(v0: i128,v1: i128):
br_icmp.i128 ule v0, v1, block2
jump block1
block1:
v6 = bconst.b1 false
return v6
v2 = bconst.b1 false
return v2
block2:
v7 = bconst.b1 true
return v7
v3 = bconst.b1 true
return v3
}
; run: %i128_bricmp_ule(0, 0, 0, 0) == true
; run: %i128_bricmp_ule(1, 0, 1, 0) == true
; run: %i128_bricmp_ule(0, 0, 1, 0) == true
; run: %i128_bricmp_ule(-1, -1, 0, 0) == false
; run: %i128_bricmp_ule(0, 0, -1, -1) == true
; run: %i128_bricmp_ule(-1, -1, -1, -1) == true
; run: %i128_bricmp_ule(0xFFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == true
; run: %i128_bricmp_ule(0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE, 0x00000000_00000000, 0xDECAFFFF_DECAFFFF) == true
; run: %i128_bricmp_ule(0x00000000_00000000, 0xDECAFFFF_DECAFFFF, 0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE) == false
; run: %i128_bricmp_ule(0, 0) == true
; run: %i128_bricmp_ule(1, 1) == true
; run: %i128_bricmp_ule(0, 1) == true
; run: %i128_bricmp_ule(-1, 0) == false
; run: %i128_bricmp_ule(0, -1) == true
; run: %i128_bricmp_ule(-1, -1) == true
; run: %i128_bricmp_ule(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == true
; run: %i128_bricmp_ule(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == true
; run: %i128_bricmp_ule(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == false
function %i128_bricmp_sgt(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
br_icmp.i128 sgt v4, v5, block2
function %i128_bricmp_sgt(i128, i128) -> b1 {
block0(v0: i128,v1: i128):
br_icmp.i128 sgt v0, v1, block2
jump block1
block1:
v6 = bconst.b1 false
return v6
v2 = bconst.b1 false
return v2
block2:
v7 = bconst.b1 true
return v7
v3 = bconst.b1 true
return v3
}
; run: %i128_bricmp_sgt(0, 0, 0, 0) == false
; run: %i128_bricmp_sgt(1, 0, 1, 0) == false
; run: %i128_bricmp_sgt(0, 0, 1, 0) == false
; run: %i128_bricmp_sgt(-1, -1, 0, 0) == false
; run: %i128_bricmp_sgt(0, 0, -1, -1) == true
; run: %i128_bricmp_sgt(-1, -1, -1, -1) == false
; run: %i128_bricmp_sgt(0xFFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == false
; run: %i128_bricmp_sgt(0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE, 0x00000000_00000000, 0xDECAFFFF_DECAFFFF) == false
; run: %i128_bricmp_sgt(0x00000000_00000000, 0xDECAFFFF_DECAFFFF, 0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE) == true
; run: %i128_bricmp_sgt(0, 0) == false
; run: %i128_bricmp_sgt(1, 1) == false
; run: %i128_bricmp_sgt(0, 1) == false
; run: %i128_bricmp_sgt(-1, 0) == false
; run: %i128_bricmp_sgt(0, -1) == true
; run: %i128_bricmp_sgt(-1, -1) == false
; run: %i128_bricmp_sgt(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == false
; run: %i128_bricmp_sgt(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == false
; run: %i128_bricmp_sgt(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == true
function %i128_bricmp_ugt(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
br_icmp.i128 ugt v4, v5, block2
function %i128_bricmp_ugt(i128, i128) -> b1 {
block0(v0: i128,v1: i128):
br_icmp.i128 ugt v0, v1, block2
jump block1
block1:
v6 = bconst.b1 false
return v6
v2 = bconst.b1 false
return v2
block2:
v7 = bconst.b1 true
return v7
v3 = bconst.b1 true
return v3
}
; run: %i128_bricmp_ugt(0, 0, 0, 0) == false
; run: %i128_bricmp_ugt(1, 0, 1, 0) == false
; run: %i128_bricmp_ugt(0, 0, 1, 0) == false
; run: %i128_bricmp_ugt(-1, -1, 0, 0) == true
; run: %i128_bricmp_ugt(0, 0, -1, -1) == false
; run: %i128_bricmp_ugt(-1, -1, -1, -1) == false
; run: %i128_bricmp_ugt(0xFFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == false
; run: %i128_bricmp_ugt(0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE, 0x00000000_00000000, 0xDECAFFFF_DECAFFFF) == false
; run: %i128_bricmp_ugt(0x00000000_00000000, 0xDECAFFFF_DECAFFFF, 0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE) == true
; run: %i128_bricmp_ugt(0, 0) == false
; run: %i128_bricmp_ugt(1, 1) == false
; run: %i128_bricmp_ugt(0, 1) == false
; run: %i128_bricmp_ugt(-1, 0) == true
; run: %i128_bricmp_ugt(0, -1) == false
; run: %i128_bricmp_ugt(-1, -1) == false
; run: %i128_bricmp_ugt(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == false
; run: %i128_bricmp_ugt(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == false
; run: %i128_bricmp_ugt(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == true
function %i128_bricmp_sge(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
br_icmp.i128 sge v4, v5, block2
function %i128_bricmp_sge(i128, i128) -> b1 {
block0(v0: i128,v1: i128):
br_icmp.i128 sge v0, v1, block2
jump block1
block1:
v6 = bconst.b1 false
return v6
v2 = bconst.b1 false
return v2
block2:
v7 = bconst.b1 true
return v7
v3 = bconst.b1 true
return v3
}
; run: %i128_bricmp_sge(0, 0, 0, 0) == true
; run: %i128_bricmp_sge(1, 0, 1, 0) == true
; run: %i128_bricmp_sge(0, 0, 1, 0) == false
; run: %i128_bricmp_sge(-1, -1, 0, 0) == false
; run: %i128_bricmp_sge(0, 0, -1, -1) == true
; run: %i128_bricmp_sge(-1, -1, -1, -1) == true
; run: %i128_bricmp_sge(0xFFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == false
; run: %i128_bricmp_sge(0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE, 0x00000000_00000000, 0xDECAFFFF_DECAFFFF) == false
; run: %i128_bricmp_sge(0x00000000_00000000, 0xDECAFFFF_DECAFFFF, 0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE) == true
; run: %i128_bricmp_sge(0, 0) == true
; run: %i128_bricmp_sge(1, 1) == true
; run: %i128_bricmp_sge(0, 1) == false
; run: %i128_bricmp_sge(-1, 0) == false
; run: %i128_bricmp_sge(0, -1) == true
; run: %i128_bricmp_sge(-1, -1) == true
; run: %i128_bricmp_sge(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == false
; run: %i128_bricmp_sge(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == false
; run: %i128_bricmp_sge(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == true
function %i128_bricmp_uge(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
br_icmp.i128 uge v4, v5, block2
function %i128_bricmp_uge(i128, i128) -> b1 {
block0(v0: i128,v1: i128):
br_icmp.i128 uge v0, v1, block2
jump block1
block1:
v6 = bconst.b1 false
return v6
v2 = bconst.b1 false
return v2
block2:
v7 = bconst.b1 true
return v7
v3 = bconst.b1 true
return v3
}
; run: %i128_bricmp_uge(0, 0, 0, 0) == true
; run: %i128_bricmp_uge(1, 0, 1, 0) == true
; run: %i128_bricmp_uge(0, 0, 1, 0) == false
; run: %i128_bricmp_uge(-1, -1, 0, 0) == true
; run: %i128_bricmp_uge(0, 0, -1, -1) == false
; run: %i128_bricmp_uge(-1, -1, -1, -1) == true
; run: %i128_bricmp_uge(0xFFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == false
; run: %i128_bricmp_uge(0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE, 0x00000000_00000000, 0xDECAFFFF_DECAFFFF) == false
; run: %i128_bricmp_uge(0x00000000_00000000, 0xDECAFFFF_DECAFFFF, 0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE) == true
; run: %i128_bricmp_uge(0, 0) == true
; run: %i128_bricmp_uge(1, 1) == true
; run: %i128_bricmp_uge(0, 1) == false
; run: %i128_bricmp_uge(-1, 0) == true
; run: %i128_bricmp_uge(0, -1) == false
; run: %i128_bricmp_uge(-1, -1) == true
; run: %i128_bricmp_uge(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == false
; run: %i128_bricmp_uge(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == false
; run: %i128_bricmp_uge(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == true
function %i128_bricmp_of(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
br_icmp.i128 of v4, v5, block2
function %i128_bricmp_of(i128, i128) -> b1 {
block0(v0: i128,v1: i128):
br_icmp.i128 of v0, v1, block2
jump block1
block1:
v6 = bconst.b1 false
return v6
v2 = bconst.b1 false
return v2
block2:
v7 = bconst.b1 true
return v7
v3 = bconst.b1 true
return v3
}
; run: %i128_bricmp_of(0, 0, 0, 0) == false
; run: %i128_bricmp_of(0, 0, 1, 0) == false
; run: %i128_bricmp_of(0, 0, -1, -1) == false
; run: %i128_bricmp_of(-1, -1, -1, -1) == false
; run: %i128_bricmp_of(0x00000000_00000000, 0x80000000_00000000, 0, 0) == false
; run: %i128_bricmp_of(0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF, 0, 0) == false
; run: %i128_bricmp_of(1, 0, 0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF) == true
; run: %i128_bricmp_of(0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF, 1, 0) == true
; run: %i128_bricmp_of(0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF, 0x00000000_00000000, 0x80000000_00000000) == false
; run: %i128_bricmp_of(0x00000000_00000000, 0x80000000_00000000, 0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF) == false
; run: %i128_bricmp_of(0xFFFFFFFF_FFFFFFFF, 0x4FFFFFFF_FFFFFFFF, 0x00000000_00000000, 0x30000000_00000000) == false
; run: %i128_bricmp_of(0xFFFFFFFF_FFFFFFFF, 0x4FFFFFFF_FFFFFFFF, 0x00000000_00000001, 0x30000000_00000000) == true
; run: %i128_bricmp_of(0, 0) == false
; run: %i128_bricmp_of(0, 1) == false
; run: %i128_bricmp_of(0, -1) == false
; run: %i128_bricmp_of(-1, -1) == false
; run: %i128_bricmp_of(0x80000000_00000000_00000000_00000000, 0) == false
; run: %i128_bricmp_of(0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0) == false
; run: %i128_bricmp_of(1, 0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == true
; run: %i128_bricmp_of(0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 1) == true
; run: %i128_bricmp_of(0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0x80000000_00000000_00000000_00000000) == false
; run: %i128_bricmp_of(0x80000000_00000000_00000000_00000000, 0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == false
; run: %i128_bricmp_of(0x4FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0x30000000_00000000_00000000_00000000) == false
; run: %i128_bricmp_of(0x4FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0x30000000_00000000_00000000_00000001) == true
function %i128_bricmp_nof(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
br_icmp.i128 nof v4, v5, block2
function %i128_bricmp_nof(i128, i128) -> b1 {
block0(v0: i128,v1: i128):
br_icmp.i128 nof v0, v1, block2
jump block1
block1:
v6 = bconst.b1 false
return v6
v2 = bconst.b1 false
return v2
block2:
v7 = bconst.b1 true
return v7
v3 = bconst.b1 true
return v3
}
; run: %i128_bricmp_nof(0, 0, 0, 0) == true
; run: %i128_bricmp_nof(0, 0, 1, 0) == true
; run: %i128_bricmp_nof(0, 0, -1, -1) == true
; run: %i128_bricmp_nof(-1, -1, -1, -1) == true
; run: %i128_bricmp_nof(0x00000000_00000000, 0x80000000_00000000, 0, 0) == true
; run: %i128_bricmp_nof(0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF, 0, 0) == true
; run: %i128_bricmp_nof(1, 0, 0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF) == false
; run: %i128_bricmp_nof(0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF, 1, 0) == false
; run: %i128_bricmp_nof(0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF, 0x00000000_00000000, 0x80000000_00000000) == true
; run: %i128_bricmp_nof(0x00000000_00000000, 0x80000000_00000000, 0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF) == true
; run: %i128_bricmp_nof(0xFFFFFFFF_FFFFFFFF, 0x4FFFFFFF_FFFFFFFF, 0x00000000_00000000, 0x30000000_00000000) == true
; run: %i128_bricmp_nof(0xFFFFFFFF_FFFFFFFF, 0x4FFFFFFF_FFFFFFFF, 0x00000000_00000001, 0x30000000_00000000) == false
; run: %i128_bricmp_nof(0, 0) == true
; run: %i128_bricmp_nof(0, 1) == true
; run: %i128_bricmp_nof(0, -1) == true
; run: %i128_bricmp_nof(-1, -1) == true
; run: %i128_bricmp_nof(0x80000000_00000000_00000000_00000000, 0) == true
; run: %i128_bricmp_nof(0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0) == true
; run: %i128_bricmp_nof(1, 0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == false
; run: %i128_bricmp_nof(0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 1) == false
; run: %i128_bricmp_nof(0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0x80000000_00000000_00000000_00000000) == true
; run: %i128_bricmp_nof(0x80000000_00000000_00000000_00000000, 0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == true
; run: %i128_bricmp_nof(0x4FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0x30000000_00000000_00000000_00000000) == true
; run: %i128_bricmp_nof(0x4FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0x30000000_00000000_00000000_00000001) == false

14
cranelift/filetests/filetests/runtests/i128-bxornot.clif Normal file
View File

@@ -0,0 +1,14 @@
test run
target aarch64
function %bxor_not_i128(i128, i128) -> i128 {
block0(v0: i128, v1: i128):
v2 = bxor_not v0, v1
return v2
}
; run: %bxor_not_i128(0, 0) == -1
; run: %bxor_not_i128(-1, 0) == 0
; run: %bxor_not_i128(-1, -1) == -1
; run: %bxor_not_i128(-1, 0xFFFFFFFF_FFFFFFFF_00000000_00000000) == 0xFFFFFFFF_FFFFFFFF_00000000_00000000
; run: %bxor_not_i128(0xFEDCBA98_76543210_01234567_89ABCDEF, 0x01234567_89ABCDEF_FEDCBA98_76543210) == 0
; run: %bxor_not_i128(0x9440A07D_9440A07D_8FA50A64_8FA50A64, 0xB575A07D_B575A07D_B0A51B75_B0A51B75) == 0xDECAFFFF_DECAFFFF_C0FFEEEE_C0FFEEEE

18
cranelift/filetests/filetests/runtests/i128-cls.clif Normal file
View File

@@ -0,0 +1,18 @@
test run
target aarch64
function %cls_i128(i128) -> i128 {
block0(v0: i128):
v1 = cls v0
return v1
}
; run: %cls_i128(0x00000000_00000000_00000000_00000000) == 127
; run: %cls_i128(0x00000000_00000000_FFFFFFFF_FFFFFFFF) == 63
; run: %cls_i128(0xFFFFFFFF_FFFFFFFF_00000000_00000000) == 63
; run: %cls_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == 127
; run: %cls_i128(0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == 0
; run: %cls_i128(0x3FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == 1
; run: %cls_i128(0xFFFFFFFF_FFFFFFFF_7FFFFFFF_FFFFFFFF) == 63
; run: %cls_i128(0xC0000000_00000000_80000000_00000000) == 1
; run: %cls_i128(0xC0000000_00000000_00000000_00000000) == 1
; run: %cls_i128(0x80000000_00000000_80000000_00000000) == 0

8
cranelift/filetests/filetests/runtests/i128-const.clif
View File

@@ -1,13 +1,13 @@
test interpret
test run
set enable_llvm_abi_extensions=true
target aarch64
; target s390x TODO: Not yet implemented on s390x
target x86_64 machinst
function %i128_const_0() -> i64, i64 {
function %i128_const_0() -> i128 {
block0:
v1 = iconst.i128 0
v2, v3 = isplit v1
return v2, v3
return v1
}
; run: %i128_const_0() == [0, 0]
; run: %i128_const_0() == 0

73
cranelift/filetests/filetests/runtests/i128-extend-2.clif
View File

@@ -1,69 +1,64 @@
test run
set enable_llvm_abi_extensions=true
target aarch64
target x86_64 machinst
; TODO: Merge this file with i128-extend once the x86 legacy backend is removed
function %i128_uextend_i32(i32) -> i64, i64 {
function %i128_uextend_i32(i32) -> i128 {
block0(v0: i32):
v1 = uextend.i128 v0
v2, v3 = isplit v1
return v2, v3
return v1
}
; run: %i128_uextend_i32(0) == [0, 0]
; run: %i128_uextend_i32(-1) == [0xffff_ffff, 0]
; run: %i128_uextend_i32(0xffff_eeee) == [0xffff_eeee, 0]
; run: %i128_uextend_i32(0) == 0
; run: %i128_uextend_i32(-1) == 0x00000000_00000000_00000000_ffffffff
; run: %i128_uextend_i32(0xffff_eeee) == 0x00000000_00000000_00000000_ffffeeee
function %i128_sextend_i32(i32) -> i64, i64 {
function %i128_sextend_i32(i32) -> i128 {
block0(v0: i32):
v1 = sextend.i128 v0
v2, v3 = isplit v1
return v2, v3
return v1
}
; run: %i128_sextend_i32(0) == [0, 0]
; run: %i128_sextend_i32(-1) == [-1, -1]
; run: %i128_sextend_i32(0x7fff_ffff) == [0x7fff_ffff, 0x0000_0000_0000_0000]
; run: %i128_sextend_i32(0xffff_eeee) == [0xffff_ffff_ffff_eeee, 0xffff_ffff_ffff_ffff]
; run: %i128_sextend_i32(0) == 0
; run: %i128_sextend_i32(-1) == -1
; run: %i128_sextend_i32(0x7fff_ffff) == 0x00000000_00000000_00000000_7fffffff
; run: %i128_sextend_i32(0xffff_eeee) == 0xffffffff_ffffffff_ffffffff_ffff_eeee
function %i128_uextend_i16(i16) -> i64, i64 {
function %i128_uextend_i16(i16) -> i128 {
block0(v0: i16):
v1 = uextend.i128 v0
v2, v3 = isplit v1
return v2, v3
return v1
}
; run: %i128_uextend_i16(0) == [0, 0]
; run: %i128_uextend_i16(-1) == [0xffff, 0]
; run: %i128_uextend_i16(0xffee) == [0xffee, 0]
; run: %i128_uextend_i16(0) == 0
; run: %i128_uextend_i16(-1) == 0x00000000_00000000_00000000_0000ffff
; run: %i128_uextend_i16(0xffee) == 0x00000000_00000000_00000000_0000ffee
function %i128_sextend_i16(i16) -> i64, i64 {
function %i128_sextend_i16(i16) -> i128 {
block0(v0: i16):
v1 = sextend.i128 v0
v2, v3 = isplit v1
return v2, v3
return v1
}
; run: %i128_sextend_i16(0) == [0, 0]
; run: %i128_sextend_i16(-1) == [-1, -1]
; run: %i128_sextend_i16(0x7fff) == [0x7fff, 0x0000_0000_0000_0000]
; run: %i128_sextend_i16(0xffee) == [0xffff_ffff_ffff_ffee, 0xffff_ffff_ffff_ffff]
; run: %i128_sextend_i16(0) == 0
; run: %i128_sextend_i16(-1) == -1
; run: %i128_sextend_i16(0x7fff) == 0x00000000_00000000_00000000_00007fff
; run: %i128_sextend_i16(0xffee) == 0xffffffff_ffffffff_ffffffff_ffffffee
function %i128_uextend_i8(i8) -> i64, i64 {
function %i128_uextend_i8(i8) -> i128 {
block0(v0: i8):
v1 = uextend.i128 v0
v2, v3 = isplit v1
return v2, v3
return v1
}
; run: %i128_uextend_i8(0) == [0, 0]
; run: %i128_uextend_i8(-1) == [0xff, 0]
; run: %i128_uextend_i8(0xfe) == [0xfe, 0]
; run: %i128_uextend_i8(0) == 0
; run: %i128_uextend_i8(-1) == 0x00000000_00000000_00000000_000000ff
; run: %i128_uextend_i8(0xfe) == 0x00000000_00000000_00000000_000000fe
function %i128_sextend_i8(i8) -> i64, i64 {
function %i128_sextend_i8(i8) -> i128 {
block0(v0: i8):
v1 = sextend.i128 v0
v2, v3 = isplit v1
return v2, v3
return v1
}
; run: %i128_sextend_i8(0) == [0, 0]
; run: %i128_sextend_i8(-1) == [-1, -1]
; run: %i128_sextend_i8(0x7f) == [0x7f, 0x0000_0000_0000_0000]
; run: %i128_sextend_i8(0xfe) == [0xffff_ffff_ffff_fffe, 0xffff_ffff_ffff_ffff]
; run: %i128_sextend_i8(0) == 0
; run: %i128_sextend_i8(-1) == -1
; run: %i128_sextend_i8(0x7f) == 0x00000000_00000000_00000000_0000007f
; run: %i128_sextend_i8(0xfe) == 0xffffffff_ffffffff_ffffffff_fffffffe

26
cranelift/filetests/filetests/runtests/i128-extend.clif
View File

@@ -1,26 +1,24 @@
test run
set enable_llvm_abi_extensions=true
target aarch64
; target s390x TODO: Not yet implemented on s390x
target x86_64 machinst
target x86_64 legacy
function %i128_uextend_i64(i64) -> i64, i64 {
function %i128_uextend_i64(i64) -> i128 {
block0(v0: i64):
v1 = uextend.i128 v0
v2, v3 = isplit v1
return v2, v3
return v1
}
; run: %i128_uextend_i64(0) == [0, 0]
; run: %i128_uextend_i64(-1) == [-1, 0]
; run: %i128_uextend_i64(0xffff_ffff_eeee_0000) == [0xffff_ffff_eeee_0000, 0]
; run: %i128_uextend_i64(0) == 0
; run: %i128_uextend_i64(-1) == 0x00000000_00000000_ffffffff_ffffffff
; run: %i128_uextend_i64(0xffff_ffff_eeee_0000) == 0x00000000_00000000_ffff_ffff_eeee_0000
function %i128_sextend_i64(i64) -> i64, i64 {
function %i128_sextend_i64(i64) -> i128 {
block0(v0: i64):
v1 = sextend.i128 v0
v2, v3 = isplit v1
return v2, v3
return v1
}
; run: %i128_sextend_i64(0) == [0, 0]
; run: %i128_sextend_i64(-1) == [-1, -1]
; run: %i128_sextend_i64(0x7fff_ffff_ffff_ffff) == [0x7fff_ffff_ffff_ffff, 0x0000_0000_0000_0000]
; run: %i128_sextend_i64(0xffff_ffff_eeee_0000) == [0xffff_ffff_eeee_0000, 0xffff_ffff_ffff_ffff]
; run: %i128_sextend_i64(0) == 0
; run: %i128_sextend_i64(-1) == -1
; run: %i128_sextend_i64(0x7fff_ffff_ffff_ffff) == 0x00000000_00000000_7fffffffffffffff
; run: %i128_sextend_i64(0xffff_ffff_eeee_0000) == 0xffffffff_ffffffff_ffffffff_eeee0000

72
cranelift/filetests/filetests/runtests/i128-icmp-overflow.clif
View File

@@ -1,46 +1,38 @@
test run
target aarch64
; target x86_64 machinst TODO: X86_64 does not implement i128 icmp overflow
; TODO: Cleanup these tests when we have native support for i128 immediates in CLIF's parser
function %icmp_of_i128(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = icmp.i128 of v4, v5
return v6
function %icmp_of_i128(i128, i128) -> b1 {
block0(v0: i128, v1: i128):
v2 = icmp.i128 of v0, v1
return v2
}
; run: %icmp_of_i128(0, 0, 0, 0) == false
; run: %icmp_of_i128(0, 0, 1, 0) == false
; run: %icmp_of_i128(0, 0, -1, -1) == false
; run: %icmp_of_i128(-1, -1, -1, -1) == false
; run: %icmp_of_i128(0x00000000_00000000, 0x80000000_00000000, 0, 0) == false
; run: %icmp_of_i128(0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF, 0, 0) == false
; run: %icmp_of_i128(1, 0, 0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF) == true
; run: %icmp_of_i128(0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF, 1, 0) == true
; run: %icmp_of_i128(0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF, 0x00000000_00000000, 0x80000000_00000000) == false
; run: %icmp_of_i128(0x00000000_00000000, 0x80000000_00000000, 0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF) == false
; run: %icmp_of_i128(0xFFFFFFFF_FFFFFFFF, 0x4FFFFFFF_FFFFFFFF, 0x00000000_00000000, 0x30000000_00000000) == false
; run: %icmp_of_i128(0xFFFFFFFF_FFFFFFFF, 0x4FFFFFFF_FFFFFFFF, 0x00000000_00000001, 0x30000000_00000000) == true
; run: %icmp_of_i128(0, 0) == false
; run: %icmp_of_i128(0, 1) == false
; run: %icmp_of_i128(0, -1) == false
; run: %icmp_of_i128(-1, -1) == false
; run: %icmp_of_i128(0x80000000_00000000_00000000_00000000, 0) == false
; run: %icmp_of_i128(0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0) == false
; run: %icmp_of_i128(1, 0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == true
; run: %icmp_of_i128(0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 1) == true
; run: %icmp_of_i128(0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0x80000000_00000000_00000000_00000000) == false
; run: %icmp_of_i128(0x80000000_00000000_00000000_00000000, 0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == false
; run: %icmp_of_i128(0x4FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0x30000000_00000000_00000000_00000000) == false
; run: %icmp_of_i128(0x4FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0x30000000_00000000_00000000_00000001) == true
function %icmp_nof_i128(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = icmp.i128 nof v4, v5
return v6
function %icmp_nof_i128(i128, i128) -> b1 {
block0(v0: i128, v1: i128):
v2 = icmp.i128 nof v0, v1
return v2
}
; run: %icmp_nof_i128(0, 0, 0, 0) == true
; run: %icmp_nof_i128(0, 0, 1, 0) == true
; run: %icmp_nof_i128(0, 0, -1, -1) == true
; run: %icmp_nof_i128(-1, -1, -1, -1) == true
; run: %icmp_nof_i128(0x00000000_00000000, 0x80000000_00000000, 0, 0) == true
; run: %icmp_nof_i128(0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF, 0, 0) == true
; run: %icmp_nof_i128(1, 0, 0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF) == false
; run: %icmp_nof_i128(0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF, 1, 0) == false
; run: %icmp_nof_i128(0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF, 0x00000000_00000000, 0x80000000_00000000) == true
; run: %icmp_nof_i128(0x00000000_00000000, 0x80000000_00000000, 0xFFFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF) == true
; run: %icmp_nof_i128(0xFFFFFFFF_FFFFFFFF, 0x4FFFFFFF_FFFFFFFF, 0x00000000_00000000, 0x30000000_00000000) == true
; run: %icmp_nof_i128(0xFFFFFFFF_FFFFFFFF, 0x4FFFFFFF_FFFFFFFF, 0x00000000_00000001, 0x30000000_00000000) == false
; run: %icmp_nof_i128(0, 0) == true
; run: %icmp_nof_i128(0, 1) == true
; run: %icmp_nof_i128(0, -1) == true
; run: %icmp_nof_i128(-1, -1) == true
; run: %icmp_nof_i128(0x80000000_00000000_00000000_00000000, 0) == true
; run: %icmp_nof_i128(0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0) == true
; run: %icmp_nof_i128(1, 0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == false
; run: %icmp_nof_i128(0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 1) == false
; run: %icmp_nof_i128(0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0x80000000_00000000_00000000_00000000) == true
; run: %icmp_nof_i128(0x80000000_00000000_00000000_00000000, 0x7FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == true
; run: %icmp_nof_i128(0x4FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0x30000000_00000000_00000000_00000000) == true
; run: %icmp_nof_i128(0x4FFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0x30000000_00000000_00000000_00000001) == false

283
cranelift/filetests/filetests/runtests/i128-icmp.clif
View File

@@ -1,189 +1,168 @@
test interpret
test run
set enable_llvm_abi_extensions=true
target aarch64
target x86_64 machinst
; TODO: Cleanup these tests when we have native support for i128 immediates in CLIF's parser
function %icmp_eq_i128(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = icmp.i128 eq v4, v5
return v6
function %icmp_eq_i128(i128, i128) -> b1 {
block0(v0: i128, v1: i128):
v2 = icmp.i128 eq v0, v1
return v2
}
; run: %icmp_eq_i128(0, 0, 0, 0) == true
; run: %icmp_eq_i128(-1, -1, -1, -1) == true
; run: %icmp_eq_i128(-1, -1, 0, 0) == false
; run: %icmp_eq_i128(-1, -1, 0, -1) == false
; run: %icmp_eq_i128(-1, 0, -1, -1) == false
; run: %icmp_eq_i128(0, -1, -1, -1) == false
; run: %icmp_eq_i128(0xC0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE, 0xC0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE) == true
; run: %icmp_eq_i128(0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF, 0x00000000_00000001, 0x00000000_00000001) == false
; run: %icmp_eq_i128(0xFFFFFFFF_FFFFFFFF, 0x00000000_00000001, 0x00000000_00000001, 0x00000000_00000001) == false
; run: %icmp_eq_i128(0, 0) == true
; run: %icmp_eq_i128(-1, -1) == true
; run: %icmp_eq_i128(-1, 0) == false
; run: %icmp_eq_i128(-1, 0x00000000_00000000_FFFFFFFF_FFFFFFFF) == false
; run: %icmp_eq_i128(0x00000000_00000000_FFFFFFFF_FFFFFFFF, -1) == false
; run: %icmp_eq_i128(0xFFFFFFFF_FFFFFFFF_00000000_00000000, -1) == false
; run: %icmp_eq_i128(0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF) == true
; run: %icmp_eq_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0x00000000_00000001_00000000_00000001) == false
; run: %icmp_eq_i128(0x00000000_00000001_FFFFFFFF_FFFFFFFF, 0x00000000_00000001_00000000_00000001) == false
function %icmp_ne_i128(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = icmp.i128 ne v4, v5
return v6
function %icmp_ne_i128(i128, i128) -> b1 {
block0(v0: i128, v1: i128):
v2 = icmp.i128 ne v0, v1
return v2
}
; run: %icmp_ne_i128(0, 0, 0, 0) == false
; run: %icmp_ne_i128(-1, -1, -1, -1) == false
; run: %icmp_ne_i128(-1, -1, 0, 0) == true
; run: %icmp_ne_i128(-1, -1, 0, -1) == true
; run: %icmp_ne_i128(-1, 0, -1, -1) == true
; run: %icmp_ne_i128(0, -1, -1, -1) == true
; run: %icmp_ne_i128(0xC0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE, 0xC0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE) == false
; run: %icmp_ne_i128(0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF, 0x00000000_00000001, 0x00000000_00000001) == true
; run: %icmp_ne_i128(0xFFFFFFFF_FFFFFFFF, 0x00000000_00000001, 0x00000000_00000001, 0x00000000_00000001) == true
; run: %icmp_ne_i128(0, 0) == false
; run: %icmp_ne_i128(-1, -1) == false
; run: %icmp_ne_i128(-1, 0) == true
; run: %icmp_ne_i128(-1, 0x00000000_00000000_FFFFFFFF_FFFFFF) == true
; run: %icmp_ne_i128(0x00000000_00000000_FFFFFFFF_FFFFFFFF, -1) == true
; run: %icmp_ne_i128(0xFFFFFFFF_FFFFFFFF_00000000_00000000, -1) == true
; run: %icmp_ne_i128(0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF) == false
; run: %icmp_ne_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0x00000000_00000001_00000000_00000001) == true
; run: %icmp_ne_i128(0x00000000_00000001_FFFFFFFF_FFFFFFFF, 0x00000000_00000001_00000000_00000001) == true
function %icmp_slt_i128(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = icmp.i128 slt v4, v5
return v6
function %icmp_slt_i128(i128, i128) -> b1 {
block0(v0: i128, v1: i128):
v2 = icmp.i128 slt v0, v1
return v2
}
; run: %icmp_slt_i128(0, 0, 0, 0) == false
; run: %icmp_slt_i128(1, 0, 1, 0) == false
; run: %icmp_slt_i128(0, 0, 1, 0) == true
; run: %icmp_slt_i128(-1, -1, 0, 0) == true
; run: %icmp_slt_i128(0, 0, -1, -1) == false
; run: %icmp_slt_i128(-1, -1, -1, -1) == false
; run: %icmp_slt_i128(0xFFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == true
; run: %icmp_slt_i128(0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE, 0x00000000_00000000, 0xDECAFFFF_DECAFFFF) == true
; run: %icmp_slt_i128(0x00000000_00000000, 0xDECAFFFF_DECAFFFF, 0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE) == false
; run: %icmp_slt_i128(0, 0) == false
; run: %icmp_slt_i128(1, 1) == false
; run: %icmp_slt_i128(0, 1) == true
; run: %icmp_slt_i128(-1, 0) == true
; run: %icmp_slt_i128(0, -1) == false
; run: %icmp_slt_i128(-1, -1) == false
; run: %icmp_slt_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == true
; run: %icmp_slt_i128(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == true
; run: %icmp_slt_i128(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == false
function %icmp_ult_i128(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = icmp.i128 ult v4, v5
return v6
function %icmp_ult_i128(i128, i128) -> b1 {
block0(v0: i128, v1: i128):
v2 = icmp.i128 ult v0, v1
return v2
}
; run: %icmp_ult_i128(0, 0, 0, 0) == false
; run: %icmp_ult_i128(1, 0, 1, 0) == false
; run: %icmp_ult_i128(0, 0, 1, 0) == true
; run: %icmp_ult_i128(-1, -1, 0, 0) == false
; run: %icmp_ult_i128(0, 0, -1, -1) == true
; run: %icmp_ult_i128(-1, -1, -1, -1) == false
; run: %icmp_ult_i128(0xFFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == true
; run: %icmp_ult_i128(0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE, 0x00000000_00000000, 0xDECAFFFF_DECAFFFF) == true
; run: %icmp_ult_i128(0x00000000_00000000, 0xDECAFFFF_DECAFFFF, 0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE) == false
; run: %icmp_ult_i128(0, 0) == false
; run: %icmp_ult_i128(1, 1) == false
; run: %icmp_ult_i128(0, 1) == true
; run: %icmp_ult_i128(-1, 0) == false
; run: %icmp_ult_i128(0, -1) == true
; run: %icmp_ult_i128(-1, -1) == false
; run: %icmp_ult_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == true
; run: %icmp_ult_i128(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == true
; run: %icmp_ult_i128(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == false
function %icmp_sle_i128(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = icmp.i128 sle v4, v5
return v6
function %icmp_sle_i128(i128, i128) -> b1 {
block0(v0: i128, v1: i128):
v2 = icmp.i128 sle v0, v1
return v2
}
; run: %icmp_sle_i128(0, 0, 0, 0) == true
; run: %icmp_sle_i128(1, 0, 1, 0) == true
; run: %icmp_sle_i128(0, 0, 1, 0) == true
; run: %icmp_sle_i128(-1, -1, 0, 0) == true
; run: %icmp_sle_i128(0, 0, -1, -1) == false
; run: %icmp_sle_i128(-1, -1, -1, -1) == true
; run: %icmp_sle_i128(0xFFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == true
; run: %icmp_sle_i128(0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE, 0x00000000_00000000, 0xDECAFFFF_DECAFFFF) == true
; run: %icmp_sle_i128(0x00000000_00000000, 0xDECAFFFF_DECAFFFF, 0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE) == false
; run: %icmp_sle_i128(0, 0) == true
; run: %icmp_sle_i128(1, 1) == true
; run: %icmp_sle_i128(0, 1) == true
; run: %icmp_sle_i128(-1, 0) == true
; run: %icmp_sle_i128(0, -1) == false
; run: %icmp_sle_i128(-1, -1) == true
; run: %icmp_sle_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == true
; run: %icmp_sle_i128(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == true
; run: %icmp_sle_i128(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == false
function %icmp_ule_i128(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = icmp.i128 ule v4, v5
return v6
function %icmp_ule_i128(i128, i128) -> b1 {
block0(v0: i128, v1: i128):
v2 = icmp.i128 ule v0, v1
return v2
}
; run: %icmp_ule_i128(0, 0, 0, 0) == true
; run: %icmp_ule_i128(1, 0, 1, 0) == true
; run: %icmp_ule_i128(0, 0, 1, 0) == true
; run: %icmp_ule_i128(-1, -1, 0, 0) == false
; run: %icmp_ule_i128(0, 0, -1, -1) == true
; run: %icmp_ule_i128(-1, -1, -1, -1) == true
; run: %icmp_ule_i128(0xFFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == true
; run: %icmp_ule_i128(0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE, 0x00000000_00000000, 0xDECAFFFF_DECAFFFF) == true
; run: %icmp_ule_i128(0x00000000_00000000, 0xDECAFFFF_DECAFFFF, 0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE) == false
; run: %icmp_ule_i128(0, 0) == true
; run: %icmp_ule_i128(1, 1) == true
; run: %icmp_ule_i128(0, 1) == true
; run: %icmp_ule_i128(-1, 0) == false
; run: %icmp_ule_i128(0, -1) == true
; run: %icmp_ule_i128(-1, -1) == true
; run: %icmp_ule_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == true
; run: %icmp_ule_i128(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == true
; run: %icmp_ule_i128(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == false
function %icmp_sgt_i128(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = icmp.i128 sgt v4, v5
return v6
function %icmp_sgt_i128(i128, i128) -> b1 {
block0(v0: i128, v1: i128):
v2 = icmp.i128 sgt v0, v1
return v2
}
; run: %icmp_sgt_i128(0, 0, 0, 0) == false
; run: %icmp_sgt_i128(1, 0, 1, 0) == false
; run: %icmp_sgt_i128(0, 0, 1, 0) == false
; run: %icmp_sgt_i128(-1, -1, 0, 0) == false
; run: %icmp_sgt_i128(0, 0, -1, -1) == true
; run: %icmp_sgt_i128(-1, -1, -1, -1) == false
; run: %icmp_sgt_i128(0xFFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == false
; run: %icmp_sgt_i128(0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE, 0x00000000_00000000, 0xDECAFFFF_DECAFFFF) == false
; run: %icmp_sgt_i128(0x00000000_00000000, 0xDECAFFFF_DECAFFFF, 0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE) == true
; run: %icmp_sgt_i128(0, 0) == false
; run: %icmp_sgt_i128(1, 1) == false
; run: %icmp_sgt_i128(0, 1) == false
; run: %icmp_sgt_i128(-1, 0) == false
; run: %icmp_sgt_i128(0, -1) == true
; run: %icmp_sgt_i128(-1, -1) == false
; run: %icmp_sgt_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == false
; run: %icmp_sgt_i128(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == false
; run: %icmp_sgt_i128(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == true
function %icmp_ugt_i128(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = icmp.i128 ugt v4, v5
return v6
function %icmp_ugt_i128(i128, i128) -> b1 {
block0(v0: i128, v1: i128):
v2 = icmp.i128 ugt v0, v1
return v2
}
; run: %icmp_ugt_i128(0, 0, 0, 0) == false
; run: %icmp_ugt_i128(1, 0, 1, 0) == false
; run: %icmp_ugt_i128(0, 0, 1, 0) == false
; run: %icmp_ugt_i128(-1, -1, 0, 0) == true
; run: %icmp_ugt_i128(0, 0, -1, -1) == false
; run: %icmp_ugt_i128(-1, -1, -1, -1) == false
; run: %icmp_ugt_i128(0xFFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == false
; run: %icmp_ugt_i128(0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE, 0x00000000_00000000, 0xDECAFFFF_DECAFFFF) == false
; run: %icmp_ugt_i128(0x00000000_00000000, 0xDECAFFFF_DECAFFFF, 0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE) == true
; run: %icmp_ugt_i128(0, 0) == false
; run: %icmp_ugt_i128(1, 1) == false
; run: %icmp_ugt_i128(0, 1) == false
; run: %icmp_ugt_i128(-1, 0) == true
; run: %icmp_ugt_i128(0, -1) == false
; run: %icmp_ugt_i128(-1, -1) == false
; run: %icmp_ugt_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == false
; run: %icmp_ugt_i128(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == false
; run: %icmp_ugt_i128(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == true
function %icmp_sge_i128(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = icmp.i128 sge v4, v5
return v6
function %icmp_sge_i128(i128, i128) -> b1 {
block0(v0: i128, v1: i128):
v2 = icmp.i128 sge v0, v1
return v2
}
; run: %icmp_sge_i128(0, 0, 0, 0) == true
; run: %icmp_sge_i128(1, 0, 1, 0) == true
; run: %icmp_sge_i128(0, 0, 1, 0) == false
; run: %icmp_sge_i128(-1, -1, 0, 0) == false
; run: %icmp_sge_i128(0, 0, -1, -1) == true
; run: %icmp_sge_i128(-1, -1, -1, -1) == true
; run: %icmp_sge_i128(0xFFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == false
; run: %icmp_sge_i128(0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE, 0x00000000_00000000, 0xDECAFFFF_DECAFFFF) == false
; run: %icmp_sge_i128(0x00000000_00000000, 0xDECAFFFF_DECAFFFF, 0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE) == true
; run: %icmp_sge_i128(0, 0) == true
; run: %icmp_sge_i128(1, 1) == true
; run: %icmp_sge_i128(0, 1) == false
; run: %icmp_sge_i128(-1, 0) == false
; run: %icmp_sge_i128(0, -1) == true
; run: %icmp_sge_i128(-1, -1) == true
; run: %icmp_sge_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == false
; run: %icmp_sge_i128(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == false
; run: %icmp_sge_i128(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == true
function %icmp_uge_i128(i64, i64, i64, i64) -> b1 {
block0(v0: i64,v1: i64,v2: i64,v3: i64):
v4 = iconcat v0, v1
v5 = iconcat v2, v3
v6 = icmp.i128 uge v4, v5
return v6
function %icmp_uge_i128(i128, i128) -> b1 {
block0(v0: i128, v1: i128):
v2 = icmp.i128 uge v0, v1
return v2
}
; run: %icmp_uge_i128(0, 0, 0, 0) == true
; run: %icmp_uge_i128(1, 0, 1, 0) == true
; run: %icmp_uge_i128(0, 0, 1, 0) == false
; run: %icmp_uge_i128(-1, -1, 0, 0) == true
; run: %icmp_uge_i128(0, 0, -1, -1) == false
; run: %icmp_uge_i128(-1, -1, -1, -1) == true
; run: %icmp_uge_i128(0xFFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == false
; run: %icmp_uge_i128(0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE, 0x00000000_00000000, 0xDECAFFFF_DECAFFFF) == false
; run: %icmp_uge_i128(0x00000000_00000000, 0xDECAFFFF_DECAFFFF, 0x00000000_00000000, 0xC0FFEEEE_C0FFEEEE) == true
; run: %icmp_uge_i128(0, 0) == true
; run: %icmp_uge_i128(1, 1) == true
; run: %icmp_uge_i128(0, 1) == false
; run: %icmp_uge_i128(-1, 0) == true
; run: %icmp_uge_i128(0, -1) == false
; run: %icmp_uge_i128(-1, -1) == true
; run: %icmp_uge_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == false
; run: %icmp_uge_i128(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == false
; run: %icmp_uge_i128(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == true
; Icmp Imm Tests

173
cranelift/filetests/filetests/runtests/i128-load-store.clif
View File

@@ -1,136 +1,125 @@
test run
set enable_llvm_abi_extensions=true
target x86_64 machinst
target aarch64
function %i128_stack_store_load(i64, i64) -> b1 {
function %i128_stack_store_load(i128) -> b1 {
ss0 = explicit_slot 16
block0(v0: i64,v1: i64):
v2 = iconcat v0, v1
block0(v0: i128):
stack_store.i128 v0, ss0
v1 = stack_load.i128 ss0
stack_store.i128 v2, ss0
v3 = stack_load.i128 ss0
v4 = icmp.i128 eq v2, v3
return v4
v2 = icmp.i128 eq v0, v1
return v2
}
; run: %i128_stack_store_load(0, 0) == true
; run: %i128_stack_store_load(-1, -1) == true
; run: %i128_stack_store_load(-1, 0) == true
; run: %i128_stack_store_load(0, -1) == true
; run: %i128_stack_store_load(0x01234567_89ABCDEF, 0xFEDCBA98_76543210) == true
; run: %i128_stack_store_load(0x06060606_06060606, 0xA00A00A0_0A00A00A) == true
; run: %i128_stack_store_load(0xC0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE) == true
; run: %i128_stack_store_load(0) == true
; run: %i128_stack_store_load(-1) == true
; run: %i128_stack_store_load(0x00000000_00000000_FFFFFFFF_FFFFFFFF) == true
; run: %i128_stack_store_load(0xFFFFFFFF_FFFFFFFF_00000000_00000000) == true
; run: %i128_stack_store_load(0xFEDCBA98_76543210_01234567_89ABCDEF) == true
; run: %i128_stack_store_load(0xA00A00A0_0A00A00A_06060606_06060606) == true
; run: %i128_stack_store_load(0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF) == true
function %i128_stack_store_load_offset(i64, i64) -> b1 {
function %i128_stack_store_load_offset(i128) -> b1 {
ss0 = explicit_slot 16, offset 16
block0(v0: i64,v1: i64):
v2 = iconcat v0, v1
block0(v0: i128):
stack_store.i128 v0, ss0
v1 = stack_load.i128 ss0
stack_store.i128 v2, ss0
v3 = stack_load.i128 ss0
v4 = icmp.i128 eq v2, v3
return v4
v2 = icmp.i128 eq v0, v1
return v2
}
; run: %i128_stack_store_load_offset(0, 0) == true
; run: %i128_stack_store_load_offset(-1, -1) == true
; run: %i128_stack_store_load_offset(-1, 0) == true
; run: %i128_stack_store_load_offset(0, -1) == true
; run: %i128_stack_store_load_offset(0x01234567_89ABCDEF, 0xFEDCBA98_76543210) == true
; run: %i128_stack_store_load_offset(0x06060606_06060606, 0xA00A00A0_0A00A00A) == true
; run: %i128_stack_store_load_offset(0xC0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE) == true
; run: %i128_stack_store_load_offset(0) == true
; run: %i128_stack_store_load_offset(-1) == true
; run: %i128_stack_store_load_offset(0x00000000_00000000_FFFFFFFF_FFFFFFFF) == true
; run: %i128_stack_store_load_offset(0xFFFFFFFF_FFFFFFFF_00000000_00000000) == true
; run: %i128_stack_store_load_offset(0xFEDCBA98_76543210_01234567_89ABCDEF) == true
; run: %i128_stack_store_load_offset(0xA00A00A0_0A00A00A_06060606_06060606) == true
; run: %i128_stack_store_load_offset(0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF) == true
function %i128_stack_store_load_inst_offset(i64, i64) -> b1 {
function %i128_stack_store_load_inst_offset(i128) -> b1 {
ss0 = explicit_slot 16
ss1 = explicit_slot 16
ss2 = explicit_slot 16
block0(v0: i64,v1: i64):
v2 = iconcat v0, v1
block0(v0: i128):
stack_store.i128 v0, ss1+16
v1 = stack_load.i128 ss1+16
stack_store.i128 v2, ss1+16
v3 = stack_load.i128 ss1+16
v4 = icmp.i128 eq v2, v3
return v4
v2 = icmp.i128 eq v0, v1
return v2
}
; run: %i128_stack_store_load_inst_offset(0, 0) == true
; run: %i128_stack_store_load_inst_offset(-1, -1) == true
; run: %i128_stack_store_load_inst_offset(-1, 0) == true
; run: %i128_stack_store_load_inst_offset(0, -1) == true
; run: %i128_stack_store_load_inst_offset(0x01234567_89ABCDEF, 0xFEDCBA98_76543210) == true
; run: %i128_stack_store_load_inst_offset(0x06060606_06060606, 0xA00A00A0_0A00A00A) == true
; run: %i128_stack_store_load_inst_offset(0xC0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE) == true
; run: %i128_stack_store_load_inst_offset(0) == true
; run: %i128_stack_store_load_inst_offset(-1) == true
; run: %i128_stack_store_load_inst_offset(0x00000000_00000000_FFFFFFFF_FFFFFFFF) == true
; run: %i128_stack_store_load_inst_offset(0xFFFFFFFF_FFFFFFFF_00000000_00000000) == true
; run: %i128_stack_store_load_inst_offset(0xFEDCBA98_76543210_01234567_89ABCDEF) == true
; run: %i128_stack_store_load_inst_offset(0xA00A00A0_0A00A00A_06060606_06060606) == true
; run: %i128_stack_store_load_inst_offset(0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF) == true
; Some arches (aarch64) try to encode the offset into the load/store instructions
; test that we spill if the offset is too large and doesn't fit in the instruction
function %i128_stack_store_load_big_offset(i64, i64) -> b1 {
function %i128_stack_store_load_big_offset(i128) -> b1 {
ss0 = explicit_slot 100000
ss1 = explicit_slot 8
block0(v0: i64,v1: i64):
v2 = iconcat v0, v1
block0(v0: i128):
stack_store.i128 v0, ss0
v1 = stack_load.i128 ss0
stack_store.i128 v2, ss0
v3 = stack_load.i128 ss0
v4 = icmp.i128 eq v2, v3
return v4
v2 = icmp.i128 eq v0, v1
return v2
}
; run: %i128_stack_store_load_big_offset(0, 0) == true
; run: %i128_stack_store_load_big_offset(-1, -1) == true
; run: %i128_stack_store_load_big_offset(-1, 0) == true
; run: %i128_stack_store_load_big_offset(0, -1) == true
; run: %i128_stack_store_load_big_offset(0x01234567_89ABCDEF, 0xFEDCBA98_76543210) == true
; run: %i128_stack_store_load_big_offset(0x06060606_06060606, 0xA00A00A0_0A00A00A) == true
; run: %i128_stack_store_load_big_offset(0xC0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE) == true
; run: %i128_stack_store_load_big_offset(0) == true
; run: %i128_stack_store_load_big_offset(-1) == true
; run: %i128_stack_store_load_big_offset(0x00000000_00000000_FFFFFFFF_FFFFFFFF) == true
; run: %i128_stack_store_load_big_offset(0xFFFFFFFF_FFFFFFFF_00000000_00000000) == true
; run: %i128_stack_store_load_big_offset(0xFEDCBA98_76543210_01234567_89ABCDEF) == true
; run: %i128_stack_store_load_big_offset(0xA00A00A0_0A00A00A_06060606_06060606) == true
; run: %i128_stack_store_load_big_offset(0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF) == true
function %i128_store_load(i64, i64) -> b1 {
function %i128_store_load(i128) -> b1 {
ss0 = explicit_slot 16
block0(v0: i64,v1: i64):
v2 = iconcat v0, v1
block0(v0: i128):
v1 = stack_addr.i64 ss0
store.i128 v0, v1
v2 = load.i128 v1
v3 = stack_addr.i64 ss0
store.i128 v2, v3
v4 = load.i128 v3
v5 = icmp.i128 eq v2, v4
return v5
v3 = icmp.i128 eq v0, v2
return v3
}
; run: %i128_store_load(0, 0) == true
; run: %i128_store_load(-1, -1) == true
; run: %i128_store_load(-1, 0) == true
; run: %i128_store_load(0, -1) == true
; run: %i128_store_load(0x01234567_89ABCDEF, 0xFEDCBA98_76543210) == true
; run: %i128_store_load(0x06060606_06060606, 0xA00A00A0_0A00A00A) == true
; run: %i128_store_load(0xC0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE) == true
; run: %i128_store_load(0) == true
; run: %i128_store_load(-1) == true
; run: %i128_store_load(0x00000000_00000000_FFFFFFFF_FFFFFFFF) == true
; run: %i128_store_load(0xFFFFFFFF_FFFFFFFF_00000000_00000000) == true
; run: %i128_store_load(0xFEDCBA98_76543210_01234567_89ABCDEF) == true
; run: %i128_store_load(0xA00A00A0_0A00A00A_06060606_06060606) == true
; run: %i128_store_load(0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF) == true
function %i128_store_load_offset(i64, i64) -> b1 {
function %i128_store_load_offset(i128) -> b1 {
ss0 = explicit_slot 32
block0(v0: i64,v1: i64):
v2 = iconcat v0, v1
block0(v0: i128):
v1 = stack_addr.i64 ss0
store.i128 v0, v1+16
v2 = load.i128 v1+16
v3 = stack_addr.i64 ss0
store.i128 v2, v3+16
v4 = load.i128 v3+16
v5 = icmp.i128 eq v2, v4
return v5
v3 = icmp.i128 eq v0, v2
return v3
}
; run: %i128_store_load_offset(0, 0) == true
; run: %i128_store_load_offset(-1, -1) == true
; run: %i128_store_load_offset(-1, 0) == true
; run: %i128_store_load_offset(0, -1) == true
; run: %i128_store_load_offset(0x01234567_89ABCDEF, 0xFEDCBA98_76543210) == true
; run: %i128_store_load_offset(0x06060606_06060606, 0xA00A00A0_0A00A00A) == true
; run: %i128_store_load_offset(0xC0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE) == true
; run: %i128_store_load_offset(0) == true
; run: %i128_store_load_offset(-1) == true
; run: %i128_store_load_offset(0x00000000_00000000_FFFFFFFF_FFFFFFFF) == true
; run: %i128_store_load_offset(0xFFFFFFFF_FFFFFFFF_00000000_00000000) == true
; run: %i128_store_load_offset(0xFEDCBA98_76543210_01234567_89ABCDEF) == true
; run: %i128_store_load_offset(0xA00A00A0_0A00A00A_06060606_06060606) == true
; run: %i128_store_load_offset(0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF) == true

61
cranelift/filetests/filetests/runtests/i128-reduce.clif
View File

@@ -1,43 +1,40 @@
test run
set enable_llvm_abi_extensions=true
target aarch64
target x86_64 machinst
function %ireduce_128_64(i64, i64) -> i64 {
block0(v0: i64, v1: i64):
v2 = iconcat v0, v1
v3 = ireduce.i64 v2
return v3
function %ireduce_128_64(i128) -> i64 {
block0(v0: i128):
v1 = ireduce.i64 v0
return v1
}
; run: %ireduce_128_64(0, 0) == 0
; run: %ireduce_128_64(-1, -1) == -1
; run: %ireduce_128_64(0xC0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE) == 0xC0FFEEEE_DECAFFFF
; run: %ireduce_128_64(0) == 0
; run: %ireduce_128_64(-1) == -1
; run: %ireduce_128_64(0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF) == 0xC0FFEEEE_DECAFFFF
function %ireduce_128_32(i64, i64) -> i32 {
block0(v0: i64, v1: i64):
v2 = iconcat v0, v1
v3 = ireduce.i32 v2
return v3
function %ireduce_128_32(i128) -> i32 {
block0(v0: i128):
v1 = ireduce.i32 v0
return v1
}
; run: %ireduce_128_32(0, 0) == 0
; run: %ireduce_128_32(-1, -1) == -1
; run: %ireduce_128_32(0xC0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE) == 0xDECAFFFF
; run: %ireduce_128_32(0) == 0
; run: %ireduce_128_32(-1) == -1
; run: %ireduce_128_32(0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF) == 0xDECAFFFF
function %ireduce_128_16(i64, i64) -> i16 {
block0(v0: i64, v1: i64):
v2 = iconcat v0, v1
v3 = ireduce.i16 v2
return v3
function %ireduce_128_16(i128) -> i16 {
block0(v0: i128):
v1 = ireduce.i16 v0
return v1
}
; run: %ireduce_128_16(0, 0) == 0
; run: %ireduce_128_16(-1, -1) == -1
; run: %ireduce_128_16(0xC0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE) == 0xFFFF
; run: %ireduce_128_16(0) == 0
; run: %ireduce_128_16(-1) == -1
; run: %ireduce_128_16(0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF) == 0xFFFF
function %ireduce_128_8(i64, i64) -> i8 {
block0(v0: i64, v1: i64):
v2 = iconcat v0, v1
v3 = ireduce.i8 v2
return v3
function %ireduce_128_8(i128) -> i8 {
block0(v0: i128):
v1 = ireduce.i8 v0
return v1
}
; run: %ireduce_128_8(0, 0) == 0
; run: %ireduce_128_8(-1, -1) == -1
; run: %ireduce_128_8(0xC0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE) == 0xFF
; run: %ireduce_128_8(0) == 0
; run: %ireduce_128_8(-1) == -1
; run: %ireduce_128_8(0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF) == 0xFF

83
cranelift/filetests/filetests/runtests/i128-rotate.clif
View File

@@ -1,60 +1,51 @@
test run
set enable_llvm_abi_extensions=true
target aarch64
; target s390x TODO: Not yet implemented on s390x
target x86_64 machinst
function %rotl(i64, i64, i8) -> i64, i64 {
block0(v0: i64, v1: i64, v2: i8):
v3 = iconcat v0, v1
v4 = rotl.i128 v3, v2
v5, v6 = isplit v4
return v5, v6
function %rotl(i128, i8) -> i128 {
block0(v0: i128, v1: i8):
v2 = rotl.i128 v0, v1
return v2
}
; run: %rotl(0x01010101_01010101, 0x01010101_01010101, 9) == [0x02020202_02020202, 0x02020202_02020202]
; run: %rotl(0x01010101_01010101, 0x01010101_01010101, 73) == [0x02020202_02020202, 0x02020202_02020202]
; run: %rotl(0x01010101_01010101, 0x02020202_02020202, 0) == [0x01010101_01010101, 0x02020202_02020202]
; run: %rotl(0x01010101_01010101, 0x03030303_03030303, 128) == [0x01010101_01010101, 0x03030303_03030303]
; run: %rotl(0x01010101_01010101_01010101_01010101, 9) == 0x02020202_02020202_02020202_02020202
; run: %rotl(0x01010101_01010101_01010101_01010101, 73) == 0x02020202_02020202_02020202_02020202
; run: %rotl(0x02020202_02020202_01010101_01010101, 0) == 0x02020202_02020202_01010101_01010101
; run: %rotl(0x03030303_03030303_01010101_01010101, 128) == 0x03030303_03030303_01010101_01010101
function %rotr(i64, i64, i8) -> i64, i64 {
block0(v0: i64, v1: i64, v2: i8):
v3 = iconcat v0, v1
v4 = rotr.i128 v3, v2
v5, v6 = isplit v4
return v5, v6
function %rotr(i128, i8) -> i128 {
block0(v0: i128, v1: i8):
v2 = rotr.i128 v0, v1
return v2
}
; run: %rotr(0x01010101_01010101, 0x01010101_01010101, 9) == [0x80808080_80808080, 0x80808080_80808080]
; run: %rotr(0x01010101_01010101, 0x01010101_01010101, 73) == [0x80808080_80808080, 0x80808080_80808080]
; run: %rotr(0x01010101_01010101, 0x02020202_02020202, 0) == [0x01010101_01010101, 0x02020202_02020202]
; run: %rotr(0x01010101_01010101, 0x03030303_03030303, 128) == [0x01010101_01010101, 0x03030303_03030303]
; run: %rotr(0x01010101_01010101_01010101_01010101, 9) == 0x80808080_80808080_80808080_80808080
; run: %rotr(0x01010101_01010101_01010101_01010101, 73) == 0x80808080_80808080_80808080_80808080
; run: %rotr(0x02020202_02020202_01010101_01010101, 0) == 0x02020202_02020202_01010101_01010101
; run: %rotr(0x03030303_03030303_01010101_01010101, 128) == 0x03030303_03030303_01010101_01010101
function %rotl_amt_i128(i64, i64, i8) -> i64, i64 {
block0(v0: i64, v1: i64, v2: i8):
v3 = uextend.i64 v2
v4 = iconcat v3, v3
function %rotl_amt_i128(i128, i8) -> i128 {
block0(v0: i128, v1: i8):
v2 = uextend.i64 v1
v3 = iconcat v2, v2
v5 = iconcat v0, v1
v6 = rotl.i128 v5, v4
v7, v8 = isplit v6
return v7, v8
v4 = rotl.i128 v0, v3
return v4
}
; run: %rotl_amt_i128(0x01010101_01010101, 0x01010101_01010101, 9) == [0x02020202_02020202, 0x02020202_02020202]
; run: %rotl_amt_i128(0x01010101_01010101, 0x01010101_01010101, 73) == [0x02020202_02020202, 0x02020202_02020202]
; run: %rotl_amt_i128(0x01010101_01010101, 0x02020202_02020202, 0) == [0x01010101_01010101, 0x02020202_02020202]
; run: %rotl_amt_i128(0x01010101_01010101, 0x03030303_03030303, 128) == [0x01010101_01010101, 0x03030303_03030303]
; run: %rotl_amt_i128(0x01010101_01010101_01010101_01010101, 9) == 0x02020202_02020202_02020202_02020202
; run: %rotl_amt_i128(0x01010101_01010101_01010101_01010101, 73) == 0x02020202_02020202_02020202_02020202
; run: %rotl_amt_i128(0x02020202_02020202_01010101_01010101, 0) == 0x02020202_02020202_01010101_01010101
; run: %rotl_amt_i128(0x03030303_03030303_01010101_01010101, 128) == 0x03030303_03030303_01010101_01010101
function %rotr_amt_i128(i64, i64, i8) -> i64, i64 {
block0(v0: i64, v1: i64, v2: i8):
v3 = uextend.i64 v2
v4 = iconcat v3, v3
v5 = iconcat v0, v1
function %rotr_amt_i128(i128, i8) -> i128 {
block0(v0: i128, v1: i8):
v2 = uextend.i64 v1
v3 = iconcat v2, v2
v6 = rotr.i128 v5, v4
v7, v8 = isplit v6
return v7, v8
v4 = rotr.i128 v0, v3
return v4
}
; run: %rotr_amt_i128(0x01010101_01010101, 0x01010101_01010101, 9) == [0x80808080_80808080, 0x80808080_80808080]
; run: %rotr_amt_i128(0x01010101_01010101, 0x01010101_01010101, 73) == [0x80808080_80808080, 0x80808080_80808080]
; run: %rotr_amt_i128(0x01010101_01010101, 0x02020202_02020202, 0) == [0x01010101_01010101, 0x02020202_02020202]
; run: %rotr_amt_i128(0x01010101_01010101, 0x03030303_03030303, 128) == [0x01010101_01010101, 0x03030303_03030303]
; run: %rotr_amt_i128(0x01010101_01010101_01010101_01010101, 9) == 0x80808080_80808080_80808080_80808080
; run: %rotr_amt_i128(0x01010101_01010101_01010101_01010101, 73) == 0x80808080_80808080_80808080_80808080
; run: %rotr_amt_i128(0x02020202_02020202_01010101_01010101, 0) == 0x02020202_02020202_01010101_01010101
; run: %rotr_amt_i128(0x03030303_03030303_01010101_01010101, 128) == 0x03030303_03030303_01010101_01010101

24
cranelift/filetests/filetests/runtests/i128-select.clif
View File

@@ -1,21 +1,15 @@
test run
set enable_llvm_abi_extensions=true
target aarch64
target x86_64 machinst
function %i128_select(i8, i64, i64, i64, i64) -> i64, i64 {
block0(v0: i8, v1: i64, v2: i64, v3: i64, v4: i64):
v5 = icmp_imm ne v0, 0
v6 = iconcat v1, v2
v7 = iconcat v3, v4
v8 = select.i128 v5, v6, v7
v9, v10 = isplit v8
return v9, v10
function %i128_select(b1, i128, i128) -> i128 {
block0(v0: b1, v1: i128, v2: i128):
v3 = select.i128 v0, v1, v2
return v3
}
; run: %i128_select(1, 0, 0, 1, 1) == [0, 0]
; run: %i128_select(0, 0, 0, 1, 1) == [1, 1]
; run: %i128_select(true, 0, 1) == 0
; run: %i128_select(false, 0, 1) == 1
; run: %i128_select(1, 1, 2, 3, 4) == [1, 2]
; run: %i128_select(0, 1, 2, 3, 4) == [3, 4]
; run: %i128_select(true, 0x00000000_00000000_DECAFFFF_C0FFEEEE, 0xFFFFFFFF_FFFFFFFF_C0FFEEEE_DECAFFFF) == 0x00000000_00000000_DECAFFFF_C0FFEEEE
; run: %i128_select(false, 0x00000000_00000000_DECAFFFF_C0FFEEEE, 0xFFFFFFFF_FFFFFFFF_C0FFEEEE_DECAFFFF) == 0xFFFFFFFF_FFFFFFFF_C0FFEEEE_DECAFFFF

138
cranelift/filetests/filetests/runtests/i128-shifts-small-types.clif
View File

@@ -3,88 +3,82 @@ target aarch64
; TODO: Merge this with the main i128-shifts file when x86_64 passes these.
function %ishl_i16_i128(i16, i64, i64) -> i16 {
block0(v0: i16, v1: i64, v2: i64):
v3 = iconcat v1, v2
v4 = ishl.i16 v0, v3
return v4
function %ishl_i16_i128(i16, i128) -> i16 {
block0(v0: i16, v1: i128):
v2 = ishl.i16 v0, v1
return v2
}
; run: %ishl_i16_i128(0x0000, 0, 0) == 0x0000
; run: %ishl_i16_i128(0x0000, 1, 0) == 0x0000
; run: %ishl_i16_i128(0x000f, 0, 4) == 0x000f
; run: %ishl_i16_i128(0x000f, 4, 0) == 0x00f0
; run: %ishl_i16_i128(0x0004, 16, 0) == 0x0004
; run: %ishl_i16_i128(0x0004, 17, 0) == 0x0008
; run: %ishl_i16_i128(0x0004, 18, 1) == 0x0010
; run: %ishl_i16_i128(0x0000, 0) == 0x0000
; run: %ishl_i16_i128(0x0000, 1) == 0x0000
; run: %ishl_i16_i128(0x000f, 4) == 0x00f0
; run: %ishl_i16_i128(0x0004, 16) == 0x0004
; run: %ishl_i16_i128(0x0004, 17) == 0x0008
; run: %ishl_i16_i128(0x000f, 0x00000000_00000004_00000000_00000000) == 0x000f
; run: %ishl_i16_i128(0x0004, 0x00000000_00000001_00000000_00000012) == 0x0010
function %ishl_i8_i128(i8, i64, i64) -> i8 {
block0(v0: i8, v1: i64, v2: i64):
v3 = iconcat v1, v2
v4 = ishl.i8 v0, v3
return v4
function %ishl_i8_i128(i8, i128) -> i8 {
block0(v0: i8, v1: i128):
v2 = ishl.i8 v0, v1
return v2
}
; run: %ishl_i8_i128(0x00, 0, 0) == 0x00
; run: %ishl_i8_i128(0x00, 1, 0) == 0x00
; run: %ishl_i8_i128(0x0f, 0, 4) == 0x0f
; run: %ishl_i8_i128(0x0f, 4, 0) == 0xf0
; run: %ishl_i8_i128(0x04, 8, 0) == 0x04
; run: %ishl_i8_i128(0x04, 9, 0) == 0x08
; run: %ishl_i8_i128(0x04, 10, 1) == 0x10
; run: %ishl_i8_i128(0x00, 0) == 0x00
; run: %ishl_i8_i128(0x00, 1) == 0x00
; run: %ishl_i8_i128(0x0f, 4) == 0xf0
; run: %ishl_i8_i128(0x04, 8) == 0x04
; run: %ishl_i8_i128(0x04, 9) == 0x08
; run: %ishl_i8_i128(0x0f, 0x00000000_00000004_00000000_00000000) == 0x0f
; run: %ishl_i8_i128(0x04, 0x00000000_00000001_00000000_0000000A) == 0x10
function %ushr_i16_i128(i16, i64, i64) -> i16 {
block0(v0: i16, v1: i64, v2: i64):
v3 = iconcat v1, v2
v4 = ushr.i16 v0, v3
return v4
function %ushr_i16_i128(i16, i128) -> i16 {
block0(v0: i16, v1: i128):
v2 = ushr.i16 v0, v1
return v2
}
; run: %ushr_i16_i128(0x1000, 0, 0) == 0x1000
; run: %ushr_i16_i128(0x1000, 1, 0) == 0x0800
; run: %ushr_i16_i128(0xf000, 0, 4) == 0xf000
; run: %ushr_i16_i128(0xf000, 4, 0) == 0x0f00
; run: %ushr_i16_i128(0x4000, 16, 0) == 0x4000
; run: %ushr_i16_i128(0x4000, 17, 0) == 0x2000
; run: %ushr_i16_i128(0x4000, 18, 1) == 0x1000
; run: %ushr_i16_i128(0x1000, 0) == 0x1000
; run: %ushr_i16_i128(0x1000, 1) == 0x0800
; run: %ushr_i16_i128(0xf000, 4) == 0x0f00
; run: %ushr_i16_i128(0x4000, 16) == 0x4000
; run: %ushr_i16_i128(0x4000, 17) == 0x2000
; run: %ushr_i16_i128(0xf000, 0x00000000_00000004_00000000_00000000) == 0xf000
; run: %ushr_i16_i128(0x4000, 0x00000000_00000001_00000000_00000012) == 0x1000
function %ushr_i8_i128(i8, i64, i64) -> i8 {
block0(v0: i8, v1: i64, v2: i64):
v3 = iconcat v1, v2
v4 = ushr.i8 v0, v3
return v4
function %ushr_i8_i128(i8, i128) -> i8 {
block0(v0: i8, v1: i128):
v2 = ushr.i8 v0, v1
return v2
}
; run: %ushr_i8_i128(0x10, 0, 0) == 0x10
; run: %ushr_i8_i128(0x10, 1, 0) == 0x08
; run: %ushr_i8_i128(0xf0, 0, 4) == 0xf0
; run: %ushr_i8_i128(0xf0, 4, 0) == 0x0f
; run: %ushr_i8_i128(0x40, 8, 0) == 0x40
; run: %ushr_i8_i128(0x40, 9, 0) == 0x20
; run: %ushr_i8_i128(0x40, 10, 1) == 0x10
; run: %ushr_i8_i128(0x10, 0) == 0x10
; run: %ushr_i8_i128(0x10, 1) == 0x08
; run: %ushr_i8_i128(0xf0, 4) == 0x0f
; run: %ushr_i8_i128(0x40, 8) == 0x40
; run: %ushr_i8_i128(0x40, 9) == 0x20
; run: %ushr_i8_i128(0xf0, 0x00000000_00000004_00000000_00000000) == 0xf0
; run: %ushr_i8_i128(0x40, 0x00000000_00000001_00000000_0000000A) == 0x10
function %sshr_i16_i128(i16, i64, i64) -> i16 {
block0(v0: i16, v1: i64, v2: i64):
v3 = iconcat v1, v2
v4 = sshr.i16 v0, v3
return v4
function %sshr_i16_i128(i16, i128) -> i16 {
block0(v0: i16, v1: i128):
v2 = sshr.i16 v0, v1
return v2
}
; run: %sshr_i16_i128(0x8000, 0, 0) == 0x8000
; run: %sshr_i16_i128(0x8000, 1, 0) == 0xC000
; run: %sshr_i16_i128(0xf000, 0, 4) == 0xf000
; run: %sshr_i16_i128(0xf000, 4, 0) == 0xff00
; run: %sshr_i16_i128(0x4000, 16, 0) == 0x4000
; run: %sshr_i16_i128(0x4000, 17, 0) == 0x2000
; run: %sshr_i16_i128(0x4000, 18, 1) == 0x1000
; run: %sshr_i16_i128(0x8000, 0) == 0x8000
; run: %sshr_i16_i128(0x8000, 1) == 0xC000
; run: %sshr_i16_i128(0xf000, 4) == 0xff00
; run: %sshr_i16_i128(0x4000, 16) == 0x4000
; run: %sshr_i16_i128(0x4000, 17) == 0x2000
; run: %sshr_i16_i128(0xf000, 0x00000000_00000004_00000000_00000000) == 0xf000
; run: %sshr_i16_i128(0x4000, 0x00000000_00000001_00000000_00000012) == 0x1000
function %sshr_i8_i128(i8, i64, i64) -> i8 {
block0(v0: i8, v1: i64, v2: i64):
v3 = iconcat v1, v2
v4 = sshr.i8 v0, v3
return v4
function %sshr_i8_i128(i8, i128) -> i8 {
block0(v0: i8, v1: i128):
v2 = sshr.i8 v0, v1
return v2
}
; run: %sshr_i8_i128(0x80, 0, 0) == 0x80
; run: %sshr_i8_i128(0x80, 1, 0) == 0xC0
; run: %sshr_i8_i128(0xf0, 0, 4) == 0xf0
; run: %sshr_i8_i128(0xf0, 4, 0) == 0xff
; run: %sshr_i8_i128(0x40, 8, 0) == 0x40
; run: %sshr_i8_i128(0x40, 9, 0) == 0x20
; run: %sshr_i8_i128(0x40, 10, 1) == 0x10
; run: %sshr_i8_i128(0x80, 0) == 0x80
; run: %sshr_i8_i128(0x80, 1) == 0xC0
; run: %sshr_i8_i128(0xf0, 4) == 0xff
; run: %sshr_i8_i128(0x40, 8) == 0x40
; run: %sshr_i8_i128(0x40, 9) == 0x20
; run: %sshr_i8_i128(0xf0, 0x00000000_00000004_00000000_00000000) == 0xf0
; run: %sshr_i8_i128(0x40, 0x00000000_00000001_00000000_0000000A) == 0x10

675
cranelift/filetests/filetests/runtests/i128-shifts.clif
View File

@@ -1,271 +1,232 @@
test run
set enable_llvm_abi_extensions=true
target aarch64
target x86_64 machinst
function %ishl_i128_i128(i64, i64, i8) -> i64, i64 {
block0(v0: i64, v1: i64, v2: i8):
v3 = iconcat v0, v1
v4 = uextend.i64 v2
v5 = iconcat v4, v4
function %ishl_i128_i128(i128, i8) -> i128 {
block0(v0: i128, v1: i8):
v2 = uextend.i64 v1
v3 = iconcat v2, v2
v6 = ishl.i128 v3, v5
v4 = ishl.i128 v0, v3
v7, v8 = isplit v6
return v7, v8
}
; run: %ishl_i128_i128(0x01010101_01010101, 0x01010101_01010101, 2) == [0x04040404_04040404, 0x04040404_04040404]
; run: %ishl_i128_i128(0x01010101_01010101, 0x01010101_01010101, 9) == [0x02020202_02020200, 0x02020202_02020202]
; run: %ishl_i128_i128(0x01010101_01010101, 0xffffffff_ffffffff, 66) == [0x00000000_00000000, 0x04040404_04040404]
; run: %ishl_i128_i128(0x01010101_01010101, 0x01010101_01010101, 0) == [0x01010101_01010101, 0x01010101_01010101]
; run: %ishl_i128_i128(0x01010101_01010101, 0x01010101_01010101, 128) == [0x01010101_01010101, 0x01010101_01010101]
; run: %ishl_i128_i128(0x00000000_00000001, 0x00000000_00000000, 0) == [0x00000000_00000001, 0x00000000_00000000]
; run: %ishl_i128_i128(0x00000000_00000000, 0x00000000_00000001, 0) == [0x00000000_00000000, 0x00000000_00000001]
; run: %ishl_i128_i128(0x12340000_00000000, 0x56780000_00000000, 0) == [0x12340000_00000000, 0x56780000_00000000]
; run: %ishl_i128_i128(0x12340000_00000000, 0x56780000_00000000, 64) == [0x00000000_00000000, 0x12340000_00000000]
; run: %ishl_i128_i128(0x12340000_00000000, 0x56780000_00000000, 32) == [0x00000000_00000000, 0x00000000_12340000]
; run: %ishl_i128_i128(0x01010101_01010101, 0x01010101_01010101, 129) == [0x02020202_02020202, 0x02020202_02020202]
; run: %ishl_i128_i128(0x01010101_01010101, 0x01010101_01010101, 130) == [0x04040404_04040404, 0x04040404_04040404]
function %ishl_i128_i64(i64, i64, i64) -> i64, i64 {
block0(v0: i64, v1: i64, v2: i64):
v3 = iconcat v0, v1
v4 = ishl.i128 v3, v2
v5, v6 = isplit v4
return v5, v6
}
; run: %ishl_i128_i64(0x01010101_01010101, 0x01010101_01010101, 2) == [0x04040404_04040404, 0x04040404_04040404]
; run: %ishl_i128_i64(0x01010101_01010101, 0x01010101_01010101, 9) == [0x02020202_02020200, 0x02020202_02020202]
; run: %ishl_i128_i64(0x01010101_01010101, 0xffffffff_ffffffff, 66) == [0x00000000_00000000, 0x04040404_04040404]
; run: %ishl_i128_i64(0x01010101_01010101, 0x01010101_01010101, 0) == [0x01010101_01010101, 0x01010101_01010101]
; run: %ishl_i128_i64(0x01010101_01010101, 0x01010101_01010101, 128) == [0x01010101_01010101, 0x01010101_01010101]
; run: %ishl_i128_i64(0x00000000_00000001, 0x00000000_00000000, 0) == [0x00000000_00000001, 0x00000000_00000000]
; run: %ishl_i128_i64(0x00000000_00000000, 0x00000000_00000001, 0) == [0x00000000_00000000, 0x00000000_00000001]
; run: %ishl_i128_i64(0x12340000_00000000, 0x56780000_00000000, 0) == [0x12340000_00000000, 0x56780000_00000000]
; run: %ishl_i128_i64(0x12340000_00000000, 0x56780000_00000000, 64) == [0x00000000_00000000, 0x12340000_00000000]
; run: %ishl_i128_i64(0x12340000_00000000, 0x56780000_00000000, 32) == [0x00000000_00000000, 0x00000000_12340000]
; run: %ishl_i128_i64(0x01010101_01010101, 0x01010101_01010101, 129) == [0x02020202_02020202, 0x02020202_02020202]
; run: %ishl_i128_i64(0x01010101_01010101, 0x01010101_01010101, 130) == [0x04040404_04040404, 0x04040404_04040404]
function %ishl_i128_i32(i64, i64, i32) -> i64, i64 {
block0(v0: i64, v1: i64, v2: i32):
v3 = iconcat v0, v1
v4 = ishl.i128 v3, v2
v5, v6 = isplit v4
return v5, v6
}
; run: %ishl_i128_i32(0x01010101_01010101, 0x01010101_01010101, 2) == [0x04040404_04040404, 0x04040404_04040404]
; run: %ishl_i128_i32(0x01010101_01010101, 0x01010101_01010101, 9) == [0x02020202_02020200, 0x02020202_02020202]
; run: %ishl_i128_i32(0x01010101_01010101, 0xffffffff_ffffffff, 66) == [0x00000000_00000000, 0x04040404_04040404]
; run: %ishl_i128_i32(0x01010101_01010101, 0x01010101_01010101, 0) == [0x01010101_01010101, 0x01010101_01010101]
; run: %ishl_i128_i32(0x01010101_01010101, 0x01010101_01010101, 128) == [0x01010101_01010101, 0x01010101_01010101]
; run: %ishl_i128_i32(0x00000000_00000001, 0x00000000_00000000, 0) == [0x00000000_00000001, 0x00000000_00000000]
; run: %ishl_i128_i32(0x00000000_00000000, 0x00000000_00000001, 0) == [0x00000000_00000000, 0x00000000_00000001]
; run: %ishl_i128_i32(0x12340000_00000000, 0x56780000_00000000, 0) == [0x12340000_00000000, 0x56780000_00000000]
; run: %ishl_i128_i32(0x12340000_00000000, 0x56780000_00000000, 64) == [0x00000000_00000000, 0x12340000_00000000]
; run: %ishl_i128_i32(0x12340000_00000000, 0x56780000_00000000, 32) == [0x00000000_00000000, 0x00000000_12340000]
; run: %ishl_i128_i32(0x01010101_01010101, 0x01010101_01010101, 129) == [0x02020202_02020202, 0x02020202_02020202]
; run: %ishl_i128_i32(0x01010101_01010101, 0x01010101_01010101, 130) == [0x04040404_04040404, 0x04040404_04040404]
function %ishl_i128_i16(i64, i64, i16) -> i64, i64 {
block0(v0: i64, v1: i64, v2: i16):
v3 = iconcat v0, v1
v4 = ishl.i128 v3, v2
v5, v6 = isplit v4
return v5, v6
}
; run: %ishl_i128_i16(0x01010101_01010101, 0x01010101_01010101, 2) == [0x04040404_04040404, 0x04040404_04040404]
; run: %ishl_i128_i16(0x01010101_01010101, 0x01010101_01010101, 9) == [0x02020202_02020200, 0x02020202_02020202]
; run: %ishl_i128_i16(0x01010101_01010101, 0xffffffff_ffffffff, 66) == [0x00000000_00000000, 0x04040404_04040404]
; run: %ishl_i128_i16(0x01010101_01010101, 0x01010101_01010101, 0) == [0x01010101_01010101, 0x01010101_01010101]
; run: %ishl_i128_i16(0x01010101_01010101, 0x01010101_01010101, 128) == [0x01010101_01010101, 0x01010101_01010101]
; run: %ishl_i128_i16(0x00000000_00000001, 0x00000000_00000000, 0) == [0x00000000_00000001, 0x00000000_00000000]
; run: %ishl_i128_i16(0x00000000_00000000, 0x00000000_00000001, 0) == [0x00000000_00000000, 0x00000000_00000001]
; run: %ishl_i128_i16(0x12340000_00000000, 0x56780000_00000000, 0) == [0x12340000_00000000, 0x56780000_00000000]
; run: %ishl_i128_i16(0x12340000_00000000, 0x56780000_00000000, 64) == [0x00000000_00000000, 0x12340000_00000000]
; run: %ishl_i128_i16(0x12340000_00000000, 0x56780000_00000000, 32) == [0x00000000_00000000, 0x00000000_12340000]
; run: %ishl_i128_i16(0x01010101_01010101, 0x01010101_01010101, 129) == [0x02020202_02020202, 0x02020202_02020202]
; run: %ishl_i128_i16(0x01010101_01010101, 0x01010101_01010101, 130) == [0x04040404_04040404, 0x04040404_04040404]
function %ishl_i128_i8(i64, i64, i8) -> i64, i64 {
block0(v0: i64, v1: i64, v2: i8):
v3 = iconcat v0, v1
v4 = ishl.i128 v3, v2
v5, v6 = isplit v4
return v5, v6
}
; run: %ishl_i128_i8(0x01010101_01010101, 0x01010101_01010101, 2) == [0x04040404_04040404, 0x04040404_04040404]
; run: %ishl_i128_i8(0x01010101_01010101, 0x01010101_01010101, 9) == [0x02020202_02020200, 0x02020202_02020202]
; run: %ishl_i128_i8(0x01010101_01010101, 0xffffffff_ffffffff, 66) == [0x00000000_00000000, 0x04040404_04040404]
; run: %ishl_i128_i8(0x01010101_01010101, 0x01010101_01010101, 0) == [0x01010101_01010101, 0x01010101_01010101]
; run: %ishl_i128_i8(0x01010101_01010101, 0x01010101_01010101, 128) == [0x01010101_01010101, 0x01010101_01010101]
; run: %ishl_i128_i8(0x00000000_00000001, 0x00000000_00000000, 0) == [0x00000000_00000001, 0x00000000_00000000]
; run: %ishl_i128_i8(0x00000000_00000000, 0x00000000_00000001, 0) == [0x00000000_00000000, 0x00000000_00000001]
; run: %ishl_i128_i8(0x12340000_00000000, 0x56780000_00000000, 0) == [0x12340000_00000000, 0x56780000_00000000]
; run: %ishl_i128_i8(0x12340000_00000000, 0x56780000_00000000, 64) == [0x00000000_00000000, 0x12340000_00000000]
; run: %ishl_i128_i8(0x12340000_00000000, 0x56780000_00000000, 32) == [0x00000000_00000000, 0x00000000_12340000]
; run: %ishl_i128_i8(0x01010101_01010101, 0x01010101_01010101, 129) == [0x02020202_02020202, 0x02020202_02020202]
; run: %ishl_i128_i8(0x01010101_01010101, 0x01010101_01010101, 130) == [0x04040404_04040404, 0x04040404_04040404]
function %ishl_i64_i128(i64, i64, i64) -> i64 {
block0(v0: i64, v1: i64, v2: i64):
v3 = iconcat v1, v2
v4 = ishl.i64 v0, v3
return v4
}
; run: %ishl_i64_i128(0x00000000_00000000, 0, 0) == 0x00000000_00000000
; run: %ishl_i64_i128(0x00000000_00000000, 1, 0) == 0x00000000_00000000
; run: %ishl_i64_i128(0x0000000f_0000000f, 0, 4) == 0x0000000f_0000000f
; run: %ishl_i64_i128(0x0000000f_0000000f, 4, 0) == 0x000000f0_000000f0
; run: %ishl_i64_i128(0x00000000_00000004, 64, 0) == 0x00000000_00000004
; run: %ishl_i64_i128(0x00000000_00000004, 65, 0) == 0x00000000_00000008
; run: %ishl_i64_i128(0x00000000_00000004, 66, 1) == 0x00000000_00000010
; run: %ishl_i128_i128(0x01010101_01010101_01010101_01010101, 2) == 0x04040404_04040404_04040404_04040404
; run: %ishl_i128_i128(0x01010101_01010101_01010101_01010101, 9) == 0x02020202_02020202_02020202_02020200
; run: %ishl_i128_i128(0xffffffff_ffffffff_01010101_01010101, 66) == 0x04040404_04040404_00000000_00000000
; run: %ishl_i128_i128(0x01010101_01010101_01010101_01010101, 0) == 0x01010101_01010101_01010101_01010101
; run: %ishl_i128_i128(0x01010101_01010101_01010101_01010101, 128) == 0x01010101_01010101_01010101_01010101
; run: %ishl_i128_i128(0x00000000_00000000_00000000_00000001, 0) == 0x00000000_00000000_00000000_00000001
; run: %ishl_i128_i128(0x00000000_00000001_00000000_00000000, 0) == 0x00000000_00000001_00000000_00000000
; run: %ishl_i128_i128(0x56780000_00000000_12340000_00000000, 0) == 0x56780000_00000000_12340000_00000000
; run: %ishl_i128_i128(0x56780000_00000000_12340000_00000000, 64) == 0x12340000_00000000_00000000_00000000
; run: %ishl_i128_i128(0x56780000_00000000_12340000_00000000, 32) == 0x00000000_12340000_00000000_00000000
; run: %ishl_i128_i128(0x01010101_01010101_01010101_01010101, 129) == 0x02020202_02020202_02020202_02020202
; run: %ishl_i128_i128(0x01010101_01010101_01010101_01010101, 130) == 0x04040404_04040404_04040404_04040404
function %ishl_i32_i128(i32, i64, i64) -> i32 {
block0(v0: i32, v1: i64, v2: i64):
v3 = iconcat v1, v2
v4 = ishl.i32 v0, v3
function %ishl_i128_i64(i128, i64) -> i128 {
block0(v0: i128, v1: i64):
v2 = ishl.i128 v0, v1
return v2
}
; run: %ishl_i128_i64(0x01010101_01010101_01010101_01010101, 2) == 0x04040404_04040404_04040404_04040404
; run: %ishl_i128_i64(0x01010101_01010101_01010101_01010101, 9) == 0x02020202_02020202_02020202_02020200
; run: %ishl_i128_i64(0xffffffff_ffffffff_01010101_01010101, 66) == 0x04040404_04040404_00000000_00000000
; run: %ishl_i128_i64(0x01010101_01010101_01010101_01010101, 0) == 0x01010101_01010101_01010101_01010101
; run: %ishl_i128_i64(0x01010101_01010101_01010101_01010101, 128) == 0x01010101_01010101_01010101_01010101
; run: %ishl_i128_i64(0x00000000_00000000_00000000_00000001, 0) == 0x00000000_00000000_00000000_00000001
; run: %ishl_i128_i64(0x00000000_00000001_00000000_00000000, 0) == 0x00000000_00000001_00000000_00000000
; run: %ishl_i128_i64(0x56780000_00000000_12340000_00000000, 0) == 0x56780000_00000000_12340000_00000000
; run: %ishl_i128_i64(0x56780000_00000000_12340000_00000000, 64) == 0x12340000_00000000_00000000_00000000
; run: %ishl_i128_i64(0x56780000_00000000_12340000_00000000, 32) == 0x00000000_12340000_00000000_00000000
; run: %ishl_i128_i64(0x01010101_01010101_01010101_01010101, 129) == 0x02020202_02020202_02020202_02020202
; run: %ishl_i128_i64(0x01010101_01010101_01010101_01010101, 130) == 0x04040404_04040404_04040404_04040404
function %ishl_i128_i32(i128, i32) -> i128 {
block0(v0: i128, v1: i32):
v2 = ishl.i128 v0, v1
return v2
}
; run: %ishl_i128_i32(0x01010101_01010101_01010101_01010101, 2) == 0x04040404_04040404_04040404_04040404
; run: %ishl_i128_i32(0x01010101_01010101_01010101_01010101, 9) == 0x02020202_02020202_02020202_02020200
; run: %ishl_i128_i32(0xffffffff_ffffffff_01010101_01010101, 66) == 0x04040404_04040404_00000000_00000000
; run: %ishl_i128_i32(0x01010101_01010101_01010101_01010101, 0) == 0x01010101_01010101_01010101_01010101
; run: %ishl_i128_i32(0x01010101_01010101_01010101_01010101, 128) == 0x01010101_01010101_01010101_01010101
; run: %ishl_i128_i32(0x00000000_00000000_00000000_00000001, 0) == 0x00000000_00000000_00000000_00000001
; run: %ishl_i128_i32(0x00000000_00000001_00000000_00000000, 0) == 0x00000000_00000001_00000000_00000000
; run: %ishl_i128_i32(0x56780000_00000000_12340000_00000000, 0) == 0x56780000_00000000_12340000_00000000
; run: %ishl_i128_i32(0x56780000_00000000_12340000_00000000, 64) == 0x12340000_00000000_00000000_00000000
; run: %ishl_i128_i32(0x56780000_00000000_12340000_00000000, 32) == 0x00000000_12340000_00000000_00000000
; run: %ishl_i128_i32(0x01010101_01010101_01010101_01010101, 129) == 0x02020202_02020202_02020202_02020202
; run: %ishl_i128_i32(0x01010101_01010101_01010101_01010101, 130) == 0x04040404_04040404_04040404_04040404
function %ishl_i128_i16(i128, i16) -> i128 {
block0(v0: i128, v1: i16):
v2 = ishl.i128 v0, v1
return v2
}
; run: %ishl_i128_i16(0x01010101_01010101_01010101_01010101, 2) == 0x04040404_04040404_04040404_04040404
; run: %ishl_i128_i16(0x01010101_01010101_01010101_01010101, 9) == 0x02020202_02020202_02020202_02020200
; run: %ishl_i128_i16(0xffffffff_ffffffff_01010101_01010101, 66) == 0x04040404_04040404_00000000_00000000
; run: %ishl_i128_i16(0x01010101_01010101_01010101_01010101, 0) == 0x01010101_01010101_01010101_01010101
; run: %ishl_i128_i16(0x01010101_01010101_01010101_01010101, 128) == 0x01010101_01010101_01010101_01010101
; run: %ishl_i128_i16(0x00000000_00000000_00000000_00000001, 0) == 0x00000000_00000000_00000000_00000001
; run: %ishl_i128_i16(0x00000000_00000001_00000000_00000000, 0) == 0x00000000_00000001_00000000_00000000
; run: %ishl_i128_i16(0x56780000_00000000_12340000_00000000, 0) == 0x56780000_00000000_12340000_00000000
; run: %ishl_i128_i16(0x56780000_00000000_12340000_00000000, 64) == 0x12340000_00000000_00000000_00000000
; run: %ishl_i128_i16(0x56780000_00000000_12340000_00000000, 32) == 0x00000000_12340000_00000000_00000000
; run: %ishl_i128_i16(0x01010101_01010101_01010101_01010101, 129) == 0x02020202_02020202_02020202_02020202
; run: %ishl_i128_i16(0x01010101_01010101_01010101_01010101, 130) == 0x04040404_04040404_04040404_04040404
function %ishl_i128_i8(i128, i8) -> i128 {
block0(v0: i128, v1: i8):
v2 = ishl.i128 v0, v1
return v2
}
; run: %ishl_i128_i8(0x01010101_01010101_01010101_01010101, 2) == 0x04040404_04040404_04040404_04040404
; run: %ishl_i128_i8(0x01010101_01010101_01010101_01010101, 9) == 0x02020202_02020202_02020202_02020200
; run: %ishl_i128_i8(0xffffffff_ffffffff_01010101_01010101, 66) == 0x04040404_04040404_00000000_00000000
; run: %ishl_i128_i8(0x01010101_01010101_01010101_01010101, 0) == 0x01010101_01010101_01010101_01010101
; run: %ishl_i128_i8(0x01010101_01010101_01010101_01010101, 128) == 0x01010101_01010101_01010101_01010101
; run: %ishl_i128_i8(0x00000000_00000000_00000000_00000001, 0) == 0x00000000_00000000_00000000_00000001
; run: %ishl_i128_i8(0x00000000_00000001_00000000_00000000, 0) == 0x00000000_00000001_00000000_00000000
; run: %ishl_i128_i8(0x56780000_00000000_12340000_00000000, 0) == 0x56780000_00000000_12340000_00000000
; run: %ishl_i128_i8(0x56780000_00000000_12340000_00000000, 64) == 0x12340000_00000000_00000000_00000000
; run: %ishl_i128_i8(0x56780000_00000000_12340000_00000000, 32) == 0x00000000_12340000_00000000_00000000
; run: %ishl_i128_i8(0x01010101_01010101_01010101_01010101, 129) == 0x02020202_02020202_02020202_02020202
; run: %ishl_i128_i8(0x01010101_01010101_01010101_01010101, 130) == 0x04040404_04040404_04040404_04040404
function %ishl_i64_i128(i64, i128) -> i64 {
block0(v0: i64, v1: i128):
v2 = ishl.i64 v0, v1
return v2
}
; run: %ishl_i64_i128(0x00000000_00000000, 0) == 0x00000000_00000000
; run: %ishl_i64_i128(0x00000000_00000000, 1) == 0x00000000_00000000
; run: %ishl_i64_i128(0x0000000f_0000000f, 4) == 0x000000f0_000000f0
; run: %ishl_i64_i128(0x00000000_00000004, 64) == 0x00000000_00000004
; run: %ishl_i64_i128(0x00000000_00000004, 65) == 0x00000000_00000008
; run: %ishl_i64_i128(0x0000000f_0000000f, 0x00000000_00000004_00000000_00000000) == 0x0000000f_0000000f
; run: %ishl_i64_i128(0x00000000_00000004, 0x00000000_00000001_00000000_00000042) == 0x00000000_00000010
function %ishl_i32_i128(i32, i128) -> i32 {
block0(v0: i32, v1: i128):
v2 = ishl.i32 v0, v1
return v2
}
; run: %ishl_i32_i128(0x00000000, 0) == 0x00000000
; run: %ishl_i32_i128(0x00000000, 1) == 0x00000000
; run: %ishl_i32_i128(0x0000000f, 4) == 0x000000f0
; run: %ishl_i32_i128(0x00000004, 32) == 0x00000004
; run: %ishl_i32_i128(0x00000004, 33) == 0x00000008
; run: %ishl_i32_i128(0x0000000f, 0x00000000_00000004_00000000_00000000) == 0x0000000f
; run: %ishl_i32_i128(0x00000004, 0x00000000_00000001_00000000_00000022) == 0x00000010
function %ushr_i128_i128(i128, i8) -> i128 {
block0(v0: i128, v1: i8):
v2 = uextend.i64 v1
v3 = iconcat v2, v2
v4 = ushr.i128 v0, v3
return v4
}
; run: %ishl_i32_i128(0x00000000, 0, 0) == 0x00000000
; run: %ishl_i32_i128(0x00000000, 1, 0) == 0x00000000
; run: %ishl_i32_i128(0x0000000f, 0, 4) == 0x0000000f
; run: %ishl_i32_i128(0x0000000f, 4, 0) == 0x000000f0
; run: %ishl_i32_i128(0x00000004, 32, 0) == 0x00000004
; run: %ishl_i32_i128(0x00000004, 33, 0) == 0x00000008
; run: %ishl_i32_i128(0x00000004, 34, 1) == 0x00000010
; run: %ushr_i128_i128(0x01010101_01010101_01010101_01010101, 2) == 0x00404040_40404040_40404040_40404040
; run: %ushr_i128_i128(0x01010101_01010101_01010101_01010101, 66) == 0x00000000_00000000_00404040_40404040
; run: %ushr_i128_i128(0x01010101_01010101_01010101_01010101, 0) == 0x01010101_01010101_01010101_01010101
; run: %ushr_i128_i128(0x01010101_01010101_01010101_01010101, 128) == 0x01010101_01010101_01010101_01010101
; run: %ushr_i128_i128(0x00000000_00000000_00000000_00000001, 0) == 0x00000000_00000000_00000000_00000001
; run: %ushr_i128_i128(0x00000000_00000001_00000000_00000000, 0) == 0x00000000_00000001_00000000_00000000
; run: %ushr_i128_i128(0x56780000_00000000_12340000_00000000, 0) == 0x56780000_00000000_12340000_00000000
; run: %ushr_i128_i128(0x56780000_00000000_12340000_00000000, 64) == 0x00000000_00000000_56780000_00000000
; run: %ushr_i128_i128(0x56780000_00000000_12340000_00000000, 32) == 0x00000000_56780000_00000000_12340000
; run: %ushr_i128_i128(0x01010101_01010101_01010101_01010101, 129) == 0x00808080_80808080_80808080_80808080
; run: %ushr_i128_i128(0x01010101_01010101_01010101_01010101, 130) == 0x00404040_40404040_40404040_40404040
function %ushr_i128_i128(i64, i64, i8) -> i64, i64 {
block0(v0: i64, v1: i64, v2: i8):
v3 = iconcat v0, v1
v4 = uextend.i64 v2
v5 = iconcat v4, v4
v6 = ushr.i128 v3, v5
v7, v8 = isplit v6
return v7, v8
function %ushr_i128_i64(i128, i64) -> i128 {
block0(v0: i128, v1: i64):
v2 = ushr.i128 v0, v1
return v2
}
; run: %ushr_i128_i128(0x01010101_01010101, 0x01010101_01010101, 2) == [0x40404040_40404040, 0x00404040_40404040]
; run: %ushr_i128_i128(0x01010101_01010101, 0x01010101_01010101, 66) == [0x00404040_40404040, 0x00000000_00000000]
; run: %ushr_i128_i128(0x01010101_01010101, 0x01010101_01010101, 0) == [0x01010101_01010101, 0x01010101_01010101]
; run: %ushr_i128_i128(0x01010101_01010101, 0x01010101_01010101, 128) == [0x01010101_01010101, 0x01010101_01010101]
; run: %ushr_i128_i128(0x00000000_00000001, 0x00000000_00000000, 0) == [0x00000000_00000001, 0x00000000_00000000]
; run: %ushr_i128_i128(0x00000000_00000000, 0x00000000_00000001, 0) == [0x00000000_00000000, 0x00000000_00000001]
; run: %ushr_i128_i128(0x12340000_00000000, 0x56780000_00000000, 0) == [0x12340000_00000000, 0x56780000_00000000]
; run: %ushr_i128_i128(0x12340000_00000000, 0x56780000_00000000, 64) == [0x56780000_00000000, 0x00000000_00000000]
; run: %ushr_i128_i128(0x12340000_00000000, 0x56780000_00000000, 32) == [0x00000000_12340000, 0x00000000_56780000]
; run: %ushr_i128_i128(0x01010101_01010101, 0x01010101_01010101, 129) == [0x80808080_80808080, 0x00808080_80808080]
; run: %ushr_i128_i128(0x01010101_01010101, 0x01010101_01010101, 130) == [0x40404040_40404040, 0x00404040_40404040]
; run: %ushr_i128_i64(0x01010101_01010101_01010101_01010101, 2) == 0x00404040_40404040_40404040_40404040
; run: %ushr_i128_i64(0x01010101_01010101_01010101_01010101, 66) == 0x00000000_00000000_00404040_40404040
; run: %ushr_i128_i64(0x01010101_01010101_01010101_01010101, 0) == 0x01010101_01010101_01010101_01010101
; run: %ushr_i128_i64(0x01010101_01010101_01010101_01010101, 128) == 0x01010101_01010101_01010101_01010101
; run: %ushr_i128_i64(0x00000000_00000000_00000000_00000001, 0) == 0x00000000_00000000_00000000_00000001
; run: %ushr_i128_i64(0x00000000_00000001_00000000_00000000, 0) == 0x00000000_00000001_00000000_00000000
; run: %ushr_i128_i64(0x56780000_00000000_12340000_00000000, 0) == 0x56780000_00000000_12340000_00000000
; run: %ushr_i128_i64(0x56780000_00000000_12340000_00000000, 64) == 0x00000000_00000000_56780000_00000000
; run: %ushr_i128_i64(0x56780000_00000000_12340000_00000000, 32) == 0x00000000_56780000_00000000_12340000
; run: %ushr_i128_i64(0x01010101_01010101_01010101_01010101, 129) == 0x00808080_80808080_80808080_80808080
; run: %ushr_i128_i64(0x01010101_01010101_01010101_01010101, 130) == 0x00404040_40404040_40404040_40404040
function %ushr_i128_i64(i64, i64, i64) -> i64, i64 {
block0(v0: i64, v1: i64, v2: i64):
v3 = iconcat v0, v1
v4 = ushr.i128 v3, v2
v5, v6 = isplit v4
return v5, v6
function %ushr_i128_i32(i128, i32) -> i128 {
block0(v0: i128, v1: i32):
v2 = ushr.i128 v0, v1
return v2
}
; run: %ushr_i128_i64(0x01010101_01010101, 0x01010101_01010101, 2) == [0x40404040_40404040, 0x00404040_40404040]
; run: %ushr_i128_i64(0x01010101_01010101, 0x01010101_01010101, 66) == [0x00404040_40404040, 0x00000000_00000000]
; run: %ushr_i128_i64(0x01010101_01010101, 0x01010101_01010101, 0) == [0x01010101_01010101, 0x01010101_01010101]
; run: %ushr_i128_i64(0x01010101_01010101, 0x01010101_01010101, 128) == [0x01010101_01010101, 0x01010101_01010101]
; run: %ushr_i128_i64(0x00000000_00000001, 0x00000000_00000000, 0) == [0x00000000_00000001, 0x00000000_00000000]
; run: %ushr_i128_i64(0x00000000_00000000, 0x00000000_00000001, 0) == [0x00000000_00000000, 0x00000000_00000001]
; run: %ushr_i128_i64(0x12340000_00000000, 0x56780000_00000000, 0) == [0x12340000_00000000, 0x56780000_00000000]
; run: %ushr_i128_i64(0x12340000_00000000, 0x56780000_00000000, 64) == [0x56780000_00000000, 0x00000000_00000000]
; run: %ushr_i128_i64(0x12340000_00000000, 0x56780000_00000000, 32) == [0x00000000_12340000, 0x00000000_56780000]
; run: %ushr_i128_i64(0x01010101_01010101, 0x01010101_01010101, 129) == [0x80808080_80808080, 0x00808080_80808080]
; run: %ushr_i128_i64(0x01010101_01010101, 0x01010101_01010101, 130) == [0x40404040_40404040, 0x00404040_40404040]
; run: %ushr_i128_i32(0x01010101_01010101_01010101_01010101, 2) == 0x00404040_40404040_40404040_40404040
; run: %ushr_i128_i32(0x01010101_01010101_01010101_01010101, 66) == 0x00000000_00000000_00404040_40404040
; run: %ushr_i128_i32(0x01010101_01010101_01010101_01010101, 0) == 0x01010101_01010101_01010101_01010101
; run: %ushr_i128_i32(0x01010101_01010101_01010101_01010101, 128) == 0x01010101_01010101_01010101_01010101
; run: %ushr_i128_i32(0x00000000_00000000_00000000_00000001, 0) == 0x00000000_00000000_00000000_00000001
; run: %ushr_i128_i32(0x00000000_00000001_00000000_00000000, 0) == 0x00000000_00000001_00000000_00000000
; run: %ushr_i128_i32(0x56780000_00000000_12340000_00000000, 0) == 0x56780000_00000000_12340000_00000000
; run: %ushr_i128_i32(0x56780000_00000000_12340000_00000000, 64) == 0x00000000_00000000_56780000_00000000
; run: %ushr_i128_i32(0x56780000_00000000_12340000_00000000, 32) == 0x00000000_56780000_00000000_12340000
; run: %ushr_i128_i32(0x01010101_01010101_01010101_01010101, 129) == 0x00808080_80808080_80808080_80808080
; run: %ushr_i128_i32(0x01010101_01010101_01010101_01010101, 130) == 0x00404040_40404040_40404040_40404040
function %ushr_i128_i32(i64, i64, i32) -> i64, i64 {
block0(v0: i64, v1: i64, v2: i32):
v3 = iconcat v0, v1
v4 = ushr.i128 v3, v2
v5, v6 = isplit v4
return v5, v6
function %ushr_i128_i16(i128, i16) -> i128 {
block0(v0: i128, v1: i16):
v2 = ushr.i128 v0, v1
return v2
}
; run: %ushr_i128_i32(0x01010101_01010101, 0x01010101_01010101, 2) == [0x40404040_40404040, 0x00404040_40404040]
; run: %ushr_i128_i32(0x01010101_01010101, 0x01010101_01010101, 66) == [0x00404040_40404040, 0x00000000_00000000]
; run: %ushr_i128_i32(0x01010101_01010101, 0x01010101_01010101, 0) == [0x01010101_01010101, 0x01010101_01010101]
; run: %ushr_i128_i32(0x01010101_01010101, 0x01010101_01010101, 128) == [0x01010101_01010101, 0x01010101_01010101]
; run: %ushr_i128_i32(0x00000000_00000001, 0x00000000_00000000, 0) == [0x00000000_00000001, 0x00000000_00000000]
; run: %ushr_i128_i32(0x00000000_00000000, 0x00000000_00000001, 0) == [0x00000000_00000000, 0x00000000_00000001]
; run: %ushr_i128_i32(0x12340000_00000000, 0x56780000_00000000, 0) == [0x12340000_00000000, 0x56780000_00000000]
; run: %ushr_i128_i32(0x12340000_00000000, 0x56780000_00000000, 64) == [0x56780000_00000000, 0x00000000_00000000]
; run: %ushr_i128_i32(0x12340000_00000000, 0x56780000_00000000, 32) == [0x00000000_12340000, 0x00000000_56780000]
; run: %ushr_i128_i32(0x01010101_01010101, 0x01010101_01010101, 129) == [0x80808080_80808080, 0x00808080_80808080]
; run: %ushr_i128_i32(0x01010101_01010101, 0x01010101_01010101, 130) == [0x40404040_40404040, 0x00404040_40404040]
; run: %ushr_i128_i16(0x01010101_01010101_01010101_01010101, 2) == 0x00404040_40404040_40404040_40404040
; run: %ushr_i128_i16(0x01010101_01010101_01010101_01010101, 66) == 0x00000000_00000000_00404040_40404040
; run: %ushr_i128_i16(0x01010101_01010101_01010101_01010101, 0) == 0x01010101_01010101_01010101_01010101
; run: %ushr_i128_i16(0x01010101_01010101_01010101_01010101, 128) == 0x01010101_01010101_01010101_01010101
; run: %ushr_i128_i16(0x00000000_00000000_00000000_00000001, 0) == 0x00000000_00000000_00000000_00000001
; run: %ushr_i128_i16(0x00000000_00000001_00000000_00000000, 0) == 0x00000000_00000001_00000000_00000000
; run: %ushr_i128_i16(0x56780000_00000000_12340000_00000000, 0) == 0x56780000_00000000_12340000_00000000
; run: %ushr_i128_i16(0x56780000_00000000_12340000_00000000, 64) == 0x00000000_00000000_56780000_00000000
; run: %ushr_i128_i16(0x56780000_00000000_12340000_00000000, 32) == 0x00000000_56780000_00000000_12340000
; run: %ushr_i128_i16(0x01010101_01010101_01010101_01010101, 129) == 0x00808080_80808080_80808080_80808080
; run: %ushr_i128_i16(0x01010101_01010101_01010101_01010101, 130) == 0x00404040_40404040_40404040_40404040
function %ushr_i128_i16(i64, i64, i16) -> i64, i64 {
block0(v0: i64, v1: i64, v2: i16):
v3 = iconcat v0, v1
v4 = ushr.i128 v3, v2
v5, v6 = isplit v4
return v5, v6
function %ushr_i128_i8(i128, i8) -> i128 {
block0(v0: i128, v1: i8):
v2 = ushr.i128 v0, v1
return v2
}
; run: %ushr_i128_i16(0x01010101_01010101, 0x01010101_01010101, 2) == [0x40404040_40404040, 0x00404040_40404040]
; run: %ushr_i128_i16(0x01010101_01010101, 0x01010101_01010101, 66) == [0x00404040_40404040, 0x00000000_00000000]
; run: %ushr_i128_i16(0x01010101_01010101, 0x01010101_01010101, 0) == [0x01010101_01010101, 0x01010101_01010101]
; run: %ushr_i128_i16(0x01010101_01010101, 0x01010101_01010101, 128) == [0x01010101_01010101, 0x01010101_01010101]
; run: %ushr_i128_i16(0x00000000_00000001, 0x00000000_00000000, 0) == [0x00000000_00000001, 0x00000000_00000000]
; run: %ushr_i128_i16(0x00000000_00000000, 0x00000000_00000001, 0) == [0x00000000_00000000, 0x00000000_00000001]
; run: %ushr_i128_i16(0x12340000_00000000, 0x56780000_00000000, 0) == [0x12340000_00000000, 0x56780000_00000000]
; run: %ushr_i128_i16(0x12340000_00000000, 0x56780000_00000000, 64) == [0x56780000_00000000, 0x00000000_00000000]
; run: %ushr_i128_i16(0x12340000_00000000, 0x56780000_00000000, 32) == [0x00000000_12340000, 0x00000000_56780000]
; run: %ushr_i128_i16(0x01010101_01010101, 0x01010101_01010101, 129) == [0x80808080_80808080, 0x00808080_80808080]
; run: %ushr_i128_i16(0x01010101_01010101, 0x01010101_01010101, 130) == [0x40404040_40404040, 0x00404040_40404040]
; run: %ushr_i128_i8(0x01010101_01010101_01010101_01010101, 2) == 0x00404040_40404040_40404040_40404040
; run: %ushr_i128_i8(0x01010101_01010101_01010101_01010101, 66) == 0x00000000_00000000_00404040_40404040
; run: %ushr_i128_i8(0x01010101_01010101_01010101_01010101, 0) == 0x01010101_01010101_01010101_01010101
; run: %ushr_i128_i8(0x01010101_01010101_01010101_01010101, 128) == 0x01010101_01010101_01010101_01010101
; run: %ushr_i128_i8(0x00000000_00000000_00000000_00000001, 0) == 0x00000000_00000000_00000000_00000001
; run: %ushr_i128_i8(0x00000000_00000001_00000000_00000000, 0) == 0x00000000_00000001_00000000_00000000
; run: %ushr_i128_i8(0x56780000_00000000_12340000_00000000, 0) == 0x56780000_00000000_12340000_00000000
; run: %ushr_i128_i8(0x56780000_00000000_12340000_00000000, 64) == 0x00000000_00000000_56780000_00000000
; run: %ushr_i128_i8(0x56780000_00000000_12340000_00000000, 32) == 0x00000000_56780000_00000000_12340000
; run: %ushr_i128_i8(0x01010101_01010101_01010101_01010101, 129) == 0x00808080_80808080_80808080_80808080
; run: %ushr_i128_i8(0x01010101_01010101_01010101_01010101, 130) == 0x00404040_40404040_40404040_40404040
function %ushr_i128_i8(i64, i64, i8) -> i64, i64 {
block0(v0: i64, v1: i64, v2: i8):
v3 = iconcat v0, v1
v4 = ushr.i128 v3, v2
v5, v6 = isplit v4
return v5, v6
function %ushr_i64_i128(i64, i128) -> i64 {
block0(v0: i64, v1: i128):
v2 = ushr.i64 v0, v1
return v2
}
; run: %ushr_i128_i8(0x01010101_01010101, 0x01010101_01010101, 2) == [0x40404040_40404040, 0x00404040_40404040]
; run: %ushr_i128_i8(0x01010101_01010101, 0x01010101_01010101, 66) == [0x00404040_40404040, 0x00000000_00000000]
; run: %ushr_i128_i8(0x01010101_01010101, 0x01010101_01010101, 0) == [0x01010101_01010101, 0x01010101_01010101]
; run: %ushr_i128_i8(0x01010101_01010101, 0x01010101_01010101, 128) == [0x01010101_01010101, 0x01010101_01010101]
; run: %ushr_i128_i8(0x00000000_00000001, 0x00000000_00000000, 0) == [0x00000000_00000001, 0x00000000_00000000]
; run: %ushr_i128_i8(0x00000000_00000000, 0x00000000_00000001, 0) == [0x00000000_00000000, 0x00000000_00000001]
; run: %ushr_i128_i8(0x12340000_00000000, 0x56780000_00000000, 0) == [0x12340000_00000000, 0x56780000_00000000]
; run: %ushr_i128_i8(0x12340000_00000000, 0x56780000_00000000, 64) == [0x56780000_00000000, 0x00000000_00000000]
; run: %ushr_i128_i8(0x12340000_00000000, 0x56780000_00000000, 32) == [0x00000000_12340000, 0x00000000_56780000]
; run: %ushr_i128_i8(0x01010101_01010101, 0x01010101_01010101, 129) == [0x80808080_80808080, 0x00808080_80808080]
; run: %ushr_i128_i8(0x01010101_01010101, 0x01010101_01010101, 130) == [0x40404040_40404040, 0x00404040_40404040]
function %ushr_i64_i128(i64, i64, i64) -> i64 {
block0(v0: i64, v1: i64, v2: i64):
v3 = iconcat v1, v2
v4 = ushr.i64 v0, v3
return v4
}
; run: %ushr_i64_i128(0x10000000_10000000, 0, 0) == 0x10000000_10000000
; run: %ushr_i64_i128(0x10000000_10000000, 1, 0) == 0x08000000_08000000
; run: %ushr_i64_i128(0xf0000000_f0000000, 0, 4) == 0xf0000000_f0000000
; run: %ushr_i64_i128(0xf0000000_f0000000, 4, 0) == 0x0f000000_0f000000
; run: %ushr_i64_i128(0x40000000_40000000, 64, 0) == 0x40000000_40000000
; run: %ushr_i64_i128(0x40000000_40000000, 65, 0) == 0x20000000_20000000
; run: %ushr_i64_i128(0x40000000_40000000, 66, 1) == 0x10000000_10000000
; run: %ushr_i64_i128(0x10000000_10000000, 0) == 0x10000000_10000000
; run: %ushr_i64_i128(0x10000000_10000000, 1) == 0x08000000_08000000
; run: %ushr_i64_i128(0xf0000000_f0000000, 4) == 0x0f000000_0f000000
; run: %ushr_i64_i128(0x40000000_40000000, 64) == 0x40000000_40000000
; run: %ushr_i64_i128(0x40000000_40000000, 65) == 0x20000000_20000000
; run: %ushr_i64_i128(0xf0000000_f0000000, 0x00000000_00000004_00000000_00000000) == 0xf0000000_f0000000
; run: %ushr_i64_i128(0x40000000_40000000, 0x00000000_00000001_00000000_00000042) == 0x10000000_10000000
function %ushr_i32_i128(i32, i64, i64) -> i32 {
block0(v0: i32, v1: i64, v2: i64):
@@ -283,130 +244,110 @@ block0(v0: i32, v1: i64, v2: i64):
function %sshr_i128_i128(i64, i64, i8) -> i64, i64 {
block0(v0: i64, v1: i64, v2: i8):
v3 = iconcat v0, v1
v4 = uextend.i64 v2
v5 = iconcat v4, v4
function %sshr_i128_i128(i128, i8) -> i128 {
block0(v0: i128, v1: i8):
v2 = uextend.i64 v1
v3 = iconcat v2, v2
v6 = sshr.i128 v3, v5
v4 = sshr.i128 v0, v3
v7, v8 = isplit v6
return v7, v8
}
; run: %sshr_i128_i128(0x01010101_01010101, 0x81010101_01010101, 2) == [0x40404040_40404040, 0xe0404040_40404040]
; run: %sshr_i128_i128(0x00000000_00000000, 0xffffffff_ffffffff, 32) == [0xffffffff_00000000, 0xffffffff_ffffffff]
; run: %sshr_i128_i128(0x80000000_00000000, 0xffffffff_00000000, 32) == [0x00000000_80000000, 0xffffffff_ffffffff]
; run: %sshr_i128_i128(0x12345678_9abcdef0, 0x80101010_10101010, 66) == [0xe0040404_04040404, 0xffffffff_ffffffff]
; run: %sshr_i128_i128(0x00000000_00000000, 0x00000000_00000000, 64) == [0x00000000_00000000, 0x00000000_00000000]
; run: %sshr_i128_i128(0x12345678_9abcdef0, 0x80101010_10101010, 0) == [0x12345678_9abcdef0, 0x80101010_10101010]
; run: %sshr_i128_i128(0x12345678_9abcdef0, 0x80101010_10101010, 128) == [0x12345678_9abcdef0, 0x80101010_10101010]
; run: %sshr_i128_i128(0x01010101_01010101, 0x81010101_01010101, 129) == [0x80808080_80808080, 0xc0808080_80808080]
; run: %sshr_i128_i128(0x01010101_01010101, 0x81010101_01010101, 130) == [0x40404040_40404040, 0xe0404040_40404040]
function %sshr_i128_i64(i64, i64, i64) -> i64, i64 {
block0(v0: i64, v1: i64, v2: i64):
v3 = iconcat v0, v1
v4 = sshr.i128 v3, v2
v5, v6 = isplit v4
return v5, v6
}
; run: %sshr_i128_i64(0x01010101_01010101, 0x81010101_01010101, 2) == [0x40404040_40404040, 0xe0404040_40404040]
; run: %sshr_i128_i64(0x00000000_00000000, 0xffffffff_ffffffff, 32) == [0xffffffff_00000000, 0xffffffff_ffffffff]
; run: %sshr_i128_i64(0x80000000_00000000, 0xffffffff_00000000, 32) == [0x00000000_80000000, 0xffffffff_ffffffff]
; run: %sshr_i128_i64(0x12345678_9abcdef0, 0x80101010_10101010, 66) == [0xe0040404_04040404, 0xffffffff_ffffffff]
; run: %sshr_i128_i64(0x00000000_00000000, 0x00000000_00000000, 64) == [0x00000000_00000000, 0x00000000_00000000]
; run: %sshr_i128_i64(0x12345678_9abcdef0, 0x80101010_10101010, 0) == [0x12345678_9abcdef0, 0x80101010_10101010]
; run: %sshr_i128_i64(0x12345678_9abcdef0, 0x80101010_10101010, 128) == [0x12345678_9abcdef0, 0x80101010_10101010]
; run: %sshr_i128_i64(0x01010101_01010101, 0x81010101_01010101, 129) == [0x80808080_80808080, 0xc0808080_80808080]
; run: %sshr_i128_i64(0x01010101_01010101, 0x81010101_01010101, 130) == [0x40404040_40404040, 0xe0404040_40404040]
function %sshr_i128_i32(i64, i64, i32) -> i64, i64 {
block0(v0: i64, v1: i64, v2: i32):
v3 = iconcat v0, v1
v4 = sshr.i128 v3, v2
v5, v6 = isplit v4
return v5, v6
}
; run: %sshr_i128_i32(0x01010101_01010101, 0x81010101_01010101, 2) == [0x40404040_40404040, 0xe0404040_40404040]
; run: %sshr_i128_i32(0x00000000_00000000, 0xffffffff_ffffffff, 32) == [0xffffffff_00000000, 0xffffffff_ffffffff]
; run: %sshr_i128_i32(0x80000000_00000000, 0xffffffff_00000000, 32) == [0x00000000_80000000, 0xffffffff_ffffffff]
; run: %sshr_i128_i32(0x12345678_9abcdef0, 0x80101010_10101010, 66) == [0xe0040404_04040404, 0xffffffff_ffffffff]
; run: %sshr_i128_i32(0x00000000_00000000, 0x00000000_00000000, 64) == [0x00000000_00000000, 0x00000000_00000000]
; run: %sshr_i128_i32(0x12345678_9abcdef0, 0x80101010_10101010, 0) == [0x12345678_9abcdef0, 0x80101010_10101010]
; run: %sshr_i128_i32(0x12345678_9abcdef0, 0x80101010_10101010, 128) == [0x12345678_9abcdef0, 0x80101010_10101010]
; run: %sshr_i128_i32(0x01010101_01010101, 0x81010101_01010101, 129) == [0x80808080_80808080, 0xc0808080_80808080]
; run: %sshr_i128_i32(0x01010101_01010101, 0x81010101_01010101, 130) == [0x40404040_40404040, 0xe0404040_40404040]
function %sshr_i128_i16(i64, i64, i16) -> i64, i64 {
block0(v0: i64, v1: i64, v2: i16):
v3 = iconcat v0, v1
v4 = sshr.i128 v3, v2
v5, v6 = isplit v4
return v5, v6
}
; run: %sshr_i128_i16(0x01010101_01010101, 0x81010101_01010101, 2) == [0x40404040_40404040, 0xe0404040_40404040]
; run: %sshr_i128_i16(0x00000000_00000000, 0xffffffff_ffffffff, 32) == [0xffffffff_00000000, 0xffffffff_ffffffff]
; run: %sshr_i128_i16(0x80000000_00000000, 0xffffffff_00000000, 32) == [0x00000000_80000000, 0xffffffff_ffffffff]
; run: %sshr_i128_i16(0x12345678_9abcdef0, 0x80101010_10101010, 66) == [0xe0040404_04040404, 0xffffffff_ffffffff]
; run: %sshr_i128_i16(0x00000000_00000000, 0x00000000_00000000, 64) == [0x00000000_00000000, 0x00000000_00000000]
; run: %sshr_i128_i16(0x12345678_9abcdef0, 0x80101010_10101010, 0) == [0x12345678_9abcdef0, 0x80101010_10101010]
; run: %sshr_i128_i16(0x12345678_9abcdef0, 0x80101010_10101010, 128) == [0x12345678_9abcdef0, 0x80101010_10101010]
; run: %sshr_i128_i16(0x01010101_01010101, 0x81010101_01010101, 129) == [0x80808080_80808080, 0xc0808080_80808080]
; run: %sshr_i128_i16(0x01010101_01010101, 0x81010101_01010101, 130) == [0x40404040_40404040, 0xe0404040_40404040]
function %sshr_i128_i8(i64, i64, i8) -> i64, i64 {
block0(v0: i64, v1: i64, v2: i8):
v3 = iconcat v0, v1
v4 = sshr.i128 v3, v2
v5, v6 = isplit v4
return v5, v6
}
; run: %sshr_i128_i8(0x01010101_01010101, 0x81010101_01010101, 2) == [0x40404040_40404040, 0xe0404040_40404040]
; run: %sshr_i128_i8(0x00000000_00000000, 0xffffffff_ffffffff, 32) == [0xffffffff_00000000, 0xffffffff_ffffffff]
; run: %sshr_i128_i8(0x80000000_00000000, 0xffffffff_00000000, 32) == [0x00000000_80000000, 0xffffffff_ffffffff]
; run: %sshr_i128_i8(0x12345678_9abcdef0, 0x80101010_10101010, 66) == [0xe0040404_04040404, 0xffffffff_ffffffff]
; run: %sshr_i128_i8(0x00000000_00000000, 0x00000000_00000000, 64) == [0x00000000_00000000, 0x00000000_00000000]
; run: %sshr_i128_i8(0x12345678_9abcdef0, 0x80101010_10101010, 0) == [0x12345678_9abcdef0, 0x80101010_10101010]
; run: %sshr_i128_i8(0x12345678_9abcdef0, 0x80101010_10101010, 128) == [0x12345678_9abcdef0, 0x80101010_10101010]
; run: %sshr_i128_i8(0x01010101_01010101, 0x81010101_01010101, 129) == [0x80808080_80808080, 0xc0808080_80808080]
; run: %sshr_i128_i8(0x01010101_01010101, 0x81010101_01010101, 130) == [0x40404040_40404040, 0xe0404040_40404040]
function %sshr_i64_i128(i64, i64, i64) -> i64 {
block0(v0: i64, v1: i64, v2: i64):
v3 = iconcat v1, v2
v4 = sshr.i64 v0, v3
return v4
}
; run: %sshr_i64_i128(0x80000000_80000000, 0, 0) == 0x80000000_80000000
; run: %sshr_i64_i128(0x80000000_80000000, 1, 0) == 0xC0000000_40000000
; run: %sshr_i64_i128(0xf0000000_f0000000, 0, 4) == 0xf0000000_f0000000
; run: %sshr_i64_i128(0xf0000000_f0000000, 4, 0) == 0xff000000_0f000000
; run: %sshr_i64_i128(0x40000000_40000000, 64, 0) == 0x40000000_40000000
; run: %sshr_i64_i128(0x40000000_40000000, 65, 0) == 0x20000000_20000000
; run: %sshr_i64_i128(0x40000000_40000000, 66, 1) == 0x10000000_10000000
; run: %sshr_i128_i128(0x81010101_01010101_01010101_01010101, 2) == 0xe0404040_40404040_40404040_40404040
; run: %sshr_i128_i128(0xffffffff_ffffffff_00000000_00000000, 32) == 0xffffffff_ffffffff_ffffffff_00000000
; run: %sshr_i128_i128(0xffffffff_00000000_80000000_00000000, 32) == 0xffffffff_ffffffff_00000000_80000000
; run: %sshr_i128_i128(0x80101010_10101010_12345678_9abcdef0, 66) == 0xffffffff_ffffffff_e0040404_04040404
; run: %sshr_i128_i128(0x00000000_00000000_00000000_00000000, 64) == 0x00000000_00000000_00000000_00000000
; run: %sshr_i128_i128(0x80101010_10101010_12345678_9abcdef0, 0) == 0x80101010_10101010_12345678_9abcdef0
; run: %sshr_i128_i128(0x80101010_10101010_12345678_9abcdef0, 128) == 0x80101010_10101010_12345678_9abcdef0
; run: %sshr_i128_i128(0x81010101_01010101_01010101_01010101, 129) == 0xc0808080_80808080_80808080_80808080
; run: %sshr_i128_i128(0x81010101_01010101_01010101_01010101, 130) == 0xe0404040_40404040_40404040_40404040
function %sshr_i32_i128(i32, i64, i64) -> i32 {
block0(v0: i32, v1: i64, v2: i64):
v3 = iconcat v1, v2
v4 = sshr.i32 v0, v3
return v4
function %sshr_i128_i64(i128, i64) -> i128 {
block0(v0: i128, v1: i64):
v2 = sshr.i128 v0, v1
return v2
}
; run: %sshr_i32_i128(0x80000000, 0, 0) == 0x80000000
; run: %sshr_i32_i128(0x80000000, 1, 0) == 0xC0000000
; run: %sshr_i32_i128(0xf0000000, 0, 4) == 0xf0000000
; run: %sshr_i32_i128(0xf0000000, 4, 0) == 0xff000000
; run: %sshr_i32_i128(0x40000000, 32, 0) == 0x40000000
; run: %sshr_i32_i128(0x40000000, 33, 0) == 0x20000000
; run: %sshr_i32_i128(0x40000000, 34, 1) == 0x10000000
; run: %sshr_i128_i64(0x81010101_01010101_01010101_01010101, 2) == 0xe0404040_40404040_40404040_40404040
; run: %sshr_i128_i64(0xffffffff_ffffffff_00000000_00000000, 32) == 0xffffffff_ffffffff_ffffffff_00000000
; run: %sshr_i128_i64(0xffffffff_00000000_80000000_00000000, 32) == 0xffffffff_ffffffff_00000000_80000000
; run: %sshr_i128_i64(0x80101010_10101010_12345678_9abcdef0, 66) == 0xffffffff_ffffffff_e0040404_04040404
; run: %sshr_i128_i64(0x00000000_00000000_00000000_00000000, 64) == 0x00000000_00000000_00000000_00000000
; run: %sshr_i128_i64(0x80101010_10101010_12345678_9abcdef0, 0) == 0x80101010_10101010_12345678_9abcdef0
; run: %sshr_i128_i64(0x80101010_10101010_12345678_9abcdef0, 128) == 0x80101010_10101010_12345678_9abcdef0
; run: %sshr_i128_i64(0x81010101_01010101_01010101_01010101, 129) == 0xc0808080_80808080_80808080_80808080
; run: %sshr_i128_i64(0x81010101_01010101_01010101_01010101, 130) == 0xe0404040_40404040_40404040_40404040
function %sshr_i128_i32(i128, i32) -> i128 {
block0(v0: i128, v1: i32):
v2 = sshr.i128 v0, v1
return v2
}
; run: %sshr_i128_i32(0x81010101_01010101_01010101_01010101, 2) == 0xe0404040_40404040_40404040_40404040
; run: %sshr_i128_i32(0xffffffff_ffffffff_00000000_00000000, 32) == 0xffffffff_ffffffff_ffffffff_00000000
; run: %sshr_i128_i32(0xffffffff_00000000_80000000_00000000, 32) == 0xffffffff_ffffffff_00000000_80000000
; run: %sshr_i128_i32(0x80101010_10101010_12345678_9abcdef0, 66) == 0xffffffff_ffffffff_e0040404_04040404
; run: %sshr_i128_i32(0x00000000_00000000_00000000_00000000, 64) == 0x00000000_00000000_00000000_00000000
; run: %sshr_i128_i32(0x80101010_10101010_12345678_9abcdef0, 0) == 0x80101010_10101010_12345678_9abcdef0
; run: %sshr_i128_i32(0x80101010_10101010_12345678_9abcdef0, 128) == 0x80101010_10101010_12345678_9abcdef0
; run: %sshr_i128_i32(0x81010101_01010101_01010101_01010101, 129) == 0xc0808080_80808080_80808080_80808080
; run: %sshr_i128_i32(0x81010101_01010101_01010101_01010101, 130) == 0xe0404040_40404040_40404040_40404040
function %sshr_i128_i16(i128, i16) -> i128 {
block0(v0: i128, v1: i16):
v2 = sshr.i128 v0, v1
return v2
}
; run: %sshr_i128_i16(0x81010101_01010101_01010101_01010101, 2) == 0xe0404040_40404040_40404040_40404040
; run: %sshr_i128_i16(0xffffffff_ffffffff_00000000_00000000, 32) == 0xffffffff_ffffffff_ffffffff_00000000
; run: %sshr_i128_i16(0xffffffff_00000000_80000000_00000000, 32) == 0xffffffff_ffffffff_00000000_80000000
; run: %sshr_i128_i16(0x80101010_10101010_12345678_9abcdef0, 66) == 0xffffffff_ffffffff_e0040404_04040404
; run: %sshr_i128_i16(0x00000000_00000000_00000000_00000000, 64) == 0x00000000_00000000_00000000_00000000
; run: %sshr_i128_i16(0x80101010_10101010_12345678_9abcdef0, 0) == 0x80101010_10101010_12345678_9abcdef0
; run: %sshr_i128_i16(0x80101010_10101010_12345678_9abcdef0, 128) == 0x80101010_10101010_12345678_9abcdef0
; run: %sshr_i128_i16(0x81010101_01010101_01010101_01010101, 129) == 0xc0808080_80808080_80808080_80808080
; run: %sshr_i128_i16(0x81010101_01010101_01010101_01010101, 130) == 0xe0404040_40404040_40404040_40404040
function %sshr_i128_i8(i128, i8) -> i128 {
block0(v0: i128, v1: i8):
v2 = sshr.i128 v0, v1
return v2
}
; run: %sshr_i128_i8(0x81010101_01010101_01010101_01010101, 2) == 0xe0404040_40404040_40404040_40404040
; run: %sshr_i128_i8(0xffffffff_ffffffff_00000000_00000000, 32) == 0xffffffff_ffffffff_ffffffff_00000000
; run: %sshr_i128_i8(0xffffffff_00000000_80000000_00000000, 32) == 0xffffffff_ffffffff_00000000_80000000
; run: %sshr_i128_i8(0x80101010_10101010_12345678_9abcdef0, 66) == 0xffffffff_ffffffff_e0040404_04040404
; run: %sshr_i128_i8(0x00000000_00000000_00000000_00000000, 64) == 0x00000000_00000000_00000000_00000000
; run: %sshr_i128_i8(0x80101010_10101010_12345678_9abcdef0, 0) == 0x80101010_10101010_12345678_9abcdef0
; run: %sshr_i128_i8(0x80101010_10101010_12345678_9abcdef0, 128) == 0x80101010_10101010_12345678_9abcdef0
; run: %sshr_i128_i8(0x81010101_01010101_01010101_01010101, 129) == 0xc0808080_80808080_80808080_80808080
; run: %sshr_i128_i8(0x81010101_01010101_01010101_01010101, 130) == 0xe0404040_40404040_40404040_40404040
function %sshr_i64_i128(i64, i128) -> i64 {
block0(v0: i64, v1: i128):
v2 = sshr.i64 v0, v1
return v2
}
; run: %sshr_i64_i128(0x80000000_80000000, 0) == 0x80000000_80000000
; run: %sshr_i64_i128(0x80000000_80000000, 1) == 0xC0000000_40000000
; run: %sshr_i64_i128(0xf0000000_f0000000, 4) == 0xff000000_0f000000
; run: %sshr_i64_i128(0x40000000_40000000, 64) == 0x40000000_40000000
; run: %sshr_i64_i128(0x40000000_40000000, 65) == 0x20000000_20000000
; run: %sshr_i64_i128(0xf0000000_f0000000, 0x00000000_00000004_00000000_00000000) == 0xf0000000_f0000000
; run: %sshr_i64_i128(0x40000000_40000000, 0x00000000_00000001_00000000_00000042) == 0x10000000_10000000
function %sshr_i32_i128(i32, i128) -> i32 {
block0(v0: i32, v1: i128):
v2 = sshr.i32 v0, v1
return v2
}
; run: %sshr_i32_i128(0x80000000, 0) == 0x80000000
; run: %sshr_i32_i128(0x80000000, 1) == 0xC0000000
; run: %sshr_i32_i128(0xf0000000, 4) == 0xff000000
; run: %sshr_i32_i128(0x40000000, 32) == 0x40000000
; run: %sshr_i32_i128(0x40000000, 33) == 0x20000000
; run: %sshr_i32_i128(0xf0000000, 0x00000000_00000004_00000000_00000000) == 0xf0000000
; run: %sshr_i32_i128(0x40000000, 0x00000000_00000001_00000000_00000022) == 0x10000000

174
cranelift/reader/src/parser.rs
View File

@@ -31,6 +31,51 @@ use std::str::FromStr;
use std::{u16, u32};
use target_lexicon::Triple;
macro_rules! match_imm {
($signed:ty, $unsigned:ty, $parser:expr, $err_msg:expr) => {{
if let Some(Token::Integer(text)) = $parser.token() {
$parser.consume();
let negative = text.starts_with('-');
let positive = text.starts_with('+');
let text = if negative || positive {
// Strip sign prefix.
&text[1..]
} else {
text
};
// Parse the text value; the lexer gives us raw text that looks like an integer.
let value = if text.starts_with("0x") {
// Skip underscores.
let text = text.replace("_", "");
// Parse it in hexadecimal form.
<$unsigned>::from_str_radix(&text[2..], 16).map_err(|_| {
$parser.error("unable to parse value as a hexadecimal immediate")
})?
} else {
// Parse it as a signed type to check for overflow and other issues.
text.parse()
.map_err(|_| $parser.error("expected decimal immediate"))?
};
// Apply sign if necessary.
let signed = if negative {
let value = value.wrapping_neg() as $signed;
if value > 0 {
return Err($parser.error("negative number too small"));
}
value
} else {
value as $signed
};
Ok(signed)
} else {
err!($parser.loc, $err_msg)
}
}};
}
/// After some quick benchmarks a program should never have more than 100,000 blocks.
const MAX_BLOCKS_IN_A_FUNCTION: u32 = 100_000;
@@ -793,132 +838,23 @@ impl<'a> Parser<'a> {
// Match and consume an i8 immediate.
fn match_imm8(&mut self, err_msg: &str) -> ParseResult<i8> {
if let Some(Token::Integer(text)) = self.token() {
self.consume();
let negative = text.starts_with('-');
let positive = text.starts_with('+');
let text = if negative || positive {
// Strip sign prefix.
&text[1..]
} else {
text
};
// Parse the text value; the lexer gives us raw text that looks like an integer.
let value = if text.starts_with("0x") {
// Skip underscores.
let text = text.replace("_", "");
// Parse it as a i8 in hexadecimal form.
u8::from_str_radix(&text[2..], 16)
.map_err(|_| self.error("unable to parse i8 as a hexadecimal immediate"))?
} else {
// Parse it as a i8 to check for overflow and other issues.
text.parse()
.map_err(|_| self.error("expected i8 decimal immediate"))?
};
// Apply sign if necessary.
let signed = if negative {
let value = value.wrapping_neg() as i8;
if value > 0 {
return Err(self.error("negative number too small"));
}
value
} else {
value as i8
};
Ok(signed)
} else {
err!(self.loc, err_msg)
}
match_imm!(i8, u8, self, err_msg)
}
// Match and consume a signed 16-bit immediate.
fn match_imm16(&mut self, err_msg: &str) -> ParseResult<i16> {
if let Some(Token::Integer(text)) = self.token() {
self.consume();
let negative = text.starts_with('-');
let positive = text.starts_with('+');
let text = if negative || positive {
// Strip sign prefix.
&text[1..]
} else {
text
};
// Parse the text value; the lexer gives us raw text that looks like an integer.
let value = if text.starts_with("0x") {
// Skip underscores.
let text = text.replace("_", "");
// Parse it as a i16 in hexadecimal form.
u16::from_str_radix(&text[2..], 16)
.map_err(|_| self.error("unable to parse i16 as a hexadecimal immediate"))?
} else {
// Parse it as a i16 to check for overflow and other issues.
text.parse()
.map_err(|_| self.error("expected i16 decimal immediate"))?
};
// Apply sign if necessary.
let signed = if negative {
let value = value.wrapping_neg() as i16;
if value > 0 {
return Err(self.error("negative number too small"));
}
value
} else {
value as i16
};
Ok(signed)
} else {
err!(self.loc, err_msg)
}
match_imm!(i16, u16, self, err_msg)
}
// Match and consume an i32 immediate.
// This is used for stack argument byte offsets.
fn match_imm32(&mut self, err_msg: &str) -> ParseResult<i32> {
if let Some(Token::Integer(text)) = self.token() {
self.consume();
let negative = text.starts_with('-');
let positive = text.starts_with('+');
let text = if negative || positive {
// Strip sign prefix.
&text[1..]
} else {
text
};
match_imm!(i32, u32, self, err_msg)
}
// Parse the text value; the lexer gives us raw text that looks like an integer.
let value = if text.starts_with("0x") {
// Skip underscores.
let text = text.replace("_", "");
// Parse it as a i32 in hexadecimal form.
u32::from_str_radix(&text[2..], 16)
.map_err(|_| self.error("unable to parse i32 as a hexadecimal immediate"))?
} else {
// Parse it as a i32 to check for overflow and other issues.
text.parse()
.map_err(|_| self.error("expected i32 decimal immediate"))?
};
// Apply sign if necessary.
let signed = if negative {
let value = value.wrapping_neg() as i32;
if value > 0 {
return Err(self.error("negative number too small"));
}
value
} else {
value as i32
};
Ok(signed)
} else {
err!(self.loc, err_msg)
}
// Match and consume an i128 immediate.
fn match_imm128(&mut self, err_msg: &str) -> ParseResult<i128> {
match_imm!(i128, u128, self, err_msg)
}
// Match and consume an optional offset32 immediate.
@@ -2805,6 +2741,7 @@ impl<'a> Parser<'a> {
I16 => DataValue::from(self.match_imm16("expected an i16")?),
I32 => DataValue::from(self.match_imm32("expected an i32")?),
I64 => DataValue::from(Into::<i64>::into(self.match_imm64("expected an i64")?)),
I128 => DataValue::from(self.match_imm128("expected an i128")?),
F32 => DataValue::from(self.match_ieee32("expected an f32")?),
F64 => DataValue::from(self.match_ieee64("expected an f64")?),
_ if ty.is_vector() => {
@@ -4126,6 +4063,11 @@ mod tests {
assert_eq!(parse("16", I16).to_string(), "16");
assert_eq!(parse("32", I32).to_string(), "32");
assert_eq!(parse("64", I64).to_string(), "64");
assert_eq!(
parse("0x01234567_01234567_01234567_01234567", I128).to_string(),
"1512366032949150931280199141537564007"
);
assert_eq!(parse("1234567", I128).to_string(), "1234567");
assert_eq!(parse("0x32.32", F32).to_string(), "0x1.919000p5");
assert_eq!(parse("0x64.64", F64).to_string(), "0x1.9190000000000p6");
assert_eq!(parse("true", B1).to_string(), "true");