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

aarch64: Fix lowering amounts for shifts

Browse Source 
This commit addresses two issues:
* A panic when shifting any non i128 type by i128 amounts (#3064)
* Wrong results when lowering shifts with small types (i8, i16)

In these types when shifting for amounts larger than the size of the
type, we would not get the wrapping behaviour that we see on i32 and i64.
This is because in these larger types, the wrapping behaviour is automatically
implemented by using the appropriate instruction, however we do not
have i8 and i16 specific instructions, so we have to manually wrap
the shift amount with an AND instruction.

This issue is also found on x86_64 and s390x, and a separate issue will
be filed for those.

Closes #3064
This commit is contained in:
Afonso Bordado
2021-07-09 14:40:15 +01:00
committed by Anton Kirilov
parent 6c3d7092b9
commit db5566dadb
8 changed files with 1199 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
cranelift/codegen/src/isa/aarch64/lower.rs
View File

@@ -107,6 +107,15 @@ pub(crate) enum ResultRegImmShift {
ImmShift(ImmShift), ImmShift(ImmShift),
} }
impl ResultRegImmShift {
pub fn unwrap_reg(self) -> Reg {
match self {
ResultRegImmShift::Reg(r) => r,
_ => panic!("Unwrapped ResultRegImmShift, expected reg, got: {:?}", self),
}
}
}
//============================================================================ //============================================================================
// Lowering: convert instruction inputs to forms that we can use. // Lowering: convert instruction inputs to forms that we can use.
@@ -1468,6 +1477,43 @@ pub(crate) fn materialize_bool_result<C: LowerCtx<I = Inst>>(
} }
} }
pub(crate) fn lower_shift_amt<C: LowerCtx<I = Inst>>(
ctx: &mut C,
amt_input: InsnInput,
dst_ty: Type,
tmp_reg: Writable<Reg>,
) -> ResultRegImmShift {
let amt_ty = ctx.input_ty(amt_input.insn, amt_input.input);
match (dst_ty, amt_ty) {
// When shifting for amounts larger than the size of the type, the CLIF shift
// instructions implement a "wrapping" behaviour, such that an i8 << 8 is
// equivalent to i8 << 0
//
// On i32 and i64 types this matches what the aarch64 spec does, but on smaller
// types (i16, i8) we need to do this manually, so we wrap the shift amount
// with an AND instruction
(I16 | I8, _) => {
// We can ignore the top half of the shift amount register if the type is I128
let amt_reg = put_input_in_regs(ctx, amt_input).regs()[0];
let mask = (ty_bits(dst_ty) - 1) as u64;
ctx.emit(Inst::AluRRImmLogic {
alu_op: ALUOp::And32,
rd: tmp_reg,
rn: amt_reg,
imml: ImmLogic::maybe_from_u64(mask, I32).unwrap(),
});
ResultRegImmShift::Reg(tmp_reg.to_reg())
}
// TODO: We can use immlogic for i128 types here
(I128, _) | (_, I128) => {
// For I128 shifts, we need a register without immlogic
ResultRegImmShift::Reg(put_input_in_regs(ctx, amt_input).regs()[0])
}
_ => put_input_in_reg_immshift(ctx, amt_input, ty_bits(dst_ty)),
}
}
/// This is target-word-size dependent. And it excludes booleans and reftypes. /// This is target-word-size dependent. And it excludes booleans and reftypes.
pub(crate) fn is_valid_atomic_transaction_ty(ty: Type) -> bool { pub(crate) fn is_valid_atomic_transaction_ty(ty: Type) -> bool {
match ty { match ty {

6
cranelift/codegen/src/isa/aarch64/lower_inst.rs
View File

@@ -801,10 +801,8 @@ pub(crate) fn lower_insn_to_regs<C: LowerCtx<I = Inst>>(
let out_regs = get_output_reg(ctx, outputs[0]); let out_regs = get_output_reg(ctx, outputs[0]);
let ty = ty.unwrap(); let ty = ty.unwrap();
if ty == I128 { if ty == I128 {
// TODO: We can use immlogic here
let src = put_input_in_regs(ctx, inputs[0]); let src = put_input_in_regs(ctx, inputs[0]);
// We can ignore the top half of the shift amount register let amt = lower_shift_amt(ctx, inputs[1], ty, out_regs.regs()[0]).unwrap_reg();
let amt = put_input_in_regs(ctx, inputs[1]).regs()[0];
match op { match op {
Opcode::Ishl => emit_shl_i128(ctx, src, out_regs, amt), Opcode::Ishl => emit_shl_i128(ctx, src, out_regs, amt),
@@ -828,7 +826,7 @@ pub(crate) fn lower_insn_to_regs<C: LowerCtx<I = Inst>>(
_ => unreachable!(), _ => unreachable!(),
}; };
let rn = put_input_in_reg(ctx, inputs[0], narrow_mode); let rn = put_input_in_reg(ctx, inputs[0], narrow_mode);
let rm = put_input_in_reg_immshift(ctx, inputs[1], ty_bits(ty)); let rm = lower_shift_amt(ctx, inputs[1], ty, out_regs.regs()[0]);
let alu_op = match op { let alu_op = match op {
Opcode::Ishl => choose_32_64(ty, ALUOp::Lsl32, ALUOp::Lsl64), Opcode::Ishl => choose_32_64(ty, ALUOp::Lsl32, ALUOp::Lsl64),
Opcode::Ushr => choose_32_64(ty, ALUOp::Lsr32, ALUOp::Lsr64), Opcode::Ushr => choose_32_64(ty, ALUOp::Lsr32, ALUOp::Lsr64),

36
cranelift/filetests/filetests/isa/aarch64/shift-rotate.clif
View File

@@ -237,12 +237,9 @@ block0(v0: i16, v1: i16):
return v2 return v2
} }
; check: stp fp, lr, [sp, #-16]! ; check: uxth w0, w0
; nextln: mov fp, sp ; nextln: and w1, w1, #15
; nextln: uxth w0, w0
; nextln: lsr w0, w0, w1 ; nextln: lsr w0, w0, w1
; nextln: ldp fp, lr, [sp], #16
; nextln: ret
function %f11(i8, i8) -> i8 { function %f11(i8, i8) -> i8 {
block0(v0: i8, v1: i8): block0(v0: i8, v1: i8):
@@ -250,12 +247,9 @@ block0(v0: i8, v1: i8):
return v2 return v2
} }
; check: stp fp, lr, [sp, #-16]! ; check: uxtb w0, w0
; nextln: mov fp, sp ; nextln: and w1, w1, #7
; nextln: uxtb w0, w0
; nextln: lsr w0, w0, w1 ; nextln: lsr w0, w0, w1
; nextln: ldp fp, lr, [sp], #16
; nextln: ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; LSL, variable ;; LSL, variable
@@ -291,11 +285,8 @@ block0(v0: i16, v1: i16):
return v2 return v2
} }
; check: stp fp, lr, [sp, #-16]! ; check: and w1, w1, #15
; nextln: mov fp, sp
; nextln: lsl w0, w0, w1 ; nextln: lsl w0, w0, w1
; nextln: ldp fp, lr, [sp], #16
; nextln: ret
function %f15(i8, i8) -> i8 { function %f15(i8, i8) -> i8 {
block0(v0: i8, v1: i8): block0(v0: i8, v1: i8):
@@ -303,11 +294,8 @@ block0(v0: i8, v1: i8):
return v2 return v2
} }
; check: stp fp, lr, [sp, #-16]! ; check: and w1, w1, #7
; nextln: mov fp, sp
; nextln: lsl w0, w0, w1 ; nextln: lsl w0, w0, w1
; nextln: ldp fp, lr, [sp], #16
; nextln: ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ASR, variable ;; ASR, variable
@@ -343,12 +331,8 @@ block0(v0: i16, v1: i16):
return v2 return v2
} }
; check: stp fp, lr, [sp, #-16]! ; check: and w1, w1, #15
; nextln: mov fp, sp
; nextln: sxth w0, w0
; nextln: asr w0, w0, w1 ; nextln: asr w0, w0, w1
; nextln: ldp fp, lr, [sp], #16
; nextln: ret
function %f19(i8, i8) -> i8 { function %f19(i8, i8) -> i8 {
block0(v0: i8, v1: i8): block0(v0: i8, v1: i8):
@@ -356,12 +340,8 @@ block0(v0: i8, v1: i8):
return v2 return v2
} }
; check: stp fp, lr, [sp, #-16]! ; check: and w1, w1, #7
; nextln: mov fp, sp
; nextln: sxtb w0, w0
; nextln: asr w0, w0, w1 ; nextln: asr w0, w0, w1
; nextln: ldp fp, lr, [sp], #16
; nextln: ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; immediate forms ;; immediate forms

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

@@ -71,136 +71,3 @@ block0(v0: i64,v1: i64,v2: i64,v3: i64):
; run: %mul_i128(0x00000000_01234567, 0x89ABCDEF_00000000, 0x00000000_FEDCBA98, 0x76543210_00000000) == [0x0121FA00_23E20B28, 0xE2946058_00000000] ; 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(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]
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_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 = ishl.i128 v3, v5
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 %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
}
; 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_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
}
; 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]
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_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 = sshr.i128 v3, v5
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]

90
cranelift/filetests/filetests/runtests/i128-shifts-small-types.clif Normal file
View File

@@ -0,0 +1,90 @@
test run
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
}
; 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
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
}
; 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
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
}
; 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
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
}
; 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
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
}
; 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
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
}
; 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

