Convert SIMD wasm ops to runtime function calls

src/compiler/wasm-compiler.h

Index: src/compiler/wasm-compiler.h
diff --git a/src/compiler/wasm-compiler.h b/src/compiler/wasm-compiler.h
index 406336b0e189a05e50fe13987d2ef0924d35e496..e9bc43a2df152a0f5ab75d19680e5c2b27989666 100644
--- a/src/compiler/wasm-compiler.h
+++ b/src/compiler/wasm-compiler.h
@@ -161,6 +161,10 @@ class WasmGraphBuilder {
   Node* FromJS(Node* node, Node* context, wasm::LocalType type);
   Node* Invert(Node* node);
   Node* FunctionTable();
+  Node* BuildChangeInt32ToTagged(Node* value);
+  Node* BuildChangeTaggedToInt32(Node* value);
+  Node* BuildChangeFloat64ToTagged(Node* value);
+  Node* BuildChangeTaggedToFloat64(Node* value);

[bbudge, 2016/07/06 20:18:08]

It's unfortunate we have to perturb this API, given that this may be a temporary
implementation of SIMD.

Looking at the SimdLowering class, it seems to me that you could just move all
of that code into WasmGraphBuilder. That way, you'd have access to all the
builder functions, and you wouldn't need the HasSimdOps/SetHasSimdOps methods or
a separate SimdLowering pass. You could even make the ChangeToRuntimeCall method
public on WasmGraphBuilder. It seems like it could be generally useful.

[gdeepti, 2016/07/07 04:05:34]

Refactored SimdLowering class, ChangeToRuntimeCall is now a public method on
WasmGraphBuilder so that there are no API changes and still have access to
builder methods. Using the SimdLowering pass because there are a significant
number of opcodes that need to be added and I'm concerned that that means
conflating the wasm-compiler.cc file with a non trivial amount of temporary
code. Currently refactored so that only the code that would need to be removed
when moving away from the runtime function conversion is in its own file. Also,
in the future the getter/setter for has_simd_ops_ (with a name change) can be an
easy way to toggle between the runtime/native implementation. 

[gdeepti, 2016/07/08 00:09:25]

The last part in my previous comment about the boolean is incorrect, in the
current implementation there is no way to toggle between native/runtime
implementations per opcode in the WasmGraphBuilder. The only way that can be
done is in the  opcode switch statement in the SimdLowering pass. That said I'm
leaning towards keeping it separate only for keeping wasm-compiler.cc clear of
the temp code, not sure what the right thing to do in this case. Ben, thoughts? 

 
   //-----------------------------------------------------------------------
   // Operations that concern the linear memory.
@@ -192,6 +196,12 @@ class WasmGraphBuilder {
 
   void SetSourcePosition(Node* node, wasm::WasmCodePosition position);
 
+  //-----------------------------------------------------------------------
+  // SIMD operations.
+  //-----------------------------------------------------------------------
+  Node* DefaultS128Value();

[bbudge, 2016/07/06 20:18:08]

This method logically belongs near Float64Constant. Then we don't need a
separate SIMD section.

[gdeepti, 2016/07/07 04:05:34]

Moved method, removed SIMD section. 

+  bool HasSimdOps() { return has_simd_ops_; }

[bbudge, 2016/07/06 20:18:08]

nit: simple getter style would be has_simd_ops

[gdeepti, 2016/07/07 04:05:34]

Done.

+
  private:
   static const int kDefaultBufferSize = 16;
   friend class WasmTrapHelper;
@@ -213,6 +223,7 @@ class WasmGraphBuilder {
   SetOncePointer<const Operator> allocate_heap_number_operator_;
 
   compiler::SourcePositionTable* source_position_table_ = nullptr;
+  bool has_simd_ops_;
 
   // Internal helper methods.
   JSGraph* jsgraph() { return jsgraph_; }
@@ -315,9 +326,6 @@ class WasmGraphBuilder {
 
   Node* BuildJavaScriptToNumber(Node* node, Node* context, Node* effect,
                                 Node* control);
-  Node* BuildChangeInt32ToTagged(Node* value);
-  Node* BuildChangeFloat64ToTagged(Node* value);
-  Node* BuildChangeTaggedToFloat64(Node* value);
 
   Node* BuildChangeInt32ToSmi(Node* value);
   Node* BuildChangeSmiToInt32(Node* value);
@@ -348,6 +356,9 @@ class WasmGraphBuilder {
     if (buf != buffer) memcpy(buf, buffer, old_count * sizeof(Node*));
     return buf;
   }
+
+  // Simd helper functions
+  void SetHasSimdOps(bool has_simd_ops) { has_simd_ops_ = has_simd_ops; }
 };
 }  // namespace compiler
 }  // namespace internal