VM: Intrinsify some common SIMD methods to speed up precompiled SIMD code.

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/intrinsifier.h"
 #include "vm/flags.h"
 #include "vm/object.h"
 #include "vm/symbols.h"
@@ skipping 193 matching lines @@
     switch (function.recognized_kind()) {
       CORE_INTEGER_LIB_INTRINSIC_LIST(EMIT_CASE)
       default:
         break;
     }
   }
 #undef EMIT_INTRINSIC
 }
 
 
+static intptr_t CidForRepresentation(Representation rep) {
+  switch (rep) {
+    case kUnboxedDouble:
+      return kDoubleCid;
+    case kUnboxedFloat32x4:
+      return kFloat32x4Cid;
+    default:
+      UNREACHABLE();
+      return kIllegalCid;
+  }
+}
+
+
 class BlockBuilder : public ValueObject {
  public:
   BlockBuilder(FlowGraph* flow_graph, TargetEntryInstr* entry)
       : flow_graph_(flow_graph), entry_(entry), current_(entry) { }
 
   Definition* AddToInitialDefinitions(Definition* def) {
     def->set_ssa_temp_index(flow_graph_->alloc_ssa_temp_index());
     flow_graph_->AddToInitialDefinitions(def);
     return def;
   }
@@ skipping 25 matching lines @@
 
   intptr_t TokenPos() {
     return flow_graph_->function().token_pos();
   }
 
   Definition* AddNullDefinition() {
     return AddDefinition(
         new ConstantInstr(Object::ZoneHandle(Object::null())));
   }
 
+  Definition* AddUnboxInstr(Representation rep, Value* value) {
+    Definition* unboxed_value = AddDefinition(
+        UnboxInstr::Create(rep, value, Isolate::kNoDeoptId));
+    // Manually adjust reaching type because there is no type propagation
+    // when building intrinsics.
+    unboxed_value->AsUnbox()->value()->SetReachingType(ZoneCompileType::Wrap(
+        CompileType::FromCid(CidForRepresentation(rep))));
+    return unboxed_value;
+  }
+
  private:
   FlowGraph* flow_graph_;
   BlockEntryInstr* entry_;
   Instruction* current_;
 };
 
 
 static void PrepareIndexedOp(BlockBuilder* builder,
                              Definition* array,
                              Definition* index,
@@ skipping 174 matching lines @@
       String::Handle(flow_graph->function().name()),
       Object::empty_array(),  // Dummy args. descr.
       Isolate::kNoDeoptId,
       1));
   value_check.AddReceiverCheck(kDoubleCid, flow_graph->function());
   builder.AddInstruction(
       new CheckClassInstr(new Value(value),
                           Isolate::kNoDeoptId,
                           value_check,
                           builder.TokenPos()));
-  Definition* double_value = builder.AddDefinition(
-      UnboxInstr::Create(kUnboxedDouble,
-                         new Value(value),
-                         Isolate::kNoDeoptId));
-  // Manually adjust reaching type because there is no type propagation
-  // when building intrinsics.
-  double_value->AsUnbox()->value()->SetReachingType(
-      ZoneCompileType::Wrap(CompileType::FromCid(kDoubleCid)));
+  Definition* double_value =
+      builder.AddUnboxInstr(kUnboxedDouble, new Value(value));
 
   builder.AddInstruction(
       new StoreIndexedInstr(new Value(array),
                             new Value(index),
                             new Value(double_value),
                             kNoStoreBarrier,
                             8,  // index scale
                             kTypedDataFloat64ArrayCid,
                             Isolate::kNoDeoptId,
                             builder.TokenPos()));
@@ skipping 23 matching lines @@
                            kTypedDataFloat64ArrayCid,
                            Isolate::kNoDeoptId,
                            builder.TokenPos()));
   Definition* result = builder.AddDefinition(
       BoxInstr::Create(kUnboxedDouble, new Value(unboxed_value)));
   builder.AddIntrinsicReturn(new Value(result));
   return true;
 }
 
 
