From 8115e7252d27ba67a128bdca529d50ba8490e70d Mon Sep 17 00:00:00 2001 From: Afonso Bordado Date: Tue, 14 Sep 2021 15:21:37 +0100 Subject: [PATCH 1/3] cranelift: Add support for i128 immediates in parser --- cranelift/codegen/src/data_value.rs | 2 ++ cranelift/reader/src/parser.rs | 49 +++++++++++++++++++++++++++++ 2 files changed, 51 insertions(+) diff --git a/cranelift/codegen/src/data_value.rs b/cranelift/codegen/src/data_value.rs index 965ce1bec5..13aa237674 100644 --- a/cranelift/codegen/src/data_value.rs +++ b/cranelift/codegen/src/data_value.rs @@ -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(), ))), diff --git a/cranelift/reader/src/parser.rs b/cranelift/reader/src/parser.rs index 97b4a7c77d..a0e5a35e3a 100644 --- a/cranelift/reader/src/parser.rs +++ b/cranelift/reader/src/parser.rs @@ -921,6 +921,49 @@ impl<'a> Parser<'a> { } } + // Match and consume an i128 immediate. + fn match_imm128(&mut self, err_msg: &str) -> ParseResult { + 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 i128 in hexadecimal form. + u128::from_str_radix(&text[2..], 16) + .map_err(|_| self.error("unable to parse i128 as a hexadecimal immediate"))? + } else { + // Parse it as a i128 to check for overflow and other issues. + text.parse() + .map_err(|_| self.error("expected i128 decimal immediate"))? + }; + + // Apply sign if necessary. + let signed = if negative { + let value = value.wrapping_neg() as i128; + if value > 0 { + return Err(self.error("negative number too small")); + } + value + } else { + value as i128 + }; + + Ok(signed) + } else { + err!(self.loc, err_msg) + } + } + // Match and consume an optional offset32 immediate. // // Note that this will match an empty string as an empty offset, and that if an offset is @@ -2805,6 +2848,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::::into(self.match_imm64("expected an i64")?)), + I128 => DataValue::from(self.match_imm128("expected an i64")?), F32 => DataValue::from(self.match_ieee32("expected an f32")?), F64 => DataValue::from(self.match_ieee64("expected an f64")?), _ if ty.is_vector() => { @@ -4126,6 +4170,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"); From eae1b2d246dafcb1c1ed05817e33372927b0a773 Mon Sep 17 00:00:00 2001 From: Afonso Bordado Date: Wed, 15 Sep 2021 15:18:04 +0100 Subject: [PATCH 2/3] cranelift: Update i128 tests to use i128 values in functions --- .../filetests/runtests/i128-arithmetic.clif | 101 ++- .../filetests/runtests/i128-bandnot.clif | 14 + .../filetests/runtests/i128-bint.clif | 8 +- .../filetests/runtests/i128-bitops-cls.clif | 24 - .../filetests/runtests/i128-bitops-count.clif | 93 +-- .../filetests/runtests/i128-bitops.clif | 179 ++--- .../filetests/runtests/i128-bitrev.clif | 15 + .../filetests/runtests/i128-bornot.clif | 14 + .../filetests/filetests/runtests/i128-br.clif | 48 +- .../filetests/runtests/i128-bricmp.clif | 432 +++++------ .../filetests/runtests/i128-bxornot.clif | 14 + .../filetests/runtests/i128-cls.clif | 18 + .../filetests/runtests/i128-const.clif | 8 +- .../filetests/runtests/i128-extend-2.clif | 73 +- .../filetests/runtests/i128-extend.clif | 26 +- .../runtests/i128-icmp-overflow.clif | 72 +- .../filetests/runtests/i128-icmp.clif | 283 ++++---- .../filetests/runtests/i128-load-store.clif | 173 +++-- .../filetests/runtests/i128-reduce.clif | 61 +- .../filetests/runtests/i128-rotate.clif | 83 +-- .../filetests/runtests/i128-select.clif | 24 +- .../runtests/i128-shifts-small-types.clif | 138 ++-- .../filetests/runtests/i128-shifts.clif | 675 ++++++++---------- 23 files changed, 1164 insertions(+), 1412 deletions(-) create mode 100644 cranelift/filetests/filetests/runtests/i128-bandnot.clif delete mode 100644 cranelift/filetests/filetests/runtests/i128-bitops-cls.clif create mode 100644 cranelift/filetests/filetests/runtests/i128-bornot.clif create mode 100644 cranelift/filetests/filetests/runtests/i128-bxornot.clif create mode 100644 cranelift/filetests/filetests/runtests/i128-cls.clif diff --git a/cranelift/filetests/filetests/runtests/i128-arithmetic.clif b/cranelift/filetests/filetests/runtests/i128-arithmetic.clif index e5bbd08f6f..f891239155 100644 --- a/cranelift/filetests/filetests/runtests/i128-arithmetic.clif +++ b/cranelift/filetests/filetests/runtests/i128-arithmetic.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-bandnot.clif b/cranelift/filetests/filetests/runtests/i128-bandnot.clif new file mode 100644 index 0000000000..bb2a4ba2ba --- /dev/null +++ b/cranelift/filetests/filetests/runtests/i128-bandnot.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-bint.clif b/cranelift/filetests/filetests/runtests/i128-bint.clif index 4c0ed4f890..f959af583b 100644 --- a/cranelift/filetests/filetests/runtests/i128-bint.clif +++ b/cranelift/filetests/filetests/runtests/i128-bint.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-bitops-cls.clif b/cranelift/filetests/filetests/runtests/i128-bitops-cls.clif deleted file mode 100644 index 14c82ceec4..0000000000 --- a/cranelift/filetests/filetests/runtests/i128-bitops-cls.clif +++ /dev/null @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-bitops-count.clif b/cranelift/filetests/filetests/runtests/i128-bitops-count.clif index 6c0f23dd1f..627dbf3e91 100644 --- a/cranelift/filetests/filetests/runtests/i128-bitops-count.clif +++ b/cranelift/filetests/filetests/runtests/i128-bitops-count.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-bitops.clif b/cranelift/filetests/filetests/runtests/i128-bitops.clif index 1723186e6b..4a86f43fe5 100644 --- a/cranelift/filetests/filetests/runtests/i128-bitops.clif +++ b/cranelift/filetests/filetests/runtests/i128-bitops.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-bitrev.clif b/cranelift/filetests/filetests/runtests/i128-bitrev.clif index e494b32597..5e30ad90fd 100644 --- a/cranelift/filetests/filetests/runtests/i128-bitrev.clif +++ b/cranelift/filetests/filetests/runtests/i128-bitrev.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-bornot.clif b/cranelift/filetests/filetests/runtests/i128-bornot.clif new file mode 100644 index 0000000000..e86f71915d --- /dev/null +++ b/cranelift/filetests/filetests/runtests/i128-bornot.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-br.clif b/cranelift/filetests/filetests/runtests/i128-br.clif index 74b4f6fa8f..d755a5bd06 100644 --- a/cranelift/filetests/filetests/runtests/i128-br.clif +++ b/cranelift/filetests/filetests/runtests/i128-br.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-bricmp.clif b/cranelift/filetests/filetests/runtests/i128-bricmp.clif index 0f5f96536b..29f340fbdb 100644 --- a/cranelift/filetests/filetests/runtests/i128-bricmp.clif +++ b/cranelift/filetests/filetests/runtests/i128-bricmp.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-bxornot.clif b/cranelift/filetests/filetests/runtests/i128-bxornot.clif new file mode 100644 index 0000000000..ecacc84387 --- /dev/null +++ b/cranelift/filetests/filetests/runtests/i128-bxornot.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-cls.clif b/cranelift/filetests/filetests/runtests/i128-cls.clif new file mode 100644 index 0000000000..212d2e5135 --- /dev/null +++ b/cranelift/filetests/filetests/runtests/i128-cls.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-const.clif b/cranelift/filetests/filetests/runtests/i128-const.clif index 604015a99f..65975c680c 100644 --- a/cranelift/filetests/filetests/runtests/i128-const.clif +++ b/cranelift/filetests/filetests/runtests/i128-const.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-extend-2.clif b/cranelift/filetests/filetests/runtests/i128-extend-2.clif index 906d699bbc..0d5ce42a58 100644 --- a/cranelift/filetests/filetests/runtests/i128-extend-2.clif +++ b/cranelift/filetests/filetests/runtests/i128-extend-2.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-extend.clif b/cranelift/filetests/filetests/runtests/i128-extend.clif index 57263be68e..1789299479 100644 --- a/cranelift/filetests/filetests/runtests/i128-extend.clif +++ b/cranelift/filetests/filetests/runtests/i128-extend.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-icmp-overflow.clif b/cranelift/filetests/filetests/runtests/i128-icmp-overflow.clif index e91b21de50..abbcd7d2f8 100644 --- a/cranelift/filetests/filetests/runtests/i128-icmp-overflow.clif +++ b/cranelift/filetests/filetests/runtests/i128-icmp-overflow.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-icmp.clif b/cranelift/filetests/filetests/runtests/i128-icmp.clif index e29000b931..5758d5ef35 100644 --- a/cranelift/filetests/filetests/runtests/i128-icmp.clif +++ b/cranelift/filetests/filetests/runtests/i128-icmp.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-load-store.clif b/cranelift/filetests/filetests/runtests/i128-load-store.clif index 41046e8717..4d4c9e11dd 100644 --- a/cranelift/filetests/filetests/runtests/i128-load-store.clif +++ b/cranelift/filetests/filetests/runtests/i128-load-store.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-reduce.clif b/cranelift/filetests/filetests/runtests/i128-reduce.clif index 08ddfad194..15baef87f1 100644 --- a/cranelift/filetests/filetests/runtests/i128-reduce.clif +++ b/cranelift/filetests/filetests/runtests/i128-reduce.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-rotate.clif b/cranelift/filetests/filetests/runtests/i128-rotate.clif index 359e9c1a7c..47a4ab9ea5 100644 --- a/cranelift/filetests/filetests/runtests/i128-rotate.clif +++ b/cranelift/filetests/filetests/runtests/i128-rotate.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-select.clif b/cranelift/filetests/filetests/runtests/i128-select.clif index 0d23939673..d557d31e2f 100644 --- a/cranelift/filetests/filetests/runtests/i128-select.clif +++ b/cranelift/filetests/filetests/runtests/i128-select.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-shifts-small-types.clif b/cranelift/filetests/filetests/runtests/i128-shifts-small-types.clif index c486092703..094315426f 100644 --- a/cranelift/filetests/filetests/runtests/i128-shifts-small-types.clif +++ b/cranelift/filetests/filetests/runtests/i128-shifts-small-types.clif @@ -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 diff --git a/cranelift/filetests/filetests/runtests/i128-shifts.clif b/cranelift/filetests/filetests/runtests/i128-shifts.clif index 1e862cb7e9..41cef85e16 100644 --- a/cranelift/filetests/filetests/runtests/i128-shifts.clif +++ b/cranelift/filetests/filetests/runtests/i128-shifts.clif @@ -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 From 3a4ebd772700deb77e5da2fa310e10203ba4ec9d Mon Sep 17 00:00:00 2001 From: Afonso Bordado Date: Sun, 19 Sep 2021 15:00:41 +0100 Subject: [PATCH 3/3] cranelift: Deduplicate match_imm functions Transforming this into a generic function is proving to be a challenge since most of the necessary methods are not in a trait. We also need to cast between the signed and unsigned types, which is difficult to do in a generic function. This can be solved for example by adding the num crate as a dependency. But adding a dependency just to solve this issue seems a bit much. --- cranelift/reader/src/parser.rs | 207 ++++++++------------------------- 1 file changed, 50 insertions(+), 157 deletions(-) diff --git a/cranelift/reader/src/parser.rs b/cranelift/reader/src/parser.rs index a0e5a35e3a..a8f20230fc 100644 --- a/cranelift/reader/src/parser.rs +++ b/cranelift/reader/src/parser.rs @@ -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,175 +838,23 @@ impl<'a> Parser<'a> { // Match and consume an i8 immediate. fn match_imm8(&mut self, err_msg: &str) -> ParseResult { - 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 { - 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 { - 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 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_imm!(i32, u32, self, err_msg) } // Match and consume an i128 immediate. fn match_imm128(&mut self, err_msg: &str) -> ParseResult { - 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 i128 in hexadecimal form. - u128::from_str_radix(&text[2..], 16) - .map_err(|_| self.error("unable to parse i128 as a hexadecimal immediate"))? - } else { - // Parse it as a i128 to check for overflow and other issues. - text.parse() - .map_err(|_| self.error("expected i128 decimal immediate"))? - }; - - // Apply sign if necessary. - let signed = if negative { - let value = value.wrapping_neg() as i128; - if value > 0 { - return Err(self.error("negative number too small")); - } - value - } else { - value as i128 - }; - - Ok(signed) - } else { - err!(self.loc, err_msg) - } + match_imm!(i128, u128, self, err_msg) } // Match and consume an optional offset32 immediate. @@ -2848,7 +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::::into(self.match_imm64("expected an i64")?)), - I128 => DataValue::from(self.match_imm128("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() => {