Optimize the multiplication of two 32-bit unsigned integers.

runtime/vm/flow_graph_optimizer.cc

Index: runtime/vm/flow_graph_optimizer.cc
===================================================================
--- runtime/vm/flow_graph_optimizer.cc	(revision 38362)
+++ runtime/vm/flow_graph_optimizer.cc	(working copy)
@@ -2020,6 +2020,7 @@
   switch (op_kind) {
     case Token::kADD:
     case Token::kSUB:
+    case Token::kMUL:
       if (HasOnlyTwoOf(ic_data, kSmiCid)) {
         // Don't generate smi code if the IC data is marked because
         // of an overflow.
@@ -2037,6 +2038,7 @@
       } else if (HasOnlyTwoOf(ic_data, kFloat32x4Cid)) {
         operands_type = kFloat32x4Cid;
       } else if (HasOnlyTwoOf(ic_data, kInt32x4Cid)) {
+        ASSERT(op_kind != Token::kMUL);

[srdjan, 2014/07/18 16:32:54]

Why can this be guaranteed?

[Cutch, 2014/07/18 16:39:39]

Because Int32x4 doesn't have a multiply operation.

[regis, 2014/07/18 17:59:43]

I have added a comment.

         operands_type = kInt32x4Cid;
       } else if (HasOnlyTwoOf(ic_data, kFloat64x2Cid)) {
         operands_type = kFloat64x2Cid;
@@ -2044,23 +2046,6 @@
         return false;
       }
       break;
-    case Token::kMUL:
-      if (HasOnlyTwoOf(ic_data, kSmiCid)) {
-        // Don't generate smi code if the IC data is marked because of an
-        // overflow.
-        // TODO(fschneider): Add unboxed mint multiplication.
-        if (ic_data.HasDeoptReason(ICData::kDeoptBinarySmiOp)) return false;
-        operands_type = kSmiCid;
-      } else if (ShouldSpecializeForDouble(ic_data)) {
-        operands_type = kDoubleCid;
-      } else if (HasOnlyTwoOf(ic_data, kFloat32x4Cid)) {
-        operands_type = kFloat32x4Cid;
-      } else if (HasOnlyTwoOf(ic_data, kFloat64x2Cid)) {
-        operands_type = kFloat64x2Cid;
-      } else {
-        return false;
-      }
-      break;
     case Token::kDIV:
       if (ShouldSpecializeForDouble(ic_data) ||
           HasOnlyTwoOf(ic_data, kSmiCid)) {