ctor evaller (#982)

Add wasm-ctor-eval, which evaluates functions at compile time - typically static constructor functions - and applies their effects into memory, saving work at startup. If we encounter something we can't evaluate at compile time in our interpreter, stop there.

This is similar to ctor_evaller.py in emscripten (which was for asm.js).

Author: kripken

CMakeLists.txt

@@ -265,3 +265,14 @@ TARGET_LINK_LIBRARIES(wasm-dis passes wasm asmjs ast support)
 SET_PROPERTY(TARGET wasm-dis PROPERTY CXX_STANDARD 11)
 SET_PROPERTY(TARGET wasm-dis PROPERTY CXX_STANDARD_REQUIRED ON)
 INSTALL(TARGETS wasm-dis DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+SET(wasm-ctor-eval_SOURCES
+  src/tools/wasm-ctor-eval.cpp
+)
+ADD_EXECUTABLE(wasm-ctor-eval
+               ${wasm-ctor-eval_SOURCES})
+TARGET_LINK_LIBRARIES(wasm-ctor-eval wasm asmjs emscripten-optimizer ${all_passes} ast support)
+SET_PROPERTY(TARGET wasm-ctor-eval PROPERTY CXX_STANDARD 11)
+SET_PROPERTY(TARGET wasm-ctor-eval PROPERTY CXX_STANDARD_REQUIRED ON)
+INSTALL(TARGETS wasm-ctor-eval DESTINATION bin)
+

auto_update_tests.py

@@ -226,4 +226,17 @@
   out = run_command(cmd, stderr=subprocess.STDOUT)
   open(os.path.join('test', 'binaryen.js', s + '.txt'), 'w').write(out)
 
+print '\n[ checking wasm-ctor-eval... ]\n'
+
+for t in os.listdir(os.path.join('test', 'ctor-eval')):
+  if t.endswith(('.wast', '.wasm')):
+    print '..', t
+    t = os.path.join('test', 'ctor-eval', t)
+    ctors = open(t + '.ctors').read().strip()
+    cmd = [os.path.join('bin', 'wasm-ctor-eval'), t, '-o', 'a.wast', '-S', '--ctors', ctors]
+    stdout = run_command(cmd)
+    actual = open('a.wast').read()
+    out = t + '.out'
+    with open(out, 'w') as o: o.write(actual)
+
 print '\n[ success! ]'

check.py

@@ -237,6 +237,20 @@
         with open(out + '.stdout') as f:
           fail_if_not_identical(f.read(), stdout)
 
+print '\n[ checking wasm-ctor-eval... ]\n'
+
+for t in os.listdir(os.path.join('test', 'ctor-eval')):
+  if t.endswith(('.wast', '.wasm')):
+    print '..', t
+    t = os.path.join('test', 'ctor-eval', t)
+    ctors = open(t + '.ctors').read().strip()
+    cmd = [os.path.join('bin', 'wasm-ctor-eval'), t, '-o', 'a.wast', '-S', '--ctors', ctors]
+    stdout = run_command(cmd)
+    actual = open('a.wast').read()
+    out = t + '.out'
+    with open(out) as f:
+      fail_if_not_identical(f.read(), actual)
+
 print '\n[ checking wasm-shell spec testcases... ]\n'
 
 if len(requested) == 0:

src/ast/memory-utils.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2017 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef wasm_ast_memory_h
+#define wasm_ast_memory_h
+
+#include <algorithm>
+#include <vector>
+
+#include "literal.h"
+#include "wasm.h"
+
+namespace wasm {
+
+namespace MemoryUtils {
+  // flattens memory into a single data segment. returns true if successful
+  inline bool flatten(Memory& memory) {
+    if (memory.segments.size() == 0) return true;
+    std::vector<char> data;
+    for (auto& segment : memory.segments) {
+      auto* offset = segment.offset->dynCast<Const>();
+      if (!offset) return false;
+    }
+    for (auto& segment : memory.segments) {
+      auto* offset = segment.offset->dynCast<Const>();
+      auto start = offset->value.getInteger();
+      auto end = start + segment.data.size();
+      if (end > data.size()) {
+        data.resize(end);
+      }
+      std::copy(segment.data.begin(), segment.data.end(), data.begin() + start);
+    }
+    memory.segments.resize(1);
+    memory.segments[0].offset->cast<Const>()->value = Literal(int32_t(0));
+    memory.segments[0].data.swap(data);
+    return true;
+  }
+};
+
+} // namespace wasm
+
+#endif // wasm_ast_memory_h
+

src/passes/Precompute.cpp

@@ -26,7 +26,7 @@
 
 namespace wasm {
 
-Name NONSTANDALONE_FLOW("Binaryen|nonstandalone");
+static const Name NONSTANDALONE_FLOW("Binaryen|nonstandalone");
 
 // Execute an expression by itself. Errors if we hit anything we need anything not in the expression itself standalone.
 class StandaloneExpressionRunner : public ExpressionRunner<StandaloneExpressionRunner> {

src/shell-interface.h

@@ -95,7 +95,7 @@ struct ShellExternalInterface : ModuleInstance::ExternalInterface {
     memory.resize(wasm.memory.initial * wasm::Memory::kPageSize);
     // apply memory segments
     for (auto& segment : wasm.memory.segments) {
-      Address offset = ConstantExpressionRunner(instance.globals).visit(segment.offset).value.geti32();
+      Address offset = ConstantExpressionRunner<TrivialGlobalManager>(instance.globals).visit(segment.offset).value.geti32();
       assert(offset + segment.data.size() <= wasm.memory.initial * wasm::Memory::kPageSize);
       for (size_t i = 0; i != segment.data.size(); ++i) {
         memory.set(offset + i, segment.data[i]);
@@ -104,7 +104,7 @@ struct ShellExternalInterface : ModuleInstance::ExternalInterface {
 
     table.resize(wasm.table.initial);
     for (auto& segment : wasm.table.segments) {
-      Address offset = ConstantExpressionRunner(instance.globals).visit(segment.offset).value.geti32();
+      Address offset = ConstantExpressionRunner<TrivialGlobalManager>(instance.globals).visit(segment.offset).value.geti32();
       assert(offset + segment.data.size() <= wasm.table.initial);
       for (size_t i = 0; i != segment.data.size(); ++i) {
         table[offset + i] = segment.data[i];
@@ -143,7 +143,7 @@ struct ShellExternalInterface : ModuleInstance::ExternalInterface {
       throw ExitException();
     }
     std::cout << "callImport " << import->name.str << "\n";
-    abort();
+    WASM_UNREACHABLE();
   }
 
   Literal callTable(Index index, LiteralList& arguments, WasmType result, ModuleInstance& instance) override {
@@ -159,60 +159,19 @@ struct ShellExternalInterface : ModuleInstance::ExternalInterface {
     return instance.callFunctionInternal(func->name, arguments);
   }
 
-  Literal load(Load* load, Address addr) override {
-    switch (load->type) {
-      case i32: {
-        switch (load->bytes) {
-          case 1: return load->signed_ ? Literal((int32_t)memory.get<int8_t>(addr)) : Literal((int32_t)memory.get<uint8_t>(addr));
-          case 2: return load->signed_ ? Literal((int32_t)memory.get<int16_t>(addr)) : Literal((int32_t)memory.get<uint16_t>(addr));
-          case 4: return load->signed_ ? Literal((int32_t)memory.get<int32_t>(addr)) : Literal((int32_t)memory.get<uint32_t>(addr));
-          default: abort();
-        }
-        break;
-      }
-      case i64: {
-        switch (load->bytes) {
-          case 1: return load->signed_ ? Literal((int64_t)memory.get<int8_t>(addr)) : Literal((int64_t)memory.get<uint8_t>(addr));
-          case 2: return load->signed_ ? Literal((int64_t)memory.get<int16_t>(addr)) : Literal((int64_t)memory.get<uint16_t>(addr));
-          case 4: return load->signed_ ? Literal((int64_t)memory.get<int32_t>(addr)) : Literal((int64_t)memory.get<uint32_t>(addr));
-          case 8: return load->signed_ ? Literal((int64_t)memory.get<int64_t>(addr)) : Literal((int64_t)memory.get<uint64_t>(addr));
-          default: abort();
-        }
-        break;
-      }
-      case f32: return Literal(memory.get<float>(addr));
-      case f64: return Literal(memory.get<double>(addr));
-      default: abort();
-    }
-  }
-
-  void store(Store* store, Address addr, Literal value) override {
-    switch (store->valueType) {
-      case i32: {
-        switch (store->bytes) {
-          case 1: memory.set<int8_t>(addr, value.geti32()); break;
-          case 2: memory.set<int16_t>(addr, value.geti32()); break;
-          case 4: memory.set<int32_t>(addr, value.geti32()); break;
-          default: abort();
-        }
-        break;
-      }
-      case i64: {
-        switch (store->bytes) {
-          case 1: memory.set<int8_t>(addr, (int8_t)value.geti64()); break;
-          case 2: memory.set<int16_t>(addr, (int16_t)value.geti64()); break;
-          case 4: memory.set<int32_t>(addr, (int32_t)value.geti64()); break;
-          case 8: memory.set<int64_t>(addr, value.geti64()); break;
-          default: abort();
-        }
-        break;
-      }
-      // write floats carefully, ensuring all bits reach memory
-      case f32: memory.set<int32_t>(addr, value.reinterpreti32()); break;
-      case f64: memory.set<int64_t>(addr, value.reinterpreti64()); break;
-      default: abort();
-    }
-  }
+  int8_t load8s(Address addr) override { return memory.get<int8_t>(addr); }
+  uint8_t load8u(Address addr) override { return memory.get<uint8_t>(addr); }
+  int16_t load16s(Address addr) override { return memory.get<int16_t>(addr); }
+  uint16_t load16u(Address addr) override { return memory.get<uint16_t>(addr); }
+  int32_t load32s(Address addr) override { return memory.get<int32_t>(addr); }
+  uint32_t load32u(Address addr) override { return memory.get<uint32_t>(addr); }
+  int64_t load64s(Address addr) override { return memory.get<int64_t>(addr); }
+  uint64_t load64u(Address addr) override { return memory.get<uint64_t>(addr); }
+
+  void store8(Address addr, int8_t value) override { memory.set<int8_t>(addr, value); }
+  void store16(Address addr, int16_t value) override { memory.set<int16_t>(addr, value); }
+  void store32(Address addr, int32_t value) override { memory.set<int32_t>(addr, value); }
+  void store64(Address addr, int64_t value) override { memory.set<int64_t>(addr, value); }
 
   void growMemory(Address /*oldSize*/, Address newSize) override {
     memory.resize(newSize);