Add flow-graph generated SIMD array intrinsics.

runtime/vm/intrinsifier.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 // Class for intrinsifying functions.
 
 #include "vm/assembler.h"
 #include "vm/compiler.h"
 #include "vm/cpu.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
@@ skipping 247 matching lines @@
 }
 
 
 #if !defined(TARGET_ARCH_DBC)
 static intptr_t CidForRepresentation(Representation rep) {
   switch (rep) {
     case kUnboxedDouble:
       return kDoubleCid;
     case kUnboxedFloat32x4:
       return kFloat32x4Cid;
+    case kUnboxedInt32x4:
+      return kInt32x4Cid;
+    case kUnboxedFloat64x2:
+      return kFloat64x2Cid;
     case kUnboxedUint32:
       return kDynamicCid;  // smi or mint.
     default:
       UNREACHABLE();
       return kIllegalCid;
   }
 }
 
 
 // Notes about the graph intrinsics:
@@ skipping 150 matching lines @@
           BoxInstr::Create(kUnboxedUint32, new Value(result)));
       break;
     case kTypedDataFloat32ArrayCid:
       result = builder.AddDefinition(
           new FloatToDoubleInstr(new Value(result), Thread::kNoDeoptId));
       // Fall through.
     case kTypedDataFloat64ArrayCid:
       result = builder.AddDefinition(
           BoxInstr::Create(kUnboxedDouble, new Value(result)));
       break;
+    case kTypedDataFloat32x4ArrayCid:
+      result = builder.AddDefinition(
+          BoxInstr::Create(kUnboxedFloat32x4, new Value(result)));
+      break;
+    case kTypedDataInt32x4ArrayCid:
+      result = builder.AddDefinition(
+          BoxInstr::Create(kUnboxedInt32x4, new Value(result)));
+      break;
+    case kTypedDataFloat64x2ArrayCid:
+      result = builder.AddDefinition(
+          BoxInstr::Create(kUnboxedFloat64x2, new Value(result)));
+      break;
     case kArrayCid:
     case kImmutableArrayCid:
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid:
       // Nothing to do.
@@ skipping 44 matching lines @@
       // Use same truncating unbox-instruction for int32 and uint32.
       // Fall-through.
     case kTypedDataUint32ArrayCid:
     case kExternalTypedDataUint32ArrayCid:
       // Supports smi and mint, slow-case for bigints.
       value = builder.AddUnboxInstr(kUnboxedUint32,
                                     new Value(value),
                                     /* is_checked = */ false);
       break;
     case kTypedDataFloat32ArrayCid:
-    case kTypedDataFloat64ArrayCid: {
+    case kTypedDataFloat64ArrayCid:
+    case kTypedDataFloat32x4ArrayCid:
+    case kTypedDataInt32x4ArrayCid:
+    case kTypedDataFloat64x2ArrayCid: {
+      intptr_t value_check_cid = kDoubleCid;
+      Representation rep = kUnboxedDouble;
+      switch (array_cid) {
+        case kTypedDataFloat32x4ArrayCid:
+          value_check_cid = kFloat32x4Cid;
+          rep = kUnboxedFloat32x4;
+          break;
+        case kTypedDataInt32x4ArrayCid:
+          value_check_cid = kInt32x4Cid;
+          rep = kUnboxedInt32x4;
+          break;
+        case kTypedDataFloat64x2ArrayCid:
+          value_check_cid = kFloat64x2Cid;
+          rep = kUnboxedFloat64x2;
+          break;
+        default:
+          // Float32/Float64 case already handled.
+          break;
+      }
       const ICData& value_check = ICData::ZoneHandle(ICData::New(
           flow_graph->function(),
           Symbols::Empty(),  // Dummy function name.
           Object::empty_array(),  // Dummy args. descr.
           Thread::kNoDeoptId,
           1,
           false));
-      value_check.AddReceiverCheck(kDoubleCid, flow_graph->function());
+      value_check.AddReceiverCheck(value_check_cid, flow_graph->function());
       builder.AddInstruction(
           new CheckClassInstr(new Value(value),
                               Thread::kNoDeoptId,
                               value_check,
                               builder.TokenPos()));
-      value = builder.AddUnboxInstr(kUnboxedDouble,
+      value = builder.AddUnboxInstr(rep,
                                     new Value(value),
                                     /* is_checked = */ true);
       if (array_cid == kTypedDataFloat32ArrayCid) {
         value = builder.AddDefinition(
             new DoubleToFloatInstr(new Value(value), Thread::kNoDeoptId));
       }
       break;
     }
     default:
       UNREACHABLE();
@@ skipping 90 matching lines @@
 DEFINE_FLOAT_ARRAY_SETTER_INTRINSIC(enum_name)
 
 DEFINE_FLOAT_ARRAY_GETTER_SETTER_INTRINSICS(Float64Array)
 DEFINE_FLOAT_ARRAY_GETTER_SETTER_INTRINSICS(Float32Array)
 
 #undef DEFINE_FLOAT_ARRAY_GETTER_SETTER_INTRINSICS
 #undef DEFINE_FLOAT_ARRAY_GETTER_INTRINSIC
 #undef DEFINE_FLOAT_ARRAY_SETTER_INTRINSIC
 
 
+#define DEFINE_SIMD_ARRAY_GETTER_INTRINSIC(enum_name)                          \
+bool Intrinsifier::Build_##enum_name##GetIndexed(FlowGraph* flow_graph) {      \
+  if (!FlowGraphCompiler::SupportsUnboxedSimd128()) {                          \
+    return false;                                                              \
+  }                                                                            \
+  return IntrinsifyArrayGetIndexed(                                            \
+      flow_graph,                                                              \
+      MethodRecognizer::MethodKindToReceiverCid(                               \
+          MethodRecognizer::k##enum_name##GetIndexed));                        \
+}
+
+
+#define DEFINE_SIMD_ARRAY_SETTER_INTRINSIC(enum_name)                          \
+bool Intrinsifier::Build_##enum_name##SetIndexed(FlowGraph* flow_graph) {      \
+  if (!FlowGraphCompiler::SupportsUnboxedSimd128()) {                          \
+    return false;                                                              \
+  }                                                                            \
+  return IntrinsifyArraySetIndexed(                                            \
+      flow_graph,                                                              \
+      MethodRecognizer::MethodKindToReceiverCid(                               \
+          MethodRecognizer::k##enum_name##SetIndexed));                        \
+}
+
+#define DEFINE_SIMD_ARRAY_GETTER_SETTER_INTRINSICS(enum_name)                 \
+DEFINE_SIMD_ARRAY_GETTER_INTRINSIC(enum_name)                                 \
+DEFINE_SIMD_ARRAY_SETTER_INTRINSIC(enum_name)
+
+DEFINE_SIMD_ARRAY_GETTER_SETTER_INTRINSICS(Float32x4Array)
+DEFINE_SIMD_ARRAY_GETTER_SETTER_INTRINSICS(Int32x4Array)
+DEFINE_SIMD_ARRAY_GETTER_SETTER_INTRINSICS(Float64x2Array)
+
+#undef DEFINE_SIMD_ARRAY_GETTER_SETTER_INTRINSICS
+#undef DEFINE_SIMD_ARRAY_GETTER_INTRINSIC
+#undef DEFINE_SIMD_ARRAY_SETTER_INTRINSIC
+
+
 static bool BuildCodeUnitAt(FlowGraph* flow_graph, intptr_t cid) {
   GraphEntryInstr* graph_entry = flow_graph->graph_entry();
   TargetEntryInstr* normal_entry = graph_entry->normal_entry();
   BlockBuilder builder(flow_graph, normal_entry);
 
   Definition* index = builder.AddParameter(1);
   Definition* str = builder.AddParameter(2);
   PrepareIndexedOp(&builder, str, index, String::length_offset());
 
   // For external strings: Load external data.
@@ skipping 556 matching lines @@
   TargetEntryInstr* normal_entry = graph_entry->normal_entry();
   BlockBuilder builder(flow_graph, normal_entry);
 
   return BuildInvokeMathCFunction(&builder,
                                   MethodRecognizer::kDoubleRound);
 }
 #endif  // !defined(TARGET_ARCH_DBC)
 
 
 }  // namespace dart