Convert SIMD wasm ops to runtime function calls

src/compiler/wasm-compiler.h

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_COMPILER_WASM_COMPILER_H_
 #define V8_COMPILER_WASM_COMPILER_H_
 
 // Clients of this interface shouldn't depend on lots of compiler internals.
 // Do not include anything from src/compiler here!
 #include "src/compiler.h"
@@ skipping 143 matching lines @@
   Node* CallIndirect(uint32_t index, Node** args,
                      wasm::WasmCodePosition position);
   void BuildJSToWasmWrapper(Handle<Code> wasm_code, wasm::FunctionSig* sig);
   void BuildWasmToJSWrapper(Handle<JSFunction> function,
                             wasm::FunctionSig* sig);
 
   Node* ToJS(Node* node, Node* context, wasm::LocalType type);
   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.
   //-----------------------------------------------------------------------
   Node* MemSize(uint32_t offset);
   Node* LoadGlobal(uint32_t index);
   Node* StoreGlobal(uint32_t index, Node* val);
   Node* LoadMem(wasm::LocalType type, MachineType memtype, Node* index,
                 uint32_t offset, uint32_t alignment,
                 wasm::WasmCodePosition position);
@@ skipping 11 matching lines @@
   void set_control_ptr(Node** control) { this->control_ = control; }
 
   void set_effect_ptr(Node** effect) { this->effect_ = effect; }
 
   wasm::FunctionSig* GetFunctionSignature() { return function_signature_; }
 
   void Int64LoweringForTesting();
 
   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;
 
   Zone* zone_;
   JSGraph* jsgraph_;
   wasm::ModuleEnv* module_;
   Node* mem_buffer_;
   Node* mem_size_;
   Node* function_table_;
   Node** control_;
   Node** effect_;
   Node** cur_buffer_;
   size_t cur_bufsize_;
   Node* def_buffer_[kDefaultBufferSize];
 
   WasmTrapHelper* trap_;
   wasm::FunctionSig* function_signature_;
   SetOncePointer<const Operator> allocate_heap_number_operator_;
 
   compiler::SourcePositionTable* source_position_table_ = nullptr;
+  bool has_simd_ops_;
 
   // Internal helper methods.
   JSGraph* jsgraph() { return jsgraph_; }
   Graph* graph();
 
   Node* String(const char* string);
   Node* MemBuffer(uint32_t offset);
   void BoundsCheckMem(MachineType memtype, Node* index, uint32_t offset,
                       wasm::WasmCodePosition position);
 
@@ skipping 82 matching lines @@
   Node* BuildI64DivS(Node* left, Node* right, wasm::WasmCodePosition position);
   Node* BuildI64RemS(Node* left, Node* right, wasm::WasmCodePosition position);
   Node* BuildI64DivU(Node* left, Node* right, wasm::WasmCodePosition position);
   Node* BuildI64RemU(Node* left, Node* right, wasm::WasmCodePosition position);
   Node* BuildDiv64Call(Node* left, Node* right, ExternalReference ref,
                        MachineType result_type, int trap_zero,
                        wasm::WasmCodePosition position);
 
   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);
   Node* BuildChangeUint32ToSmi(Node* value);
   Node* BuildChangeSmiToFloat64(Node* value);
   Node* BuildTestNotSmi(Node* value);
   Node* BuildSmiShiftBitsConstant();
 
   Node* BuildAllocateHeapNumberWithValue(Node* value, Node* control);
   Node* BuildLoadHeapNumberValue(Node* value, Node* control);
@@ skipping 10 matching lines @@
   Node* BuildI32AsmjsDivU(Node* left, Node* right);
   Node* BuildI32AsmjsRemU(Node* left, Node* right);
   Node* BuildAsmjsLoadMem(MachineType type, Node* index);
   Node* BuildAsmjsStoreMem(MachineType type, Node* index, Node* val);
 
   Node** Realloc(Node** buffer, size_t old_count, size_t new_count) {
     Node** buf = Buffer(new_count);
     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
 }  // namespace v8
 
 #endif  // V8_COMPILER_WASM_COMPILER_H_