WIP: wasm

Author: skoppe

src/core/atomic.d

@@ -576,6 +576,11 @@ TailShared!T atomicOp(string op, T, V1)(ref shared T val, V1 mod) pure nothrow @
     if (__traits(compiles, mixin("*cast(T*)&val" ~ op ~ "mod")))
 in (atomicValueIsProperlyAligned(val))
 {
+  version (WebAssembly) {
+      T* get = cast(T*)&val;
+      // TODO: WASM atomics
+      mixin("return (*get)" ~ op ~ "mod;");
+  } else {
     version (LDC)
     {
         import ldc.intrinsics;
@@ -655,6 +660,7 @@ in (atomicValueIsProperlyAligned(val))
     {
         static assert(false, "Operation not supported.");
     }
+  }
 }
 
 
@@ -1114,6 +1120,7 @@ version (CoreUnittest)
     {
         debug: // tests CAS in-contract
 
+            version (WebAssembly) {} else
         pure nothrow unittest
         {
             import core.exception : AssertError;
@@ -1179,6 +1186,8 @@ version (CoreUnittest)
         assert(ptr is null);
     }
 
+    // TODO: WebAssembly has no threads
+    version (WebAssembly) {} else
     unittest
     {
         import core.thread;

src/core/demangle.d

@@ -2355,6 +2355,7 @@ char[] mangleFunc(T:FT*, FT)(const(char)[] fqn, char[] dst = null) @safe pure no
 
 private enum hasTypeBackRef = (int function(void**,void**)).mangleof[$-4 .. $] == "QdZi";
 
+version (WebAssembly) {} else
 @safe pure nothrow unittest
 {
     assert(mangleFunc!(int function(int))("a.b") == "_D1a1bFiZi");
@@ -2431,6 +2432,8 @@ else version (Darwin)
 else
     enum string cPrefix = "";
 
+// TODO: can this be removed?
+version (WebAssembly) {} else
 @safe pure nothrow unittest
 {
     immutable string[2][] table =
@@ -2562,6 +2565,7 @@ else
         else
             alias staticIota = Seq!(staticIota!(x - 1), x - 1);
     }
+
     foreach ( i, name; table )
     {
         auto r = demangle( name[0] );
@@ -2585,6 +2589,7 @@ else
     }
 }
 
+version (WebAssembly) {} else
 unittest
 {
     // https://issues.dlang.org/show_bug.cgi?id=18300
@@ -2597,6 +2602,7 @@ unittest
     }
 }
 
+version (WebAssembly) {} else
 unittest
 {
     // https://issues.dlang.org/show_bug.cgi?id=18300
@@ -2669,7 +2675,12 @@ extern (C) private
         import core.stdc.errno : errno;
 
         const err = errno;
-        real val = strtold(nptr.ptr, null);
+        version (WebAssembly) {
+            real val;
+            strtold(nptr.ptr, null, &val);
+        } else {
+            real val = strtold(nptr.ptr, null);
+        }
         snprintf(nptr.ptr, nptr.length, "%#Lg", val);
         errno = err;
     }

src/core/exception.d

@@ -425,8 +425,18 @@ alias AssertHandler = void function(string file, size_t line, string msg) nothro
  */
 extern (C) void onAssertError( string file = __FILE__, size_t line = __LINE__ ) nothrow
 {
-    if ( _assertHandler is null )
-        throw new AssertError( file, line );
+    if ( _assertHandler is null ) {
+        version (WebAssembly)
+        {
+            import core.stdc.stdio;
+            printf("Failed assert @ %.*s:%d\n", cast(uint)file.length, file.ptr, line);
+            import ldc.intrinsics : llvm_trap;
+            llvm_trap(); // an unreachable is better than abort since it will translate to an unreachable in WASM and most WASM engines give stack traces then. Whereas with an abort it will terminate and you get no stack trace.
+        } else
+        {
+            throw new AssertError( file, line );
+        }
+    }
     _assertHandler( file, line, null);
 }
 
@@ -441,10 +451,21 @@ extern (C) void onAssertError( string file = __FILE__, size_t line = __LINE__ )
  *  line = The line number on which this error occurred.
  *  msg  = An error message supplied by the user.
  */
-extern (C) void onAssertErrorMsg( string file, size_t line, string msg ) nothrow
+extern (C) void onAssertErrorMsg( string file, size_t line, string msg ) nothrow @trusted
 {
-    if ( _assertHandler is null )
-        throw new AssertError( msg, file, line );
+    if (_assertHandler is null) {
+        version (WebAssembly)
+        {
+            import core.stdc.stdio;
+            printf("Failed assert: %.*s @ %.*s:%d\n", cast(uint)msg.length, msg.ptr, cast(uint)file.length, file.ptr, line);
+            import ldc.intrinsics : llvm_trap;
+            llvm_trap(); // an unreachable is better than abort since it will translate to an unreachable in WASM and most WASM engines give stack traces then. Whereas with an abort it will terminate and you get no stack trace.
+        } else
+        {
+            throw new AssertError( msg, file, line );
+        }
+    }
+
     _assertHandler( file, line, msg );
 }
 
@@ -479,11 +500,17 @@ extern (C) void onUnittestErrorMsg( string file, size_t line, string msg ) nothr
  * Throws:
  *  $(LREF RangeError).
  */
-extern (C) void onRangeError( string file = __FILE__, size_t line = __LINE__ ) @trusted pure nothrow @nogc
-{
-    throw staticError!RangeError( file, line, null );
-}
-
+version (WebAssembly) {
+    extern (C) void onRangeError( string file = __FILE__, size_t line = __LINE__ ) @trusted nothrow
+    {
+        onAssertErrorMsg(file, line, "onRangeError");
+    }
+} else {
+    extern (C) void onRangeError( string file = __FILE__, size_t line = __LINE__ ) @trusted nothrow @nogc
+    {
+        throw staticError!RangeError( file, line, null );
+    }
+ }
 
 /**
  * A callback for finalize errors in D.  A $(LREF FinalizeError) will be thrown.
@@ -499,9 +526,14 @@ extern (C) void onRangeError( string file = __FILE__, size_t line = __LINE__ ) @
  */
 extern (C) void onFinalizeError( TypeInfo info, Throwable e, string file = __FILE__, size_t line = __LINE__ ) @trusted nothrow
 {
-    // This error is thrown during a garbage collection, so no allocation must occur while
-    //  generating this object. So we use a preallocated instance
-    throw staticError!FinalizeError(info, e, file, line);
+    version (WebAssembly) {
+        onAssertErrorMsg( file, line, e.msg );
+    } else
+    {
+        // This error is thrown during a garbage collection, so no allocation must occur while
+        //  generating this object. So we use a preallocated instance
+        throw staticError!FinalizeError(info, e, file, line);
+    }
 }
 
 /**
@@ -513,15 +545,24 @@ extern (C) void onFinalizeError( TypeInfo info, Throwable e, string file = __FIL
  */
 extern (C) void onOutOfMemoryError(void* pretend_sideffect = null) @trusted pure nothrow @nogc /* dmd @@@BUG11461@@@ */
 {
-    // NOTE: Since an out of memory condition exists, no allocation must occur
-    //       while generating this object.
-    throw staticError!OutOfMemoryError();
+    version (WebAssembly) {
+        assert(0, "Out of memory" );
+    } else
+    {
+        // NOTE: Since an out of memory condition exists, no allocation must occur
+        //       while generating this object.
+        throw staticError!OutOfMemoryError();
+    }
 }
 
 extern (C) void onOutOfMemoryErrorNoGC() @trusted nothrow @nogc
 {
-    // suppress stacktrace until they are @nogc
-    throw staticError!OutOfMemoryError(false);
+    version (WebAssembly) {
+        assert(0, "Out of memory" );
+    } else {
+        // suppress stacktrace until they are @nogc
+        throw staticError!OutOfMemoryError(false);
+    }
 }
 
 
@@ -534,9 +575,13 @@ extern (C) void onOutOfMemoryErrorNoGC() @trusted nothrow @nogc
  */
 extern (C) void onInvalidMemoryOperationError(void* pretend_sideffect = null) @trusted pure nothrow @nogc /* dmd @@@BUG11461@@@ */
 {
-    // The same restriction applies as for onOutOfMemoryError. The GC is in an
-    // undefined state, thus no allocation must occur while generating this object.
-    throw staticError!InvalidMemoryOperationError();
+    version (WebAssembly) {
+        assert(0, "Invalid memory operation" );
+    } else {
+        // The same restriction applies as for onOutOfMemoryError. The GC is in an
+        // undefined state, thus no allocation must occur while generating this object.
+        throw staticError!InvalidMemoryOperationError();
+    }
 }
 
 /**
@@ -551,9 +596,13 @@ extern (C) void onInvalidMemoryOperationError(void* pretend_sideffect = null) @t
  * Throws:
  *  $(LREF UnicodeException).
  */
-extern (C) void onUnicodeError( string msg, size_t idx, string file = __FILE__, size_t line = __LINE__ ) @safe pure
+extern (C) void onUnicodeError( string msg, size_t idx, string file = __FILE__, size_t line = __LINE__ ) @safe
 {
-    throw new UnicodeException( msg, idx, file, line );
+    version (WebAssembly) {
+        onAssertErrorMsg(file, line, msg); // TODO: what to do with idx? is it is already in msg?
+    } else {
+        throw new UnicodeException( msg, idx, file, line );
+    }
 }
 
 /***********************************

src/core/internal/abort.d

@@ -6,6 +6,13 @@ module core.internal.abort;
  */
 void abort(scope string msg, scope string filename = __FILE__, size_t line = __LINE__) @nogc nothrow @safe
 {
+  version (WebAssembly) {
+    import core.stdc.stdio;
+    import core.sys.wasi.core;
+    (() @trusted { fprintf(stderr, "Abort: %s @ %s:%d\n", &msg[0], &filename[0], line); })();
+    proc_exit(1);
+  }
+  else {
     import core.stdc.stdlib: c_abort = abort;
     // use available OS system calls to print the message to stderr
     version (Posix)
@@ -50,4 +57,5 @@ void abort(scope string msg, scope string filename = __FILE__, size_t line = __L
     // write an appropriate message, then abort the program
     writeStr("Aborting from ", filename, "(", line.unsignedToTempString(strbuff), ") ", msg);
     c_abort();
+  }
 }

src/core/internal/array/construction.d

@@ -117,6 +117,7 @@ Tarr _d_arrayctor(Tarr : T[], T)(return scope Tarr to, scope Tarr from) @trusted
     assert(arr1 == arr2);
 }
 
+version (WebAssembly) {} else // in WASI no catching of exceptions
 @safe nothrow unittest
 {
     // Test that throwing works
@@ -250,6 +251,7 @@ void _d_arraysetctor(Tarr : T[], T)(scope Tarr p, scope ref T value) @trusted
     assert(arr == [S(1234), S(1234), S(1234), S(1234)]);
 }
 
+version (WebAssembly) {} else // in WASI no catching of exceptions
 @safe nothrow unittest
 {
     // Test that throwing works

src/core/internal/atomic.d

@@ -22,30 +22,54 @@ version (LDC)
     inout(T) atomicLoad(MemoryOrder order = MemoryOrder.seq, T)(inout(T)* src) pure nothrow @nogc @trusted
     {
         alias A = _AtomicType!T;
+        version (WebAssembly) {
+          return *src;
+        } else {
         A result = llvm_atomic_load!A(cast(shared A*) src, _ordering!(order));
         return *cast(inout(T)*) &result;
+        }
     }
 
     void atomicStore(MemoryOrder order = MemoryOrder.seq, T)(T* dest, T value) pure nothrow @nogc @trusted
     {
         alias A = _AtomicType!T;
+        version (WebAssembly) {
+          *dest = value;
+        } else
         llvm_atomic_store!A(*cast(A*) &value, cast(shared A*) dest, _ordering!(order));
     }
 
     T atomicExchange(MemoryOrder order = MemoryOrder.seq, bool result = true, T)(T* dest, T value) pure nothrow @nogc @trusted
     {
         alias A = _AtomicType!T;
+        version (WebAssembly) {
+          auto old = *dest;
+          *dest = value;
+          return old;
+        } else {
         A result = llvm_atomic_rmw_xchg!A(cast(shared A*) dest, *cast(A*) &value, _ordering!(order));
         return *cast(T*) &result;
+        }
     }
 
     bool atomicCompareExchange(bool weak = false, MemoryOrder succ = MemoryOrder.seq, MemoryOrder fail = MemoryOrder.seq, T)(T* dest, T* compare, T value) pure nothrow @nogc @trusted
     {
         alias A = _AtomicType!T;
+        version (WebAssembly) {
+          // TODO: WebAssembly has no atomic ops yet
+          import core.stdc.string : memcmp;
+          if (memcmp(cast(void*)dest, cast(void*)compare, T.sizeof) == 0) {
+            *dest = value;
+            return true;
+          }
+          *compare = *dest;
+          return false;
+        } else {
         auto result = llvm_atomic_cmp_xchg!A(cast(shared A*) dest, *cast(A*) compare, *cast(A*) &value,
             _ordering!(succ), _ordering!(fail), weak);
         *compare = *cast(T*) &result.previousValue;
         return result.exchanged;
+        }
     }
     bool atomicCompareExchangeWeak(MemoryOrder succ = MemoryOrder.seq, MemoryOrder fail = MemoryOrder.seq, T)(T* dest, T* compare, T value) pure nothrow @nogc @trusted
     {
@@ -59,9 +83,19 @@ version (LDC)
     bool atomicCompareExchangeNoResult(bool weak = false, MemoryOrder succ = MemoryOrder.seq, MemoryOrder fail = MemoryOrder.seq, T)(T* dest, const T compare, T value) pure nothrow @nogc @trusted
     {
         alias A = _AtomicType!T;
+        version (WebAssembly) {
+          // TODO: WebAssembly has no atomic ops yet
+          import core.stdc.string : memcmp;
+          if (memcmp(cast(void*)dest, cast(void*)&compare, T.sizeof) == 0) {
+            *dest = value;
+            return true;
+          }
+          return false;
+        } else {
         auto result = llvm_atomic_cmp_xchg!A(cast(shared A*) dest, *cast(A*) &compare, *cast(A*) &value,
             _ordering!(succ), _ordering!(fail), weak);
         return result.exchanged;
+        }
     }
     bool atomicCompareExchangeStrongNoResult(MemoryOrder succ = MemoryOrder.seq, MemoryOrder fail = MemoryOrder.seq, T)(T* dest, const T compare, T value) pure nothrow @nogc @trusted
     {
@@ -70,6 +104,7 @@ version (LDC)
 
     void atomicFence(MemoryOrder order = MemoryOrder.seq)() pure nothrow @nogc @trusted
     {
+      version (WebAssembly) {} else
         llvm_memory_fence(_ordering!(order));
     }
 

src/core/internal/container/array.d

@@ -208,6 +208,8 @@ unittest
     assert(cnt == 0);
 }
 
+// NOTE: fails in wasm because of exceptions
+version (WebAssembly) {} else
 unittest
 {
     import core.exception;

src/core/internal/container/hashtab.d

@@ -306,6 +306,8 @@ unittest
     assert(cnt == 0);
 }
 
+// NOTE: fails in wasm because of exceptions
+version (WebAssembly) {} else
 unittest
 {
     import core.exception;

src/core/internal/entrypoint.d

@@ -52,5 +52,16 @@ template _d_cmain()
                 }
             }
         }
+        version (WebAssembly)
+          {
+            import ldc.attributes;
+            import core.sys.wasi.core;
+            void __wasm_call_ctors();
+            pragma(mangle, "_start")
+              @weak export void _start() {
+              __wasm_call_ctors();
+              proc_exit(main(0, null));
+            }
+          }
     }
 }