412
cranelift/filetests/filetests/runtests/i128-shifts.clif Normal file
View File

@@ -0,0 +1,412 @@
test run
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
v6 = ishl.i128 v3, v5
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
function %ishl_i32_i128(i32, i64, i64) -> i32 {
block0(v0: i32, v1: i64, v2: i64):
v3 = iconcat v1, v2
v4 = ishl.i32 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
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
}
; 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]
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
}
; 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]
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
}
; 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]
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
}
; 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]
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
}
; 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
function %ushr_i32_i128(i32, i64, i64) -> i32 {
block0(v0: i32, v1: i64, v2: i64):
v3 = iconcat v1, v2
v4 = ushr.i32 v0, v3
return v4
}
; run: %ushr_i32_i128(0x10000000, 0, 0) == 0x10000000
; run: %ushr_i32_i128(0x10000000, 1, 0) == 0x08000000
; run: %ushr_i32_i128(0xf0000000, 0, 4) == 0xf0000000
; run: %ushr_i32_i128(0xf0000000, 4, 0) == 0x0f000000
; run: %ushr_i32_i128(0x40000000, 32, 0) == 0x40000000
; run: %ushr_i32_i128(0x40000000, 33, 0) == 0x20000000
; run: %ushr_i32_i128(0x40000000, 34, 1) == 0x10000000
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
v6 = sshr.i128 v3, v5
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
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
}
; 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

321
cranelift/filetests/filetests/runtests/shifts-small-types.clif Normal file
View File

@@ -0,0 +1,321 @@
test run
target aarch64
; TODO: Merge this with the main shifts file when x86_64 & s390x passes these.
function %ishl_i16_i64(i16, i64) -> i16 {
block0(v0: i16, v1: i64):
v2 = ishl.i16 v0, v1
return v2
}
; run: %ishl_i16_i64(0x0000, 0) == 0x0000
; run: %ishl_i16_i64(0x0000, 1) == 0x0000
; run: %ishl_i16_i64(0x000f, 0) == 0x000f
; run: %ishl_i16_i64(0x000f, 4) == 0x00f0
; run: %ishl_i16_i64(0x0004, 16) == 0x0004
; run: %ishl_i16_i64(0x0004, 17) == 0x0008
; run: %ishl_i16_i64(0x0004, 18) == 0x0010
function %ishl_i16_i32(i16, i32) -> i16 {
block0(v0: i16, v1: i32):
v2 = ishl.i16 v0, v1
return v2
}
; run: %ishl_i16_i32(0x0000, 0) == 0x0000
; run: %ishl_i16_i32(0x0000, 1) == 0x0000
; run: %ishl_i16_i32(0x000f, 0) == 0x000f
; run: %ishl_i16_i32(0x000f, 4) == 0x00f0
; run: %ishl_i16_i32(0x0004, 16) == 0x0004
; run: %ishl_i16_i32(0x0004, 17) == 0x0008
; run: %ishl_i16_i32(0x0004, 18) == 0x0010
function %ishl_i16_i16(i16, i16) -> i16 {
block0(v0: i16, v1: i16):
v2 = ishl.i16 v0, v1
return v2
}
; run: %ishl_i16_i16(0x0000, 0) == 0x0000
; run: %ishl_i16_i16(0x0000, 1) == 0x0000
; run: %ishl_i16_i16(0x000f, 0) == 0x000f
; run: %ishl_i16_i16(0x000f, 4) == 0x00f0
; run: %ishl_i16_i16(0x0004, 16) == 0x0004
; run: %ishl_i16_i16(0x0004, 17) == 0x0008
; run: %ishl_i16_i16(0x0004, 18) == 0x0010
function %ishl_i16_i8(i16, i8) -> i16 {
block0(v0: i16, v1: i8):
v2 = ishl.i16 v0, v1
return v2
}
; run: %ishl_i16_i8(0x0000, 0) == 0x0000
; run: %ishl_i16_i8(0x0000, 1) == 0x0000
; run: %ishl_i16_i8(0x000f, 0) == 0x000f
; run: %ishl_i16_i8(0x000f, 4) == 0x00f0
; run: %ishl_i16_i8(0x0004, 16) == 0x0004
; run: %ishl_i16_i8(0x0004, 17) == 0x0008
; run: %ishl_i16_i8(0x0004, 18) == 0x0010
function %ishl_i8_i64(i8, i64) -> i8 {
block0(v0: i8, v1: i64):
v2 = ishl.i8 v0, v1
return v2
}
; run: %ishl_i8_i64(0x00, 0) == 0x00
; run: %ishl_i8_i64(0x00, 1) == 0x00
; run: %ishl_i8_i64(0x0f, 0) == 0x0f
; run: %ishl_i8_i64(0x0f, 4) == 0xf0
; run: %ishl_i8_i64(0x04, 8) == 0x04
; run: %ishl_i8_i64(0x04, 9) == 0x08
; run: %ishl_i8_i64(0x04, 10) == 0x10
function %ishl_i8_i32(i8, i32) -> i8 {
block0(v0: i8, v1: i32):
v2 = ishl.i8 v0, v1
return v2
}
; run: %ishl_i8_i32(0x00, 0) == 0x00
; run: %ishl_i8_i32(0x00, 1) == 0x00
; run: %ishl_i8_i32(0x0f, 0) == 0x0f
; run: %ishl_i8_i32(0x0f, 4) == 0xf0
; run: %ishl_i8_i32(0x04, 8) == 0x04
; run: %ishl_i8_i32(0x04, 9) == 0x08
; run: %ishl_i8_i32(0x04, 10) == 0x10
function %ishl_i8_i16(i8, i16) -> i8 {
block0(v0: i8, v1: i16):
v2 = ishl.i8 v0, v1
return v2
}
; run: %ishl_i8_i16(0x00, 0) == 0x00
; run: %ishl_i8_i16(0x00, 1) == 0x00
; run: %ishl_i8_i16(0x0f, 0) == 0x0f
; run: %ishl_i8_i16(0x0f, 4) == 0xf0
; run: %ishl_i8_i16(0x04, 8) == 0x04
; run: %ishl_i8_i16(0x04, 9) == 0x08
; run: %ishl_i8_i16(0x04, 10) == 0x10
function %ishl_i8_i8(i8, i8) -> i8 {
block0(v0: i8, v1: i8):
v2 = ishl.i8 v0, v1
return v2
}
; run: %ishl_i8_i8(0x00, 0) == 0x00
; run: %ishl_i8_i8(0x00, 1) == 0x00
; run: %ishl_i8_i8(0x0f, 0) == 0x0f
; run: %ishl_i8_i8(0x0f, 4) == 0xf0
; run: %ishl_i8_i8(0x04, 8) == 0x04
; run: %ishl_i8_i8(0x04, 9) == 0x08
; run: %ishl_i8_i8(0x04, 10) == 0x10
function %ushr_i16_i64(i16, i64) -> i16 {
block0(v0: i16, v1: i64):
v2 = ushr.i16 v0, v1
return v2
}
; run: %ushr_i16_i64(0x1000, 0) == 0x1000
; run: %ushr_i16_i64(0x1000, 1) == 0x0800
; run: %ushr_i16_i64(0xf000, 0) == 0xf000
; run: %ushr_i16_i64(0xf000, 4) == 0x0f00
; run: %ushr_i16_i64(0x4000, 16) == 0x4000
; run: %ushr_i16_i64(0x4000, 17) == 0x2000
; run: %ushr_i16_i64(0x4000, 18) == 0x1000
function %ushr_i16_i32(i16, i32) -> i16 {
block0(v0: i16, v1: i32):
v2 = ushr.i16 v0, v1
return v2
}
; run: %ushr_i16_i32(0x1000, 0) == 0x1000
; run: %ushr_i16_i32(0x1000, 1) == 0x0800
; run: %ushr_i16_i32(0xf000, 0) == 0xf000
; run: %ushr_i16_i32(0xf000, 4) == 0x0f00
; run: %ushr_i16_i32(0x4000, 16) == 0x4000
; run: %ushr_i16_i32(0x4000, 17) == 0x2000
; run: %ushr_i16_i32(0x4000, 18) == 0x1000
function %ushr_i16_i16(i16, i16) -> i16 {
block0(v0: i16, v1: i16):
v2 = ushr.i16 v0, v1
return v2
}
; run: %ushr_i16_i16(0x1000, 0) == 0x1000
; run: %ushr_i16_i16(0x1000, 1) == 0x0800
; run: %ushr_i16_i16(0xf000, 0) == 0xf000
; run: %ushr_i16_i16(0xf000, 4) == 0x0f00
; run: %ushr_i16_i16(0x4000, 16) == 0x4000
; run: %ushr_i16_i16(0x4000, 17) == 0x2000
; run: %ushr_i16_i16(0x4000, 18) == 0x1000
function %ushr_i16_i8(i16, i8) -> i16 {
block0(v0: i16, v1: i8):
v2 = ushr.i16 v0, v1
return v2
}
; run: %ushr_i16_i8(0x1000, 0) == 0x1000
; run: %ushr_i16_i8(0x1000, 1) == 0x0800
; run: %ushr_i16_i8(0xf000, 0) == 0xf000
; run: %ushr_i16_i8(0xf000, 4) == 0x0f00
; run: %ushr_i16_i8(0x4000, 16) == 0x4000
; run: %ushr_i16_i8(0x4000, 17) == 0x2000
; run: %ushr_i16_i8(0x4000, 18) == 0x1000
function %ushr_i8_i64(i8, i64) -> i8 {
block0(v0: i8, v1: i64):
v2 = ushr.i8 v0, v1
return v2
}
; run: %ushr_i8_i64(0x10, 0) == 0x10
; run: %ushr_i8_i64(0x10, 1) == 0x08
; run: %ushr_i8_i64(0xf0, 0) == 0xf0
; run: %ushr_i8_i64(0xf0, 4) == 0x0f
; run: %ushr_i8_i64(0x40, 8) == 0x40
; run: %ushr_i8_i64(0x40, 9) == 0x20
; run: %ushr_i8_i64(0x40, 10) == 0x10
function %ushr_i8_i32(i8, i32) -> i8 {
block0(v0: i8, v1: i32):
v2 = ushr.i8 v0, v1
return v2
}
; run: %ushr_i8_i32(0x10, 0) == 0x10
; run: %ushr_i8_i32(0x10, 1) == 0x08
; run: %ushr_i8_i32(0xf0, 0) == 0xf0
; run: %ushr_i8_i32(0xf0, 4) == 0x0f
; run: %ushr_i8_i32(0x40, 8) == 0x40
; run: %ushr_i8_i32(0x40, 9) == 0x20
; run: %ushr_i8_i32(0x40, 10) == 0x10
function %ushr_i8_i16(i8, i16) -> i8 {
block0(v0: i8, v1: i16):
v2 = ushr.i8 v0, v1
return v2
}
; run: %ushr_i8_i16(0x10, 0) == 0x10
; run: %ushr_i8_i16(0x10, 1) == 0x08
; run: %ushr_i8_i16(0xf0, 0) == 0xf0
; run: %ushr_i8_i16(0xf0, 4) == 0x0f
; run: %ushr_i8_i16(0x40, 8) == 0x40
; run: %ushr_i8_i16(0x40, 9) == 0x20
; run: %ushr_i8_i16(0x40, 10) == 0x10
function %ushr_i8_i8(i8, i8) -> i8 {
block0(v0: i8, v1: i8):
v2 = ushr.i8 v0, v1
return v2
}
; run: %ushr_i8_i8(0x10, 0) == 0x10
; run: %ushr_i8_i8(0x10, 1) == 0x08
; run: %ushr_i8_i8(0xf0, 0) == 0xf0
; run: %ushr_i8_i8(0xf0, 4) == 0x0f
; run: %ushr_i8_i8(0x40, 8) == 0x40
; run: %ushr_i8_i8(0x40, 9) == 0x20
; run: %ushr_i8_i8(0x40, 10) == 0x10
function %sshr_i16_i64(i16, i64) -> i16 {
block0(v0: i16, v1: i64):
v2 = sshr.i16 v0, v1
return v2
}
; run: %sshr_i16_i64(0x8000, 0) == 0x8000
; run: %sshr_i16_i64(0x8000, 1) == 0xC000
; run: %sshr_i16_i64(0xf000, 0) == 0xf000
; run: %sshr_i16_i64(0xf000, 4) == 0xff00
; run: %sshr_i16_i64(0x4000, 16) == 0x4000
; run: %sshr_i16_i64(0x4000, 17) == 0x2000
; run: %sshr_i16_i64(0x4000, 18) == 0x1000
function %sshr_i16_i32(i16, i32) -> i16 {
block0(v0: i16, v1: i32):
v2 = sshr.i16 v0, v1
return v2
}
; run: %sshr_i16_i32(0x8000, 0) == 0x8000
; run: %sshr_i16_i32(0x8000, 1) == 0xC000
; run: %sshr_i16_i32(0xf000, 0) == 0xf000
; run: %sshr_i16_i32(0xf000, 4) == 0xff00
; run: %sshr_i16_i32(0x4000, 16) == 0x4000
; run: %sshr_i16_i32(0x4000, 17) == 0x2000
; run: %sshr_i16_i32(0x4000, 18) == 0x1000
function %sshr_i16_i16(i16, i16) -> i16 {
block0(v0: i16, v1: i16):
v2 = sshr.i16 v0, v1
return v2
}
; run: %sshr_i16_i16(0x8000, 0) == 0x8000
; run: %sshr_i16_i16(0x8000, 1) == 0xC000
; run: %sshr_i16_i16(0xf000, 0) == 0xf000
; run: %sshr_i16_i16(0xf000, 4) == 0xff00
; run: %sshr_i16_i16(0x4000, 16) == 0x4000
; run: %sshr_i16_i16(0x4000, 17) == 0x2000
; run: %sshr_i16_i16(0x4000, 18) == 0x1000
function %sshr_i16_i8(i16, i8) -> i16 {
block0(v0: i16, v1: i8):
v2 = sshr.i16 v0, v1
return v2
}
; run: %sshr_i16_i8(0x8000, 0) == 0x8000
; run: %sshr_i16_i8(0x8000, 1) == 0xC000
; run: %sshr_i16_i8(0xf000, 0) == 0xf000
; run: %sshr_i16_i8(0xf000, 4) == 0xff00
; run: %sshr_i16_i8(0x4000, 16) == 0x4000
; run: %sshr_i16_i8(0x4000, 17) == 0x2000
; run: %sshr_i16_i8(0x4000, 18) == 0x1000
function %sshr_i8_i64(i8, i64) -> i8 {
block0(v0: i8, v1: i64):
v2 = sshr.i8 v0, v1
return v2
}
; run: %sshr_i8_i64(0x80, 0) == 0x80
; run: %sshr_i8_i64(0x80, 1) == 0xC0
; run: %sshr_i8_i64(0xf0, 0) == 0xf0
; run: %sshr_i8_i64(0xf0, 4) == 0xff
; run: %sshr_i8_i64(0x40, 8) == 0x40
; run: %sshr_i8_i64(0x40, 9) == 0x20
; run: %sshr_i8_i64(0x40, 10) == 0x10
function %sshr_i8_i32(i8, i32) -> i8 {
block0(v0: i8, v1: i32):
v2 = sshr.i8 v0, v1
return v2
}
; run: %sshr_i8_i32(0x80, 0) == 0x80
; run: %sshr_i8_i32(0x80, 1) == 0xC0
; run: %sshr_i8_i32(0xf0, 0) == 0xf0
; run: %sshr_i8_i32(0xf0, 4) == 0xff
; run: %sshr_i8_i32(0x40, 8) == 0x40
; run: %sshr_i8_i32(0x40, 9) == 0x20
; run: %sshr_i8_i32(0x40, 10) == 0x10
function %sshr_i8_i16(i8, i16) -> i8 {
block0(v0: i8, v1: i16):
v2 = sshr.i8 v0, v1
return v2
}
; run: %sshr_i8_i16(0x80, 0) == 0x80
; run: %sshr_i8_i16(0x80, 1) == 0xC0
; run: %sshr_i8_i16(0xf0, 0) == 0xf0
; run: %sshr_i8_i16(0xf0, 4) == 0xff
; run: %sshr_i8_i16(0x40, 8) == 0x40
; run: %sshr_i8_i16(0x40, 9) == 0x20
; run: %sshr_i8_i16(0x40, 10) == 0x10
function %sshr_i8_i64(i8, i64) -> i8 {
block0(v0: i8, v1: i64):
v2 = sshr.i8 v0, v1
return v2
}
; run: %sshr_i8_i64(0x80, 0) == 0x80
; run: %sshr_i8_i64(0x80, 1) == 0xC0
; run: %sshr_i8_i64(0xf0, 0) == 0xf0
; run: %sshr_i8_i64(0xf0, 4) == 0xff
; run: %sshr_i8_i64(0x40, 8) == 0x40
; run: %sshr_i8_i64(0x40, 9) == 0x20
; run: %sshr_i8_i64(0x40, 10) == 0x10

