Allow SIMD types to be used on mips

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, 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.
 
 #include "vm/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 18 matching lines @@
 DEFINE_FLAG(bool, remove_redundant_phis, true, "Remove redundant phis.");
 DEFINE_FLAG(bool, trace_constant_propagation, false,
     "Print constant propagation and useless code elimination.");
 DEFINE_FLAG(bool, trace_optimization, false, "Print optimization details.");
 DEFINE_FLAG(bool, trace_range_analysis, false, "Trace range analysis progress");
 DEFINE_FLAG(bool, truncating_left_shift, true,
     "Optimize left shift to truncate if possible");
 DEFINE_FLAG(bool, use_cha, true, "Use class hierarchy analysis.");
 DEFINE_FLAG(bool, trace_load_optimization, false,
     "Print live sets for load optimization pass.");
+DEFINE_FLAG(bool, enable_simd_inline, true,
+    "Enable inlining of SIMD related method calls.");
 DECLARE_FLAG(bool, eliminate_type_checks);
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, trace_type_check_elimination);
 
 
+static bool ShouldInlineSimd() {
+#if defined(TARGET_ARCH_MIPS)
+  return false;
+#endif
+  return FLAG_enable_simd_inline;
+}
+
+
 // Optimize instance calls using ICData.
 void FlowGraphOptimizer::ApplyICData() {
   VisitBlocks();
 }
 
 
 // Optimize instance calls using cid.
 // Attempts to convert an instance call (IC call) using propagated class-ids,
 // e.g., receiver class id, guarded-cid.
 void FlowGraphOptimizer::ApplyClassIds() {
@@ skipping 379 matching lines @@
 // Returns true if phi's representation was changed.
 static bool UnboxPhi(PhiInstr* phi) {
   Representation current = phi->representation();
   Representation unboxed = current;
 
   switch (phi->Type()->ToCid()) {
     case kDoubleCid:
       unboxed = kUnboxedDouble;
       break;
     case kFloat32x4Cid:
-      unboxed = kUnboxedFloat32x4;
+      if (ShouldInlineSimd()) {
+        unboxed = kUnboxedFloat32x4;
+      }
       break;
     case kUint32x4Cid:
-      unboxed = kUnboxedUint32x4;
+      if (ShouldInlineSimd()) {
+        unboxed = kUnboxedUint32x4;
+      }
       break;
   }
 
   if (unboxed != current) {
     phi->set_representation(unboxed);
     return true;
   }
 
   return false;
 }
@@ skipping 356 matching lines @@
     case kTypedDataFloat64ArrayCid: {
       // Check that value is always double.
       value_check = call->ic_data()->AsUnaryClassChecksForArgNr(2);
       if ((value_check.NumberOfChecks() != 1) ||
           (value_check.GetReceiverClassIdAt(0) != kDoubleCid)) {
         return false;
       }
       break;
     }
     case kTypedDataFloat32x4ArrayCid: {
+      if (!ShouldInlineSimd()) {
+        return false;
+      }
       // Check that value is always a Float32x4.
       value_check = call->ic_data()->AsUnaryClassChecksForArgNr(2);
       if ((value_check.NumberOfChecks() != 1) ||
           (value_check.GetReceiverClassIdAt(0) != kFloat32x4Cid)) {
           return false;
       }
     }
     break;
     default:
       // TODO(fschneider): Add support for other array types.
@@ skipping 112 matching lines @@
 bool FlowGraphOptimizer::TryReplaceWithLoadIndexed(InstanceCallInstr* call) {
   const intptr_t class_id = ReceiverClassId(call);
   // Set deopt_id to a valid id if the LoadIndexedInstr can cause deopt.
   intptr_t deopt_id = Isolate::kNoDeoptId;
   switch (class_id) {
     case kArrayCid:
     case kImmutableArrayCid:
     case kGrowableObjectArrayCid:
     case kTypedDataFloat32ArrayCid:
     case kTypedDataFloat64ArrayCid:
-    case kTypedDataFloat32x4ArrayCid:
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
     case kExternalTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid:
       break;
+    case kTypedDataFloat32x4ArrayCid:
+      if (!ShouldInlineSimd()) {
+        return false;
+      }
+      break;
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid: {
         if (!CanUnboxInt32()) return false;
 
         // Set deopt_id if we can optimistically assume that the result is Smi.
         // Assume mixed Mint/Smi if this instruction caused deoptimization once.
         ASSERT(call->HasICData());
         const ICData& ic_data = *call->ic_data();
         deopt_id = (ic_data.deopt_reason() == kDeoptUnknown) ?
             call->deopt_id() : Isolate::kNoDeoptId;
@@ skipping 150 matching lines @@
           new ShiftMintOpInstr(op_kind, new Value(left), new Value(right),
                                call->deopt_id());
       ReplaceCall(call, shift_op);
     } else {
       BinaryMintOpInstr* bin_op =
           new BinaryMintOpInstr(op_kind, new Value(left), new Value(right),
                                 call->deopt_id());
       ReplaceCall(call, bin_op);
     }
   } else if (operands_type == kFloat32x4Cid) {
-    // Type check left.
-    AddCheckClass(left,
-                  ICData::ZoneHandle(
-                      call->ic_data()->AsUnaryClassChecksForArgNr(0)),
-                  call->deopt_id(),
-                  call->env(),
-                  call);
-    // Type check right.
-    AddCheckClass(right,
-                  ICData::ZoneHandle(
-                      call->ic_data()->AsUnaryClassChecksForArgNr(1)),
-                  call->deopt_id(),
-                  call->env(),
-                  call);
-    // Replace call.
-    BinaryFloat32x4OpInstr* float32x4_bin_op =
-        new BinaryFloat32x4OpInstr(op_kind, new Value(left), new Value(right),
-                                   call->deopt_id());
-    ReplaceCall(call, float32x4_bin_op);
+    return InlineFloat32x4BinaryOp(call, op_kind);
   } else if (operands_type == kUint32x4Cid) {
-    // Type check left.
-    AddCheckClass(left,
-                  ICData::ZoneHandle(
-                      call->ic_data()->AsUnaryClassChecksForArgNr(0)),
-                  call->deopt_id(),
-                  call->env(),
-                  call);
-    // Type check right.
-    AddCheckClass(right,
-                  ICData::ZoneHandle(
-                      call->ic_data()->AsUnaryClassChecksForArgNr(1)),
-                  call->deopt_id(),
-                  call->env(),
-                  call);
-    // Replace call.
-    BinaryUint32x4OpInstr* uint32x4_bin_op =
-        new BinaryUint32x4OpInstr(op_kind, new Value(left), new Value(right),
-                                  call->deopt_id());
-    ReplaceCall(call, uint32x4_bin_op);
+    return InlineUint32x4BinaryOp(call, op_kind);
   } else if (op_kind == Token::kMOD) {
     // TODO(vegorov): implement fast path code for modulo.
     ASSERT(operands_type == kSmiCid);
     if (!right->IsConstant()) return false;
     const Object& obj = right->AsConstant()->value();
     if (!obj.IsSmi()) return false;
     const intptr_t value = Smi::Cast(obj).Value();
     if ((value <= 0) || !Utils::IsPowerOfTwo(value)) return false;
 
     // Insert smi check and attach a copy of the original environment
@@ skipping 275 matching lines @@
       return GrowableObjectArray::length_offset();
     default:
       UNREACHABLE();
       return 0;
   }
 }
 
 
 bool FlowGraphOptimizer::InlineFloat32x4Getter(InstanceCallInstr* call,
                                                MethodRecognizer::Kind getter) {
+  if (!ShouldInlineSimd()) {
+    return false;
+  }
   AddCheckClass(call->ArgumentAt(0),
                 ICData::ZoneHandle(
                     call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                 call->deopt_id(),
                 call->env(),
                 call);
   intptr_t mask = 0;
   if (getter == MethodRecognizer::kFloat32x4Shuffle) {
     ASSERT(call->ArgumentCount() == 2);
     // Extract shuffle mask.
@@ skipping 11 matching lines @@
       new Value(call->ArgumentAt(0)),
       mask,
       call->deopt_id());
   ReplaceCall(call, instr);
   return true;
 }
 
 
 bool FlowGraphOptimizer::InlineUint32x4Getter(InstanceCallInstr* call,
                                               MethodRecognizer::Kind getter) {
+  if (!ShouldInlineSimd()) {
+    return false;
+  }
   AddCheckClass(call->ArgumentAt(0),
                 ICData::ZoneHandle(
                     call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                 call->deopt_id(),
                 call->env(),
                 call);
   Uint32x4GetFlagInstr* instr = new Uint32x4GetFlagInstr(
       getter,
       new Value(call->ArgumentAt(0)),
       call->deopt_id());
   ReplaceCall(call, instr);
   return true;
 }
 
 
+bool FlowGraphOptimizer::InlineFloat32x4BinaryOp(InstanceCallInstr* call,
+                                                 Token::Kind op_kind) {
+  if (!ShouldInlineSimd()) {
+    return false;
+  }
+  ASSERT(call->ArgumentCount() == 2);
+  Definition* left = call->ArgumentAt(0);
+  Definition* right = call->ArgumentAt(1);
+  // Type check left.
+  AddCheckClass(left,
+                ICData::ZoneHandle(
+                    call->ic_data()->AsUnaryClassChecksForArgNr(0)),
+                call->deopt_id(),
+                call->env(),
+                call);
+  // Type check right.
+  AddCheckClass(right,
+                ICData::ZoneHandle(
+                    call->ic_data()->AsUnaryClassChecksForArgNr(1)),
+                call->deopt_id(),
+                call->env(),
+                call);
+  // Replace call.
+  BinaryFloat32x4OpInstr* float32x4_bin_op =
+      new BinaryFloat32x4OpInstr(op_kind, new Value(left), new Value(right),
+                                 call->deopt_id());
+  ReplaceCall(call, float32x4_bin_op);
+
+  return true;
+}
+
+
+bool FlowGraphOptimizer::InlineUint32x4BinaryOp(InstanceCallInstr* call,
+                                                Token::Kind op_kind) {
+  if (!ShouldInlineSimd()) {
+    return false;
+  }
+  ASSERT(call->ArgumentCount() == 2);
+  Definition* left = call->ArgumentAt(0);
+  Definition* right = call->ArgumentAt(1);
+  // Type check left.
+  AddCheckClass(left,
+                ICData::ZoneHandle(
+                    call->ic_data()->AsUnaryClassChecksForArgNr(0)),
+                call->deopt_id(),
+                call->env(),
+                call);
+  // Type check right.
+  AddCheckClass(right,
+                ICData::ZoneHandle(
+                    call->ic_data()->AsUnaryClassChecksForArgNr(1)),
+                call->deopt_id(),
+                call->env(),
+                call);
+  // Replace call.
+  BinaryUint32x4OpInstr* uint32x4_bin_op =
+      new BinaryUint32x4OpInstr(op_kind, new Value(left), new Value(right),
+                                call->deopt_id());
+  ReplaceCall(call, uint32x4_bin_op);
+  return true;
+}
+
+
 // Only unique implicit instance getters can be currently handled.
 bool FlowGraphOptimizer::TryInlineInstanceGetter(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback collected.
     return false;
   }
   Function& target = Function::Handle(ic_data.GetTargetAt(0));
   if (target.kind() == RawFunction::kImplicitGetter) {
@@ skipping 370 matching lines @@
     return TryInlineFloat32x4Method(call, recognized_kind);
   }
 
   if ((class_ids[0] == kUint32x4Cid) && (ic_data.NumberOfChecks() == 1)) {
     return TryInlineUint32x4Method(call, recognized_kind);
   }
   return false;
 }
 
 
+bool FlowGraphOptimizer::TryInlineFloat32x4Constructor(
+    StaticCallInstr* call,
+    MethodRecognizer::Kind recognized_kind) {
+  if (!ShouldInlineSimd()) {
+    return false;
+  }
+  if (recognized_kind == MethodRecognizer::kFloat32x4Zero) {
+    Float32x4ZeroInstr* zero = new Float32x4ZeroInstr(call->deopt_id());
+    ReplaceCall(call, zero);
+    return true;
+  } else if (recognized_kind == MethodRecognizer::kFloat32x4Splat) {
+    Float32x4SplatInstr* splat =
+        new Float32x4SplatInstr(new Value(call->ArgumentAt(1)),
+                                call->deopt_id());
+    ReplaceCall(call, splat);
+    return true;
+  } else if (recognized_kind == MethodRecognizer::kFloat32x4Constructor) {
+    Float32x4ConstructorInstr* con =
+        new Float32x4ConstructorInstr(new Value(call->ArgumentAt(1)),
+                                      new Value(call->ArgumentAt(2)),
+                                      new Value(call->ArgumentAt(3)),
+                                      new Value(call->ArgumentAt(4)),
+                                      call->deopt_id());
+    ReplaceCall(call, con);
+    return true;
+  }
+  return false;
+}
+
+
+bool FlowGraphOptimizer::TryInlineUint32x4Constructor(
+    StaticCallInstr* call,
+    MethodRecognizer::Kind recognized_kind) {
+  if (!ShouldInlineSimd()) {
+    return false;
+  }
+  if (recognized_kind == MethodRecognizer::kUint32x4BoolConstructor) {
+    Uint32x4BoolConstructorInstr* con = new Uint32x4BoolConstructorInstr(
+        new Value(call->ArgumentAt(1)),
+        new Value(call->ArgumentAt(2)),
+        new Value(call->ArgumentAt(3)),
+        new Value(call->ArgumentAt(4)),
+        call->deopt_id());
+    ReplaceCall(call, con);
+    return true;
+  }
+  return false;
+}
+
+
 bool FlowGraphOptimizer::TryInlineFloat32x4Method(
     InstanceCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
+  if (!ShouldInlineSimd()) {
+    return false;
+  }
   ASSERT(call->HasICData());
   switch (recognized_kind) {
     case MethodRecognizer::kFloat32x4Equal:
     case MethodRecognizer::kFloat32x4GreaterThan:
     case MethodRecognizer::kFloat32x4GreaterThanOrEqual:
     case MethodRecognizer::kFloat32x4LessThan:
     case MethodRecognizer::kFloat32x4LessThanOrEqual:
     case MethodRecognizer::kFloat32x4NotEqual: {
       Definition* left = call->ArgumentAt(0);
       Definition* right = call->ArgumentAt(1);
@@ skipping 136 matching lines @@
     }
     default:
       return false;
   }
 }
 
 
 bool FlowGraphOptimizer::TryInlineUint32x4Method(
     InstanceCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
+  if (!ShouldInlineSimd()) {
+    return false;
+  }
   ASSERT(call->HasICData());
   switch (recognized_kind) {
     case MethodRecognizer::kUint32x4Select: {
       Definition* mask = call->ArgumentAt(0);
       Definition* trueValue = call->ArgumentAt(1);
       Definition* falseValue = call->ArgumentAt(2);
       // Type check left.
       AddCheckClass(mask,
                     ICData::ZoneHandle(
                         call->ic_data()->AsUnaryClassChecksForArgNr(0)),
@@ skipping 46 matching lines @@
     default:
       return false;
   }
 }
 
 
 bool FlowGraphOptimizer::BuildByteArrayViewLoad(
     InstanceCallInstr* call,
     intptr_t receiver_cid,
     intptr_t view_cid) {
+  if ((view_cid == kTypedDataFloat32x4ArrayCid) && !ShouldInlineSimd()) {
+    return false;
+  }
+
   Definition* array = call->ArgumentAt(0);
   PrepareByteArrayViewOp(call, receiver_cid, view_cid, &array);
 
   // Optimistically build a smi-checked load for Int32 and Uint32
   // loads on ia32 like we do for normal array loads, and only revert to
   // mint case after deoptimizing here.
   intptr_t deopt_id = Isolate::kNoDeoptId;
   if ((view_cid == kTypedDataInt32ArrayCid ||
        view_cid == kTypedDataUint32ArrayCid) &&
       call->ic_data()->deopt_reason() == kDeoptUnknown) {
     deopt_id = call->deopt_id();
   }
   Definition* byte_index = call->ArgumentAt(1);
   LoadIndexedInstr* array_op = new LoadIndexedInstr(new Value(array),
                                                     new Value(byte_index),
                                                     1,  // Index scale.
                                                     view_cid,
                                                     deopt_id);
   ReplaceCall(call, array_op);
   return true;
 }
 
 
 bool FlowGraphOptimizer::BuildByteArrayViewStore(
     InstanceCallInstr* call,
     intptr_t receiver_cid,
     intptr_t view_cid) {
+  if ((view_cid == kTypedDataFloat32x4ArrayCid) && !ShouldInlineSimd()) {
+    return false;
+  }
   Definition* array = call->ArgumentAt(0);
   PrepareByteArrayViewOp(call, receiver_cid, view_cid, &array);
   ICData& value_check = ICData::ZoneHandle();
   switch (view_cid) {
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
     case kExternalTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
     case kTypedDataInt16ArrayCid:
@@ skipping 330 matching lines @@
 }
 
 
 void FlowGraphOptimizer::VisitStaticCall(StaticCallInstr* call) {
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(call->function());
   if (recognized_kind == MethodRecognizer::kMathSqrt) {
     MathSqrtInstr* sqrt =
         new MathSqrtInstr(new Value(call->ArgumentAt(0)), call->deopt_id());
     ReplaceCall(call, sqrt);
-  } else if (recognized_kind == MethodRecognizer::kFloat32x4Zero) {
-    Float32x4ZeroInstr* zero = new Float32x4ZeroInstr(call->deopt_id());
-    ReplaceCall(call, zero);
-  } else if (recognized_kind == MethodRecognizer::kFloat32x4Splat) {
-    Float32x4SplatInstr* splat =
-        new Float32x4SplatInstr(new Value(call->ArgumentAt(1)),
-                                call->deopt_id());
-    ReplaceCall(call, splat);
-  } else if (recognized_kind == MethodRecognizer::kFloat32x4Constructor) {
-    Float32x4ConstructorInstr* con =
-        new Float32x4ConstructorInstr(new Value(call->ArgumentAt(1)),
-                                      new Value(call->ArgumentAt(2)),
-                                      new Value(call->ArgumentAt(3)),
-                                      new Value(call->ArgumentAt(4)),
-                                      call->deopt_id());
-    ReplaceCall(call, con);
+  } else if ((recognized_kind == MethodRecognizer::kFloat32x4Zero) ||
+             (recognized_kind == MethodRecognizer::kFloat32x4Splat) ||
+             (recognized_kind == MethodRecognizer::kFloat32x4Constructor)) {
+    TryInlineFloat32x4Constructor(call, recognized_kind);
   } else if (recognized_kind == MethodRecognizer::kUint32x4BoolConstructor) {
-    Uint32x4BoolConstructorInstr* con = new Uint32x4BoolConstructorInstr(
-        new Value(call->ArgumentAt(1)),
-        new Value(call->ArgumentAt(2)),
-        new Value(call->ArgumentAt(3)),
-        new Value(call->ArgumentAt(4)),
-        call->deopt_id());
-    ReplaceCall(call, con);
+    TryInlineUint32x4Constructor(call, recognized_kind);
   } else if (recognized_kind == MethodRecognizer::kObjectConstructor) {
     // Remove the original push arguments.
     for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
       PushArgumentInstr* push = call->PushArgumentAt(i);
       push->ReplaceUsesWith(push->value()->definition());
       push->RemoveFromGraph();
     }
     // Manually replace call with global null constant. ReplaceCall can't
     // be used for definitions that are already in the graph.
     call->ReplaceUsesWith(flow_graph_->constant_null());
@@ skipping 4704 matching lines @@
 
   // Insert materializations at environment uses.
   const Class& cls = Class::Handle(alloc->constructor().Owner());
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, cls, *fields);
   }
 }
 
 
 }  // namespace dart