nostdlib.

Author: ncruces

libc/README.md

@@ -0,0 +1,7 @@
+# SQLite Libc 
+
+This is a minimal libc that offers just enough
+to compile SQLite for wasm32 with nostdlib.
+
+The allocator is currently a bump allocator,
+and math is provided by the host side.

libc/assert.h

@@ -0,0 +1,3 @@
+#ifndef assert
+#define assert(ignore) ((void)0)
+#endif

libc/ctype.c

@@ -0,0 +1,18 @@
+#include <ctype.h>
+
+int(isalnum)(int c) { return isalpha(c) || isdigit(c); }
+int(isalpha)(int c) { return ((unsigned)c | 32) - 'a' < 26; }
+int(isascii)(int c) { return !(c & ~0x7f); }
+int(isblank)(int c) { return (c == ' ' || c == '\t'); }
+int(iscntrl)(int c) { return (unsigned)c < 0x20 || c == 0x7f; }
+int(isdigit)(int c) { return (unsigned)c - '0' < 10; }
+int(isgraph)(int c) { return (unsigned)c - 0x21 < 0x5e; }
+int(islower)(int c) { return (unsigned)c - 'a' < 26; }
+int(isprint)(int c) { return (unsigned)c - 0x20 < 0x5f; }
+int(ispunct)(int c) { return isgraph(c) && !isalnum(c); }
+int(isspace)(int c) { return c == ' ' || (unsigned)c - '\t' < 5; }
+int(isupper)(int c) { return (unsigned)c - 'A' < 26; }
+int(isxdigit)(int c) { return isdigit(c) || ((unsigned)c | 32) - 'a' < 6; }
+
+int(tolower)(int c) { return isupper(c) ? c | 32 : c; }
+int(toupper)(int c) { return islower(c) ? c & 0x5f : c; }

libc/ctype.h

@@ -0,0 +1,25 @@
+#pragma once
+
+int isalnum(int);
+int isalpha(int);
+int isascii(int);
+int isblank(int);
+int iscntrl(int);
+int isdigit(int);
+int isgraph(int);
+int islower(int);
+int isprint(int);
+int ispunct(int);
+int isspace(int);
+int isupper(int);
+int isxdigit(int);
+
+int tolower(int);
+int toupper(int);
+
+#define isalpha(a) (0 ? isalpha(a) : (((unsigned)(a) | 32) - 'a') < 26)
+#define isdigit(a) (0 ? isdigit(a) : ((unsigned)(a) - '0') < 10)
+#define isgraph(a) (0 ? isgraph(a) : ((unsigned)(a) - 0x21) < 0x5e)
+#define islower(a) (0 ? islower(a) : ((unsigned)(a) - 'a') < 26)
+#define isprint(a) (0 ? isprint(a) : ((unsigned)(a) - 0x20) < 0x5f)
+#define isupper(a) (0 ? isupper(a) : ((unsigned)(a) - 'A') < 26)

libc/format.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd -P -- "$(dirname -- "$0")"
+
+ROOT=../
+WASI_SDK="$ROOT/tools/wasi-sdk/bin"
+
+"$WASI_SDK/clang-format" --style=Google -i *.c *.h

libc/libc.c

@@ -0,0 +1,4 @@
+#include "ctype.c"
+#include "math.c"
+#include "stdlib.c"
+#include "string.c"

libc/math.c

@@ -0,0 +1,3 @@
+#include <math.h>
+
+double(sqrt)(double x) { return __builtin_sqrt(x); }

libc/math.h

@@ -0,0 +1,29 @@
+#pragma once
+
+double acos(double);
+double acosh(double);
+double asin(double);
+double asinh(double);
+double atan(double);
+double atan2(double, double);
+double atanh(double);
+double ceil(double);
+double cos(double);
+double cosh(double);
+double exp(double);
+double fabs(double);
+double floor(double);
+double fmod(double, double);
+double log(double);
+double log10(double);
+double log2(double);
+double pow(double, double);
+double sin(double);
+double sinh(double);
+double tan(double);
+double tanh(double);
+double trunc(double);
+double sqrt(double);
+
+#define sqrt(x) (__builtin_sqrt(x))
+#define isnan(x) (__builtin_isnan(x))

libc/stdio.h

@@ -0,0 +1,94 @@
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+extern char __heap_base[];
+extern char __heap_end[];
+
+static void* __arena_beg = __heap_base;
+static void* __arena_end = __heap_end;
+
+static void __arena_grow(size_t size) {
+  size_t avail = __arena_end - __arena_beg;
+  if (size > avail) {
+    size_t npages = (size - avail + 0xfffful) >> 16;
+    size_t old = __builtin_wasm_memory_grow(0, npages);
+    if (old == ~0ul) __builtin_trap();
+    __arena_end += npages << 16;
+  }
+}
+
+__attribute__((always_inline)) void free(void*) {}
+
+__attribute__((malloc)) void* malloc(size_t size) {
+  if (size == 0) return NULL;
+  size = (size + 15) & ~15;
+  void* res = __arena_beg;
+  __arena_grow(size);
+  __arena_beg += size;
+  return res;
+}
+
+__attribute__((malloc)) void* calloc(size_t nelem, size_t elsize) {
+  return malloc(nelem * elsize);
+}
+
+__attribute__((malloc)) void* aligned_alloc(size_t align, size_t size) {
+  if ((align & -align) != align) __builtin_trap();
+  align = (align - ((uintptr_t)__arena_beg & (align - 1))) & (align - 1);
+  return malloc(size + align) + align;
+}
+
+void* realloc(void* ptr, size_t size) {
+  size_t copy = __arena_beg - ptr;
+  void* res = malloc(size);
+  if (ptr != NULL && res != NULL) {
+    if (size < copy) copy = size;
+    memcpy(res, ptr, copy);
+  }
+  return res;
+}
+
+__attribute__((noreturn)) void abort(void) { __builtin_trap(); }
+
+// Shellsort with Gonnet & Baeza-Yates gap sequence.
+// Simple, no recursion, doesn't use the C stack.
+// Clang auto-vectorizes the inner loop.
+
+void qsort(void* base, size_t nel, size_t width,
+           int (*comp)(const void*, const void*)) {
+  // If nel is zero, we're required to do nothing.
+  // If it's one, the array is already sorted.
+  size_t wnel = width * nel;
+  size_t gap = nel;
+  while (gap > 1) {
+    // Use 64-bit unsigned arithmetic to avoid intermediate overflow.
+    // Absent overflow, gap will be strictly less than its previous value.
+    // Once it is one or zero, set it to one: do a final pass, and stop.
+    gap = (5ull * gap - 1) / 11;
+    if (gap == 0) gap = 1;
+
+    // It'd be undefined behavior for wnel to overflow a size_t;
+    // or if width is zero: the base pointer would be invalid.
+    // Since gap is stricly less than nel, we can assume
+    // wgap is strictly less than wnel.
+    size_t wgap = width * gap;
+    __builtin_assume(wgap < wnel);
+    for (size_t i = wgap; i < wnel; i += width) {
+      // Even without overflow flags, the overflow builtin helps the compiler.
+      for (size_t j = i; !__builtin_sub_overflow(j, wgap, &j);) {
+        char* a = j + (char*)base;
+        char* b = a + wgap;
+        if (comp(a, b) <= 0) break;
+
+        // This well known loop is automatically vectorized.
+        size_t s = width;
+        do {
+          char tmp = *a;
+          *a++ = *b;
+          *b++ = tmp;
+        } while (--s);
+      }
+    }
+  }
+}