SSA pass (#1049)

 * Add SSA pass which ensures a single assign for each local, except for merged locals where we ensure exactly a single assign from one of the paths leading to that use

 * Also add InstrumentLocals pass, useful for debugging locals (similar to InstrumentMemory but for locals)

 * Fix a PickLoadSigns bug with tees not being ignored, which was not noticed until now because we ran it on flatter output by default, but the ssa pass uncovered the bug

Author: kripken

src/asm2wasm.h

@@ -1162,6 +1162,9 @@ void Asm2WasmBuilder::processAsm(Ref ast) {
     } else if (curr[0] == DEFUN) {
       // function
       auto* func = processFunction(curr);
+      if (wasm.getFunctionOrNull(func->name)) {
+        Fatal() << "duplicate function: " << func->name;
+      }
       if (runOptimizationPasses) {
         optimizingBuilder->addFunction(func);
       } else {

src/ast/literal-utils.h

@@ -0,0 +1,46 @@
+/*
+ * 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_literl_utils_h
+#define wasm_ast_literl_utils_h
+
+#include "wasm.h"
+
+namespace wasm {
+
+namespace LiteralUtils {
+
+inline Expression* makeZero(WasmType type, Module& wasm) {
+  Literal value;
+  switch (type) {
+    case i32: value = Literal(int32_t(0)); break;
+    case i64: value = Literal(int64_t(0)); break;
+    case f32: value = Literal(float(0)); break;
+    case f64: value = Literal(double(0)); break;
+    default: WASM_UNREACHABLE();
+  }
+  auto* ret = wasm.allocator.alloc<Const>();
+  ret->value = value;
+  ret->type = value.type;
+  return ret;
+}
+
+} // namespace LiteralUtils
+
+} // namespace wasm
+
+#endif // wasm_ast_literl_utils_h
+

src/passes/CMakeLists.txt

@@ -10,6 +10,7 @@ SET(passes_SOURCES
   LegalizeJSInterface.cpp
   LocalCSE.cpp
   LogExecution.cpp
+  InstrumentLocals.cpp
   InstrumentMemory.cpp
   MemoryPacking.cpp
   MergeBlocks.cpp
@@ -32,6 +33,7 @@ SET(passes_SOURCES
   ReorderLocals.cpp
   ReorderFunctions.cpp
   SimplifyLocals.cpp
+  SSAify.cpp
   Vacuum.cpp
 )
 ADD_LIBRARY(passes STATIC ${passes_SOURCES})

src/passes/CoalesceLocals.cpp

@@ -32,6 +32,7 @@
 #include "cfg/cfg-traversal.h"
 #include "wasm-builder.h"
 #include "support/learning.h"
+#include "support/permutations.h"
 #ifdef CFG_PROFILE
 #include "support/timing.h"
 #endif
@@ -533,35 +534,6 @@ void CoalesceLocals::pickIndicesFromOrder(std::vector<Index>& order, std::vector
   }
 }
 
-// Utilities for operating on permutation vectors
-
-static std::vector<Index> makeIdentity(Index num) {
-  std::vector<Index> ret;
-  ret.resize(num);
-  for (Index i = 0; i < num; i++) {
-    ret[i] = i;
-  }
-  return ret;
-}
-
-static void setIdentity(std::vector<Index>& ret) {
-  auto num = ret.size();
-  assert(num > 0); // must already be of the right size
-  for (Index i = 0; i < num; i++) {
-    ret[i] = i;
-  }
-}
-
-static std::vector<Index> makeReversed(std::vector<Index>& original) {
-  std::vector<Index> ret;
-  auto num = original.size();
-  ret.resize(num);
-  for (Index i = 0; i < num; i++) {
-    ret[original[i]] = i;
-  }
-  return ret;
-}
-
 // given a baseline order, adjust it based on an important order of priorities (higher values
 // are higher priority). The priorities take precedence, unless they are equal and then
 // the original order should be kept.

src/passes/InstrumentLocals.cpp

@@ -0,0 +1,140 @@
+/*
+ * 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.
+ */
+
+//
+// Instruments the build with code to intercept all local reads and writes.
+//
+// gets:
+//
+//  Before:
+//   (get_local $x)
+//
+//  After:
+//    (call $get_TYPE
+//     (i32.const n) // call id
+//     (i32.const n) // local id
+//     (get_local $x)
+//    )
+//
+// sets:
+//
+//  Before:
+//   (set_local $x (i32.const 1))
+//
+//  After:
+//   (set_local $x
+//    (call $set_TYPE
+//     (i32.const n) // call id
+//     (i32.const n) // local id
+//     (i32.const 1) // value
+//    )
+//   )
+
+#include <wasm.h>
+#include <wasm-builder.h>
+#include <pass.h>
+#include "shared-constants.h"
+#include "asmjs/shared-constants.h"
+#include "asm_v_wasm.h"
+
+namespace wasm {
+
+Name get_i32("get_i32");
+Name get_i64("get_i64");
+Name get_f32("get_f32");
+Name get_f64("get_f64");
+
+Name set_i32("set_i32");
+Name set_i64("set_i64");
+Name set_f32("set_f32");
+Name set_f64("set_f64");
+
+struct InstrumentLocals : public WalkerPass<PostWalker<InstrumentLocals>> {
+  void visitGetLocal(GetLocal* curr) {
+    Builder builder(*getModule());
+    Name import;
+    switch (curr->type) {
+      case i32: import = get_i32; break;
+      case i64: return; // TODO
+      case f32: import = get_f32; break;
+      case f64: import = get_f64; break;
+      default: WASM_UNREACHABLE();
+    }
+    replaceCurrent(
+      builder.makeCallImport(
+        import,
+        {
+          builder.makeConst(Literal(int32_t(id++))),
+          builder.makeConst(Literal(int32_t(curr->index))),
+          curr
+        },
+        curr->type
+      )
+    );
+  }
+
+  void visitSetLocal(SetLocal* curr) {
+    Builder builder(*getModule());
+    Name import;
+    switch (curr->value->type) {
+      case i32: import = set_i32; break;
+      case i64: return; // TODO
+      case f32: import = set_f32; break;
+      case f64: import = set_f64; break;
+      case unreachable: return; // nothing to do here
+      default: WASM_UNREACHABLE();
+    }
+    curr->value = builder.makeCallImport(
+      import,
+      {
+        builder.makeConst(Literal(int32_t(id++))),
+        builder.makeConst(Literal(int32_t(curr->index))),
+        curr->value
+      },
+      curr->value->type
+    );
+  }
+
+  void visitModule(Module* curr) {
+    addImport(curr, get_i32,  "iiii");
+    addImport(curr, get_i64,  "jiij");
+    addImport(curr, get_f32,  "fiif");
+    addImport(curr, get_f64,  "diid");
+    addImport(curr, set_i32,  "iiii");
+    addImport(curr, set_i64,  "jiij");
+    addImport(curr, set_f32,  "fiif");
+    addImport(curr, set_f64,  "diid");
+  }
+
+private:
+  Index id = 0;
+
+  void addImport(Module* wasm, Name name, std::string sig) {
+    auto import = new Import;
+    import->name = name;
+    import->module = INSTRUMENT;
+    import->base = name;
+    import->functionType = ensureFunctionType(sig, wasm)->name;
+    import->kind = ExternalKind::Function;
+    wasm->addImport(import);
+  }
+};
+
+Pass* createInstrumentLocalsPass() {
+  return new InstrumentLocals();
+}
+
+} // namespace wasm

src/passes/PickLoadSigns.cpp

@@ -94,6 +94,10 @@ struct PickLoadSigns : public WalkerPass<ExpressionStackWalker<PickLoadSigns>> {
   }
 
   void visitSetLocal(SetLocal* curr) {
+    if (curr->isTee()) {
+      // we can't modify a tee, the value is used elsewhere
+      return;
+    }
     if (auto* load = curr->value->dynCast<Load>()) {
       loads[load] = curr->index;
     }