Optimize the multiplication of two 32-bit unsigned integers.

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 2002 matching lines @@
 
 
 bool FlowGraphOptimizer::TryReplaceWithBinaryOp(InstanceCallInstr* call,
                                                 Token::Kind op_kind) {
   intptr_t operands_type = kIllegalCid;
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   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.
         operands_type = ic_data.HasDeoptReason(ICData::kDeoptBinarySmiOp)
             ? 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.HasDeoptReason(ICData::kDeoptBinaryMintOp)) return false;
         operands_type = kMintCid;
       } else if (ShouldSpecializeForDouble(ic_data)) {
         operands_type = kDoubleCid;
       } else if (HasOnlyTwoOf(ic_data, kFloat32x4Cid)) {
         operands_type = kFloat32x4Cid;
       } else if (HasOnlyTwoOf(ic_data, kInt32x4Cid)) {
+        ASSERT(op_kind != Token::kMUL);
         operands_type = kInt32x4Cid;
       } else if (HasOnlyTwoOf(ic_data, kFloat64x2Cid)) {
         operands_type = kFloat64x2Cid;
       } else {
         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;
+      // The binary mint multiplication only supports uint32 as inputs.
+      if ((operands_type == kMintCid) && (op_kind == Token::kMUL)) {
+        ASSERT(call->ArgumentCount() == 2);
+        Definition* left_input = call->ArgumentAt(0);
+        Definition* right_input = call->ArgumentAt(1);
+        ASSERT(left_input != NULL);
+        ASSERT(right_input != NULL);
+        Range* left_range = left_input->range();
+        Range* right_range = right_input->range();
+        if ((left_range == NULL) ||

[Vyacheslav Egorov (Google), 2014/07/16 23:51:35]

Unfortunately range information is not available at this point yet so this check
would always fail. You would have to resort for runtime check.

[regis, 2014/07/18 02:44:57]

You are right. I removed this range check.

+            !left_range->IsWithin(0, static_cast<int64_t>(kMaxUint32)) ||
+            (right_range == NULL) ||
+            !right_range->IsWithin(0, static_cast<int64_t>(kMaxUint32))) {
+          return false;
+        }
       }
       break;
     case Token::kDIV:
       if (ShouldSpecializeForDouble(ic_data) ||
           HasOnlyTwoOf(ic_data, kSmiCid)) {
         operands_type = kDoubleCid;
       } else if (HasOnlyTwoOf(ic_data, kFloat32x4Cid)) {
         operands_type = kFloat32x4Cid;
       } else if (HasOnlyTwoOf(ic_data, kFloat64x2Cid)) {
         operands_type = kFloat64x2Cid;
@@ skipping 8053 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart