Revert of Remove SIMD.js from V8.

src/code-stubs.cc

 // Copyright 2012 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.
 
 #include "src/code-stubs.h"
 
 #include <sstream>
 
 #include "src/arguments.h"
 #include "src/ast/ast.h"
@@ skipping 470 matching lines @@
 
 void AllocateHeapNumberStub::GenerateAssembly(
     compiler::CodeAssemblerState* state) const {
   typedef compiler::Node Node;
   CodeStubAssembler assembler(state);
 
   Node* result = assembler.AllocateHeapNumber();
   assembler.Return(result);
 }
 
+#define SIMD128_GEN_ASM(TYPE, Type, type, lane_count, lane_type)           \
+  void Allocate##Type##Stub::GenerateAssembly(                             \
+      compiler::CodeAssemblerState* state) const {                         \
+    CodeStubAssembler assembler(state);                                    \
+    compiler::Node* result =                                               \
+        assembler.Allocate(Simd128Value::kSize, CodeStubAssembler::kNone); \
+    compiler::Node* map = assembler.LoadMap(result);                       \
+    assembler.StoreNoWriteBarrier(                                         \
+        MachineRepresentation::kTagged, map,                               \
+        assembler.HeapConstant(isolate()->factory()->type##_map()));       \
+    assembler.Return(result);                                              \
+  }
+SIMD128_TYPES(SIMD128_GEN_ASM)
+#undef SIMD128_GEN_ASM
+
 void StringLengthStub::GenerateAssembly(
     compiler::CodeAssemblerState* state) const {
   CodeStubAssembler assembler(state);
   compiler::Node* value = assembler.Parameter(0);
   compiler::Node* string = assembler.LoadJSValueValue(value);
   compiler::Node* result = assembler.LoadStringLength(string);
   assembler.Return(result);
 }
 
 #define BINARY_OP_STUB(Name)                                                  \
@@ skipping 1437 matching lines @@
 }
 
 
 void AllocateHeapNumberStub::InitializeDescriptor(
     CodeStubDescriptor* descriptor) {
   descriptor->Initialize(
       Runtime::FunctionForId(Runtime::kAllocateHeapNumber)->entry);
 }
 
 
+#define SIMD128_INIT_DESC(TYPE, Type, type, lane_count, lane_type) \
+  void Allocate##Type##Stub::InitializeDescriptor(                 \
+      CodeStubDescriptor* descriptor) {                            \
+    descriptor->Initialize(                                        \
+        Runtime::FunctionForId(Runtime::kCreate##Type)->entry);    \
+  }
+SIMD128_TYPES(SIMD128_INIT_DESC)
+#undef SIMD128_INIT_DESC
+
 void ToBooleanICStub::InitializeDescriptor(CodeStubDescriptor* descriptor) {
   descriptor->Initialize(FUNCTION_ADDR(Runtime_ToBooleanIC_Miss));
   descriptor->SetMissHandler(Runtime::kToBooleanIC_Miss);
 }
 
 
 void BinaryOpICStub::InitializeDescriptor(CodeStubDescriptor* descriptor) {
   descriptor->Initialize(FUNCTION_ADDR(Runtime_BinaryOpIC_Miss));
   descriptor->SetMissHandler(Runtime::kBinaryOpIC_Miss);
 }
@@ skipping 165 matching lines @@
     new_hints |= ToBooleanHint::kString;
     to_boolean_value = String::cast(*object)->length() != 0;
   } else if (object->IsSymbol()) {
     new_hints |= ToBooleanHint::kSymbol;
     to_boolean_value = true;
   } else if (object->IsHeapNumber()) {
     DCHECK(!object->IsUndetectable());
     new_hints |= ToBooleanHint::kHeapNumber;
     double value = HeapNumber::cast(*object)->value();
     to_boolean_value = value != 0 && !std::isnan(value);
+  } else if (object->IsSimd128Value()) {
+    new_hints |= ToBooleanHint::kSimdValue;
+    to_boolean_value = true;
   } else {
     // We should never see an internal object at runtime here!
     UNREACHABLE();
     to_boolean_value = true;
   }
   TraceTransition(old_hints, new_hints);
   set_sub_minor_key(HintsBits::update(sub_minor_key(), new_hints));
   return to_boolean_value;
 }
 
@@ skipping 196 matching lines @@
 }
 
 ArrayConstructorStub::ArrayConstructorStub(Isolate* isolate)
     : PlatformCodeStub(isolate) {}
 
 InternalArrayConstructorStub::InternalArrayConstructorStub(Isolate* isolate)
     : PlatformCodeStub(isolate) {}
 
 }  // namespace internal
 }  // namespace v8