Add a few Subzero intrinsics (not the atomic ones yet).

crosstest/mem_intrin_main.c

Index: crosstest/mem_intrin_main.c
diff --git a/crosstest/mem_intrin_main.c b/crosstest/mem_intrin_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..31016131e516fcddce084f948d9c26209086ef7b
--- /dev/null
+++ b/crosstest/mem_intrin_main.c
@@ -0,0 +1,38 @@
+/* crosstest.py --test=mem_intrin.c --driver=mem_intrin_main.c \
+   --prefix=Subzero_ --output=mem_intrin */
+
+#include <stdint.h>
+#include <stdio.h>
+
+int memcpy_test(uint8_t n);
+int memmove_test(uint8_t n);
+int memset_test(uint8_t n);
+int Subzero_memcpy_test(uint8_t n);
+int Subzero_memmove_test(uint8_t n);
+int Subzero_memset_test(uint8_t n);
+
+int main(int argc, char **argv) {
+  unsigned TotalTests = 0;
+  unsigned Passes = 0;
+  unsigned Failures = 0;
+#define do_test(test_func) \

[Jim Stichnoth, 2014/06/12 20:52:07]

Do you think this test will be getting much bigger?  If it does, it would be
worthwhile making it a C++ test instead of C.  That would make templates
available, and makes declarations a bit simpler (#include a header twice - once
inside a namespace Subzero_ {} block and once at the top level).

The only downside of C++ cross tests that I'm aware of is that the name mangling
is a pain when the test includes a manually written .ll file.

[jvoung (off chromium), 2014/06/16 20:51:59]

Added some variable-length mem() calls, (vs the fixed size alloca buffers).

Converted to c++, but didn't really use it for much besides the namespace
Subzero_ #include trick.

One thing to watch out for is more complex name-mangling rules. E.g.,
compression / element substitution.

I don't know if we should make the Subzero name-mangling injection any more
complicated, though. Let me know if you disagree. I had one workaround (make a
param void* instead of uint8_t*).

====

Otherwise, I there is a test in scons for memcpy/memmove/memset, so I didn't go
and make this more complicated.

+  for (uint8_t i = 0; i < 100; ++i) { \
+    ++TotalTests; \
+    int llc_result = test_func(i); \
+    int sz_result = Subzero_##test_func(i); \
+    if (llc_result == sz_result) { \
+      ++Passes; \
+    } else { \
+      ++Failures; \
+      printf("Failure (%s): i=%d, llc=%d, sz=%d\n", #test_func, \
+             i, llc_result, sz_result); \
+    } \
+  }
+
+  do_test(memcpy_test)
+  do_test(memmove_test)
+  /* Broken: invalid push byte for val argument */
+  /* do_test(memset_test) */
+  printf("TotalTests=%u Passes=%u Failures=%u\n", TotalTests, Passes, Failures);
+  return Failures;
+}