Inline Float32x4 Getters

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 1375 matching lines @@
       return TypedData::length_offset();
     case MethodRecognizer::kGrowableArrayLength:
       return GrowableObjectArray::length_offset();
     default:
       UNREACHABLE();
       return 0;
   }
 }
 
 
+bool FlowGraphOptimizer::InlineFloat32x4Getter(InstanceCallInstr* call,
+                                               MethodRecognizer::Kind getter) {
+  AddCheckClass(call->ArgumentAt(0),
+                ICData::ZoneHandle(
+                      call->ic_data()->AsUnaryClassChecksForArgNr(0)),

[srdjan, 2013/04/22 22:28:18]

indent of 4 chars

[Cutch, 2013/04/22 23:05:41]

Done.

+                call->deopt_id(),
+                call->env(),
+                call);
+  Float32x4ShuffleInstr* instr = new Float32x4ShuffleInstr(
+      getter,
+      new Value(call->ArgumentAt(0)),
+      call);
+  ReplaceCall(call, instr);
+  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 41 matching lines @@
       }
       InlineStringLengthGetter(call);
       return true;
     case MethodRecognizer::kStringBaseIsEmpty:
       if (!ic_data.HasOneTarget()) {
         // Target is not only StringBase_get_isEmpty.
         return false;
       }
       InlineStringIsEmptyGetter(call);
       return true;
+    case MethodRecognizer::kFloat32x4ShuffleXXXX:
+    case MethodRecognizer::kFloat32x4ShuffleYYYY:
+    case MethodRecognizer::kFloat32x4ShuffleZZZZ:
+    case MethodRecognizer::kFloat32x4ShuffleWWWW:
+    case MethodRecognizer::kFloat32x4ShuffleX:
+    case MethodRecognizer::kFloat32x4ShuffleY:
+    case MethodRecognizer::kFloat32x4ShuffleZ:
+    case MethodRecognizer::kFloat32x4ShuffleW:
+      if (!ic_data.HasReceiverClassId(kFloat32x4Cid) ||
+          !ic_data.HasOneTarget()) {
+        return false;
+      }
+      return InlineFloat32x4Getter(call, recognized_kind);
     default:
       ASSERT(recognized_kind == MethodRecognizer::kUnknown);
   }
   return false;
 }
 
 
 LoadIndexedInstr* FlowGraphOptimizer::BuildStringCodeUnitAt(
     InstanceCallInstr* call,
     intptr_t cid) {
@@ skipping 3028 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::VisitFloat32x4Shuffle(Float32x4ShuffleInstr* instr) {
+  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