Lower NumberMultiply, NumberDivide, and NumberModulus to Int32Mul, Int32[U]Div, and Int32[U]Mod whe…

src/compiler/simplified-lowering.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/simplified-lowering.h"
 
 #include "src/base/bits.h"
 #include "src/code-factory.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph-inl.h"
+#include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/representation-change.h"
 #include "src/compiler/simplified-lowering.h"
 #include "src/compiler/simplified-operator.h"
 #include "src/objects.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
@@ skipping 323 matching lines @@
   }
 
   const Operator* Uint32Op(Node* node) {
     return changer_->Uint32OperatorFor(node->opcode());
   }
 
   const Operator* Float64Op(Node* node) {
     return changer_->Float64OperatorFor(node->opcode());
   }
 
+  bool CanBeInt32Binop(Node* node, MachineTypeUnion use) {

[Michael Starzinger, 2014/10/01 21:11:32]

I find the "CanBe" prefix confusing in this setting, I assume it is meant to
indicate "can be lowered to"? Could we instead just call it "IsInt32Binop"?

[Michael Starzinger, 2014/10/01 21:15:57]

Alternatively "CanBecome" would also work for me.

+    return BothInputsAre(node, Type::Signed32()) && !CanObserveNonInt32(use);
+  }
+
+  bool CanBeUint32Binop(Node* node, MachineTypeUnion use) {

[Michael Starzinger, 2014/10/01 21:11:32]

Likewise.

+    return BothInputsAre(node, Type::Unsigned32()) && !CanObserveNonUint32(use);
+  }
+
+  bool CanObserveNonInt32(MachineTypeUnion use) {
+    return (use & (kTypeUint32 | kTypeNumber | kTypeAny)) != 0;
+  }
+
+  bool CanObserveNonUint32(MachineTypeUnion use) {
+    return (use & (kTypeInt32 | kTypeNumber | kTypeAny)) != 0;
+  }
+
   // Dispatching routine for visiting the node {node} with the usage {use}.
   // Depending on the operator, propagate new usage info to the inputs.
   void VisitNode(Node* node, MachineTypeUnion use,
                  SimplifiedLowering* lowering) {
     switch (node->opcode()) {
       //------------------------------------------------------------------
       // Common operators.
       //------------------------------------------------------------------
       case IrOpcode::kStart:
       case IrOpcode::kDead:
@@ skipping 104 matching lines @@
           // => Float64Cmp
           VisitFloat64Cmp(node);
           if (lower()) node->set_op(Float64Op(node));
         }
         break;
       }
       case IrOpcode::kNumberAdd:
       case IrOpcode::kNumberSubtract: {
         // Add and subtract reduce to Int32Add/Sub if the inputs
         // are already integers and all uses are truncating.
-        if (BothInputsAre(node, Type::Signed32()) &&
-            (use & (kTypeUint32 | kTypeNumber | kTypeAny)) == 0) {
+        if (CanBeInt32Binop(node, use)) {
           // => signed Int32Add/Sub
           VisitInt32Binop(node);
           if (lower()) node->set_op(Int32Op(node));
-        } else if (BothInputsAre(node, Type::Unsigned32()) &&
-                   (use & (kTypeInt32 | kTypeNumber | kTypeAny)) == 0) {
+        } else if (CanBeUint32Binop(node, use)) {
           // => unsigned Int32Add/Sub
           VisitUint32Binop(node);
           if (lower()) node->set_op(Uint32Op(node));
         } else {
           // => Float64Add/Sub
           VisitFloat64Binop(node);
           if (lower()) node->set_op(Float64Op(node));
         }
         break;
       }
-      case IrOpcode::kNumberMultiply:
-      case IrOpcode::kNumberDivide:
-      case IrOpcode::kNumberModulus: {
-        // Float64Mul/Div/Mod
+      case IrOpcode::kNumberMultiply: {
+        NumberMatcher right(node->InputAt(1));
+        if (right.IsInRange(-1048576, 1048576)) {  // must fit double mantissa.
+          if (CanBeInt32Binop(node, use)) {
+            // => signed Int32Mul
+            VisitInt32Binop(node);
+            if (lower()) node->set_op(Int32Op(node));
+            break;
+          }
+        }
+        // => Float64Mul
         VisitFloat64Binop(node);
         if (lower()) node->set_op(Float64Op(node));
         break;
+      }
+      case IrOpcode::kNumberDivide: {
+        NumberMatcher right(node->InputAt(1));
+        if (right.HasValue() && !right.Is(0) && !right.Is(-1)) {
+          if (CanBeInt32Binop(node, use)) {
+            // => signed Int32Div
+            VisitInt32Binop(node);
+            if (lower()) node->set_op(Int32Op(node));
+            break;
+          } else if (CanBeUint32Binop(node, use)) {
+            // => unsigned Uint32Div
+            VisitUint32Binop(node);
+            if (lower()) node->set_op(Uint32Op(node));
+            break;
+          }
+        }
+        // => Float64Div
+        VisitFloat64Binop(node);
+        if (lower()) node->set_op(Float64Op(node));
+        break;
+      }
+      case IrOpcode::kNumberModulus: {
+        NumberMatcher right(node->InputAt(1));
+        if (right.HasValue() && !right.Is(0) && !right.Is(-1)) {
+          if (BothInputsAre(node, Type::Signed32())) {
+            // => signed Int32Mod
+            VisitInt32Binop(node);
+            if (lower()) node->set_op(Int32Op(node));
+            break;
+          } else if (BothInputsAre(node, Type::Unsigned32())) {
+            // => unsigned Uint32Mod
+            VisitUint32Binop(node);
+            if (lower()) node->set_op(Uint32Op(node));
+            break;
+          }
+        }
+        // => Float64Mod
+        VisitFloat64Binop(node);
+        if (lower()) node->set_op(Float64Op(node));
+        break;
       }
       case IrOpcode::kNumberToInt32: {
         MachineTypeUnion use_rep = use & kRepMask;
         if (lower()) {
           MachineTypeUnion in = GetInfo(node->InputAt(0))->output;
           if ((in & kTypeMask) == kTypeInt32 || (in & kRepMask) == kRepWord32) {
             // If the input has type int32, or is already a word32, just change
             // representation if necessary.
             VisitUnop(node, kTypeInt32 | use_rep, kTypeInt32 | use_rep);
             DeferReplacement(node, node->InputAt(0));
@@ skipping 456 matching lines @@
 void SimplifiedLowering::DoStringLessThanOrEqual(Node* node) {
   node->set_op(machine()->IntLessThanOrEqual());
   node->ReplaceInput(0, StringComparison(node, true));
   node->ReplaceInput(1, jsgraph()->SmiConstant(EQUAL));
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8