Experimental implementation: Exposing SIMD instructions into JavaScript

src/objects.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 59 matching lines @@
     if (!maybe_result->ToObject(&result)) return maybe_result;
   }
   JSValue::cast(result)->set_value(value);
   return result;
 }
 
 
 MaybeObject* Object::ToObject(Context* native_context) {
   if (IsNumber()) {
     return CreateJSValue(native_context->number_function(), this);
+  } else if (IsFloat32x4()) {
+    return CreateJSValue(native_context->float32x4_function(), this);
+  } else if (IsInt32x4()) {
+    return CreateJSValue(native_context->int32x4_function(), this);
   } else if (IsBoolean()) {
     return CreateJSValue(native_context->boolean_function(), this);
   } else if (IsString()) {
     return CreateJSValue(native_context->string_function(), this);
   }
   ASSERT(IsJSObject());
   return this;
 }
 
 
 MaybeObject* Object::ToObject(Isolate* isolate) {
   if (IsJSReceiver()) {
     return this;
   } else if (IsNumber()) {
     Context* native_context = isolate->context()->native_context();
     return CreateJSValue(native_context->number_function(), this);
+  } else if (IsFloat32x4()) {
+    Isolate* isolate = HeapObject::cast(this)->GetIsolate();
+    Context* native_context = isolate->context()->native_context();
+    return CreateJSValue(native_context->float32x4_function(), this);
+  } else if (IsInt32x4()) {
+    Isolate* isolate = HeapObject::cast(this)->GetIsolate();
+    Context* native_context = isolate->context()->native_context();
+    return CreateJSValue(native_context->int32x4_function(), this);
   } else if (IsBoolean()) {
     Context* native_context = isolate->context()->native_context();
     return CreateJSValue(native_context->boolean_function(), this);
   } else if (IsString()) {
     Context* native_context = isolate->context()->native_context();
     return CreateJSValue(native_context->string_function(), this);
   } else if (IsSymbol()) {
     Context* native_context = isolate->context()->native_context();
     return CreateJSValue(native_context->symbol_function(), this);
   }
@@ skipping 15 matching lines @@
 
 
 void Object::Lookup(Name* name, LookupResult* result) {
   Object* holder = NULL;
   if (IsJSReceiver()) {
     holder = this;
   } else {
     Context* native_context = result->isolate()->context()->native_context();
     if (IsNumber()) {
       holder = native_context->number_function()->instance_prototype();
+    } else if (IsFloat32x4()) {
+      holder = native_context->float32x4_function()->instance_prototype();
+    } else if (IsInt32x4()) {
+      holder = native_context->int32x4_function()->instance_prototype();
     } else if (IsString()) {
       holder = native_context->string_function()->instance_prototype();
     } else if (IsSymbol()) {
       holder = native_context->symbol_function()->instance_prototype();
     } else if (IsBoolean()) {
       holder = native_context->boolean_function()->instance_prototype();
     } else {
       result->isolate()->PushStackTraceAndDie(
           0xDEAD0000, this, JSReceiver::cast(this)->map(), 0xDEAD0001);
     }
@@ skipping 829 matching lines @@
 
   // Iterate up the prototype chain until an element is found or the null
   // prototype is encountered.
   for (holder = this;
        holder != heap->null_value();
        holder = holder->GetPrototype(isolate)) {
     if (!holder->IsJSObject()) {
       Context* native_context = isolate->context()->native_context();
       if (holder->IsNumber()) {
         holder = native_context->number_function()->instance_prototype();
+      } else if (holder->IsFloat32x4()) {
+        holder = native_context->float32x4_function()->instance_prototype();
+      } else if (holder->IsInt32x4()) {
+        holder = native_context->int32x4_function()->instance_prototype();
       } else if (holder->IsString()) {
         holder = native_context->string_function()->instance_prototype();
       } else if (holder->IsSymbol()) {
         holder = native_context->symbol_function()->instance_prototype();
       } else if (holder->IsBoolean()) {
         holder = native_context->boolean_function()->instance_prototype();
       } else if (holder->IsJSProxy()) {
         return JSProxy::cast(holder)->GetElementWithHandler(receiver, index);
       } else {
         // Undefined and null have no indexed properties.
@@ skipping 43 matching lines @@
   // The object is either a number, a string, a boolean,
   // a real JS object, or a Harmony proxy.
   if (heap_object->IsJSReceiver()) {
     return heap_object->map()->prototype();
   }
   Context* context = isolate->context()->native_context();
 
   if (heap_object->IsHeapNumber()) {
     return context->number_function()->instance_prototype();
   }
+  if (heap_object->IsFloat32x4()) {
+    return context->float32x4_function()->instance_prototype();
+  }
+  if (heap_object->IsInt32x4()) {
+    return context->int32x4_function()->instance_prototype();
+  }
   if (heap_object->IsString()) {
     return context->string_function()->instance_prototype();
   }
   if (heap_object->IsSymbol()) {
     return context->symbol_function()->instance_prototype();
   }
   if (heap_object->IsBoolean()) {
     return context->boolean_function()->instance_prototype();
   } else {
     return isolate->heap()->null_value();
@@ skipping 603 matching lines @@
                        ExternalIntArray::cast(this)->length());
       break;
     case EXTERNAL_UNSIGNED_INT_ARRAY_TYPE:
       accumulator->Add("<ExternalUnsignedIntArray[%u]>",
                        ExternalUnsignedIntArray::cast(this)->length());
       break;
     case EXTERNAL_FLOAT_ARRAY_TYPE:
       accumulator->Add("<ExternalFloatArray[%u]>",
                        ExternalFloatArray::cast(this)->length());
       break;
+    case EXTERNAL_FLOAT32x4_ARRAY_TYPE:
+      accumulator->Add("<ExternalFloat32x4Array[%u]>",
+                       ExternalFloat32x4Array::cast(this)->length());
+      break;
+    case EXTERNAL_INT32x4_ARRAY_TYPE:
+      accumulator->Add("<ExternalInt32x4Array[%u]>",
+                       ExternalInt32x4Array::cast(this)->length());
+      break;
     case EXTERNAL_DOUBLE_ARRAY_TYPE:
       accumulator->Add("<ExternalDoubleArray[%u]>",
                        ExternalDoubleArray::cast(this)->length());
       break;
     case SHARED_FUNCTION_INFO_TYPE: {
       SharedFunctionInfo* shared = SharedFunctionInfo::cast(this);
       SmartArrayPointer<char> debug_name =
           shared->DebugName()->ToCString();
       if (debug_name[0] != 0) {
         accumulator->Add("<SharedFunctionInfo %s>", *debug_name);
@@ skipping 39 matching lines @@
         String::cast(symbol->name())->StringShortPrint(accumulator);
       }
       accumulator->Add(">");
       break;
     }
     case HEAP_NUMBER_TYPE:
       accumulator->Add("<Number: ");
       HeapNumber::cast(this)->HeapNumberPrint(accumulator);
       accumulator->Put('>');
       break;
+    case FLOAT32x4_TYPE:
+      accumulator->Add("<Float32x4: ");
+      Float32x4::cast(this)->Float32x4Print(accumulator);
+      accumulator->Put('>');
+      break;
+    case INT32x4_TYPE:
+      accumulator->Add("<Int32x4: ");
+      Int32x4::cast(this)->Int32x4Print(accumulator);
+      accumulator->Put('>');
+      break;
     case JS_PROXY_TYPE:
       accumulator->Add("<JSProxy>");
       break;
     case JS_FUNCTION_PROXY_TYPE:
       accumulator->Add("<JSFunctionProxy>");
       break;
     case FOREIGN_TYPE:
       accumulator->Add("<Foreign>");
       break;
     case CELL_TYPE:
@@ skipping 102 matching lines @@
     case CELL_TYPE:
       Cell::BodyDescriptor::IterateBody(this, v);
       break;
     case PROPERTY_CELL_TYPE:
       PropertyCell::BodyDescriptor::IterateBody(this, v);
       break;
     case SYMBOL_TYPE:
       Symbol::BodyDescriptor::IterateBody(this, v);
       break;
     case HEAP_NUMBER_TYPE:
+    case FLOAT32x4_TYPE:
+    case INT32x4_TYPE:
     case FILLER_TYPE:
     case BYTE_ARRAY_TYPE:
     case FREE_SPACE_TYPE:
     case EXTERNAL_PIXEL_ARRAY_TYPE:
     case EXTERNAL_BYTE_ARRAY_TYPE:
     case EXTERNAL_UNSIGNED_BYTE_ARRAY_TYPE:
     case EXTERNAL_SHORT_ARRAY_TYPE:
     case EXTERNAL_UNSIGNED_SHORT_ARRAY_TYPE:
     case EXTERNAL_INT_ARRAY_TYPE:
     case EXTERNAL_UNSIGNED_INT_ARRAY_TYPE:
     case EXTERNAL_FLOAT_ARRAY_TYPE:
+    case EXTERNAL_FLOAT32x4_ARRAY_TYPE:
+    case EXTERNAL_INT32x4_ARRAY_TYPE:
     case EXTERNAL_DOUBLE_ARRAY_TYPE:
       break;
     case SHARED_FUNCTION_INFO_TYPE: {
       SharedFunctionInfo::BodyDescriptor::IterateBody(this, v);
       break;
     }
 
 #define MAKE_STRUCT_CASE(NAME, Name, name) \
         case NAME##_TYPE:
       STRUCT_LIST(MAKE_STRUCT_CASE)
@@ skipping 42 matching lines @@
   // allocation when producing post-crash stack traces, so we print into a
   // buffer that is plenty big enough for any floating point number, then
   // print that using vsnprintf (which may truncate but never allocate if
   // there is no more space in the buffer).
   EmbeddedVector<char, 100> buffer;
   OS::SNPrintF(buffer, "%.16g", Number());
   accumulator->Add("%s", buffer.start());
 }
 
 
+void Float32x4::Float32x4Print(FILE* out) {
+  PrintF(out, "%.16g %.16g %.16g %.16g", x(), y(), z(), w());
+}
+
+
+void Float32x4::Float32x4Print(StringStream* accumulator) {
+  // The Windows version of vsnprintf can allocate when printing a %g string
+  // into a buffer that may not be big enough.  We don't want random memory
+  // allocation when producing post-crash stack traces, so we print into a
+  // buffer that is plenty big enough for any floating point number, then
+  // print that using vsnprintf (which may truncate but never allocate if
+  // there is no more space in the buffer).
+  EmbeddedVector<char, 100> buffer;
+  OS::SNPrintF(buffer, "%.16g %.16g %.16g %.16g", x(), y(), z(), w());
+  accumulator->Add("%s", buffer.start());
+}
+
+
+void Int32x4::Int32x4Print(FILE* out) {
+  PrintF(out, "%u %u %u %u", x(), y(), z(), w());
+}
+
+
+void Int32x4::Int32x4Print(StringStream* accumulator) {
+  // The Windows version of vsnprintf can allocate when printing a %g string
+  // into a buffer that may not be big enough.  We don't want random memory
+  // allocation when producing post-crash stack traces, so we print into a
+  // buffer that is plenty big enough for any floating point number, then
+  // print that using vsnprintf (which may truncate but never allocate if
+  // there is no more space in the buffer).
+  EmbeddedVector<char, 100> buffer;
+  OS::SNPrintF(buffer, "%u %u %u %u", x(), y(), z(), w());
+  accumulator->Add("%s", buffer.start());
+}
+
+
 String* JSReceiver::class_name() {
   if (IsJSFunction() && IsJSFunctionProxy()) {
     return GetHeap()->function_class_string();
   }
   if (map()->constructor()->IsJSFunction()) {
     JSFunction* constructor = JSFunction::cast(map()->constructor());
     return String::cast(constructor->shared()->instance_class_name());
   }
   // If the constructor is not present, return "Object".
   return GetHeap()->Object_string();
@@ skipping 346 matching lines @@
   JSObject::SetNormalizedProperty(object, name, value, new_details);
 }
 
 
 const char* Representation::Mnemonic() const {
   switch (kind_) {
     case kNone: return "v";
     case kTagged: return "t";
     case kSmi: return "s";
     case kDouble: return "d";
+    case kFloat32x4: return "float32x4";
+    case kInt32x4: return "int32x44";
     case kInteger32: return "i";
     case kHeapObject: return "h";
     case kExternal: return "x";
     default:
       UNREACHABLE();
       return NULL;
   }
 }
 
 
@@ skipping 3063 matching lines @@
   ElementsKind kind = GetElementsKind();
   switch (kind) {
     case EXTERNAL_PIXEL_ELEMENTS:
     case EXTERNAL_BYTE_ELEMENTS:
     case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
     case EXTERNAL_SHORT_ELEMENTS:
     case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
     case EXTERNAL_INT_ELEMENTS:
     case EXTERNAL_UNSIGNED_INT_ELEMENTS:
     case EXTERNAL_FLOAT_ELEMENTS:
+    case EXTERNAL_FLOAT32x4_ELEMENTS:
+    case EXTERNAL_INT32x4_ELEMENTS:
     case EXTERNAL_DOUBLE_ELEMENTS:
     case FAST_DOUBLE_ELEMENTS:
     case FAST_HOLEY_DOUBLE_ELEMENTS:
       // Raw pixels and external arrays do not reference other
       // objects.
       break;
     case FAST_SMI_ELEMENTS:
     case FAST_HOLEY_SMI_ELEMENTS:
       break;
     case FAST_ELEMENTS:
@@ skipping 475 matching lines @@
         UNIMPLEMENTED();
         break;
       case EXTERNAL_PIXEL_ELEMENTS:
       case EXTERNAL_BYTE_ELEMENTS:
       case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
       case EXTERNAL_SHORT_ELEMENTS:
       case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
       case EXTERNAL_INT_ELEMENTS:
       case EXTERNAL_UNSIGNED_INT_ELEMENTS:
       case EXTERNAL_FLOAT_ELEMENTS:
+      case EXTERNAL_FLOAT32x4_ELEMENTS:
+      case EXTERNAL_INT32x4_ELEMENTS:
       case EXTERNAL_DOUBLE_ELEMENTS:
       case FAST_DOUBLE_ELEMENTS:
       case FAST_HOLEY_DOUBLE_ELEMENTS:
         // No contained objects, nothing to do.
         break;
     }
   }
 
   return copy;
 }
@@ skipping 201 matching lines @@
     case FAST_HOLEY_DOUBLE_ELEMENTS:
       break;
     case EXTERNAL_PIXEL_ELEMENTS:
     case EXTERNAL_BYTE_ELEMENTS:
     case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
     case EXTERNAL_SHORT_ELEMENTS:
     case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
     case EXTERNAL_INT_ELEMENTS:
     case EXTERNAL_UNSIGNED_INT_ELEMENTS:
     case EXTERNAL_FLOAT_ELEMENTS:
+    case EXTERNAL_FLOAT32x4_ELEMENTS:
+    case EXTERNAL_INT32x4_ELEMENTS:
     case EXTERNAL_DOUBLE_ELEMENTS:
       // Ignore getters and setters on pixel and external array elements.
       return;
     case DICTIONARY_ELEMENTS:
       if (UpdateGetterSetterInDictionary(object->element_dictionary(),
                                          index,
                                          *getter,
                                          *setter,
                                          attributes)) {
         return;
@@ skipping 438 matching lines @@
       case FAST_HOLEY_DOUBLE_ELEMENTS:
         break;
       case EXTERNAL_PIXEL_ELEMENTS:
       case EXTERNAL_BYTE_ELEMENTS:
       case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
       case EXTERNAL_SHORT_ELEMENTS:
       case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
       case EXTERNAL_INT_ELEMENTS:
       case EXTERNAL_UNSIGNED_INT_ELEMENTS:
       case EXTERNAL_FLOAT_ELEMENTS:
+      case EXTERNAL_FLOAT32x4_ELEMENTS:
+      case EXTERNAL_INT32x4_ELEMENTS:
       case EXTERNAL_DOUBLE_ELEMENTS:
         // Ignore getters and setters on pixel and external array
         // elements.
         return factory->undefined_value();
       case DICTIONARY_ELEMENTS:
         break;
       case NON_STRICT_ARGUMENTS_ELEMENTS:
         UNIMPLEMENTED();
         break;
     }
@@ skipping 4435 matching lines @@
           break;
         }
 
         case Translation::DOUBLE_REGISTER: {
           int reg_code = iterator.Next();
           PrintF(out, "{input=%s}",
                  DoubleRegister::AllocationIndexToString(reg_code));
           break;
         }
 
+        case Translation::FLOAT32x4_REGISTER: {
+          int reg_code = iterator.Next();
+          PrintF(out, "{input=%s}",
+                 Float32x4Register::AllocationIndexToString(reg_code));
+          break;
+        }
+
+        case Translation::INT32x4_REGISTER: {
+          int reg_code = iterator.Next();
+          PrintF(out, "{input=%s}",
+                 Int32x4Register::AllocationIndexToString(reg_code));
+          break;
+        }
+
         case Translation::STACK_SLOT: {
           int input_slot_index = iterator.Next();
           PrintF(out, "{input=%d}", input_slot_index);
           break;
         }
 
         case Translation::INT32_STACK_SLOT: {
           int input_slot_index = iterator.Next();
           PrintF(out, "{input=%d}", input_slot_index);
           break;
         }
 
         case Translation::UINT32_STACK_SLOT: {
           int input_slot_index = iterator.Next();
           PrintF(out, "{input=%d (unsigned)}", input_slot_index);
           break;
         }
 
         case Translation::DOUBLE_STACK_SLOT: {
           int input_slot_index = iterator.Next();
           PrintF(out, "{input=%d}", input_slot_index);
           break;
         }
 
+        case Translation::FLOAT32x4_STACK_SLOT: {
+          int input_slot_index = iterator.Next();
+          PrintF(out, "{input=%d}", input_slot_index);
+          break;
+        }
+
+        case Translation::INT32x4_STACK_SLOT: {
+          int input_slot_index = iterator.Next();
+          PrintF(out, "{input=%d}", input_slot_index);
+          break;
+        }
+
         case Translation::LITERAL: {
           unsigned literal_index = iterator.Next();
           PrintF(out, "{literal_id=%u}", literal_index);
           break;
         }
 
         case Translation::DUPLICATED_OBJECT: {
           int object_index = iterator.Next();
           PrintF(out, "{object_index=%d}", object_index);
           break;
@@ skipping 1502 matching lines @@
 Handle<Object> JSObject::SetElement(Handle<JSObject> object,
                                     uint32_t index,
                                     Handle<Object> value,
                                     PropertyAttributes attributes,
                                     StrictModeFlag strict_mode,
                                     bool check_prototype,
                                     SetPropertyMode set_mode) {
   Isolate* isolate = object->GetIsolate();
 
   if (object->HasExternalArrayElements()) {
-    if (!value->IsNumber() && !value->IsUndefined()) {
+    // TODO(ningxin): Throw an error if setting a Float32x4Array element
+    // while the value is not Float32x4Object.
+    if (!value->IsNumber() && !value->IsFloat32x4() &&
+        !value->IsInt32x4() && !value->IsUndefined()) {
       bool has_exception;
       Handle<Object> number =
           Execution::ToNumber(isolate, value, &has_exception);
       if (has_exception) return Handle<Object>();
       value = number;
     }
   }
 
   // Check access rights if needed.
   if (object->IsAccessCheckNeeded()) {
@@ skipping 172 matching lines @@
     case EXTERNAL_UNSIGNED_INT_ELEMENTS: {
       Handle<ExternalUnsignedIntArray> array(
           ExternalUnsignedIntArray::cast(object->elements()));
       return ExternalUnsignedIntArray::SetValue(array, index, value);
     }
     case EXTERNAL_FLOAT_ELEMENTS: {
       Handle<ExternalFloatArray> array(
           ExternalFloatArray::cast(object->elements()));
       return ExternalFloatArray::SetValue(array, index, value);
     }
+    case EXTERNAL_FLOAT32x4_ELEMENTS: {
+      Handle<ExternalFloat32x4Array> array(
+          ExternalFloat32x4Array::cast(object->elements()));
+      return ExternalFloat32x4Array::SetValue(array, index, value);
+    }
+    case EXTERNAL_INT32x4_ELEMENTS: {
+      Handle<ExternalInt32x4Array> array(
+          ExternalInt32x4Array::cast(object->elements()));
+      return ExternalInt32x4Array::SetValue(array, index, value);
+    }
     case EXTERNAL_DOUBLE_ELEMENTS: {
       Handle<ExternalDoubleArray> array(
           ExternalDoubleArray::cast(object->elements()));
       return ExternalDoubleArray::SetValue(array, index, value);
     }
     case DICTIONARY_ELEMENTS:
       return SetDictionaryElement(object, index, value, attributes, strict_mode,
                                   check_prototype,
                                   set_mode);
     case NON_STRICT_ARGUMENTS_ELEMENTS: {
@@ skipping 372 matching lines @@
       }
       break;
     }
     case EXTERNAL_BYTE_ELEMENTS:
     case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
     case EXTERNAL_SHORT_ELEMENTS:
     case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
     case EXTERNAL_INT_ELEMENTS:
     case EXTERNAL_UNSIGNED_INT_ELEMENTS:
     case EXTERNAL_FLOAT_ELEMENTS:
+    case EXTERNAL_FLOAT32x4_ELEMENTS:
+    case EXTERNAL_INT32x4_ELEMENTS:
     case EXTERNAL_DOUBLE_ELEMENTS:
     case EXTERNAL_PIXEL_ELEMENTS:
       // External arrays are considered 100% used.
       ExternalArray* external_array = ExternalArray::cast(elements());
       *capacity = external_array->length();
       *used = external_array->length();
       break;
   }
 }
 
@@ skipping 494 matching lines @@
       ASSERT(!storage || storage->length() >= counter);
       break;
     }
     case EXTERNAL_BYTE_ELEMENTS:
     case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
     case EXTERNAL_SHORT_ELEMENTS:
     case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
     case EXTERNAL_INT_ELEMENTS:
     case EXTERNAL_UNSIGNED_INT_ELEMENTS:
     case EXTERNAL_FLOAT_ELEMENTS:
+    case EXTERNAL_FLOAT32x4_ELEMENTS:
+    case EXTERNAL_INT32x4_ELEMENTS:
     case EXTERNAL_DOUBLE_ELEMENTS: {
       int length = ExternalArray::cast(elements())->length();
       while (counter < length) {
         if (storage != NULL) {
           storage->set(counter, Smi::FromInt(counter));
         }
         counter++;
       }
       ASSERT(!storage || storage->length() >= counter);
       break;
@@ skipping 1027 matching lines @@
     case EXTERNAL_SHORT_ARRAY_TYPE:
       return kExternalShortArray;
     case EXTERNAL_UNSIGNED_SHORT_ARRAY_TYPE:
       return kExternalUnsignedShortArray;
     case EXTERNAL_INT_ARRAY_TYPE:
       return kExternalIntArray;
     case EXTERNAL_UNSIGNED_INT_ARRAY_TYPE:
       return kExternalUnsignedIntArray;
     case EXTERNAL_FLOAT_ARRAY_TYPE:
       return kExternalFloatArray;
+    case EXTERNAL_FLOAT32x4_ARRAY_TYPE:
+      return kExternalFloat32x4Array;
+    case EXTERNAL_INT32x4_ARRAY_TYPE:
+      return kExternalInt32x4Array;
     case EXTERNAL_DOUBLE_ARRAY_TYPE:
       return kExternalDoubleArray;
     case EXTERNAL_PIXEL_ARRAY_TYPE:
       return kExternalPixelArray;
     default:
       return static_cast<ExternalArrayType>(-1);
   }
 }
 
 
 size_t JSTypedArray::element_size() {
   switch (elements()->map()->instance_type()) {
     case EXTERNAL_BYTE_ARRAY_TYPE:
       return 1;
     case EXTERNAL_UNSIGNED_BYTE_ARRAY_TYPE:
       return 1;
     case EXTERNAL_SHORT_ARRAY_TYPE:
       return 2;
     case EXTERNAL_UNSIGNED_SHORT_ARRAY_TYPE:
       return 2;
     case EXTERNAL_INT_ARRAY_TYPE:
       return 4;
     case EXTERNAL_UNSIGNED_INT_ARRAY_TYPE:
       return 4;
     case EXTERNAL_FLOAT_ARRAY_TYPE:
       return 4;
+    case EXTERNAL_FLOAT32x4_ARRAY_TYPE:
+      return 16;
+    case EXTERNAL_INT32x4_ARRAY_TYPE:
+      return 16;
     case EXTERNAL_DOUBLE_ARRAY_TYPE:
       return 8;
     case EXTERNAL_PIXEL_ARRAY_TYPE:
       return 1;
     default:
       UNREACHABLE();
       return 0;
   }
 }
 
@@ skipping 221 matching lines @@
       // Clamp undefined to NaN (default). All other types have been
       // converted to a number type further up in the call chain.
       ASSERT(value->IsUndefined());
     }
     set(index, double_value);
   }
   return heap->AllocateHeapNumber(double_value);
 }
 
 
+Handle<Object> ExternalFloat32x4Array::SetValue(
+    Handle<ExternalFloat32x4Array> array,
+    uint32_t index,
+    Handle<Object> value) {
+  CALL_HEAP_FUNCTION(array->GetIsolate(),
+                     array->SetValue(index, *value),
+                     Object);
+}
+
+
+MaybeObject* ExternalFloat32x4Array::SetValue(uint32_t index, Object* value) {
+  float32x4_value_t cast_value;
+  cast_value.storage[0] = static_cast<float>(OS::nan_value());
+  cast_value.storage[1] = static_cast<float>(OS::nan_value());
+  cast_value.storage[2] = static_cast<float>(OS::nan_value());
+  cast_value.storage[3] = static_cast<float>(OS::nan_value());
+  Heap* heap = GetHeap();
+  if (index < static_cast<uint32_t>(length())) {
+    if (value->IsFloat32x4()) {
+      cast_value = Float32x4::cast(value)->value();
+    } else {
+      // Clamp undefined to NaN (default). All other types have been
+      // converted to a number type further up in the call chain.
+      ASSERT(value->IsUndefined());
+    }
+    set(index, cast_value);
+  }
+  return heap->AllocateFloat32x4(cast_value);
+}
+
+
+Handle<Object> ExternalInt32x4Array::SetValue(
+    Handle<ExternalInt32x4Array> array, uint32_t index, Handle<Object> value) {
+  CALL_HEAP_FUNCTION(array->GetIsolate(),
+                     array->SetValue(index, *value),
+                     Object);
+}
+
+
+MaybeObject* ExternalInt32x4Array::SetValue(uint32_t index, Object* value) {
+  int32x4_value_t cast_value;
+  cast_value.storage[0] = 0;
+  cast_value.storage[1] = 0;
+  cast_value.storage[2] = 0;
+  cast_value.storage[3] = 0;
+  Heap* heap = GetHeap();
+  if (index < static_cast<uint32_t>(length())) {
+    if (value->IsInt32x4()) {
+      cast_value = Int32x4::cast(value)->value();
+    } else {
+      // Clamp undefined to zero (default). All other types have been
+      // converted to a number type further up in the call chain.
+      ASSERT(value->IsUndefined());
+    }
+    set(index, cast_value);
+  }
+  return heap->AllocateInt32x4(cast_value);
+}
+
+
 PropertyCell* GlobalObject::GetPropertyCell(LookupResult* result) {
   ASSERT(!HasFastProperties());
   Object* value = property_dictionary()->ValueAt(result->GetDictionaryEntry());
   return PropertyCell::cast(value);
 }
 
 
 Handle<PropertyCell> JSGlobalObject::EnsurePropertyCell(
     Handle<JSGlobalObject> global,
     Handle<Name> name) {
@@ skipping 1685 matching lines @@
 #define ERROR_MESSAGES_TEXTS(C, T) T,
   static const char* error_messages_[] = {
       ERROR_MESSAGES_LIST(ERROR_MESSAGES_TEXTS)
   };
 #undef ERROR_MESSAGES_TEXTS
   return error_messages_[reason];
 }
 
 
 } }  // namespace v8::internal