Add wasm tacle-bench targets

2026-06-12 20:06:22 +02:00
parent 30daa8a00c
commit 08c2e9c13d
1122 changed files with 520422 additions and 0 deletions
--- a/targets/wasm-tacle/kernel/sha/generated/modified_sources/default/memset.c
+++ b/targets/wasm-tacle/kernel/sha/generated/modified_sources/default/memset.c
@ -0,0 +1,92 @@
+/*
+
+  This program is part of the TACLeBench benchmark suite.
+  Version V 1.x
+
+  Name: menset.h
+
+  Author: Torbjorn Granlund
+
+  NIST Secure Hash Algorithm
+
+  Copy memory to memory until the specified number of bytes
+  has been copied. Overlap is NOT handled correctly.
+
+  Source: GNU C Library
+
+  Changes: no major functional changes
+
+  License: GNU Lesser General Public License
+*/
+#include "memset.h"
+
+// Wasm loop bounds
+
+__attribute__((import_module("__pragma"), import_name("loopbound"))) extern void
+__pragma_loopbound(unsigned int min_bound, unsigned int max_bound);
+
+int printf(const char *restrict format, ...);
+
+void *
+sha_glibc_memset(void *dstpp, int c, size_t len) {
+    long int dstp = (long int) dstpp;
+
+    if (len >= 8) {
+        size_t xlen;
+        op_t cccc;
+
+        cccc = (unsigned char) c;
+        cccc |= cccc << 8;
+        cccc |= cccc << 16;
+        if (OPSIZ > 4)
+            /* Do the shift in two steps to avoid warning if long has 32 bits.
+             */
+            cccc |= (cccc << 16) << 16;
+
+        /* There are at least some bytes to set.
+          No need to test for LEN == 0 in this alignment loop.  */
+        __pragma_loopbound(3, 3);
+        while (dstp % OPSIZ != 0) {
+            ((BYTE *) dstp)[0] = c;
+            dstp += 1;
+            len -= 1;
+        }
+
+        /* Write 8 `op_t' per iteration until less than 8 `op_t' remain.  */
+        xlen = len / (OPSIZ * 8);
+        __pragma_loopbound(0, 1);
+        while (xlen > 0) {
+            ((op_t *) dstp)[0] = cccc;
+            ((op_t *) dstp)[1] = cccc;
+            ((op_t *) dstp)[2] = cccc;
+            ((op_t *) dstp)[3] = cccc;
+            ((op_t *) dstp)[4] = cccc;
+            ((op_t *) dstp)[5] = cccc;
+            ((op_t *) dstp)[6] = cccc;
+            ((op_t *) dstp)[7] = cccc;
+            dstp += 8 * OPSIZ;
+            xlen -= 1;
+        }
+        len %= OPSIZ * 8;
+
+        /* Write 1 `op_t' per iteration until less than OPSIZ bytes remain.  */
+        xlen = len / OPSIZ;
+        __pragma_loopbound(1, 2);
+        while (xlen > 0) {
+            ((op_t *) dstp)[0] = cccc;
+            dstp += OPSIZ;
+            xlen -= 1;
+        }
+        len %= OPSIZ;
+    }
+
+    /* Write the last few bytes.  */
+    __pragma_loopbound(0, 0);
+    while (len > 0) {
+        ((BYTE *) dstp)[0] = c;
+        dstp += 1;
+        len -= 1;
+    }
+
+    return (void *) dstpp;
+}