Inline binary Float32x4 ops.

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/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 513 matching lines @@
       && ic_data.HasReceiverClassId(kSmiCid)
       && ic_data.HasReceiverClassId(kMintCid);
 }
 
 
 static bool HasOnlyTwoSmis(const ICData& ic_data) {
   return (ic_data.NumberOfChecks() == 1) &&
       ICDataHasReceiverArgumentClassIds(ic_data, kSmiCid, kSmiCid);
 }
 
+static bool HasOnlyTwoFloat32x4s(const ICData& ic_data) {
+  return (ic_data.NumberOfChecks() == 1) &&
+      ICDataHasReceiverArgumentClassIds(ic_data, kFloat32x4Cid, kFloat32x4Cid);
+}
+
 
 // Returns false if the ICData contains anything other than the 4 combinations
 // of Mint and Smi for the receiver and argument classes.
 static bool HasTwoMintOrSmi(const ICData& ic_data) {
   GrowableArray<intptr_t> class_ids(2);
   class_ids.Add(kSmiCid);
   class_ids.Add(kMintCid);
   return ICDataHasOnlyReceiverArgumentClassIds(ic_data, class_ids, class_ids);
 }
 
@@ skipping 414 matching lines @@
             ? kMintCid
             : kSmiCid;
       } else if (HasTwoMintOrSmi(ic_data) &&
                  FlowGraphCompiler::SupportsUnboxedMints()) {
         // Don't generate mint code if the IC data is marked because of an
         // overflow.
         if (ic_data.deopt_reason() == kDeoptBinaryMintOp) return false;
         operands_type = kMintCid;
       } else if (ShouldSpecializeForDouble(ic_data)) {
         operands_type = kDoubleCid;
+      } else if (HasOnlyTwoFloat32x4s(ic_data)) {
+        operands_type = kFloat32x4Cid;
       } else {
         return false;
       }
       break;
     case Token::kMUL:
       if (HasOnlyTwoSmis(ic_data)) {
         // Don't generate smi code if the IC data is marked because of an
         // overflow.
         // TODO(fschneider): Add unboxed mint multiplication.
         if (ic_data.deopt_reason() == kDeoptBinarySmiOp) return false;
         operands_type = kSmiCid;
       } else if (ShouldSpecializeForDouble(ic_data)) {
         operands_type = kDoubleCid;
+      } else if (HasOnlyTwoFloat32x4s(ic_data)) {
+        operands_type = kFloat32x4Cid;
       } else {
         return false;
       }
       break;
     case Token::kDIV:
       if (ShouldSpecializeForDouble(ic_data)) {
         operands_type = kDoubleCid;
+      } else if (HasOnlyTwoFloat32x4s(ic_data)) {
+        operands_type = kFloat32x4Cid;
       } else {
         return false;
       }
       break;
     case Token::kMOD:
       if (HasOnlyTwoSmis(ic_data)) {
         operands_type = kSmiCid;
       } else {
         return false;
       }
@@ skipping 66 matching lines @@
       ShiftMintOpInstr* shift_op =
           new ShiftMintOpInstr(op_kind, new Value(left), new Value(right),
                                call);
       ReplaceCall(call, shift_op);
     } else {
       BinaryMintOpInstr* bin_op =
           new BinaryMintOpInstr(op_kind, new Value(left), new Value(right),
                                 call);
       ReplaceCall(call, bin_op);
     }
+  } else if (operands_type == kFloat32x4Cid) {
+    BinaryFloat32x4OpInstr* float32x4_bin_op =
+        new BinaryFloat32x4OpInstr(op_kind, new Value(left), new Value(right),
+                                   call);
+    ReplaceCall(call, float32x4_bin_op);

[Vyacheslav Egorov (Google), 2013/04/15 11:09:35]

You also need to emit CheckClass here just like you do for the store into typed
data.

[Cutch, 2013/04/15 13:34:56]

Done.

   } 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 3308 matching lines @@
   const Object& right = instr->right()->definition()->constant_value();
   if (IsNonConstant(left) || IsNonConstant(right)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(left) && IsConstant(right)) {
     // TODO(kmillikin): Handle binary operation.
     SetValue(instr, non_constant_);
   }
 }
 
 
+void ConstantPropagator::VisitBinaryFloat32x4Op(
+    BinaryFloat32x4OpInstr* instr) {
+  const Object& left = instr->left()->definition()->constant_value();
+  const Object& right = instr->right()->definition()->constant_value();
+  if (IsNonConstant(left) || IsNonConstant(right)) {
+    SetValue(instr, non_constant_);
+  } else if (IsConstant(left) && IsConstant(right)) {
+    // TODO(kmillikin): Handle binary operation.
+    SetValue(instr, non_constant_);
+  }
+}
+
+
 void ConstantPropagator::VisitMathSqrt(MathSqrtInstr* instr) {
   const Object& value = instr->value()->definition()->constant_value();
   if (IsNonConstant(value)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(value)) {
     // TODO(kmillikin): Handle sqrt.
     SetValue(instr, non_constant_);
   }
 }
 
@@ skipping 604 matching lines @@
   if (changed) {
     // We may have changed the block order and the dominator tree.
     flow_graph->DiscoverBlocks();
     GrowableArray<BitVector*> dominance_frontier;
     flow_graph->ComputeDominators(&dominance_frontier);
   }
 }
 
 
 }  // namespace dart