Inline Int32x4 constructor

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/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 594 matching lines @@
            (use->Type()->ToCid() == kUnboxedMint));
     const intptr_t deopt_id = (deopt_target != NULL) ?
         deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
     converted = new(I) UnboxIntegerInstr(use->CopyWithType(), deopt_id);
   } else if ((from == kUnboxedMint) && (to == kTagged)) {
     converted = new(I) BoxIntegerInstr(use->CopyWithType());
   } else if ((from == kUnboxedMint) && (to == kUnboxedUint32)) {
     converted = new(I) UnboxedIntConverterInstr(from, to, use->CopyWithType());
   } else if ((from == kUnboxedUint32) && (to == kUnboxedMint)) {
     converted = new(I) UnboxedIntConverterInstr(from, to, use->CopyWithType());
+  } else if ((from == kTagged) && (to == kUnboxedUint32)) {
+    const intptr_t deopt_id = (deopt_target != NULL) ?
+        deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
+    converted = new UnboxUint32Instr(use->CopyWithType(), deopt_id);
   } else if (from == kUnboxedMint && to == kUnboxedDouble) {
     ASSERT(CanUnboxDouble());
     // Convert by boxing/unboxing.
     // TODO(fschneider): Implement direct unboxed mint-to-double conversion.
     BoxIntegerInstr* boxed =
         new(I) BoxIntegerInstr(use->CopyWithType());
     use->BindTo(boxed);
     InsertBefore(insert_before, boxed, NULL, FlowGraph::kValue);
 
     const intptr_t deopt_id = (deopt_target != NULL) ?
@@ skipping 2601 matching lines @@
             new(I) Value(call->ArgumentAt(4)),
             call->deopt_id());
     ReplaceCall(call, con);
     return true;
   } else if (recognized_kind == MethodRecognizer::kInt32x4FromFloat32x4Bits) {
     Float32x4ToInt32x4Instr* cast =
         new(I) Float32x4ToInt32x4Instr(
             new(I) Value(call->ArgumentAt(1)), call->deopt_id());
     ReplaceCall(call, cast);
     return true;
+  } else if (recognized_kind == MethodRecognizer::kInt32x4Constructor) {
+    Int32x4ConstructorInstr* con =
+        new(I) Int32x4ConstructorInstr(
+            new(I) Value(call->ArgumentAt(1)),
+            new(I) Value(call->ArgumentAt(2)),
+            new(I) Value(call->ArgumentAt(3)),
+            new(I) 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;
@@ skipping 1022 matching lines @@
   } else if ((recognized_kind == MethodRecognizer::kFloat32x4Zero) ||
              (recognized_kind == MethodRecognizer::kFloat32x4Splat) ||
              (recognized_kind == MethodRecognizer::kFloat32x4Constructor) ||
              (recognized_kind == MethodRecognizer::kFloat32x4FromFloat64x2)) {
     TryInlineFloat32x4Constructor(call, recognized_kind);
   } else if ((recognized_kind == MethodRecognizer::kFloat64x2Constructor) ||
              (recognized_kind == MethodRecognizer::kFloat64x2Zero) ||
              (recognized_kind == MethodRecognizer::kFloat64x2Splat) ||
              (recognized_kind == MethodRecognizer::kFloat64x2FromFloat32x4)) {
     TryInlineFloat64x2Constructor(call, recognized_kind);
-  } else if (recognized_kind == MethodRecognizer::kInt32x4BoolConstructor) {
+  } else if ((recognized_kind == MethodRecognizer::kInt32x4BoolConstructor) ||
+             (recognized_kind == MethodRecognizer::kInt32x4Constructor)) {
     TryInlineInt32x4Constructor(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.
@@ skipping 3802 matching lines @@
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitFloat32x4ToInt32x4(
     Float32x4ToInt32x4Instr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
+void ConstantPropagator::VisitInt32x4Constructor(
+    Int32x4ConstructorInstr* instr) {
+  SetValue(instr, non_constant_);
+}
+
+
 void ConstantPropagator::VisitInt32x4BoolConstructor(
     Int32x4BoolConstructorInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitInt32x4GetFlag(Int32x4GetFlagInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
@@ skipping 1427 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart