Convert between tagged and untagged kSimd128 values.

src/compiler/change-lowering.cc

 // Copyright 2014 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/compiler/change-lowering.h"
 
 #include "src/address-map.h"
 #include "src/code-factory.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/linkage.h"
@@ skipping 21 matching lines @@
     case IrOpcode::kChangeInt32ToTagged:
       return ChangeInt32ToTagged(node->InputAt(0), control);
     case IrOpcode::kChangeTaggedToFloat64:
       return ChangeTaggedToFloat64(node->InputAt(0), control);
     case IrOpcode::kChangeTaggedToInt32:
       return ChangeTaggedToUI32(node->InputAt(0), control, kSigned);
     case IrOpcode::kChangeTaggedToUint32:
       return ChangeTaggedToUI32(node->InputAt(0), control, kUnsigned);
     case IrOpcode::kChangeUint32ToTagged:
       return ChangeUint32ToTagged(node->InputAt(0), control);
+#define SIMD128_CASES(TYPE, Type, type, lane_count, lane_type) \
+  case IrOpcode::kChange##Type##ToTagged:                      \
+    return Change##Type##ToTagged(node->InputAt(0), control);  \
+  case IrOpcode::kChangeTaggedTo##Type:                        \
+    return ChangeTaggedTo##Type(node->InputAt(0), control);
+      SIMD128_TYPES(SIMD128_CASES)
+#undef SIMD128_CASES
     case IrOpcode::kLoadField:
       return LoadField(node);
     case IrOpcode::kStoreField:
       return StoreField(node);
     case IrOpcode::kLoadElement:
       return LoadElement(node);
     case IrOpcode::kStoreElement:
       return StoreElement(node);
     case IrOpcode::kAllocate:
       return Allocate(node);
@@ skipping 10 matching lines @@
   }
   UNREACHABLE();
   return NoChange();
 }
 
 
 Node* ChangeLowering::HeapNumberValueIndexConstant() {
   return jsgraph()->IntPtrConstant(HeapNumber::kValueOffset - kHeapObjectTag);
 }
 
+Node* ChangeLowering::Simd128ValueIndexConstant() {
+  return jsgraph()->IntPtrConstant(Simd128Value::kValueOffset - kHeapObjectTag);
+}
 
 Node* ChangeLowering::SmiMaxValueConstant() {
   return jsgraph()->Int32Constant(Smi::kMaxValue);
 }
 
 
 Node* ChangeLowering::SmiShiftBitsConstant() {
   return jsgraph()->IntPtrConstant(kSmiShiftSize + kSmiTagSize);
 }
 
@@ skipping 13 matching lines @@
   }
   Node* heap_number = graph()->NewNode(allocate_heap_number_operator_.get(),
                                        target, context, effect, control);
   Node* store = graph()->NewNode(
       machine()->Store(StoreRepresentation(MachineRepresentation::kFloat64,
                                            kNoWriteBarrier)),
       heap_number, HeapNumberValueIndexConstant(), value, heap_number, control);
   return graph()->NewNode(common()->FinishRegion(), heap_number, store);
 }
 
+#define SIMD128_ALLOCATE(TYPE, Type, type, lane_count, lane_type)             \
+  Node* ChangeLowering::Allocate##Type##WithValue(Node* value) {              \
+    Callable callable = CodeFactory::Allocate##Type(isolate());               \
+    Node* target = jsgraph()->HeapConstant(callable.code());                  \
+    Node* context = jsgraph()->NoContextConstant();                           \
+    Node* effect =                                                            \
+        graph()->NewNode(common()->BeginRegion(), graph()->start());          \
+    if (!allocate_##type##_value_operator_.is_set()) {                        \
+      CallDescriptor* descriptor = Linkage::GetStubCallDescriptor(            \
+          isolate(), jsgraph()->zone(), callable.descriptor(), 0,             \
+          CallDescriptor::kNoFlags, Operator::kNoThrow);                      \
+      allocate_##type##_value_operator_.set(common()->Call(descriptor));      \
+    }                                                                         \
+    Node* simd_value = graph()->NewNode(                                      \
+        allocate_##type##_value_operator_.get(), target, context, effect);    \
+    Node* store = graph()->NewNode(                                           \
+        machine()->Store(StoreRepresentation(MachineRepresentation::kSimd128, \
+                                             kNoWriteBarrier)),               \
+        simd_value, Simd128ValueIndexConstant(), value, simd_value);          \
+    return graph()->NewNode(common()->FinishRegion(), simd_value, store);     \
+  }
+SIMD128_TYPES(SIMD128_ALLOCATE)
+#undef SIMD128_ALLOCATE
 
 Node* ChangeLowering::ChangeInt32ToFloat64(Node* value) {
   return graph()->NewNode(machine()->ChangeInt32ToFloat64(), value);
 }
 
 
 Node* ChangeLowering::ChangeInt32ToSmi(Node* value) {
   if (machine()->Is64()) {
     value = graph()->NewNode(machine()->ChangeInt32ToInt64(), value);
   }
@@ skipping 27 matching lines @@
   return graph()->NewNode(machine()->WordShl(), value, SmiShiftBitsConstant());
 }
 
 
 Node* ChangeLowering::LoadHeapNumberValue(Node* value, Node* control) {
   return graph()->NewNode(machine()->Load(MachineType::Float64()), value,
                           HeapNumberValueIndexConstant(), graph()->start(),
                           control);
 }
 
+#define SIMD128_LOAD(TYPE, Type, type, lane_count, lane_type)               \
+  Node* ChangeLowering::Load##Type##Value(Node* value) {                    \
+    return graph()->NewNode(machine()->Load(MachineType::Simd128()), value, \
+                            Simd128ValueIndexConstant(), graph()->start()); \
+  }
+SIMD128_TYPES(SIMD128_LOAD)
+#undef SIMD128_LOAD
 
 Node* ChangeLowering::TestNotSmi(Node* value) {
   STATIC_ASSERT(kSmiTag == 0);
   STATIC_ASSERT(kSmiTagMask == 1);
   return graph()->NewNode(machine()->WordAnd(), value,
                           jsgraph()->IntPtrConstant(kSmiTagMask));
 }
 
 
 Reduction ChangeLowering::ChangeBitToBool(Node* value, Node* control) {
@@ skipping 258 matching lines @@
   Node* vfalse =
       AllocateHeapNumberWithValue(ChangeUint32ToFloat64(value), if_false);
 
   Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
   Node* phi = graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
                                vtrue, vfalse, merge);
 
   return Replace(phi);
 }
 
+#define SIMD128_CHANGE(TYPE, SType, type, lane_count, lane_type)       \
+  Reduction ChangeLowering::ChangeTaggedTo##SType(Node* value,         \
+                                                  Node* control) {     \
+    DCHECK(NodeProperties::GetType(value)->Is(Type::TaggedPointer())); \
+    return Replace(Load##SType##Value(value));                         \
+  }                                                                    \
+                                                                       \
+  Reduction ChangeLowering::Change##SType##ToTagged(Node* value,       \
+                                                    Node* control) {   \
+    DCHECK(NodeProperties::GetType(value)->Is(Type::Simd()));          \
+    return Replace(Allocate##SType##WithValue(value));                 \
+  }
+SIMD128_TYPES(SIMD128_CHANGE)
+#undef SIMD128_CHANGE
 
 namespace {
 
 WriteBarrierKind ComputeWriteBarrierKind(BaseTaggedness base_is_tagged,
                                          MachineRepresentation representation,
                                          Type* field_type, Type* input_type) {
   if (field_type->Is(Type::TaggedSigned()) ||
       input_type->Is(Type::TaggedSigned())) {
     // Write barriers are only for writes of heap objects.
     return kNoWriteBarrier;
@@ skipping 264 matching lines @@
 }
 
 
 MachineOperatorBuilder* ChangeLowering::machine() const {
   return jsgraph()->machine();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8