Add vslt/vsle

README.md

@@ -6,10 +6,6 @@ Arranged from QEMU implementation and [GCC Intrinsics](https://gcc.gnu.org/onlin
 
 TODO List:
 
-### vle/lt.b/h/w/d
-
-Vector Set Equal/Less than or Equal/Less Than
-
 ### vsadd.b/h/w/d
 
 Vector Saturated Add

code/gen_impl.py

@@ -143,6 +143,14 @@
             file=f,
         )
         print(f"}}", file=f)
+    for name, op in [("lt", "<"), ("le", "<=")]:
+        with open(f"vs{name}_{width}.h", "w") as f:
+            print(f"for (int i = 0;i < {128 // w};i++) {{", file=f)
+            print(
+                f"  dst.{m}[i] = (({sign}{w})a.{m}[i] {op} ({sign}{w})b.{m}[i]) ? 0x{((1 << w) - 1):X} : 0;",
+                file=f,
+            )
+            print(f"}}", file=f)
 
 for width in ["b", "bu", "h", "hu", "w", "wu", "d", "du"]:
     double_width = double_widths[width]

code/gen_tb.py

@@ -74,6 +74,8 @@
     "vmulwod": (widths_vaddw, "v128 a, v128 b"),
     "vpcnt": (widths_signed, "v128 a"),
     "vseq": (widths_signed, "v128 a, v128 b"),
+    "vslt": (widths_all, "v128 a, v128 b"),
+    "vsle": (widths_all, "v128 a, v128 b"),
     "vsub": (widths_signed, "v128 a, v128 b"),
     "vsubwev": (widths_vsubw, "v128 a, v128 b"),
     "vsubwod": (widths_vsubw, "v128 a, v128 b"),

code/vsle_b.cpp

@@ -0,0 +1,9 @@
+#include "common.h"
+
+v128 vsle_b(v128 a, v128 b) {
+  v128 dst;
+#include "vsle_b.h"
+  return dst;
+}
+
+void test() { FUZZ2(vsle_b); }

code/vsle_b.h

@@ -0,0 +1,3 @@
+for (int i = 0; i < 16; i++) {
+  dst.byte[i] = ((s8)a.byte[i] <= (s8)b.byte[i]) ? 0xFF : 0;
+}

code/vsle_bu.cpp

@@ -0,0 +1,9 @@
+#include "common.h"
+
+v128 vsle_bu(v128 a, v128 b) {
+  v128 dst;
+#include "vsle_bu.h"
+  return dst;
+}
+
+void test() { FUZZ2(vsle_bu); }

code/vsle_bu.h

@@ -0,0 +1,3 @@
+for (int i = 0; i < 16; i++) {
+  dst.byte[i] = ((u8)a.byte[i] <= (u8)b.byte[i]) ? 0xFF : 0;
+}

code/vsle_d.cpp

@@ -0,0 +1,9 @@
+#include "common.h"
+
+v128 vsle_d(v128 a, v128 b) {
+  v128 dst;
+#include "vsle_d.h"
+  return dst;
+}
+
+void test() { FUZZ2(vsle_d); }

code/vsle_d.h

@@ -0,0 +1,3 @@
+for (int i = 0; i < 2; i++) {
+  dst.dword[i] = ((s64)a.dword[i] <= (s64)b.dword[i]) ? 0xFFFFFFFFFFFFFFFF : 0;
+}

code/vsle_du.cpp

@@ -0,0 +1,9 @@
+#include "common.h"
+
+v128 vsle_du(v128 a, v128 b) {
+  v128 dst;
+#include "vsle_du.h"
+  return dst;
+}
+
+void test() { FUZZ2(vsle_du); }

code/vsle_du.h

@@ -0,0 +1,3 @@
+for (int i = 0; i < 2; i++) {
+  dst.dword[i] = ((u64)a.dword[i] <= (u64)b.dword[i]) ? 0xFFFFFFFFFFFFFFFF : 0;
+}

code/vsle_h.cpp

@@ -0,0 +1,9 @@
+#include "common.h"
+
+v128 vsle_h(v128 a, v128 b) {
+  v128 dst;
+#include "vsle_h.h"
+  return dst;
+}
+
+void test() { FUZZ2(vsle_h); }

code/vsle_h.h

@@ -0,0 +1,3 @@
+for (int i = 0; i < 8; i++) {
+  dst.half[i] = ((s16)a.half[i] <= (s16)b.half[i]) ? 0xFFFF : 0;
+}

code/vsle_hu.cpp

@@ -0,0 +1,9 @@
+#include "common.h"
+
+v128 vsle_hu(v128 a, v128 b) {
+  v128 dst;
+#include "vsle_hu.h"
+  return dst;
+}
+
+void test() { FUZZ2(vsle_hu); }

code/vsle_hu.h

@@ -0,0 +1,3 @@
+for (int i = 0; i < 8; i++) {
+  dst.half[i] = ((u16)a.half[i] <= (u16)b.half[i]) ? 0xFFFF : 0;
+}

code/vsle_w.cpp

@@ -0,0 +1,9 @@
+#include "common.h"
+
+v128 vsle_w(v128 a, v128 b) {
+  v128 dst;
+#include "vsle_w.h"
+  return dst;
+}
+
+void test() { FUZZ2(vsle_w); }

code/vsle_w.h

@@ -0,0 +1,3 @@
+for (int i = 0; i < 4; i++) {
+  dst.word[i] = ((s32)a.word[i] <= (s32)b.word[i]) ? 0xFFFFFFFF : 0;
+}

code/vsle_wu.cpp

@@ -0,0 +1,9 @@
+#include "common.h"
+
+v128 vsle_wu(v128 a, v128 b) {
+  v128 dst;
+#include "vsle_wu.h"
+  return dst;
+}
+
+void test() { FUZZ2(vsle_wu); }

code/vsle_wu.h

@@ -0,0 +1,3 @@
+for (int i = 0; i < 4; i++) {
+  dst.word[i] = ((u32)a.word[i] <= (u32)b.word[i]) ? 0xFFFFFFFF : 0;
+}

code/vslt_b.cpp

@@ -0,0 +1,9 @@
+#include "common.h"
+
+v128 vslt_b(v128 a, v128 b) {
+  v128 dst;
+#include "vslt_b.h"
+  return dst;
+}
+
+void test() { FUZZ2(vslt_b); }

code/vslt_b.h

@@ -0,0 +1,3 @@
+for (int i = 0; i < 16; i++) {
+  dst.byte[i] = ((s8)a.byte[i] < (s8)b.byte[i]) ? 0xFF : 0;
+}

code/vslt_bu.cpp

@@ -0,0 +1,9 @@
+#include "common.h"
+
+v128 vslt_bu(v128 a, v128 b) {
+  v128 dst;
+#include "vslt_bu.h"
+  return dst;
+}
+
+void test() { FUZZ2(vslt_bu); }

code/vslt_bu.h

@@ -0,0 +1,3 @@
+for (int i = 0; i < 16; i++) {
+  dst.byte[i] = ((u8)a.byte[i] < (u8)b.byte[i]) ? 0xFF : 0;
+}

code/vslt_d.cpp

@@ -0,0 +1,9 @@
+#include "common.h"
+
+v128 vslt_d(v128 a, v128 b) {
+  v128 dst;
+#include "vslt_d.h"
+  return dst;
+}
+
+void test() { FUZZ2(vslt_d); }

code/vslt_d.h

@@ -0,0 +1,3 @@
+for (int i = 0; i < 2; i++) {
+  dst.dword[i] = ((s64)a.dword[i] < (s64)b.dword[i]) ? 0xFFFFFFFFFFFFFFFF : 0;
+}

code/vslt_du.cpp

@@ -0,0 +1,9 @@
+#include "common.h"
+
+v128 vslt_du(v128 a, v128 b) {
+  v128 dst;
+#include "vslt_du.h"
+  return dst;
+}
+
+void test() { FUZZ2(vslt_du); }

code/vslt_du.h

@@ -0,0 +1,3 @@
+for (int i = 0; i < 2; i++) {
+  dst.dword[i] = ((u64)a.dword[i] < (u64)b.dword[i]) ? 0xFFFFFFFFFFFFFFFF : 0;
+}

code/vslt_h.cpp

@@ -0,0 +1,9 @@
+#include "common.h"
+
+v128 vslt_h(v128 a, v128 b) {
+  v128 dst;
+#include "vslt_h.h"
+  return dst;
+}
+
+void test() { FUZZ2(vslt_h); }

code/vslt_h.h

@@ -0,0 +1,3 @@
+for (int i = 0; i < 8; i++) {
+  dst.half[i] = ((s16)a.half[i] < (s16)b.half[i]) ? 0xFFFF : 0;
+}

code/vslt_hu.cpp

@@ -0,0 +1,9 @@
+#include "common.h"
+
+v128 vslt_hu(v128 a, v128 b) {
+  v128 dst;
+#include "vslt_hu.h"
+  return dst;
+}
+
+void test() { FUZZ2(vslt_hu); }

code/vslt_hu.h

@@ -0,0 +1,3 @@
+for (int i = 0; i < 8; i++) {
+  dst.half[i] = ((u16)a.half[i] < (u16)b.half[i]) ? 0xFFFF : 0;
+}

code/vslt_w.cpp

@@ -0,0 +1,9 @@
+#include "common.h"
+
+v128 vslt_w(v128 a, v128 b) {
+  v128 dst;
+#include "vslt_w.h"
+  return dst;
+}
+
+void test() { FUZZ2(vslt_w); }

code/vslt_w.h

@@ -0,0 +1,3 @@
+for (int i = 0; i < 4; i++) {
+  dst.word[i] = ((s32)a.word[i] < (s32)b.word[i]) ? 0xFFFFFFFF : 0;
+}

code/vslt_wu.cpp

@@ -0,0 +1,9 @@
+#include "common.h"
+
+v128 vslt_wu(v128 a, v128 b) {
+  v128 dst;
+#include "vslt_wu.h"
+  return dst;
+}
+
+void test() { FUZZ2(vslt_wu); }

code/vslt_wu.h

@@ -0,0 +1,3 @@
+for (int i = 0; i < 4; i++) {
+  dst.word[i] = ((u32)a.word[i] < (u32)b.word[i]) ? 0xFFFFFFFF : 0;
+}

docs/lsx/integer_comparison.md

@@ -3,4 +3,22 @@
 {{ vseq('b') }}
 {{ vseq('h') }}
 {{ vseq('w') }}
-{{ vseq('d') }}
+{{ vseq('d') }}
+
+{{ vslt('b') }}
+{{ vslt('bu') }}
+{{ vslt('h') }}
+{{ vslt('hu') }}
+{{ vslt('w') }}
+{{ vslt('wu') }}
+{{ vslt('d') }}
+{{ vslt('du') }}
+
+{{ vsle('b') }}
+{{ vsle('bu') }}
+{{ vsle('h') }}
+{{ vsle('hu') }}
+{{ vsle('w') }}
+{{ vsle('wu') }}
+{{ vsle('d') }}
+{{ vsle('du') }}

main.py

@@ -561,4 +561,24 @@ def vseq(name):
             intrinsic=f"__m128i __lsx_vseq_{name} (__m128i a, __m128i b)",
             instr=f"vseq.{name} vr, vr",
             desc=f"Compare the {width}-bit elements in `a` and `b`, store all-ones to `dst` if equal, zero otherwise.",
+        )
+
+    @env.macro
+    def vslt(name):
+        width = widths[name]
+        signedness = signednesses[name]
+        return instruction(
+            intrinsic=f"__m128i __lsx_vslt_{name} (__m128i a, __m128i b)",
+            instr=f"vslt.{name} vr, vr",
+            desc=f"Compare the {signedness} {width}-bit elements in `a` and `b`, store all-ones to `dst` if corresponding element in `a` is less than `b`, zero otherwise.",
+        )
+
+    @env.macro
+    def vsle(name):
+        width = widths[name]
+        signedness = signednesses[name]
+        return instruction(
+            intrinsic=f"__m128i __lsx_vslt_{name} (__m128i a, __m128i b)",
+            instr=f"vslt.{name} vr, vr",
+            desc=f"Compare the {signedness} {width}-bit elements in `a` and `b`, store all-ones to `dst` if corresponding element in `a` is less than or equal `b`, zero otherwise.",
         )