Experimental implementation: Exposing SIMD instructions into JavaScript

src/hydrogen.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 5385 matching lines @@
     }
     map->LookupDescriptor(*holder_, *name_, &lookup_);
     if (lookup_.IsFound()) return LoadResult(map);
   }
   lookup_.NotFound();
   return true;
 }
 
 
 bool HOptimizedGraphBuilder::PropertyAccessInfo::CanLoadMonomorphic() {
-  if (!CanInlinePropertyAccess(*map_)) return IsStringLength();
+  if (!CanInlinePropertyAccess(*map_)) {
+    return IsStringLength() || IsFloat32x4OrInt32x4PropertyCallback();
+  }
   if (IsJSObjectFieldAccessor()) return true;
   if (!LookupDescriptor()) return false;
   if (lookup_.IsFound()) return true;
   return LookupInPrototypes();
 }
 
 
 bool HOptimizedGraphBuilder::PropertyAccessInfo::CanLoadAsMonomorphic(
     SmallMapList* types) {
   ASSERT(map_.is_identical_to(types->first()));
   if (!CanLoadMonomorphic()) return false;
   if (types->length() > kMaxLoadPolymorphism) return false;
 
   if (IsStringLength()) {
     for (int i = 1; i < types->length(); ++i) {
       if (types->at(i)->instance_type() >= FIRST_NONSTRING_TYPE) return false;
     }
     return true;
   }
 
+  if (IsFloat32x4OrInt32x4PropertyCallback()) {
+    for (int i = 1; i < types->length(); ++i) {
+      if (types->at(i)->instance_type() == types->first()->instance_type()) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   if (IsArrayLength()) {
     bool is_fast = IsFastElementsKind(map_->elements_kind());
     for (int i = 1; i < types->length(); ++i) {
       Handle<Map> test_map = types->at(i);
       if (test_map->instance_type() != JS_ARRAY_TYPE) return false;
       if (IsFastElementsKind(test_map->elements_kind()) != is_fast) {
         return false;
       }
     }
     return true;
   }
 
   if (IsJSObjectFieldAccessor()) {
     InstanceType instance_type = map_->instance_type();
     for (int i = 1; i < types->length(); ++i) {
       if (types->at(i)->instance_type() != instance_type) return false;
     }
     return true;
   }
 
   for (int i = 1; i < types->length(); ++i) {
     PropertyAccessInfo test_info(isolate(), types->at(i), name_);
     if (!test_info.IsCompatibleForLoad(this)) return false;
   }
 
   return true;
 }
 
 
+static BuiltinFunctionId NameToId(Isolate* isolate, Handle<String> name,
+                                  InstanceType type) {
+  BuiltinFunctionId id;
+  if (name->Equals(isolate->heap()->signMask())) {
+    id = type == FLOAT32x4_TYPE ? kFloat32x4SignMask : kInt32x4SignMask;
+  } else if (name->Equals(isolate->heap()->x())) {
+    id = type == FLOAT32x4_TYPE ? kFloat32x4X : kInt32x4X;
+  } else if (name->Equals(isolate->heap()->y())) {
+    id = type == FLOAT32x4_TYPE ? kFloat32x4Y : kInt32x4Y;
+  } else if (name->Equals(isolate->heap()->z())) {
+    id = type == FLOAT32x4_TYPE ? kFloat32x4Z : kInt32x4Z;
+  } else if (name->Equals(isolate->heap()->w())) {
+    id = type == FLOAT32x4_TYPE ? kFloat32x4W : kInt32x4W;
+  } else if (name->Equals(isolate->heap()->flagX())) {
+    ASSERT(type == INT32x4_TYPE);
+    id = kInt32x4FlagX;
+  } else if (name->Equals(isolate->heap()->flagY())) {
+    ASSERT(type == INT32x4_TYPE);
+    id = kInt32x4FlagY;
+  } else if (name->Equals(isolate->heap()->flagZ())) {
+    ASSERT(type == INT32x4_TYPE);
+    id = kInt32x4FlagZ;
+  } else if (name->Equals(isolate->heap()->flagW())) {
+    ASSERT(type == INT32x4_TYPE);
+    id = kInt32x4FlagW;
+  } else {
+    UNREACHABLE();
+    id = kFloat32x4OrInt32x4Unreachable;
+  }
+
+  return id;
+}
+
+
+static bool IsSIMDProperty(Handle<String> name, uint8_t* mask) {
+  SmartArrayPointer<char> cstring = name->ToCString();
+  int i = 0;
+  while (i <= 3) {
+    int shift = 0;
+    switch (cstring[i]) {
+      case 'W':
+        shift++;
+      case 'Z':
+        shift++;
+      case 'Y':
+        shift++;
+      case 'X':
+        break;
+      default:
+        return false;
+    }
+    *mask |= (shift << 2*i);
+    i++;
+  }
+
+  return true;
+}
+
+
 HInstruction* HOptimizedGraphBuilder::BuildLoadMonomorphic(
     PropertyAccessInfo* info,
     HValue* object,
     HInstruction* checked_object,
     BailoutId ast_id,
     BailoutId return_id,
     bool can_inline_accessor) {
 
   HObjectAccess access = HObjectAccess::ForMap();  // bogus default
   if (info->GetJSObjectFieldAccess(&access)) {
     return New<HLoadNamedField>(checked_object, access);
   }
 
   HValue* checked_holder = checked_object;
   if (info->has_holder()) {
     Handle<JSObject> prototype(JSObject::cast(info->map()->prototype()));
     checked_holder = BuildCheckPrototypeMaps(prototype, info->holder());
   }
 
   if (!info->lookup()->IsFound()) return graph()->GetConstantUndefined();
 
   if (info->lookup()->IsField()) {
+    if (info->map()->constructor()->IsJSFunction()) {
+      JSFunction* constructor = JSFunction::cast(info->map()->constructor());
+      String* class_name =
+          String::cast(constructor->shared()->instance_class_name());
+      uint8_t mask = 0;
+      if (class_name->Equals(isolate()->heap()->simd()) &&
+          IsSIMDProperty(info->name(), &mask) &&
+          CpuFeatures::IsSupported(SSE2)) {
+        return New<HConstant>(mask);
+      }
+    }
+
     return BuildLoadNamedField(checked_holder, info->access());
   }
 
   if (info->lookup()->IsPropertyCallbacks()) {
     Push(checked_object);
     if (FLAG_inline_accessors &&
         can_inline_accessor &&
         TryInlineGetter(info->accessor(), ast_id, return_id)) {
       return NULL;
     }
@@ skipping 1087 matching lines @@
 
 
 static bool AreStringTypes(SmallMapList* types) {
   for (int i = 0; i < types->length(); i++) {
     if (types->at(i)->instance_type() >= FIRST_NONSTRING_TYPE) return false;
   }
   return true;
 }
 
 
+static bool AreInt32x4Types(SmallMapList* types) {
+  if (types == NULL || types->length() == 0) return false;
+  for (int i = 0; i < types->length(); i++) {
+    if (types->at(i)->instance_type() != INT32x4_TYPE) return false;
+  }
+  return true;
+}
+
+
+static bool AreFloat32x4Types(SmallMapList* types) {
+  if (types == NULL || types->length() == 0) return false;
+  for (int i = 0; i < types->length(); i++) {
+    if (types->at(i)->instance_type() != FLOAT32x4_TYPE) return false;
+  }
+  return true;
+}
+
+
 void HOptimizedGraphBuilder::BuildLoad(Property* expr,
                                        BailoutId ast_id) {
   HInstruction* instr = NULL;
   if (expr->IsStringAccess()) {
     HValue* index = Pop();
     HValue* string = Pop();
     HInstruction* char_code = BuildStringCharCodeAt(string, index);
     AddInstruction(char_code);
     instr = NewUncasted<HStringCharFromCode>(char_code);
 
@@ skipping 10 matching lines @@
     ComputeReceiverTypes(expr, object, &types);
     ASSERT(types != NULL);
 
     if (types->length() > 0) {
       PropertyAccessInfo info(isolate(), types->first(), name);
       if (!info.CanLoadAsMonomorphic(types)) {
         return HandlePolymorphicLoadNamedField(
             ast_id, expr->LoadId(), object, types, name);
       }
 
-      BuildCheckHeapObject(object);
-      HInstruction* checked_object;
       if (AreStringTypes(types)) {
-        checked_object =
+        BuildCheckHeapObject(object);
+        HInstruction* checked_object =
             Add<HCheckInstanceType>(object, HCheckInstanceType::IS_STRING);
+        instr = BuildLoadMonomorphic(
+            &info, object, checked_object, ast_id, expr->LoadId());
+      } else if (AreFloat32x4Types(types) && CpuFeatures::IsSupported(SSE2)) {
+        Handle<JSFunction> function(
+            isolate()->native_context()->float32x4_function());
+        HInstruction* constant_function = Add<HConstant>(function);
+        HObjectAccess map_access = HObjectAccess::ForPrototypeOrInitialMap();
+        HInstruction* map = Add<HLoadNamedField>(constant_function, map_access);
+        HObjectAccess prototype_access = HObjectAccess::ForMapPrototype();
+        HInstruction* prototype = Add<HLoadNamedField>(map, prototype_access);
+        Handle<Map> initial_function_prototype_map(
+            isolate()->native_context()->float32x4_function_prototype_map());
+        BuildCheckMap(prototype, initial_function_prototype_map);
+        BuiltinFunctionId id = NameToId(isolate(), name, FLOAT32x4_TYPE);
+        instr = NewUncasted<HUnarySIMDOperation>(object, id);
+      } else if (AreInt32x4Types(types) && CpuFeatures::IsSupported(SSE2)) {
+        Handle<JSFunction> function(
+            isolate()->native_context()->int32x4_function());
+        HInstruction* constant_function = Add<HConstant>(function);
+        HObjectAccess map_access = HObjectAccess::ForPrototypeOrInitialMap();
+        HInstruction* map = Add<HLoadNamedField>(constant_function, map_access);
+        HObjectAccess prototype_access = HObjectAccess::ForMapPrototype();
+        HInstruction* prototype = Add<HLoadNamedField>(map, prototype_access);
+        Handle<Map> initial_function_prototype_map(
+            isolate()->native_context()->int32x4_function_prototype_map());
+        BuildCheckMap(prototype, initial_function_prototype_map);
+        BuiltinFunctionId id = NameToId(isolate(), name, INT32x4_TYPE);
+        instr = NewUncasted<HUnarySIMDOperation>(object, id);
       } else {
-        checked_object = Add<HCheckMaps>(object, types);
+        BuildCheckHeapObject(object);
+        HInstruction* checked_object = Add<HCheckMaps>(object, types);
+        instr = BuildLoadMonomorphic(
+            &info, object, checked_object, ast_id, expr->LoadId());
       }
-      instr = BuildLoadMonomorphic(
-          &info, object, checked_object, ast_id, expr->LoadId());
       if (instr == NULL) return;
       if (instr->IsLinked()) return ast_context()->ReturnValue(instr);
     } else {
       instr = BuildLoadNamedGeneric(object, name, expr);
     }
 
   } else {
     HValue* key = Pop();
     HValue* obj = Pop();
 
@@ skipping 741 matching lines @@
       if (expr->arguments()->length() == 2) {
         HValue* right = Pop();
         HValue* left = Pop();
         Drop(1);  // Receiver.
         HInstruction* op = HMul::NewImul(zone(), context(), left, right);
         if (drop_extra) Drop(1);  // Optionally drop the function.
         ast_context()->ReturnInstruction(op, expr->id());
         return true;
       }
       break;
+    case kFloat32x4Zero:
+      if (expr->arguments()->length() == 0) {
+        if (!CpuFeatures::IsSupported(SSE2)) return false;
+        Drop(1);  // Receiver.
+        HInstruction* op = NewUncasted<HNullarySIMDOperation>(id);
+        if (drop_extra) Drop(1);  // Optionally drop the function.
+        ast_context()->ReturnInstruction(op, expr->id());
+        return true;
+      }
+      break;
+    case kSIMDAbs:
+    case kSIMDNeg:
+    case kSIMDNegU32:
+    case kSIMDReciprocal:
+    case kSIMDReciprocalSqrt:
+    case kSIMDSqrt:
+    case kSIMDBitsToFloat32x4:
+    case kSIMDToFloat32x4:
+    case kSIMDBitsToInt32x4:
+    case kSIMDToInt32x4:
+    case kFloat32x4Splat:
+    case kInt32x4Splat:
+      if (expr->arguments()->length() == 1) {
+        if (!CpuFeatures::IsSupported(SSE2)) return false;
+        HValue* argument = Pop();
+        Drop(1);  // Receiver.
+        HInstruction* op = NewUncasted<HUnarySIMDOperation>(argument, id);
+        if (drop_extra) Drop(1);  // Optionally drop the function.
+        ast_context()->ReturnInstruction(op, expr->id());
+        return true;
+      }
+      break;
+    case kSIMDAdd:
+    case kSIMDSub:
+    case kSIMDMul:
+    case kSIMDDiv:
+    case kSIMDMin:
+    case kSIMDMax:
+    case kSIMDScale:
+    case kSIMDAnd:
+    case kSIMDOr:
+    case kSIMDXor:
+    case kSIMDAddU32:
+    case kSIMDSubU32:
+    case kSIMDMulU32:
+    case kSIMDShuffle:
+    case kSIMDShuffleU32:
+    case kSIMDLessThan:
+    case kSIMDLessThanOrEqual:
+    case kSIMDEqual:
+    case kSIMDNotEqual:
+    case kSIMDGreaterThanOrEqual:
+    case kSIMDGreaterThan:
+    case kSIMDWithX:
+    case kSIMDWithY:
+    case kSIMDWithZ:
+    case kSIMDWithW:
+    case kSIMDWithXu32:
+    case kSIMDWithYu32:
+    case kSIMDWithZu32:
+    case kSIMDWithWu32:
+    case kSIMDWithFlagX:
+    case kSIMDWithFlagY:
+    case kSIMDWithFlagZ:
+    case kSIMDWithFlagW:
+      if (expr->arguments()->length() == 2) {
+        if (!CpuFeatures::IsSupported(SSE2)) return false;
+        HValue* right = Pop();
+        HValue* left = Pop();
+        Drop(1);  // Receiver.
+        HInstruction* op = NewUncasted<HBinarySIMDOperation>(left, right, id);
+        if (drop_extra) Drop(1);  // Optionally drop the function.
+        ast_context()->ReturnInstruction(op, expr->id());
+        return true;
+      }
+      break;
+    case kSIMDSelect:
+    case kSIMDShuffleMix:
+    case kSIMDClamp:
+      if (expr->arguments()->length() == 3) {
+        if (!CpuFeatures::IsSupported(SSE2)) return false;
+        HValue* right = Pop();
+        HValue* left = Pop();
+        HValue* value = Pop();
+        Drop(1);  // Receiver.
+        HInstruction* op =
+            NewUncasted<HTernarySIMDOperation>(value, left, right, id);
+        if (drop_extra) Drop(1);  // Optionally drop the function.
+        ast_context()->ReturnInstruction(op, expr->id());
+        return true;
+      }
+      break;
+    case kFloat32x4Constructor:
+    case kInt32x4Constructor:
+    case kInt32x4Bool:
+      if (expr->arguments()->length() == 4) {
+        if (!CpuFeatures::IsSupported(SSE2)) return false;
+        HValue* w = Pop();
+        HValue* z = Pop();
+        HValue* y = Pop();
+        HValue* x = Pop();
+        Drop(1);  // Receiver.
+        HInstruction* op =
+            NewUncasted<HQuarternarySIMDOperation>(x, y, z, w, id);
+        if (drop_extra) Drop(1);  // Optionally drop the function.
+        ast_context()->ReturnInstruction(op, expr->id());
+        return true;
+      }
+      break;
     default:
       // Not supported for inlining yet.
       break;
   }
   return false;
 }
 
 
 bool HOptimizedGraphBuilder::TryInlineBuiltinMethodCall(
     Call* expr,
@@ skipping 104 matching lines @@
       if (argument_count == 3 && check_type == RECEIVER_MAP_CHECK) {
         AddCheckConstantFunction(expr->holder(), receiver, receiver_map);
         HValue* right = Pop();
         HValue* left = Pop();
         Drop(1);  // Receiver.
         HInstruction* result = HMul::NewImul(zone(), context(), left, right);
         ast_context()->ReturnInstruction(result, expr->id());
         return true;
       }
       break;
+    case kFloat32x4Zero:
+      if (argument_count == 1 && check_type == RECEIVER_MAP_CHECK) {
+        if (!CpuFeatures::IsSupported(SSE2)) return false;
+        AddCheckConstantFunction(expr->holder(), receiver, receiver_map);
+        Drop(1);  // Receiver.
+        HInstruction* op = NewUncasted<HNullarySIMDOperation>(id);
+        ast_context()->ReturnInstruction(op, expr->id());
+        return true;
+      }
+      break;
+    case kSIMDAbs:
+    case kSIMDNeg:
+    case kSIMDNegU32:
+    case kSIMDReciprocal:
+    case kSIMDReciprocalSqrt:
+    case kSIMDSqrt:
+    case kSIMDBitsToFloat32x4:
+    case kSIMDToFloat32x4:
+    case kSIMDBitsToInt32x4:
+    case kSIMDToInt32x4:
+    case kFloat32x4Splat:
+    case kInt32x4Splat:
+      if (argument_count == 2 && check_type == RECEIVER_MAP_CHECK) {
+        if (!CpuFeatures::IsSupported(SSE2)) return false;
+        AddCheckConstantFunction(expr->holder(), receiver, receiver_map);
+        HValue* argument = Pop();
+        Drop(1);  // Receiver.
+        HInstruction* op = NewUncasted<HUnarySIMDOperation>(argument, id);
+        ast_context()->ReturnInstruction(op, expr->id());
+        return true;
+      }
+      break;
+    case kSIMDAdd:
+    case kSIMDSub:
+    case kSIMDMul:
+    case kSIMDDiv:
+    case kSIMDMin:
+    case kSIMDMax:
+    case kSIMDScale:
+    case kSIMDAnd:
+    case kSIMDOr:
+    case kSIMDXor:
+    case kSIMDAddU32:
+    case kSIMDSubU32:
+    case kSIMDMulU32:
+    case kSIMDShuffle:
+    case kSIMDShuffleU32:
+    case kSIMDLessThan:
+    case kSIMDLessThanOrEqual:
+    case kSIMDEqual:
+    case kSIMDNotEqual:
+    case kSIMDGreaterThanOrEqual:
+    case kSIMDGreaterThan:
+    case kSIMDWithX:
+    case kSIMDWithY:
+    case kSIMDWithZ:
+    case kSIMDWithW:
+    case kSIMDWithXu32:
+    case kSIMDWithYu32:
+    case kSIMDWithZu32:
+    case kSIMDWithWu32:
+    case kSIMDWithFlagX:
+    case kSIMDWithFlagY:
+    case kSIMDWithFlagZ:
+    case kSIMDWithFlagW:
+      if (argument_count == 3 && check_type == RECEIVER_MAP_CHECK) {
+        if (!CpuFeatures::IsSupported(SSE2)) return false;
+        AddCheckConstantFunction(expr->holder(), receiver, receiver_map);
+        HValue* right = Pop();
+        HValue* left = Pop();
+        Drop(1);  // Receiver.
+        HInstruction* op = NewUncasted<HBinarySIMDOperation>(left, right, id);
+        ast_context()->ReturnInstruction(op, expr->id());
+        return true;
+      }
+      break;
+    case kSIMDSelect:
+    case kSIMDShuffleMix:
+    case kSIMDClamp:
+      if (argument_count == 4 && check_type == RECEIVER_MAP_CHECK) {
+        if (!CpuFeatures::IsSupported(SSE2)) return false;
+        AddCheckConstantFunction(expr->holder(), receiver, receiver_map);
+        HValue* right = Pop();
+        HValue* left = Pop();
+        HValue* value = Pop();
+        Drop(1);  // Receiver.
+        HInstruction* op =
+            NewUncasted<HTernarySIMDOperation>(value, left, right, id);
+        ast_context()->ReturnInstruction(op, expr->id());
+        return true;
+      }
+      break;
+    case kInt32x4Bool:
+      if (argument_count == 5 && check_type == RECEIVER_MAP_CHECK) {
+        if (!CpuFeatures::IsSupported(SSE2)) return false;
+        AddCheckConstantFunction(expr->holder(), receiver, receiver_map);
+        HValue* w = Pop();
+        HValue* z = Pop();
+        HValue* y = Pop();
+        HValue* x = Pop();
+        Drop(1);  // Receiver.
+        HValue* context = environment()->context();
+        HInstruction* op =
+            HQuarternarySIMDOperation::New(zone(), context, x, y, z, w, id);
+        op->set_position(expr->position());
+        ast_context()->ReturnInstruction(op, expr->id());
+        return true;
+      }
+      break;
+    case kFloat32x4ArrayGetAt:
+    case kInt32x4ArrayGetAt:
+      if (argument_count == 2 && check_type == RECEIVER_MAP_CHECK) {
+        if (!CpuFeatures::IsSupported(SSE2)) return false;
+        AddCheckConstantFunction(expr->holder(), receiver, receiver_map);
+        HValue* key = Pop();
+        HValue* typed32x4_array = Pop();
+        ASSERT(typed32x4_array == receiver);
+        HInstruction* instr = BuildUncheckedMonomorphicElementAccess(
+            typed32x4_array, key, NULL,
+            receiver_map->instance_type() == JS_ARRAY_TYPE,
+            receiver_map->elements_kind(),
+            false,  // is_store.
+            NEVER_RETURN_HOLE,  // load_mode.
+            STANDARD_STORE);
+        ast_context()->ReturnValue(instr);
+        return true;
+      }
+      break;
+    case kFloat32x4ArraySetAt:
+    case kInt32x4ArraySetAt:
+      if (argument_count == 3 && check_type == RECEIVER_MAP_CHECK) {
+        if (!CpuFeatures::IsSupported(SSE2)) return false;
+        AddCheckConstantFunction(expr->holder(), receiver, receiver_map);
+        HValue* value = Pop();
+        HValue* key = Pop();
+        HValue* typed32x4_array = Pop();
+        ASSERT(typed32x4_array == receiver);
+        // TODO(haitao): add STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS.
+        KeyedAccessStoreMode store_mode = STANDARD_STORE;
+        BuildUncheckedMonomorphicElementAccess(
+            typed32x4_array, key, value,
+            receiver_map->instance_type() == JS_ARRAY_TYPE,
+            receiver_map->elements_kind(),
+            true,  // is_store.
+            NEVER_RETURN_HOLE,  // load_mode.
+            store_mode);
+        Push(value);
+        Add<HSimulate>(expr->id(), REMOVABLE_SIMULATE);
+        ast_context()->ReturnValue(Pop());
+        return true;
+      }
+      break;
     default:
       // Not yet supported for inlining.
       break;
   }
   return false;
 }
 
 
 bool HOptimizedGraphBuilder::TryCallApply(Call* expr) {
   Expression* callee = expr->expression();
@@ skipping 3128 matching lines @@
                              Zone* zone) {
   if (range != NULL && !range->IsEmpty()) {
     PrintIndent();
     trace_.Add("%d %s", range->id(), type);
     if (range->HasRegisterAssigned()) {
       LOperand* op = range->CreateAssignedOperand(zone);
       int assigned_reg = op->index();
       if (op->IsDoubleRegister()) {
         trace_.Add(" \"%s\"",
                    DoubleRegister::AllocationIndexToString(assigned_reg));
+      } else if (op->IsFloat32x4Register()) {
+        trace_.Add(" \"%s\"",
+                   Float32x4Register::AllocationIndexToString(assigned_reg));
+      } else if (op->IsInt32x4Register()) {
+        trace_.Add(" \"%s\"",
+                   Int32x4Register::AllocationIndexToString(assigned_reg));
       } else {
         ASSERT(op->IsRegister());
         trace_.Add(" \"%s\"", Register::AllocationIndexToString(assigned_reg));
       }
     } else if (range->IsSpilled()) {
       LOperand* op = range->TopLevel()->GetSpillOperand();
       if (op->IsDoubleStackSlot()) {
         trace_.Add(" \"double_stack:%d\"", op->index());
+      } else if (op->IsFloat32x4StackSlot()) {
+        trace_.Add(" \"float32x4_stack:%d\"", op->index());
+      } else if (op->IsInt32x4StackSlot()) {
+        trace_.Add(" \"int32x4_stack:%d\"", op->index());
       } else {
         ASSERT(op->IsStackSlot());
         trace_.Add(" \"stack:%d\"", op->index());
       }
     }
     int parent_index = -1;
     if (range->IsChild()) {
       parent_index = range->parent()->id();
     } else {
       parent_index = range->id();
@@ skipping 109 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal