Convert between tagged and untagged kSimd128 values.

src/compiler/representation-change.cc

 // Copyright 2015 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/representation-change.h"
 
 #include <sstream>
 
 #include "src/base/bits.h"
 #include "src/code-factory.h"
@@ skipping 119 matching lines @@
   }
   switch (use_rep) {
     case MachineRepresentation::kTagged:
       return GetTaggedRepresentationFor(node, output_rep, output_type);
     case MachineRepresentation::kFloat32:
       return GetFloat32RepresentationFor(node, output_rep, output_type,
                                          truncation);
     case MachineRepresentation::kFloat64:
       return GetFloat64RepresentationFor(node, output_rep, output_type,
                                          truncation);
+    case MachineRepresentation::kSimd128:
+      return GetSimd128RepresentationFor(node, output_rep, output_type);
     case MachineRepresentation::kBit:
       return GetBitRepresentationFor(node, output_rep, output_type);
     case MachineRepresentation::kWord8:
     case MachineRepresentation::kWord16:
     case MachineRepresentation::kWord32:
       return GetWord32RepresentationFor(node, output_rep, output_type);
     case MachineRepresentation::kWord64:
       return GetWord64RepresentationFor(node, output_rep, output_type);
-    case MachineRepresentation::kSimd128:  // Fall through.
-      // TODO(bbudge) Handle conversions between tagged and untagged.
-      break;
     case MachineRepresentation::kNone:
       return node;
   }
   UNREACHABLE();
   return nullptr;
 }
 
 
 Node* RepresentationChanger::GetTaggedRepresentationFor(
     Node* node, MachineRepresentation output_rep, Type* output_type) {
@@ skipping 146 matching lines @@
     op = simplified()->ChangeTaggedToFloat64();
   } else if (output_rep == MachineRepresentation::kFloat32) {
     op = machine()->ChangeFloat32ToFloat64();
   } else {
     return TypeError(node, output_rep, output_type,
                      MachineRepresentation::kFloat64);
   }
   return jsgraph()->graph()->NewNode(op, node);
 }
 
+Node* RepresentationChanger::GetSimd128RepresentationFor(
+    Node* node, MachineRepresentation output_rep, Type* output_type) {
+  // Select the correct X -> Simd128 operator.
+  const Operator* op;
+  if (output_rep == MachineRepresentation::kTagged) {
+    op = nullptr;
+  } else {
+    return TypeError(node, output_rep, output_type,
+                     MachineRepresentation::kFloat64);
+  }
+  return jsgraph()->graph()->NewNode(op, node);
+}
 
 Node* RepresentationChanger::MakeTruncatedInt32Constant(double value) {
   return jsgraph()->Int32Constant(DoubleToInt32(value));
 }
 
-
 Node* RepresentationChanger::GetWord32RepresentationFor(
     Node* node, MachineRepresentation output_rep, Type* output_type) {
   // Eagerly fold representation changes for constants.
   switch (node->opcode()) {
     case IrOpcode::kInt32Constant:
       return node;  // No change necessary.
     case IrOpcode::kFloat32Constant:
       return MakeTruncatedInt32Constant(OpParameter<float>(node));
     case IrOpcode::kNumberConstant:
     case IrOpcode::kFloat64Constant:
@@ skipping 197 matching lines @@
 
 
 Node* RepresentationChanger::InsertChangeTaggedToFloat64(Node* node) {
   return jsgraph()->graph()->NewNode(simplified()->ChangeTaggedToFloat64(),
                                      node);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8