320
cranelift/filetests/filetests/runtests/shifts.clif Normal file
View File

@@ -0,0 +1,320 @@
test run
target aarch64
target x86_64 machinst
target s390x
function %ishl_i64_i64(i64, i64) -> i64 {
block0(v0: i64, v1: i64):
v2 = ishl.i64 v0, v1
return v2
}
; run: %ishl_i64_i64(0x00000000_00000000, 0) == 0x00000000_00000000
; run: %ishl_i64_i64(0x00000000_00000000, 1) == 0x00000000_00000000
; run: %ishl_i64_i64(0x0000000f_0000000f, 0) == 0x0000000f_0000000f
; run: %ishl_i64_i64(0x0000000f_0000000f, 4) == 0x000000f0_000000f0
; run: %ishl_i64_i64(0x00000000_00000004, 64) == 0x00000000_00000004
; run: %ishl_i64_i64(0x00000000_00000004, 65) == 0x00000000_00000008
; run: %ishl_i64_i64(0x00000000_00000004, 66) == 0x00000000_00000010
function %ishl_i64_i32(i64, i32) -> i64 {
block0(v0: i64, v1: i32):
v2 = ishl.i64 v0, v1
return v2
}
; run: %ishl_i64_i32(0x00000000_00000000, 0) == 0x00000000_00000000
; run: %ishl_i64_i32(0x00000000_00000000, 1) == 0x00000000_00000000
; run: %ishl_i64_i32(0x0000000f_0000000f, 0) == 0x0000000f_0000000f
; run: %ishl_i64_i32(0x0000000f_0000000f, 4) == 0x000000f0_000000f0
; run: %ishl_i64_i32(0x00000000_00000004, 64) == 0x00000000_00000004
; run: %ishl_i64_i32(0x00000000_00000004, 65) == 0x00000000_00000008
; run: %ishl_i64_i32(0x00000000_00000004, 66) == 0x00000000_00000010
function %ishl_i64_i16(i64, i16) -> i64 {
block0(v0: i64, v1: i16):
v2 = ishl.i64 v0, v1
return v2
}
; run: %ishl_i64_i16(0x00000000_00000000, 0) == 0x00000000_00000000
; run: %ishl_i64_i16(0x00000000_00000000, 1) == 0x00000000_00000000
; run: %ishl_i64_i16(0x0000000f_0000000f, 0) == 0x0000000f_0000000f
; run: %ishl_i64_i16(0x0000000f_0000000f, 4) == 0x000000f0_000000f0
; run: %ishl_i64_i16(0x00000000_00000004, 64) == 0x00000000_00000004
; run: %ishl_i64_i16(0x00000000_00000004, 65) == 0x00000000_00000008
; run: %ishl_i64_i16(0x00000000_00000004, 66) == 0x00000000_00000010
function %ishl_i64_i8(i64, i8) -> i64 {
block0(v0: i64, v1: i8):
v2 = ishl.i64 v0, v1
return v2
}
; run: %ishl_i64_i8(0x00000000_00000000, 0) == 0x00000000_00000000
; run: %ishl_i64_i8(0x00000000_00000000, 1) == 0x00000000_00000000
; run: %ishl_i64_i8(0x0000000f_0000000f, 0) == 0x0000000f_0000000f
; run: %ishl_i64_i8(0x0000000f_0000000f, 4) == 0x000000f0_000000f0
; run: %ishl_i64_i8(0x00000000_00000004, 64) == 0x00000000_00000004
; run: %ishl_i64_i8(0x00000000_00000004, 65) == 0x00000000_00000008
; run: %ishl_i64_i8(0x00000000_00000004, 66) == 0x00000000_00000010
function %ishl_i32_i64(i32, i64) -> i32 {
block0(v0: i32, v1: i64):
v2 = ishl.i32 v0, v1
return v2
}
; run: %ishl_i32_i64(0x00000000, 0) == 0x00000000
; run: %ishl_i32_i64(0x00000000, 1) == 0x00000000
; run: %ishl_i32_i64(0x0000000f, 0) == 0x0000000f
; run: %ishl_i32_i64(0x0000000f, 4) == 0x000000f0
; run: %ishl_i32_i64(0x00000004, 32) == 0x00000004
; run: %ishl_i32_i64(0x00000004, 33) == 0x00000008
; run: %ishl_i32_i64(0x00000004, 34) == 0x00000010
function %ishl_i32_i32(i32, i32) -> i32 {
block0(v0: i32, v1: i32):
v2 = ishl.i32 v0, v1
return v2
}
; run: %ishl_i32_i32(0x00000000, 0) == 0x00000000
; run: %ishl_i32_i32(0x00000000, 1) == 0x00000000
; run: %ishl_i32_i32(0x0000000f, 0) == 0x0000000f
; run: %ishl_i32_i32(0x0000000f, 4) == 0x000000f0
; run: %ishl_i32_i32(0x00000004, 32) == 0x00000004
; run: %ishl_i32_i32(0x00000004, 33) == 0x00000008
; run: %ishl_i32_i32(0x00000004, 34) == 0x00000010
function %ishl_i32_i16(i32, i16) -> i32 {
block0(v0: i32, v1: i16):
v2 = ishl.i32 v0, v1
return v2
}
; run: %ishl_i32_i16(0x00000000, 0) == 0x00000000
; run: %ishl_i32_i16(0x00000000, 1) == 0x00000000
; run: %ishl_i32_i16(0x0000000f, 0) == 0x0000000f
; run: %ishl_i32_i16(0x0000000f, 4) == 0x000000f0
; run: %ishl_i32_i16(0x00000004, 32) == 0x00000004
; run: %ishl_i32_i16(0x00000004, 33) == 0x00000008
; run: %ishl_i32_i16(0x00000004, 34) == 0x00000010
function %ishl_i32_i8(i32, i8) -> i32 {
block0(v0: i32, v1: i8):
v2 = ishl.i32 v0, v1
return v2
}
; run: %ishl_i32_i8(0x00000000, 0) == 0x00000000
; run: %ishl_i32_i8(0x00000000, 1) == 0x00000000
; run: %ishl_i32_i8(0x0000000f, 0) == 0x0000000f
; run: %ishl_i32_i8(0x0000000f, 4) == 0x000000f0
; run: %ishl_i32_i8(0x00000004, 32) == 0x00000004
; run: %ishl_i32_i8(0x00000004, 33) == 0x00000008
; run: %ishl_i32_i8(0x00000004, 34) == 0x00000010
function %ushr_i64_i64(i64, i64) -> i64 {
block0(v0: i64, v1: i64):
v2 = ushr.i64 v0, v1
return v2
}
; run: %ushr_i64_i64(0x10000000_10000000, 0) == 0x10000000_10000000
; run: %ushr_i64_i64(0x10000000_10000000, 1) == 0x08000000_08000000
; run: %ushr_i64_i64(0xf0000000_f0000000, 0) == 0xf0000000_f0000000
; run: %ushr_i64_i64(0xf0000000_f0000000, 4) == 0x0f000000_0f000000
; run: %ushr_i64_i64(0x40000000_40000000, 64) == 0x40000000_40000000
; run: %ushr_i64_i64(0x40000000_40000000, 65) == 0x20000000_20000000
; run: %ushr_i64_i64(0x40000000_40000000, 66) == 0x10000000_10000000
function %ushr_i64_i32(i64, i32) -> i64 {
block0(v0: i64, v1: i32):
v2 = ushr.i64 v0, v1
return v2
}
; run: %ushr_i64_i32(0x10000000_10000000, 0) == 0x10000000_10000000
; run: %ushr_i64_i32(0x10000000_10000000, 1) == 0x08000000_08000000
; run: %ushr_i64_i32(0xf0000000_f0000000, 0) == 0xf0000000_f0000000
; run: %ushr_i64_i32(0xf0000000_f0000000, 4) == 0x0f000000_0f000000
; run: %ushr_i64_i32(0x40000000_40000000, 64) == 0x40000000_40000000
; run: %ushr_i64_i32(0x40000000_40000000, 65) == 0x20000000_20000000
; run: %ushr_i64_i32(0x40000000_40000000, 66) == 0x10000000_10000000
function %ushr_i64_i16(i64, i16) -> i64 {
block0(v0: i64, v1: i16):
v2 = ushr.i64 v0, v1
return v2
}
; run: %ushr_i64_i16(0x10000000_10000000, 0) == 0x10000000_10000000
; run: %ushr_i64_i16(0x10000000_10000000, 1) == 0x08000000_08000000
; run: %ushr_i64_i16(0xf0000000_f0000000, 0) == 0xf0000000_f0000000
; run: %ushr_i64_i16(0xf0000000_f0000000, 4) == 0x0f000000_0f000000
; run: %ushr_i64_i16(0x40000000_40000000, 64) == 0x40000000_40000000
; run: %ushr_i64_i16(0x40000000_40000000, 65) == 0x20000000_20000000
; run: %ushr_i64_i16(0x40000000_40000000, 66) == 0x10000000_10000000
function %ushr_i64_i8(i64, i8) -> i64 {
block0(v0: i64, v1: i8):
v2 = ushr.i64 v0, v1
return v2
}
; run: %ushr_i64_i8(0x10000000_10000000, 0) == 0x10000000_10000000
; run: %ushr_i64_i8(0x10000000_10000000, 1) == 0x08000000_08000000
; run: %ushr_i64_i8(0xf0000000_f0000000, 0) == 0xf0000000_f0000000
; run: %ushr_i64_i8(0xf0000000_f0000000, 4) == 0x0f000000_0f000000
; run: %ushr_i64_i8(0x40000000_40000000, 64) == 0x40000000_40000000
; run: %ushr_i64_i8(0x40000000_40000000, 65) == 0x20000000_20000000
; run: %ushr_i64_i8(0x40000000_40000000, 66) == 0x10000000_10000000
function %ushr_i32_i64(i32, i64) -> i32 {
block0(v0: i32, v1: i64):
v2 = ushr.i32 v0, v1
return v2
}
; run: %ushr_i32_i64(0x10000000, 0) == 0x10000000
; run: %ushr_i32_i64(0x10000000, 1) == 0x08000000
; run: %ushr_i32_i64(0xf0000000, 0) == 0xf0000000
; run: %ushr_i32_i64(0xf0000000, 4) == 0x0f000000
; run: %ushr_i32_i64(0x40000000, 32) == 0x40000000
; run: %ushr_i32_i64(0x40000000, 33) == 0x20000000
; run: %ushr_i32_i64(0x40000000, 34) == 0x10000000
function %ushr_i32_i32(i32, i32) -> i32 {
block0(v0: i32, v1: i32):
v2 = ushr.i32 v0, v1
return v2
}
; run: %ushr_i32_i32(0x10000000, 0) == 0x10000000
; run: %ushr_i32_i32(0x10000000, 1) == 0x08000000
; run: %ushr_i32_i32(0xf0000000, 0) == 0xf0000000
; run: %ushr_i32_i32(0xf0000000, 4) == 0x0f000000
; run: %ushr_i32_i32(0x40000000, 32) == 0x40000000
; run: %ushr_i32_i32(0x40000000, 33) == 0x20000000
; run: %ushr_i32_i32(0x40000000, 34) == 0x10000000
function %ushr_i32_i16(i32, i16) -> i32 {
block0(v0: i32, v1: i16):
v2 = ushr.i32 v0, v1
return v2
}
; run: %ushr_i32_i16(0x10000000, 0) == 0x10000000
; run: %ushr_i32_i16(0x10000000, 1) == 0x08000000
; run: %ushr_i32_i16(0xf0000000, 0) == 0xf0000000
; run: %ushr_i32_i16(0xf0000000, 4) == 0x0f000000
; run: %ushr_i32_i16(0x40000000, 32) == 0x40000000
; run: %ushr_i32_i16(0x40000000, 33) == 0x20000000
; run: %ushr_i32_i16(0x40000000, 34) == 0x10000000
function %ushr_i32_i8(i32, i8) -> i32 {
block0(v0: i32, v1: i8):
v2 = ushr.i32 v0, v1
return v2
}
; run: %ushr_i32_i8(0x10000000, 0) == 0x10000000
; run: %ushr_i32_i8(0x10000000, 1) == 0x08000000
; run: %ushr_i32_i8(0xf0000000, 0) == 0xf0000000
; run: %ushr_i32_i8(0xf0000000, 4) == 0x0f000000
; run: %ushr_i32_i8(0x40000000, 32) == 0x40000000
; run: %ushr_i32_i8(0x40000000, 33) == 0x20000000
; run: %ushr_i32_i8(0x40000000, 34) == 0x10000000
function %sshr_i64_i64(i64, i64) -> i64 {
block0(v0: i64, v1: i64):
v2 = sshr.i64 v0, v1
return v2
}
; run: %sshr_i64_i64(0x80000000_80000000, 0) == 0x80000000_80000000
; run: %sshr_i64_i64(0x80000000_80000000, 1) == 0xC0000000_40000000
; run: %sshr_i64_i64(0xf0000000_f0000000, 0) == 0xf0000000_f0000000
; run: %sshr_i64_i64(0xf0000000_f0000000, 4) == 0xff000000_0f000000
; run: %sshr_i64_i64(0x40000000_40000000, 64) == 0x40000000_40000000
; run: %sshr_i64_i64(0x40000000_40000000, 65) == 0x20000000_20000000
; run: %sshr_i64_i64(0x40000000_40000000, 66) == 0x10000000_10000000
function %sshr_i64_i32(i64, i32) -> i64 {
block0(v0: i64, v1: i32):
v2 = sshr.i64 v0, v1
return v2
}
; run: %sshr_i64_i32(0x80000000_80000000, 0) == 0x80000000_80000000
; run: %sshr_i64_i32(0x80000000_80000000, 1) == 0xC0000000_40000000
; run: %sshr_i64_i32(0xf0000000_f0000000, 0) == 0xf0000000_f0000000
; run: %sshr_i64_i32(0xf0000000_f0000000, 4) == 0xff000000_0f000000
; run: %sshr_i64_i32(0x40000000_40000000, 64) == 0x40000000_40000000
; run: %sshr_i64_i32(0x40000000_40000000, 65) == 0x20000000_20000000
; run: %sshr_i64_i32(0x40000000_40000000, 66) == 0x10000000_10000000
function %sshr_i64_i16(i64, i16) -> i64 {
block0(v0: i64, v1: i16):
v2 = sshr.i64 v0, v1
return v2
}
; run: %sshr_i64_i16(0x80000000_80000000, 0) == 0x80000000_80000000
; run: %sshr_i64_i16(0x80000000_80000000, 1) == 0xC0000000_40000000
; run: %sshr_i64_i16(0xf0000000_f0000000, 0) == 0xf0000000_f0000000
; run: %sshr_i64_i16(0xf0000000_f0000000, 4) == 0xff000000_0f000000
; run: %sshr_i64_i16(0x40000000_40000000, 64) == 0x40000000_40000000
; run: %sshr_i64_i16(0x40000000_40000000, 65) == 0x20000000_20000000
; run: %sshr_i64_i16(0x40000000_40000000, 66) == 0x10000000_10000000
function %sshr_i64_i8(i64, i8) -> i64 {
block0(v0: i64, v1: i8):
v2 = sshr.i64 v0, v1
return v2
}
; run: %sshr_i64_i8(0x80000000_80000000, 0) == 0x80000000_80000000
; run: %sshr_i64_i8(0x80000000_80000000, 1) == 0xC0000000_40000000
; run: %sshr_i64_i8(0xf0000000_f0000000, 0) == 0xf0000000_f0000000
; run: %sshr_i64_i8(0xf0000000_f0000000, 4) == 0xff000000_0f000000
; run: %sshr_i64_i8(0x40000000_40000000, 64) == 0x40000000_40000000
; run: %sshr_i64_i8(0x40000000_40000000, 65) == 0x20000000_20000000
; run: %sshr_i64_i8(0x40000000_40000000, 66) == 0x10000000_10000000
function %sshr_i32_i64(i32, i64) -> i32 {
block0(v0: i32, v1: i64):
v2 = sshr.i32 v0, v1
return v2
}
; run: %sshr_i32_i64(0x80000000, 0) == 0x80000000
; run: %sshr_i32_i64(0x80000000, 1) == 0xC0000000
; run: %sshr_i32_i64(0xf0000000, 0) == 0xf0000000
; run: %sshr_i32_i64(0xf0000000, 4) == 0xff000000
; run: %sshr_i32_i64(0x40000000, 32) == 0x40000000
; run: %sshr_i32_i64(0x40000000, 33) == 0x20000000
; run: %sshr_i32_i64(0x40000000, 34) == 0x10000000
function %sshr_i32_i32(i32, i32) -> i32 {
block0(v0: i32, v1: i32):
v2 = sshr.i32 v0, v1
return v2
}
; run: %sshr_i32_i32(0x80000000, 0) == 0x80000000
; run: %sshr_i32_i32(0x80000000, 1) == 0xC0000000
; run: %sshr_i32_i32(0xf0000000, 0) == 0xf0000000
; run: %sshr_i32_i32(0xf0000000, 4) == 0xff000000
; run: %sshr_i32_i32(0x40000000, 32) == 0x40000000
; run: %sshr_i32_i32(0x40000000, 33) == 0x20000000
; run: %sshr_i32_i32(0x40000000, 34) == 0x10000000
function %sshr_i32_i16(i32, i16) -> i32 {
block0(v0: i32, v1: i16):
v2 = sshr.i32 v0, v1
return v2
}
; run: %sshr_i32_i16(0x80000000, 0) == 0x80000000
; run: %sshr_i32_i16(0x80000000, 1) == 0xC0000000
; run: %sshr_i32_i16(0xf0000000, 0) == 0xf0000000
; run: %sshr_i32_i16(0xf0000000, 4) == 0xff000000
; run: %sshr_i32_i16(0x40000000, 32) == 0x40000000
; run: %sshr_i32_i16(0x40000000, 33) == 0x20000000
; run: %sshr_i32_i16(0x40000000, 34) == 0x10000000
function %sshr_i32_i8(i32, i8) -> i32 {
block0(v0: i32, v1: i8):
v2 = sshr.i32 v0, v1
return v2
}
; run: %sshr_i32_i8(0x80000000, 0) == 0x80000000
; run: %sshr_i32_i8(0x80000000, 1) == 0xC0000000
; run: %sshr_i32_i8(0xf0000000, 0) == 0xf0000000
; run: %sshr_i32_i8(0xf0000000, 4) == 0xff000000
; run: %sshr_i32_i8(0x40000000, 32) == 0x40000000
; run: %sshr_i32_i8(0x40000000, 33) == 0x20000000
; run: %sshr_i32_i8(0x40000000, 34) == 0x10000000