SIMD.js Add the other SIMD Phase 1 types.

src/objects.cc

 // Copyright 2013 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 <iomanip>
 #include <sstream>
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
@@ skipping 64 matching lines @@
   if (object->IsJSReceiver()) return Handle<JSReceiver>::cast(object);
   Handle<JSFunction> constructor;
   if (object->IsNumber()) {
     constructor = handle(native_context->number_function(), isolate);
   } else if (object->IsBoolean()) {
     constructor = handle(native_context->boolean_function(), isolate);
   } else if (object->IsString()) {
     constructor = handle(native_context->string_function(), isolate);
   } else if (object->IsSymbol()) {
     constructor = handle(native_context->symbol_function(), isolate);
-  } else if (object->IsFloat32x4()) {
-    constructor = handle(native_context->float32x4_function(), isolate);
+  } else if (object->IsSimd128Value()) {
+    if (object->IsFloat32x4()) {
+      constructor = handle(native_context->float32x4_function(), isolate);
+    } else if (object->IsInt32x4()) {
+      constructor = handle(native_context->int32x4_function(), isolate);
+    } else if (object->IsBool32x4()) {
+      constructor = handle(native_context->bool32x4_function(), isolate);
+    } else if (object->IsInt16x8()) {
+      constructor = handle(native_context->int16x8_function(), isolate);
+    } else if (object->IsBool16x8()) {
+      constructor = handle(native_context->bool16x8_function(), isolate);
+    } else if (object->IsInt8x16()) {
+      constructor = handle(native_context->int8x16_function(), isolate);
+    } else if (object->IsBool8x16()) {
+      constructor = handle(native_context->bool8x16_function(), isolate);
+    } else {
+      UNREACHABLE();
+    }
   } else {
     return MaybeHandle<JSReceiver>();
   }
   Handle<JSObject> result = isolate->factory()->NewJSObject(constructor);
   Handle<JSValue>::cast(result)->set_value(*object);
   return result;
 }
 
 
 bool Object::BooleanValue() {
   if (IsBoolean()) return IsTrue();
   if (IsSmi()) return Smi::cast(this)->value() != 0;
   if (IsUndefined() || IsNull()) return false;
   if (IsUndetectableObject()) return false;   // Undetectable object is false.
   if (IsString()) return String::cast(this)->length() != 0;
   if (IsHeapNumber()) return HeapNumber::cast(this)->HeapNumberBooleanValue();
-  if (IsFloat32x4()) return true;  // Simd value types always evaluate to true.
+  if (IsSimd128Value()) return true;  // Simd value types evaluate to true.
   return true;
 }
 
 
 bool Object::IsCallable() const {
   const Object* fun = this;
   while (fun->IsJSFunctionProxy()) {
     fun = JSFunctionProxy::cast(fun)->call_trap();
   }
   return fun->IsJSFunction() ||
@@ skipping 508 matching lines @@
   }
   if (heap_object->IsString()) {
     return context->string_function()->initial_map();
   }
   if (heap_object->IsSymbol()) {
     return context->symbol_function()->initial_map();
   }
   if (heap_object->IsBoolean()) {
     return context->boolean_function()->initial_map();
   }
-  if (heap_object->IsFloat32x4()) {
-    return context->float32x4_function()->initial_map();
+  if (heap_object->IsSimd128Value()) {
+    if (heap_object->IsFloat32x4()) {
+      return context->float32x4_function()->initial_map();
+    } else if (heap_object->IsInt32x4()) {
+      return context->int32x4_function()->initial_map();
+    } else if (heap_object->IsBool32x4()) {
+      return context->bool32x4_function()->initial_map();
+    } else if (heap_object->IsInt16x8()) {
+      return context->int16x8_function()->initial_map();
+    } else if (heap_object->IsBool16x8()) {
+      return context->bool16x8_function()->initial_map();
+    } else if (heap_object->IsInt8x16()) {
+      return context->int8x16_function()->initial_map();
+    } else if (heap_object->IsBool8x16()) {
+      return context->bool8x16_function()->initial_map();
+    } else {
+      UNREACHABLE();
+    }
   }
   return isolate->heap()->null_value()->map();
 }
 
 
 Object* Object::GetHash() {
   Object* hash = GetSimpleHash();
   if (hash->IsSmi()) return hash;
 
   DCHECK(IsJSReceiver());
@@ skipping 19 matching lines @@
     return Smi::FromInt(hash & Smi::kMaxValue);
   }
   if (IsName()) {
     uint32_t hash = Name::cast(this)->Hash();
     return Smi::FromInt(hash);
   }
   if (IsOddball()) {
     uint32_t hash = Oddball::cast(this)->to_string()->Hash();
     return Smi::FromInt(hash);
   }
-  if (IsFloat32x4()) {
-    Float32x4* simd = Float32x4::cast(this);
-    uint32_t seed = v8::internal::kZeroHashSeed;
-    uint32_t hash;
-    hash = ComputeIntegerHash(bit_cast<uint32_t>(simd->get_lane(0)), seed);
-    hash = ComputeIntegerHash(bit_cast<uint32_t>(simd->get_lane(1)), hash * 31);
-    hash = ComputeIntegerHash(bit_cast<uint32_t>(simd->get_lane(2)), hash * 31);
-    hash = ComputeIntegerHash(bit_cast<uint32_t>(simd->get_lane(3)), hash * 31);
+  if (IsSimd128Value()) {
+    uint32_t hash = Simd128Value::cast(this)->Hash();
     return Smi::FromInt(hash & Smi::kMaxValue);
   }
   DCHECK(IsJSReceiver());
   JSReceiver* receiver = JSReceiver::cast(this);
   return receiver->GetHeap()->undefined_value();
 }
 
 
 Handle<Smi> Object::GetOrCreateHash(Isolate* isolate, Handle<Object> object) {
   Handle<Object> hash(object->GetSimpleHash(), isolate);
   if (hash->IsSmi()) return Handle<Smi>::cast(hash);
 
   DCHECK(object->IsJSReceiver());
   return JSReceiver::GetOrCreateIdentityHash(Handle<JSReceiver>::cast(object));
 }
 
 
 bool Object::SameValue(Object* other) {
   if (other == this) return true;
 
   // The object is either a number, a name, an odd-ball,
   // a real JS object, or a Harmony proxy.
   if (IsNumber() && other->IsNumber()) {
-    return v8::internal::SameValue(Number(), other->Number());
+    double this_value = Number();
+    double other_value = other->Number();
+    // SameValue(NaN, NaN) is true.
+    if (this_value != other_value) {
+      return std::isnan(this_value) && std::isnan(other_value);
+    }
+    // SameValue(0.0, -0.0) is false.
+    return (std::signbit(this_value) == std::signbit(other_value));
   }
   if (IsString() && other->IsString()) {
     return String::cast(this)->Equals(String::cast(other));
   }
-  if (IsFloat32x4() && other->IsFloat32x4()) {
-    Float32x4* x = Float32x4::cast(this);
-    Float32x4* y = Float32x4::cast(other);
-    return v8::internal::SameValue(x->get_lane(0), y->get_lane(0)) &&
-           v8::internal::SameValue(x->get_lane(1), y->get_lane(1)) &&
-           v8::internal::SameValue(x->get_lane(2), y->get_lane(2)) &&
-           v8::internal::SameValue(x->get_lane(3), y->get_lane(3));
+  if (IsSimd128Value() && other->IsSimd128Value()) {
+    if (IsFloat32x4() && other->IsFloat32x4()) {
+      Float32x4* a = Float32x4::cast(this);
+      Float32x4* b = Float32x4::cast(other);
+      for (int i = 0; i < 4; i++) {
+        float x = a->get_lane(i);
+        float y = b->get_lane(i);
+        // Implements the ES5 SameValue operation for floating point types.
+        // http://www.ecma-international.org/ecma-262/6.0/#sec-samevalue
+        if (x != y && !(std::isnan(x) && std::isnan(y))) return false;
+        if (std::signbit(x) != std::signbit(y)) return false;
+      }
+      return true;
+    } else {
+      Simd128Value* a = Simd128Value::cast(this);
+      Simd128Value* b = Simd128Value::cast(other);
+      return a->map()->instance_type() == b->map()->instance_type() &&
+             a->BitwiseEquals(b);
+    }
   }
   return false;
 }
 
 
 bool Object::SameValueZero(Object* other) {
   if (other == this) return true;
 
   // The object is either a number, a name, an odd-ball,
   // a real JS object, or a Harmony proxy.
   if (IsNumber() && other->IsNumber()) {
-    return v8::internal::SameValueZero(Number(), other->Number());
+    double this_value = Number();
+    double other_value = other->Number();
+    // +0 == -0 is true
+    return this_value == other_value ||
+           (std::isnan(this_value) && std::isnan(other_value));
   }
   if (IsString() && other->IsString()) {
     return String::cast(this)->Equals(String::cast(other));
   }
-  if (IsFloat32x4() && other->IsFloat32x4()) {
-    Float32x4* x = Float32x4::cast(this);
-    Float32x4* y = Float32x4::cast(other);
-    return v8::internal::SameValueZero(x->get_lane(0), y->get_lane(0)) &&
-           v8::internal::SameValueZero(x->get_lane(1), y->get_lane(1)) &&
-           v8::internal::SameValueZero(x->get_lane(2), y->get_lane(2)) &&
-           v8::internal::SameValueZero(x->get_lane(3), y->get_lane(3));
+  if (IsSimd128Value() && other->IsSimd128Value()) {
+    if (IsFloat32x4() && other->IsFloat32x4()) {
+      Float32x4* a = Float32x4::cast(this);
+      Float32x4* b = Float32x4::cast(other);
+      for (int i = 0; i < 4; i++) {
+        float x = a->get_lane(i);
+        float y = b->get_lane(i);
+        // Implements the ES6 SameValueZero operation for floating point types.
+        // http://www.ecma-international.org/ecma-262/6.0/#sec-samevaluezero
+        if (x != y && !(std::isnan(x) && std::isnan(y))) return false;
+        // SameValueZero doesn't distinguish between 0 and -0.
+      }
+      return true;
+    } else {
+      Simd128Value* a = Simd128Value::cast(this);
+      Simd128Value* b = Simd128Value::cast(other);
+      return a->map()->instance_type() == b->map()->instance_type() &&
+             a->BitwiseEquals(b);
+    }
   }
   return false;
 }
 
 
 void Object::ShortPrint(FILE* out) {
   OFStream os(out);
   os << Brief(this);
 }
 
@@ skipping 591 matching lines @@
       HeapNumber::cast(this)->HeapNumberPrint(os);
       os << ">";
       break;
     }
     case MUTABLE_HEAP_NUMBER_TYPE: {
       os << "<MutableNumber: ";
       HeapNumber::cast(this)->HeapNumberPrint(os);
       os << '>';
       break;
     }
-    case FLOAT32X4_TYPE: {
-      os << "<Float32x4: ";
-      Float32x4::cast(this)->Float32x4Print(os);
-      os << ">";
+    case FLOAT32X4_TYPE:
+      os << "<Float32x4>";
       break;
-    }
+    case INT32X4_TYPE:
+      os << "<Int32x4>";
+      break;
+    case BOOL32X4_TYPE:
+      os << "<Bool32x4>";
+      break;
+    case INT16X8_TYPE:
+      os << "<Int16x8>";
+      break;
+    case BOOL16X8_TYPE:
+      os << "<Bool16x8>";
+      break;
+    case INT8X16_TYPE:
+      os << "<Int8x16>";
+      break;
+    case BOOL8X16_TYPE:
+      os << "<Bool8x16>";
+      break;
     case JS_PROXY_TYPE:
       os << "<JSProxy>";
       break;
     case JS_FUNCTION_PROXY_TYPE:
       os << "<JSFunctionProxy>";
       break;
     case FOREIGN_TYPE:
       os << "<Foreign>";
       break;
     case CELL_TYPE: {
@@ skipping 124 matching lines @@
     case WEAK_CELL_TYPE:
       WeakCell::BodyDescriptor::IterateBody(this, v);
       break;
     case SYMBOL_TYPE:
       Symbol::BodyDescriptor::IterateBody(this, v);
       break;
 
     case HEAP_NUMBER_TYPE:
     case MUTABLE_HEAP_NUMBER_TYPE:
     case FLOAT32X4_TYPE:
+    case INT32X4_TYPE:
+    case BOOL32X4_TYPE:
+    case INT16X8_TYPE:
+    case BOOL16X8_TYPE:
+    case INT8X16_TYPE:
+    case BOOL8X16_TYPE:
     case FILLER_TYPE:
     case BYTE_ARRAY_TYPE:
     case BYTECODE_ARRAY_TYPE:
     case FREE_SPACE_TYPE:
       break;
 
 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
   case FIXED_##TYPE##_ARRAY_TYPE:                       \
     reinterpret_cast<FixedTypedArrayBase*>(this)        \
         ->FixedTypedArrayBaseIterateBody(v);            \
@@ skipping 28 matching lines @@
 bool HeapNumber::HeapNumberBooleanValue() {
   return DoubleToBoolean(value());
 }
 
 
 void HeapNumber::HeapNumberPrint(std::ostream& os) {  // NOLINT
   os << value();
 }
 
 
-void Float32x4::Float32x4Print(std::ostream& os) {  // NOLINT
-  char arr[100];
-  Vector<char> buffer(arr, arraysize(arr));
-  os << std::string(DoubleToCString(get_lane(0), buffer)) << ", "
-     << std::string(DoubleToCString(get_lane(1), buffer)) << ", "
-     << std::string(DoubleToCString(get_lane(2), buffer)) << ", "
-     << std::string(DoubleToCString(get_lane(3), buffer));
+#define FIELD_ADDR_CONST(p, offset) \
+  (reinterpret_cast<const byte*>(p) + offset - kHeapObjectTag)
+
+#define READ_INT32_FIELD(p, offset) \
+  (*reinterpret_cast<const int32_t*>(FIELD_ADDR_CONST(p, offset)))
+
+#define READ_INT64_FIELD(p, offset) \
+  (*reinterpret_cast<const int64_t*>(FIELD_ADDR_CONST(p, offset)))
+
+
+bool Simd128Value::BitwiseEquals(const Simd128Value* other) const {
+  return READ_INT64_FIELD(this, kValueOffset) ==
+             READ_INT64_FIELD(other, kValueOffset) &&
+         READ_INT64_FIELD(this, kValueOffset + kInt64Size) ==
+             READ_INT64_FIELD(other, kValueOffset + kInt64Size);
 }
 
 
+uint32_t Simd128Value::Hash() const {
+  uint32_t seed = v8::internal::kZeroHashSeed;
+  uint32_t hash;
+  hash = ComputeIntegerHash(READ_INT32_FIELD(this, kValueOffset), seed);
+  hash = ComputeIntegerHash(
+      READ_INT32_FIELD(this, kValueOffset + 1 * kInt32Size), hash * 31);
+  hash = ComputeIntegerHash(
+      READ_INT32_FIELD(this, kValueOffset + 2 * kInt32Size), hash * 31);
+  hash = ComputeIntegerHash(
+      READ_INT32_FIELD(this, kValueOffset + 3 * kInt32Size), hash * 31);
+  return hash;
+}
+
+
 String* JSReceiver::class_name() {
   if (IsJSFunction() || IsJSFunctionProxy()) {
     return GetHeap()->Function_string();
   }
   Object* maybe_constructor = map()->GetConstructor();
   if (maybe_constructor->IsJSFunction()) {
     JSFunction* constructor = JSFunction::cast(maybe_constructor);
     return String::cast(constructor->shared()->instance_class_name());
   }
   // If the constructor is not present, return "Object".
@@ skipping 14204 matching lines @@
   if (cell->value() != *new_value) {
     cell->set_value(*new_value);
     Isolate* isolate = cell->GetIsolate();
     cell->dependent_code()->DeoptimizeDependentCodeGroup(
         isolate, DependentCode::kPropertyCellChangedGroup);
   }
 }
 
 }  // namespace internal
 }  // namespace v8