cranelift: Implement icmp for scalar types

Add `icmp` tests for all scalar types and condition codes.

AArch64 (no)overflow tests are disabled because they are currently failing.

cranelift/filetests/filetests/runtests/i128-icmp.clif

@@ -1,3 +1,4 @@
+test interpret
 test run
 target aarch64
 target x86_64 machinst
@@ -186,7 +187,7 @@ block0(v0: i64,v1: i64,v2: i64,v3: i64):
 
 
 ; Icmp Imm Tests
-function %test_icmp_imm_eq_i128() -> b1 {
+function %icmp_imm_eq_i128() -> b1 {
 block0:
     v11 = iconst.i64 0x0
     v12 = iconst.i64 0x0
@@ -195,9 +196,9 @@ block0:
     return v10
 }
 
-; run
+; run: %icmp_imm_eq_i128() == true
 
-function %test_icmp_imm_ne_i128() -> b1 {
+function %icmp_imm_ne_i128() -> b1 {
 block0:
     v11 = iconst.i64 0x0
     v12 = iconst.i64 0x0
@@ -206,4 +207,4 @@ block0:
     return v10
 }
 
-; run
+; run: %icmp_imm_ne_i128() == true

cranelift/filetests/filetests/runtests/icmp-eq.clif

@@ -0,0 +1,40 @@
+test interpret
+test run
+target aarch64
+target x86_64 machinst
+
+function %icmp_eq_i8(i8, i8) -> b1 {
+block0(v0: i8, v1: i8):
+    v2 = icmp eq v0, v1
+    return v2
+}
+; run: %icmp_eq_i8(0, 0) == true
+; run: %icmp_eq_i8(1, 0) == false
+; run: %icmp_eq_i8(-1, -1) == true
+
+function %icmp_eq_i16(i16, i16) -> b1 {
+block0(v0: i16, v1: i16):
+    v2 = icmp eq v0, v1
+    return v2
+}
+; run: %icmp_eq_i16(0, 0) == true
+; run: %icmp_eq_i16(1, 0) == false
+; run: %icmp_eq_i16(-1, -1) == true
+
+function %icmp_eq_i32(i32, i32) -> b1 {
+block0(v0: i32, v1: i32):
+    v2 = icmp eq v0, v1
+    return v2
+}
+; run: %icmp_eq_i32(0, 0) == true
+; run: %icmp_eq_i32(1, 0) == false
+; run: %icmp_eq_i32(-1, -1) == true
+
+function %icmp_eq_i64(i64, i64) -> b1 {
+block0(v0: i64, v1: i64):
+    v2 = icmp eq v0, v1
+    return v2
+}
+; run: %icmp_eq_i64(0, 0) == true
+; run: %icmp_eq_i64(1, 0) == false
+; run: %icmp_eq_i64(-1, -1) == true

cranelift/filetests/filetests/runtests/icmp-ne.clif

@@ -0,0 +1,40 @@
+test interpret
+test run
+target aarch64
+target x86_64 machinst
+
+function %icmp_ne_i8(i8, i8) -> b1 {
+block0(v0: i8, v1: i8):
+    v2 = icmp ne v0, v1
+    return v2
+}
+; run: %icmp_ne_i8(0, 0) == false
+; run: %icmp_ne_i8(1, 0) == true
+; run: %icmp_ne_i8(-1, -1) == false
+
+function %icmp_ne_i16(i16, i16) -> b1 {
+block0(v0: i16, v1: i16):
+    v2 = icmp ne v0, v1
+    return v2
+}
+; run: %icmp_ne_i16(0, 0) == false
+; run: %icmp_ne_i16(1, 0) == true
+; run: %icmp_ne_i16(-1, -1) == false
+
+function %icmp_ne_i32(i32, i32) -> b1 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ne v0, v1
+    return v2
+}
+; run: %icmp_ne_i32(0, 0) == false
+; run: %icmp_ne_i32(1, 0) == true
+; run: %icmp_ne_i32(-1, -1) == false
+
+function %icmp_ne_i64(i64, i64) -> b1 {
+block0(v0: i64, v1: i64):
+    v2 = icmp ne v0, v1
+    return v2
+}
+; run: %icmp_ne_i64(0, 0) == false
+; run: %icmp_ne_i64(1, 0) == true
+; run: %icmp_ne_i64(-1, -1) == false

cranelift/filetests/filetests/runtests/icmp-nof.clif

@@ -0,0 +1,75 @@
+test interpret
+test run
+target x86_64 machinst
+
+function %icmp_nof_i8(i8, i8) -> b1 {
+block0(v0: i8, v1: i8):
+    v2 = icmp nof v0, v1
+    return v2
+}
+; run: %icmp_nof_i8(0, 0) == true
+; run: %icmp_nof_i8(0, 1) == true
+; run: %icmp_nof_i8(1, 0) == true
+; run: %icmp_nof_i8(0, -1) == true
+; run: %icmp_nof_i8(0x80, 0x80) == true
+; run: %icmp_nof_i8(0x7F, 1) == true
+; run: %icmp_nof_i8(0x7F, 0x7F) == true
+; run: %icmp_nof_i8(0xFF, 1) == true
+; run: %icmp_nof_i8(0x80, 1) == false
+; run: %icmp_nof_i8(0x7F, 0x80) == false
+; run: %icmp_nof_i8(0x80, 0x7F) == false
+; run: %icmp_nof_i8(0x7F, 0xFF) == false
+
+function %icmp_nof_i16(i16, i16) -> b1 {
+block0(v0: i16, v1: i16):
+    v2 = icmp nof v0, v1
+    return v2
+}
+; run: %icmp_nof_i16(0, 0) == true
+; run: %icmp_nof_i16(0, 1) == true
+; run: %icmp_nof_i16(1, 0) == true
+; run: %icmp_nof_i16(0, -1) == true
+; run: %icmp_nof_i16(0x8000, 0x8000) == true
+; run: %icmp_nof_i16(0x7FFF, 1) == true
+; run: %icmp_nof_i16(0x7FFF, 0x7FFF) == true
+; run: %icmp_nof_i16(0xFFFF, 1) == true
+; run: %icmp_nof_i16(0x8000, 1) == false
+; run: %icmp_nof_i16(0x7FFF, 0x8000) == false
+; run: %icmp_nof_i16(0x8000, 0x7FFF) == false
+; run: %icmp_nof_i16(0x7FFF, 0xFFFF) == false
+
+function %icmp_nof_i32(i32, i32) -> b1 {
+block0(v0: i32, v1: i32):
+    v2 = icmp nof v0, v1
+    return v2
+}
+; run: %icmp_nof_i32(0, 0) == true
+; run: %icmp_nof_i32(0, 1) == true
+; run: %icmp_nof_i32(1, 0) == true
+; run: %icmp_nof_i32(0, -1) == true
+; run: %icmp_nof_i32(0x80000000, 0x80000000) == true
+; run: %icmp_nof_i32(0x7FFFFFFF, 1) == true
+; run: %icmp_nof_i32(0x7FFFFFFF, 0x7FFFFFFF) == true
+; run: %icmp_nof_i32(0xFFFFFFFF, 1) == true
+; run: %icmp_nof_i32(0x80000000, 1) == false
+; run: %icmp_nof_i32(0x7FFFFFFF, 0x80000000) == false
+; run: %icmp_nof_i32(0x80000000, 0x7FFFFFFF) == false
+; run: %icmp_nof_i32(0x7FFFFFFF, 0xFFFFFFFF) == false
+
+function %icmp_nof_i64(i64, i64) -> b1 {
+block0(v0: i64, v1: i64):
+    v2 = icmp nof v0, v1
+    return v2
+}
+; run: %icmp_nof_i64(0, 0) == true
+; run: %icmp_nof_i64(0, 1) == true
+; run: %icmp_nof_i64(1, 0) == true
+; run: %icmp_nof_i64(0, -1) == true
+; run: %icmp_nof_i64(0x80000000_00000000, 0x80000000_00000000) == true
+; run: %icmp_nof_i64(0x7FFFFFFF_FFFFFFFF, 1) == true
+; run: %icmp_nof_i64(0x7FFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF) == true
+; run: %icmp_nof_i64(0xFFFFFFFF_FFFFFFFF, 1) == true
+; run: %icmp_nof_i64(0x80000000_00000000, 1) == false
+; run: %icmp_nof_i64(0x7FFFFFFF_FFFFFFFF, 0x80000000_00000000) == false
+; run: %icmp_nof_i64(0x80000000_00000000, 0x7FFFFFFF_FFFFFFFF) == false
+; run: %icmp_nof_i64(0x7FFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == false

cranelift/filetests/filetests/runtests/icmp-of.clif

@@ -0,0 +1,75 @@
+test interpret
+test run
+target x86_64 machinst
+
+function %icmp_of_i8(i8, i8) -> b1 {
+block0(v0: i8, v1: i8):
+    v2 = icmp of v0, v1
+    return v2
+}
+; run: %icmp_of_i8(0, 0) == false
+; run: %icmp_of_i8(0, 1) == false
+; run: %icmp_of_i8(1, 0) == false
+; run: %icmp_of_i8(0, -1) == false
+; run: %icmp_of_i8(0x80, 0x80) == false
+; run: %icmp_of_i8(0x7F, 1) == false
+; run: %icmp_of_i8(0x7F, 0x7F) == false
+; run: %icmp_of_i8(0xFF, 1) == false
+; run: %icmp_of_i8(0x80, 1) == true
+; run: %icmp_of_i8(0x7F, 0x80) == true
+; run: %icmp_of_i8(0x80, 0x7F) == true
+; run: %icmp_of_i8(0x7F, 0xFF) == true
+
+function %icmp_of_i16(i16, i16) -> b1 {
+block0(v0: i16, v1: i16):
+    v2 = icmp of v0, v1
+    return v2
+}
+; run: %icmp_of_i16(0, 0) == false
+; run: %icmp_of_i16(0, 1) == false
+; run: %icmp_of_i16(1, 0) == false
+; run: %icmp_of_i16(0, -1) == false
+; run: %icmp_of_i16(0x8000, 0x8000) == false
+; run: %icmp_of_i16(0x7FFF, 1) == false
+; run: %icmp_of_i16(0x7FFF, 0x7FFF) == false
+; run: %icmp_of_i16(0xFFFF, 1) == false
+; run: %icmp_of_i16(0x8000, 1) == true
+; run: %icmp_of_i16(0x7FFF, 0x8000) == true
+; run: %icmp_of_i16(0x8000, 0x7FFF) == true
+; run: %icmp_of_i16(0x7FFF, 0xFFFF) == true
+
+function %icmp_of_i32(i32, i32) -> b1 {
+block0(v0: i32, v1: i32):
+    v2 = icmp of v0, v1
+    return v2
+}
+; run: %icmp_of_i32(0, 0) == false
+; run: %icmp_of_i32(0, 1) == false
+; run: %icmp_of_i32(1, 0) == false
+; run: %icmp_of_i32(0, -1) == false
+; run: %icmp_of_i32(0x80000000, 0x80000000) == false
+; run: %icmp_of_i32(0x7FFFFFFF, 1) == false
+; run: %icmp_of_i32(0x7FFFFFFF, 0x7FFFFFFF) == false
+; run: %icmp_of_i32(0xFFFFFFFF, 1) == false
+; run: %icmp_of_i32(0x80000000, 1) == true
+; run: %icmp_of_i32(0x7FFFFFFF, 0x80000000) == true
+; run: %icmp_of_i32(0x80000000, 0x7FFFFFFF) == true
+; run: %icmp_of_i32(0x7FFFFFFF, 0xFFFFFFFF) == true
+
+function %icmp_of_i64(i64, i64) -> b1 {
+block0(v0: i64, v1: i64):
+    v2 = icmp of v0, v1
+    return v2
+}
+; run: %icmp_of_i64(0, 0) == false
+; run: %icmp_of_i64(0, 1) == false
+; run: %icmp_of_i64(1, 0) == false
+; run: %icmp_of_i64(0, -1) == false
+; run: %icmp_of_i64(0x80000000_00000000, 0x80000000_00000000) == false
+; run: %icmp_of_i64(0x7FFFFFFF_FFFFFFFF, 1) == false
+; run: %icmp_of_i64(0x7FFFFFFF_FFFFFFFF, 0x7FFFFFFF_FFFFFFFF) == false
+; run: %icmp_of_i64(0xFFFFFFFF_FFFFFFFF, 1) == false
+; run: %icmp_of_i64(0x80000000_00000000, 1) == true
+; run: %icmp_of_i64(0x7FFFFFFF_FFFFFFFF, 0x80000000_00000000) == true
+; run: %icmp_of_i64(0x80000000_00000000, 0x7FFFFFFF_FFFFFFFF) == true
+; run: %icmp_of_i64(0x7FFFFFFF_FFFFFFFF, 0xFFFFFFFF_FFFFFFFF) == true

cranelift/filetests/filetests/runtests/icmp-sge.clif

@@ -0,0 +1,53 @@
+test interpret
+test run
+target aarch64
+target x86_64 machinst
+
+
+function %icmp_sge_i8(i8, i8) -> b1 {
+block0(v0: i8, v1: i8):
+    v2 = icmp sge v0, v1
+    return v2
+}
+; run: %icmp_sge_i8(0, 0) == true
+; run: %icmp_sge_i8(1, 0) == true
+; run: %icmp_sge_i8(-1, -1) == true
+; run: %icmp_sge_i8(0, 1) == false
+; run: %icmp_sge_i8(-5, -1) == false
+; run: %icmp_sge_i8(1, -1) == true
+
+function %icmp_sge_i16(i16, i16) -> b1 {
+block0(v0: i16, v1: i16):
+    v2 = icmp sge v0, v1
+    return v2
+}
+; run: %icmp_sge_i16(0, 0) == true
+; run: %icmp_sge_i16(1, 0) == true
+; run: %icmp_sge_i16(-1, -1) == true
+; run: %icmp_sge_i16(0, 1) == false
+; run: %icmp_sge_i16(-5, -1) == false
+; run: %icmp_sge_i16(1, -1) == true
+
+function %icmp_sge_i32(i32, i32) -> b1 {
+block0(v0: i32, v1: i32):
+    v2 = icmp sge v0, v1
+    return v2
+}
+; run: %icmp_sge_i32(0, 0) == true
+; run: %icmp_sge_i32(1, 0) == true
+; run: %icmp_sge_i32(-1, -1) == true
+; run: %icmp_sge_i32(0, 1) == false
+; run: %icmp_sge_i32(-5, -1) == false
+; run: %icmp_sge_i32(1, -1) == true
+
+function %icmp_sge_i64(i64, i64) -> b1 {
+block0(v0: i64, v1: i64):
+    v2 = icmp sge v0, v1
+    return v2
+}
+; run: %icmp_sge_i64(0, 0) == true
+; run: %icmp_sge_i64(1, 0) == true
+; run: %icmp_sge_i64(-1, -1) == true
+; run: %icmp_sge_i64(0, 1) == false
+; run: %icmp_sge_i64(-5, -1) == false
+; run: %icmp_sge_i64(1, -1) == true

cranelift/filetests/filetests/runtests/icmp-sgt.clif

@@ -0,0 +1,53 @@
+test interpret
+test run
+target aarch64
+target x86_64 machinst
+
+
+function %icmp_sgt_i8(i8, i8) -> b1 {
+block0(v0: i8, v1: i8):
+    v2 = icmp sgt v0, v1
+    return v2
+}
+; run: %icmp_sgt_i8(0, 0) == false
+; run: %icmp_sgt_i8(1, 0) == true
+; run: %icmp_sgt_i8(-1, -1) == false
+; run: %icmp_sgt_i8(0, 1) == false
+; run: %icmp_sgt_i8(-5, -1) == false
+; run: %icmp_sgt_i8(1, -1) == true
+
+function %icmp_sgt_i16(i16, i16) -> b1 {
+block0(v0: i16, v1: i16):
+    v2 = icmp sgt v0, v1
+    return v2
+}
+; run: %icmp_sgt_i16(0, 0) == false
+; run: %icmp_sgt_i16(1, 0) == true
+; run: %icmp_sgt_i16(-1, -1) == false
+; run: %icmp_sgt_i16(0, 1) == false
+; run: %icmp_sgt_i16(-5, -1) == false
+; run: %icmp_sgt_i16(1, -1) == true
+
+function %icmp_sgt_i32(i32, i32) -> b1 {
+block0(v0: i32, v1: i32):
+    v2 = icmp sgt v0, v1
+    return v2
+}
+; run: %icmp_sgt_i32(0, 0) == false
+; run: %icmp_sgt_i32(1, 0) == true
+; run: %icmp_sgt_i32(-1, -1) == false
+; run: %icmp_sgt_i32(0, 1) == false
+; run: %icmp_sgt_i32(-5, -1) == false
+; run: %icmp_sgt_i32(1, -1) == true
+
+function %icmp_sgt_i64(i64, i64) -> b1 {
+block0(v0: i64, v1: i64):
+    v2 = icmp sgt v0, v1
+    return v2
+}
+; run: %icmp_sgt_i64(0, 0) == false
+; run: %icmp_sgt_i64(1, 0) == true
+; run: %icmp_sgt_i64(-1, -1) == false
+; run: %icmp_sgt_i64(0, 1) == false
+; run: %icmp_sgt_i64(-5, -1) == false
+; run: %icmp_sgt_i64(1, -1) == true

cranelift/filetests/filetests/runtests/icmp-sle.clif

@@ -0,0 +1,53 @@
+test interpret
+test run
+target aarch64
+target x86_64 machinst
+
+
+function %icmp_sle_i8(i8, i8) -> b1 {
+block0(v0: i8, v1: i8):
+    v2 = icmp sle v0, v1
+    return v2
+}
+; run: %icmp_sle_i8(0, 0) == true
+; run: %icmp_sle_i8(1, 0) == false
+; run: %icmp_sle_i8(-1, -1) == true
+; run: %icmp_sle_i8(0, 1) == true
+; run: %icmp_sle_i8(-5, -1) == true
+; run: %icmp_sle_i8(1, -1) == false
+
+function %icmp_sle_i16(i16, i16) -> b1 {
+block0(v0: i16, v1: i16):
+    v2 = icmp sle v0, v1
+    return v2
+}
+; run: %icmp_sle_i16(0, 0) == true
+; run: %icmp_sle_i16(1, 0) == false
+; run: %icmp_sle_i16(-1, -1) == true
+; run: %icmp_sle_i16(0, 1) == true
+; run: %icmp_sle_i16(-5, -1) == true
+; run: %icmp_sle_i16(1, -1) == false
+
+function %icmp_sle_i32(i32, i32) -> b1 {
+block0(v0: i32, v1: i32):
+    v2 = icmp sle v0, v1
+    return v2
+}
+; run: %icmp_sle_i32(0, 0) == true
+; run: %icmp_sle_i32(1, 0) == false
+; run: %icmp_sle_i32(-1, -1) == true
+; run: %icmp_sle_i32(0, 1) == true
+; run: %icmp_sle_i32(-5, -1) == true
+; run: %icmp_sle_i32(1, -1) == false
+
+function %icmp_sle_i64(i64, i64) -> b1 {
+block0(v0: i64, v1: i64):
+    v2 = icmp sle v0, v1
+    return v2
+}
+; run: %icmp_sle_i64(0, 0) == true
+; run: %icmp_sle_i64(1, 0) == false
+; run: %icmp_sle_i64(-1, -1) == true
+; run: %icmp_sle_i64(0, 1) == true
+; run: %icmp_sle_i64(-5, -1) == true
+; run: %icmp_sle_i64(1, -1) == false

cranelift/filetests/filetests/runtests/icmp-slt.clif

@@ -0,0 +1,52 @@
+test interpret
+test run
+target aarch64
+target x86_64 machinst
+
+function %icmp_slt_i8(i8, i8) -> b1 {
+block0(v0: i8, v1: i8):
+    v2 = icmp slt v0, v1
+    return v2
+}
+; run: %icmp_slt_i8(0, 0) == false
+; run: %icmp_slt_i8(1, 0) == false
+; run: %icmp_slt_i8(-1, -1) == false
+; run: %icmp_slt_i8(0, 1) == true
+; run: %icmp_slt_i8(-5, -1) == true
+; run: %icmp_slt_i8(1, -1) == false
+
+function %icmp_slt_i16(i16, i16) -> b1 {
+block0(v0: i16, v1: i16):
+    v2 = icmp slt v0, v1
+    return v2
+}
+; run: %icmp_slt_i16(0, 0) == false
+; run: %icmp_slt_i16(1, 0) == false
+; run: %icmp_slt_i16(-1, -1) == false
+; run: %icmp_slt_i16(0, 1) == true
+; run: %icmp_slt_i16(-5, -1) == true
+; run: %icmp_slt_i16(1, -1) == false
+
+function %icmp_slt_i32(i32, i32) -> b1 {
+block0(v0: i32, v1: i32):
+    v2 = icmp slt v0, v1
+    return v2
+}
+; run: %icmp_slt_i32(0, 0) == false
+; run: %icmp_slt_i32(1, 0) == false
+; run: %icmp_slt_i32(-1, -1) == false
+; run: %icmp_slt_i32(0, 1) == true
+; run: %icmp_slt_i32(-5, -1) == true
+; run: %icmp_slt_i32(1, -1) == false
+
+function %icmp_slt_i64(i64, i64) -> b1 {
+block0(v0: i64, v1: i64):
+    v2 = icmp slt v0, v1
+    return v2
+}
+; run: %icmp_slt_i64(0, 0) == false
+; run: %icmp_slt_i64(1, 0) == false
+; run: %icmp_slt_i64(-1, -1) == false
+; run: %icmp_slt_i64(0, 1) == true
+; run: %icmp_slt_i64(-5, -1) == true
+; run: %icmp_slt_i64(1, -1) == false

cranelift/filetests/filetests/runtests/icmp-uge.clif

@@ -0,0 +1,52 @@
+test interpret
+test run
+target aarch64
+target x86_64 machinst
+
+function %icmp_uge_i8(i8, i8) -> b1 {
+block0(v0: i8, v1: i8):
+    v2 = icmp uge v0, v1
+    return v2
+}
+; run: %icmp_uge_i8(0, 0) == true
+; run: %icmp_uge_i8(1, 0) == true
+; run: %icmp_uge_i8(-1, -1) == true
+; run: %icmp_uge_i8(0, 1) == false
+; run: %icmp_uge_i8(-5, -1) == false
+; run: %icmp_uge_i8(1, -1) == false
+
+function %icmp_uge_i16(i16, i16) -> b1 {
+block0(v0: i16, v1: i16):
+    v2 = icmp uge v0, v1
+    return v2
+}
+; run: %icmp_uge_i16(0, 0) == true
+; run: %icmp_uge_i16(1, 0) == true
+; run: %icmp_uge_i16(-1, -1) == true
+; run: %icmp_uge_i16(0, 1) == false
+; run: %icmp_uge_i16(-5, -1) == false
+; run: %icmp_uge_i16(1, -1) == false
+
+function %icmp_uge_i32(i32, i32) -> b1 {
+block0(v0: i32, v1: i32):
+    v2 = icmp uge v0, v1
+    return v2
+}
+; run: %icmp_uge_i32(0, 0) == true
+; run: %icmp_uge_i32(1, 0) == true
+; run: %icmp_uge_i32(-1, -1) == true
+; run: %icmp_uge_i32(0, 1) == false
+; run: %icmp_uge_i32(-5, -1) == false
+; run: %icmp_uge_i32(1, -1) == false
+
+function %icmp_uge_i64(i64, i64) -> b1 {
+block0(v0: i64, v1: i64):
+    v2 = icmp uge v0, v1
+    return v2
+}
+; run: %icmp_uge_i64(0, 0) == true
+; run: %icmp_uge_i64(1, 0) == true
+; run: %icmp_uge_i64(-1, -1) == true
+; run: %icmp_uge_i64(0, 1) == false
+; run: %icmp_uge_i64(-5, -1) == false
+; run: %icmp_uge_i64(1, -1) == false

cranelift/filetests/filetests/runtests/icmp-ugt.clif

@@ -0,0 +1,52 @@
+test interpret
+test run
+target aarch64
+target x86_64 machinst
+
+function %icmp_ugt_i8(i8, i8) -> b1 {
+block0(v0: i8, v1: i8):
+    v2 = icmp ugt v0, v1
+    return v2
+}
+; run: %icmp_ugt_i8(0, 0) == false
+; run: %icmp_ugt_i8(1, 0) == true
+; run: %icmp_ugt_i8(-1, -1) == false
+; run: %icmp_ugt_i8(0, 1) == false
+; run: %icmp_ugt_i8(-5, -1) == false
+; run: %icmp_ugt_i8(1, -1) == false
+
+function %icmp_ugt_i16(i16, i16) -> b1 {
+block0(v0: i16, v1: i16):
+    v2 = icmp ugt v0, v1
+    return v2
+}
+; run: %icmp_ugt_i16(0, 0) == false
+; run: %icmp_ugt_i16(1, 0) == true
+; run: %icmp_ugt_i16(-1, -1) == false
+; run: %icmp_ugt_i16(0, 1) == false
+; run: %icmp_ugt_i16(-5, -1) == false
+; run: %icmp_ugt_i16(1, -1) == false
+
+function %icmp_ugt_i32(i32, i32) -> b1 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ugt v0, v1
+    return v2
+}
+; run: %icmp_ugt_i32(0, 0) == false
+; run: %icmp_ugt_i32(1, 0) == true
+; run: %icmp_ugt_i32(-1, -1) == false
+; run: %icmp_ugt_i32(0, 1) == false
+; run: %icmp_ugt_i32(-5, -1) == false
+; run: %icmp_ugt_i32(1, -1) == false
+
+function %icmp_ugt_i64(i64, i64) -> b1 {
+block0(v0: i64, v1: i64):
+    v2 = icmp ugt v0, v1
+    return v2
+}
+; run: %icmp_ugt_i64(0, 0) == false
+; run: %icmp_ugt_i64(1, 0) == true
+; run: %icmp_ugt_i64(-1, -1) == false
+; run: %icmp_ugt_i64(0, 1) == false
+; run: %icmp_ugt_i64(-5, -1) == false
+; run: %icmp_ugt_i64(1, -1) == false

cranelift/filetests/filetests/runtests/icmp-ule.clif

@@ -0,0 +1,52 @@
+test interpret
+test run
+target aarch64
+target x86_64 machinst
+
+function %icmp_ule_i8(i8, i8) -> b1 {
+block0(v0: i8, v1: i8):
+    v2 = icmp ule v0, v1
+    return v2
+}
+; run: %icmp_ule_i8(0, 0) == true
+; run: %icmp_ule_i8(1, 0) == false
+; run: %icmp_ule_i8(-1, -1) == true
+; run: %icmp_ule_i8(0, 1) == true
+; run: %icmp_ule_i8(-5, -1) == true
+; run: %icmp_ule_i8(1, -1) == true
+
+function %icmp_ule_i16(i16, i16) -> b1 {
+block0(v0: i16, v1: i16):
+    v2 = icmp ule v0, v1
+    return v2
+}
+; run: %icmp_ule_i16(0, 0) == true
+; run: %icmp_ule_i16(1, 0) == false
+; run: %icmp_ule_i16(-1, -1) == true
+; run: %icmp_ule_i16(0, 1) == true
+; run: %icmp_ule_i16(-5, -1) == true
+; run: %icmp_ule_i16(1, -1) == true
+
+function %icmp_ule_i32(i32, i32) -> b1 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ule v0, v1
+    return v2
+}
+; run: %icmp_ule_i32(0, 0) == true
+; run: %icmp_ule_i32(1, 0) == false
+; run: %icmp_ule_i32(-1, -1) == true
+; run: %icmp_ule_i32(0, 1) == true
+; run: %icmp_ule_i32(-5, -1) == true
+; run: %icmp_ule_i32(1, -1) == true
+
+function %icmp_ule_i64(i64, i64) -> b1 {
+block0(v0: i64, v1: i64):
+    v2 = icmp ule v0, v1
+    return v2
+}
+; run: %icmp_ule_i64(0, 0) == true
+; run: %icmp_ule_i64(1, 0) == false
+; run: %icmp_ule_i64(-1, -1) == true
+; run: %icmp_ule_i64(0, 1) == true
+; run: %icmp_ule_i64(-5, -1) == true
+; run: %icmp_ule_i64(1, -1) == true

cranelift/filetests/filetests/runtests/icmp-ult.clif

@@ -0,0 +1,52 @@
+test interpret
+test run
+target aarch64
+target x86_64 machinst
+
+function %icmp_ult_i8(i8, i8) -> b1 {
+block0(v0: i8, v1: i8):
+    v2 = icmp ult v0, v1
+    return v2
+}
+; run: %icmp_ult_i8(0, 0) == false
+; run: %icmp_ult_i8(1, 0) == false
+; run: %icmp_ult_i8(-1, -1) == false
+; run: %icmp_ult_i8(0, 1) == true
+; run: %icmp_ult_i8(-5, -1) == true
+; run: %icmp_ult_i8(1, -1) == true
+
+function %icmp_ult_i16(i16, i16) -> b1 {
+block0(v0: i16, v1: i16):
+    v2 = icmp ult v0, v1
+    return v2
+}
+; run: %icmp_ult_i16(0, 0) == false
+; run: %icmp_ult_i16(1, 0) == false
+; run: %icmp_ult_i16(-1, -1) == false
+; run: %icmp_ult_i16(0, 1) == true
+; run: %icmp_ult_i16(-5, -1) == true
+; run: %icmp_ult_i16(1, -1) == true
+
+function %icmp_ult_i32(i32, i32) -> b1 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ult v0, v1
+    return v2
+}
+; run: %icmp_ult_i32(0, 0) == false
+; run: %icmp_ult_i32(1, 0) == false
+; run: %icmp_ult_i32(-1, -1) == false
+; run: %icmp_ult_i32(0, 1) == true
+; run: %icmp_ult_i32(-5, -1) == true
+; run: %icmp_ult_i32(1, -1) == true
+
+function %icmp_ult_i64(i64, i64) -> b1 {
+block0(v0: i64, v1: i64):
+    v2 = icmp ult v0, v1
+    return v2
+}
+; run: %icmp_ult_i64(0, 0) == false
+; run: %icmp_ult_i64(1, 0) == false
+; run: %icmp_ult_i64(-1, -1) == false
+; run: %icmp_ult_i64(0, 1) == true
+; run: %icmp_ult_i64(-5, -1) == true
+; run: %icmp_ult_i64(1, -1) == true

cranelift/filetests/filetests/runtests/icmp.clif

@@ -1,3 +1,4 @@
+test interpret
 test run
 target aarch64
 target s390x
@@ -13,5 +14,5 @@ block0(v0: i8):
     v2 = icmp sge v0, v1
     return v2
 }
-; run: %test(49) == true
+; run: %overflow_rhs_con(49) == true
-; run: %test(-65) == false
+; run: %overflow_rhs_con(-65) == false

cranelift/interpreter/src/value.rs

@@ -250,6 +250,7 @@ impl Value for DataValue {
                 // TODO a lot to do here: from bmask to ireduce to raw_bitcast...
                 (DataValue::I64(n), types::I32) => DataValue::I32(i32::try_from(n)?),
                 (DataValue::I64(n), types::I64) => DataValue::I64(n),
+                (DataValue::I64(n), types::I128) => DataValue::I128(n as i128),
                 (DataValue::B(b), t) if t.is_bool() => DataValue::B(b),
                 (dv, _) => unimplemented!("conversion: {} -> {:?}", dv.ty(), kind),
             },
@@ -311,6 +312,7 @@ impl Value for DataValue {
                 DataValue::I16(n) => DataValue::U16(n as u16),
                 DataValue::I32(n) => DataValue::U32(n as u32),
                 DataValue::I64(n) => DataValue::U64(n as u64),
+                DataValue::I128(n) => DataValue::U128(n as u128),
                 _ => unimplemented!("conversion: {} -> {:?}", self.ty(), kind),
             },
             ValueConversionKind::ToSigned => match self {
@@ -318,6 +320,7 @@ impl Value for DataValue {
                 DataValue::U16(n) => DataValue::I16(n as i16),
                 DataValue::U32(n) => DataValue::I32(n as i32),
                 DataValue::U64(n) => DataValue::I64(n as i64),
+                DataValue::U128(n) => DataValue::I128(n as i128),
                 _ => unimplemented!("conversion: {} -> {:?}", self.ty(), kind),
             },
             ValueConversionKind::RoundNearestEven(ty) => match (self.ty(), ty) {
@@ -342,11 +345,11 @@ impl Value for DataValue {
     }
 
     fn eq(&self, other: &Self) -> ValueResult<bool> {
-        comparison_match!(PartialEq::eq[&self, &other]; [I8, I16, I32, I64, U8, U16, U32, U64, F32, F64])
+        comparison_match!(PartialEq::eq[&self, &other]; [I8, I16, I32, I64, I128, U8, U16, U32, U64, U128, F32, F64])
     }
 
     fn gt(&self, other: &Self) -> ValueResult<bool> {
-        comparison_match!(PartialOrd::gt[&self, &other]; [I8, I16, I32, I64, U8, U16, U32, U64, F32, F64])
+        comparison_match!(PartialOrd::gt[&self, &other]; [I8, I16, I32, I64, I128, U8, U16, U32, U64, U128, F32, F64])
     }
 
     fn uno(&self, other: &Self) -> ValueResult<bool> {
@@ -359,6 +362,7 @@ impl Value for DataValue {
             (DataValue::I16(a), DataValue::I16(b)) => a.checked_sub(*b).is_none(),
             (DataValue::I32(a), DataValue::I32(b)) => a.checked_sub(*b).is_none(),
             (DataValue::I64(a), DataValue::I64(b)) => a.checked_sub(*b).is_none(),
+            (DataValue::I128(a), DataValue::I128(b)) => a.checked_sub(*b).is_none(),
             _ => unimplemented!(),
         })
     }