+static bool BuildBinaryFloat32x4Op(FlowGraph* flow_graph, Token::Kind kind) {
+  if (!FlowGraphCompiler::SupportsUnboxedSimd128()) return false;
+
+  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
+  TargetEntryInstr* normal_entry = graph_entry->normal_entry();
+  BlockBuilder builder(flow_graph, normal_entry);
+
+  Definition* right = builder.AddParameter(1);
+  Definition* left = builder.AddParameter(2);
+
+  const ICData& value_check = ICData::ZoneHandle(ICData::New(
+      flow_graph->function(),
+      String::Handle(flow_graph->function().name()),
+      Object::empty_array(),  // Dummy args. descr.
+      Isolate::kNoDeoptId,
+      1));
+  value_check.AddReceiverCheck(kFloat32x4Cid, flow_graph->function());
+  // Check argument. Receiver (left) is known to be a Float32x4.
+  builder.AddInstruction(
+      new CheckClassInstr(new Value(right),
+                          Isolate::kNoDeoptId,
+                          value_check,
+                          builder.TokenPos()));
+  Definition* left_simd =
+      builder.AddUnboxInstr(kUnboxedFloat32x4, new Value(left));
+
+  Definition* right_simd =
+      builder.AddUnboxInstr(kUnboxedFloat32x4, new Value(right));
+
+  Definition* unboxed_result = builder.AddDefinition(
+      new BinaryFloat32x4OpInstr(kind,
+                                 new Value(left_simd),
+                                 new Value(right_simd),
+                                 Isolate::kNoDeoptId));
+  Definition* result = builder.AddDefinition(
+      BoxInstr::Create(kUnboxedFloat32x4, new Value(unboxed_result)));
+  builder.AddIntrinsicReturn(new Value(result));
+  return true;
+}
+
+
+bool Intrinsifier::Build_Float32x4Mul(FlowGraph* flow_graph) {
+  return BuildBinaryFloat32x4Op(flow_graph, Token::kMUL);
+}
+
+
+bool Intrinsifier::Build_Float32x4Sub(FlowGraph* flow_graph) {
+  return BuildBinaryFloat32x4Op(flow_graph, Token::kSUB);
+}
+
+
+bool Intrinsifier::Build_Float32x4Add(FlowGraph* flow_graph) {
+  return BuildBinaryFloat32x4Op(flow_graph, Token::kADD);
+}
+
+
+static bool BuildFloat32x4Shuffle(FlowGraph* flow_graph,
+                                  MethodRecognizer::Kind kind) {
+  if (!FlowGraphCompiler::SupportsUnboxedSimd128()) return false;
+  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
+  TargetEntryInstr* normal_entry = graph_entry->normal_entry();
+  BlockBuilder builder(flow_graph, normal_entry);
+
+  Definition* receiver = builder.AddParameter(1);
+
+  Definition* unboxed_receiver =
+      builder.AddUnboxInstr(kUnboxedFloat32x4, new Value(receiver));
+
+  Definition* unboxed_result = builder.AddDefinition(
+      new Simd32x4ShuffleInstr(kind,
+                               new Value(unboxed_receiver),
+                               0,
+                               Isolate::kNoDeoptId));
+
+  Definition* result = builder.AddDefinition(
+      BoxInstr::Create(kUnboxedDouble, new Value(unboxed_result)));
+  builder.AddIntrinsicReturn(new Value(result));
+  return true;
+}
+
+
+bool Intrinsifier::Build_Float32x4ShuffleX(FlowGraph* flow_graph) {
+  return BuildFloat32x4Shuffle(flow_graph,
+                               MethodRecognizer::kFloat32x4ShuffleX);
+}
+
+
+bool Intrinsifier::Build_Float32x4ShuffleY(FlowGraph* flow_graph) {
+  return BuildFloat32x4Shuffle(flow_graph,
+                               MethodRecognizer::kFloat32x4ShuffleY);
+}
+
+
+bool Intrinsifier::Build_Float32x4ShuffleZ(FlowGraph* flow_graph) {
+  return BuildFloat32x4Shuffle(flow_graph,
+                               MethodRecognizer::kFloat32x4ShuffleZ);
+}
+
+
+bool Intrinsifier::Build_Float32x4ShuffleW(FlowGraph* flow_graph) {
+  return BuildFloat32x4Shuffle(flow_graph,
+                               MethodRecognizer::kFloat32x4ShuffleW);
+}
+
+
 static bool BuildLoadField(FlowGraph* flow_graph, intptr_t offset) {
   GraphEntryInstr* graph_entry = flow_graph->graph_entry();
   TargetEntryInstr* normal_entry = graph_entry->normal_entry();
   BlockBuilder builder(flow_graph, normal_entry);
 
   Definition* array = builder.AddParameter(1);
 
   Definition* length = builder.AddDefinition(
       new LoadFieldInstr(new Value(array),
                          offset,
@@ skipping 168 matching lines @@
                                   new Value(growable_array),
                                   new Value(length),
                                   kNoStoreBarrier,
                                   builder.TokenPos()));
   Definition* null_def = builder.AddNullDefinition();
   builder.AddIntrinsicReturn(new Value(null_def));
   return true;
 }
 
 }  // namespace dart