Atomics support in interpreter + fuzz fixes for that

src/asm2wasm.h

@@ -32,6 +32,7 @@
 #include "pass.h"
 #include "parsing.h"
 #include "ast_utils.h"
+#include "ast/bits.h"
 #include "ast/branch-utils.h"
 #include "ast/literal-utils.h"
 #include "ast/trapping.h"
@@ -1884,7 +1885,12 @@ Function* Asm2WasmBuilder::processFunction(Ref ast) {
           View& view = views[heap];
           wasm.memory.shared = true;
           if (name == Atomics_load) {
-            return builder.makeAtomicLoad(view.bytes, view.signed_, 0, processUnshifted(ast[2][1], view.bytes), asmToWasmType(view.type));
+            Expression* ret = builder.makeAtomicLoad(view.bytes, 0, processUnshifted(ast[2][1], view.bytes), asmToWasmType(view.type));
+            if (view.signed_) {
+              // atomic loads are unsigned; add a signing
+              ret = Bits::makeSignExt(ret, view.bytes, wasm);
+            }
+            return ret;
           } else if (name == Atomics_store) {
             // asm.js stores return the value, wasm does not
             auto type = asmToWasmType(view.type);

src/ast/ExpressionManipulator.cpp

@@ -97,28 +97,28 @@ Expression* flexibleCopy(Expression* original, Module& wasm, CustomCopier custom
     }
     Expression* visitLoad(Load *curr) {
       if (curr->isAtomic) {
-	return builder.makeAtomicLoad(curr->bytes, curr->signed_, curr->offset,
-				      copy(curr->ptr), curr->type);
+        return builder.makeAtomicLoad(curr->bytes, curr->offset,
+                                      copy(curr->ptr), curr->type);
       }
       return builder.makeLoad(curr->bytes, curr->signed_, curr->offset, curr->align, copy(curr->ptr), curr->type);
     }
     Expression* visitStore(Store *curr) {
       if (curr->isAtomic) {
-	return builder.makeAtomicStore(curr->bytes, curr->offset, copy(curr->ptr), copy(curr->value), curr->valueType);
+        return builder.makeAtomicStore(curr->bytes, curr->offset, copy(curr->ptr), copy(curr->value), curr->valueType);
       }
       return builder.makeStore(curr->bytes, curr->offset, curr->align, copy(curr->ptr), copy(curr->value), curr->valueType);
     }
     Expression* visitAtomicRMW(AtomicRMW* curr) {
       return builder.makeAtomicRMW(curr->op, curr->bytes, curr->offset,
-				   copy(curr->ptr), copy(curr->value), curr->type);
+                                   copy(curr->ptr), copy(curr->value), curr->type);
     }
     Expression* visitAtomicCmpxchg(AtomicCmpxchg* curr) {
       return builder.makeAtomicCmpxchg(curr->bytes, curr->offset,
-				       copy(curr->ptr), copy(curr->expected), copy(curr->replacement),
-				       curr->type);
+                                       copy(curr->ptr), copy(curr->expected), copy(curr->replacement),
+                                       curr->type);
     }
     Expression* visitAtomicWait(AtomicWait* curr) {
-      return builder.makeAtomicWait(copy(curr->ptr), copy(curr->expected), copy(curr->timeout), curr->type);
+      return builder.makeAtomicWait(copy(curr->ptr), copy(curr->expected), copy(curr->timeout), curr->expectedType);
     }
     Expression* visitAtomicWake(AtomicWake* curr) {
       return builder.makeAtomicWake(copy(curr->ptr), copy(curr->wakeCount));

src/ast/bits.h

@@ -18,6 +18,8 @@
 #define wasm_ast_bits_h
 
 #include "support/bits.h"
+#include "wasm-builder.h"
+#include "ast/literal-utils.h"
 
 namespace wasm {
 
@@ -60,6 +62,43 @@ struct Bits {
     }
     WASM_UNREACHABLE();
   }
+
+  static Expression* makeSignExt(Expression* value, Index bytes, Module& wasm) {
+    if (value->type == i32) {
+      if (bytes == 1 || bytes == 2) {
+        auto shifts = bytes == 1 ? 24 : 16;
+        Builder builder(wasm);
+        return builder.makeBinary(
+          ShrSInt32,
+          builder.makeBinary(
+            ShlInt32,
+            value,
+            LiteralUtils::makeFromInt32(shifts, i32, wasm)
+          ),
+          LiteralUtils::makeFromInt32(shifts, i32, wasm)
+        );
+      }
+      assert(bytes == 4);
+      return value; // nothing to do
+    } else {
+      assert(value->type == i64);
+      if (bytes == 1 || bytes == 2 || bytes == 4) {
+        auto shifts = bytes == 1 ? 56 : (bytes == 2 ? 48 : 32);
+        Builder builder(wasm);
+        return builder.makeBinary(
+          ShrSInt64,
+          builder.makeBinary(
+            ShlInt64,
+            value,
+            LiteralUtils::makeFromInt32(shifts, i64, wasm)
+          ),
+          LiteralUtils::makeFromInt32(shifts, i64, wasm)
+        );
+      }
+      assert(bytes == 8);
+      return value; // nothing to do
+    }
+  }
 };
 
 } // namespace wasm

src/ast/global-utils.h

@@ -27,7 +27,7 @@ namespace wasm {
 
 namespace GlobalUtils {
   // find a global initialized to the value of an import, or null if no such global
-  inline Global* getGlobalInitializedToImport(Module&wasm, Name module, Name base) {
+  inline Global* getGlobalInitializedToImport(Module& wasm, Name module, Name base) {
     // find the import
     Name imported;
     for (auto& import : wasm.imports) {

src/passes/DeadCodeElimination.cpp

@@ -254,6 +254,10 @@ struct DeadCodeElimination : public WalkerPass<PostWalker<DeadCodeElimination>>
         case Expression::Id::HostId: DELEGATE(Host);
         case Expression::Id::NopId: DELEGATE(Nop);
         case Expression::Id::UnreachableId: break;
+        case Expression::Id::AtomicCmpxchgId: DELEGATE(AtomicCmpxchg);
+        case Expression::Id::AtomicRMWId: DELEGATE(AtomicRMW);
+        case Expression::Id::AtomicWaitId: DELEGATE(AtomicWait);
+        case Expression::Id::AtomicWakeId: DELEGATE(AtomicWake);
         case Expression::Id::InvalidId:
         default: WASM_UNREACHABLE();
       }

src/passes/Precompute.cpp

@@ -89,6 +89,12 @@ class StandaloneExpressionRunner : public ExpressionRunner<StandaloneExpressionR
   Flow visitAtomicCmpxchg(AtomicCmpxchg *curr) {
     return Flow(NONSTANDALONE_FLOW);
   }
+  Flow visitAtomicWait(AtomicWait *curr) {
+    return Flow(NONSTANDALONE_FLOW);
+  }
+  Flow visitAtomicWake(AtomicWake *curr) {
+    return Flow(NONSTANDALONE_FLOW);
+  }
   Flow visitHost(Host *curr) {
     return Flow(NONSTANDALONE_FLOW);
   }

src/passes/Print.cpp

@@ -352,7 +352,9 @@ struct PrintSExpression : public Visitor<PrintSExpression> {
   }
   static void printRMWSize(std::ostream& o, WasmType type, uint8_t bytes) {
     prepareColor(o) << printWasmType(type) << ".atomic.rmw";
-    if (bytes != getWasmTypeSize(type)) {
+    if (type == unreachable) {
+      o << '?';
+    } else if (bytes != getWasmTypeSize(type)) {
       if (bytes == 1) {
         o << '8';
       } else if (bytes == 2) {

src/passes/SafeHeap.cpp

@@ -25,6 +25,7 @@
 #include "asm_v_wasm.h"
 #include "asmjs/shared-constants.h"
 #include "wasm-builder.h"
+#include "ast/bits.h"
 #include "ast/import-utils.h"
 
 namespace wasm {
@@ -229,7 +230,13 @@ struct SafeHeap : public Pass {
     auto* load = module->allocator.alloc<Load>();
     *load = style; // basically the same as the template we are given!
     load->ptr = builder.makeGetLocal(2, i32);
-    block->list.push_back(load);
+    Expression* last = load;
+    if (load->isAtomic && load->signed_) {
+      // atomic loads cannot be signed, manually sign it
+      last = Bits::makeSignExt(load, load->bytes, *module);
+      load->signed_ = false;
+    }
+    block->list.push_back(last);
     block->finalize(style.type);
     func->body = block;
     module->addFunction(func);