Add new Float32x4 type for SIMD.js.

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 79 matching lines @@
 }
 
 
 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 Float32x4::cast(this)->Float32x4BooleanValue();

[titzer, 2015/06/03 13:27:15]

Maybe it's better just to return true for now here, since the rest of the system
will treat all objects as true. There'll be a lot of work to make the
value-objectness work correctly in V8, so let's just be consistent for now.

[bbudge, 2015/06/03 20:31:48]

Done. (I'll remove the Float32x4BooleanValue() function too.)

   return true;
 }
 
 
 bool Object::IsCallable() const {
   const Object* fun = this;
   while (fun->IsJSFunctionProxy()) {
     fun = JSFunctionProxy::cast(fun)->call_trap();
   }
   return fun->IsJSFunction() ||
@@ skipping 1283 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 << '>';
+      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 123 matching lines @@
       break;
     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 FILLER_TYPE:
     case BYTE_ARRAY_TYPE:
     case FREE_SPACE_TYPE:
       break;
 
 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size)                        \
     case EXTERNAL_##TYPE##_ARRAY_TYPE:                                         \
     case FIXED_##TYPE##_ARRAY_TYPE:                                            \
       break;
 
@@ skipping 25 matching lines @@
 bool HeapNumber::HeapNumberBooleanValue() {
   return DoubleToBoolean(value());
 }
 
 
 void HeapNumber::HeapNumberPrint(std::ostream& os) {  // NOLINT
   os << value();
 }
 
 
+bool Float32x4::Float32x4BooleanValue() { return true; }
+
+
+void Float32x4::Float32x4Print(std::ostream& os) {  // NOLINT
+  os << get_lane(0) << "," << get_lane(1) << "," << get_lane(2) << ","
+     << get_lane(3);
+}
+
+
 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 15351 matching lines @@
                                             Handle<Object> new_value) {
   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