New runtime library: libmemory

This static library provides memset, memcpy, memmove, memcmp, and
strlen. The implementations are minimal wrappers around x86 string
instructions, making them both tiny (~26 bytes apiece) and reasonably
performant, though not nearly as fast as CRT implementations. I selected
these particular functions because GCC fabricates calls to each out of
thin air at some optimization levels. The first four are also genuinely
useful as built-ins (__builtin_memset, etc.), keeping in mind arbitrary
limitations with null.

Mingw-w64 does not implement them but instead offers imports from system
DLLs: -lmsvcrt, -lmsvcr120, -lucrt, -lntdllcrt. It creates a dependency
on a system DLL: practical, though unoptimal, and no licensing woes.
With -nostartfiles instead of -nostdlib, this happens implicitly.

MSVC provides static definitions in libvcuntime.lib, useful when cl or
clang-cl fabricates calls. They weigh several KB each, and require the
application or installer to present a EULA ("external end users to agree
to terms"). Not a great trade-off just for some basic memory functions.

In w64devkit, libmemory fills this role. It's a public domain library so
there are no license terms. Just add -lmemory to the build command. It
also allows liberal use of the associated built-ins, especially in debug
builds, which can benefit from fast memory operations despite -O0. MSVC
toolchains can also freely use libmemory.a, though it won't know how to
find it without help of course.

I do not plan to add more functions except for cases of GCC fabricating
calls (e.g. strlen). Certainly no null-terminated string functions.

Author: skeeto

Dockerfile

@@ -59,7 +59,7 @@ RUN sha256sum -c $PREFIX/src/SHA256SUMS \
  && tar xJf nasm-$NASM_VERSION.tar.xz \
  && tar xjf vim-$VIM_VERSION.tar.bz2 \
  && tar xzf cppcheck-$CPPCHECK_VERSION.tar.gz
-COPY src/w64devkit.c src/w64devkit.ico \
+COPY src/w64devkit.c src/w64devkit.ico src/libmemory.c \
      src/alias.c src/debugbreak.c src/pkg-config.c src/vc++filt.c \
      $PREFIX/src/
 
@@ -123,6 +123,10 @@ RUN cat $PREFIX/src/gcc-*.patch | patch -d/gcc-$GCC_VERSION -p1 \
 
 ENV PATH="/bootstrap/bin:${PATH}"
 
+RUN mkdir -p $PREFIX/$ARCH/lib \
+ && CC=$ARCH-gcc DESTDIR=$PREFIX/$ARCH/lib/ sh $PREFIX/src/libmemory.c \
+ && ln $PREFIX/$ARCH/lib/libmemory.a /bootstrap/$ARCH/lib/
+
 WORKDIR /x-mingw-crt
 RUN /mingw-w64-v$MINGW_VERSION/mingw-w64-crt/configure \
         --prefix=/bootstrap/$ARCH \

src/libmemory.c

@@ -0,0 +1,179 @@
+#if 0
+# memset, memcpy, memmove, and memcmp via x86 string instructions
+# Execute this source with a shell to build libmemory.a.
+# This is free and unencumbered software released into the public domain.
+set -e
+CFLAGS="-Os -fno-builtin -fno-asynchronous-unwind-tables -fno-ident"
+objects=""
+for func in memset memcpy memmove memcmp strlen; do
+    FUNC="$(echo $func | tr '[:lower:]' '[:upper:]')"
+    objects="$objects $func.o"
+    (set -x; ${CC:-cc} -c -D$FUNC -Wa,--no-pad-sections $CFLAGS -o $func.o $0)
+done
+rm -f "${DESTDIR}libmemory.a"
+ar r "${DESTDIR}libmemory.a" $objects
+rm $objects
+exit 0
+#endif
+
+typedef __SIZE_TYPE__    size_t;
+typedef __UINTPTR_TYPE__ uintptr_t;
+
+#ifdef MEMSET
+void *memset(void *dst, int c, size_t len)
+{
+    void *r = dst;
+    asm volatile (
+        "rep stosb"
+        : "+D"(dst), "+c"(len)
+        : "a"(c)
+        : "memory"
+    );
+    return r;
+}
+#endif
+
+#ifdef MEMCPY
+void *memcpy(void *restrict dst, void *restrict src, size_t len)
+{
+    void *r = dst;
+    asm volatile (
+        "rep movsb"
+        : "+D"(dst), "+S"(src), "+c"(len)
+        :
+        : "memory"
+    );
+    return r;
+}
+#endif
+
+#ifdef MEMMOVE
+void *memmove(void *dst, void *src, size_t len)
+{
+    // Use uintptr_t to bypass pointer semantics:
+    // (1) comparing unrelated pointers
+    // (2) pointer arithmetic on null (i.e. gracefully handle null dst/src)
+    // (3) pointer overflow ("one-before-the-beginning" in reversed copy)
+    uintptr_t d = (uintptr_t)dst;
+    uintptr_t s = (uintptr_t)src;
+    if (d > s) {
+        d += len - 1;
+        s += len - 1;
+        asm ("std");
+    }
+    asm volatile (
+        "rep movsb; cld"
+        : "+D"(d), "+S"(s), "+c"(len)
+        :
+        : "memory"
+    );
+    return dst;
+}
+#endif
+
+#ifdef MEMCMP
+int memcmp(void *s1, void *s2, size_t len)
+{
+    // CCa "after"  == CF=0 && ZF=0
+    // CCb "before" == CF=1
+    int a, b;
+    asm volatile (
+        "xor %%eax, %%eax\n"  // CF=0, ZF=1 (i.e. CCa = CCb = 0)
+        "repz cmpsb\n"
+        : "+D"(s1), "+S"(s2), "+c"(len), "=@cca"(a), "=@ccb"(b)
+        :
+        : "ax", "memory"
+    );
+    return b - a;
+}
+#endif
+
+#ifdef STRLEN
+size_t strlen(char *s)
+{
+    size_t n = -1;
+    asm volatile (
+        "repne scasb"
+        : "+D"(s), "+c"(n)
+        : "a"(0)
+        : "memory"
+    );
+    return -n - 2;
+}
+#endif
+
+#ifdef TEST
+// $ sh libmemory.c
+// $ cc -nostdlib -fno-builtin -DTEST -g3 -O -o test libmemory.c libmemory.a
+// $ gdb -ex r -ex q ./test
+
+#define assert(c) while (!(c)) __builtin_trap()
+void   *memset(void *, int, size_t);
+int     memcmp(void *, void *, size_t);
+void   *memcpy(void *restrict, void *restrict, size_t);
+void   *memmove(void *, void *, size_t);
+size_t  strlen(char *);
+
+#if defined(__linux) && defined(__amd64)
+asm ("        .global _start\n"
+     "_start: call mainCRTStartup\n"
+     "        mov  %eax, %edi\n"
+     "        mov  $60, %eax\n"
+     "        syscall\n");
+#elif defined(__linux) && defined(__i386)
+asm ("        .global _start\n"
+     "_start: call mainCRTStartup\n"
+     "        mov  %eax, %ebx\n"
+     "        mov  $1, %eax\n"
+     "        int  $0x80\n");
+#endif
+
+int mainCRTStartup(void)
+{
+    {
+        char buf[12] = "............";
+        memset(buf+4, 'x', 4);
+        assert(!memcmp(buf, "....xxxx....", 12));
+        memset(buf, 0, 12);
+        assert(!memcmp(buf, (char[12]){0}, 12));
+        memset(buf+8, 1, 0);
+        assert(!memcmp(buf, (char[12]){0}, 12));
+    }
+
+    {
+        char buf[7] = "abcdefg";
+        memcpy(buf+0, buf+3, 3);
+        assert(!memcmp(buf, "defdefg", 7));
+        memcpy(buf+5, buf+1, 2);
+        assert(!memcmp(buf, "defdeef", 7));
+        memcpy(buf+1, buf+4, 0);
+        assert(!memcmp(buf, "defdeef", 7));
+    }
+
+    {
+        char buf[] = "abcdefgh";
+        memmove(buf+0, buf+1, 7);
+        assert(!memcmp(buf, "bcdefghh", 8));
+        buf[7] = 0;
+        memmove(buf+1, buf+0, 7);
+        assert(!memcmp(buf, "bbcdefgh", 8));
+        memmove(buf+2, buf+1, 0);
+        assert(!memcmp(buf, "bbcdefgh", 8));
+    }
+
+    assert(memcmp("\xff", "1", 1) > 0);
+    assert(memcmp("", "", 0) == 0);  // test empty after > result
+    assert(memcmp("1", "\xff", 1) < 0);
+    assert(memcmp("", "", 0) == 0);  // test empty after < result
+    assert(memcmp("ab", "aa", 2) > 0);
+    assert(memcmp("aa", "ab", 2) < 0);
+    assert(memcmp("x", "y", 0) == 0);
+
+    assert(0 == strlen(""));
+    assert(1 == strlen(" "));
+    assert(1 == strlen("\xff"));
+    assert(5 == strlen("hello"));
+
+    return 0;
+}
+#endif