[Turbofan]: Eliminate the check for -0 if it's not possible/observable.

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 <limits>
 
 #include "src/address-map.h"
 #include "src/base/bits.h"
@@ skipping 1059 matching lines @@
     return WriteBarrierKindFor(base_taggedness, field_representation,
                                field_type, value);
   }
 
   Graph* graph() const { return jsgraph_->graph(); }
   CommonOperatorBuilder* common() const { return jsgraph_->common(); }
   SimplifiedOperatorBuilder* simplified() const {
     return jsgraph_->simplified();
   }
 
+  void ChangeToInt32MulWithOverflowOp(Node* node, CheckForMinusZeroMode kMode) {
+    NodeProperties::ChangeOp(node, simplified()->CheckedInt32Mul(kMode));
+  }
+
   void ChangeToInt32OverflowOp(Node* node) {
     NodeProperties::ChangeOp(node, Int32OverflowOp(node));
   }
 
   void ChangeToUint32OverflowOp(Node* node) {
     NodeProperties::ChangeOp(node, Uint32OverflowOp(node));
   }
 
   void VisitSpeculativeAdditiveOp(Node* node, Truncation truncation,
                                   SimplifiedLowering* lowering) {
@@ skipping 237 matching lines @@
           // (b) the output is known to be Unsigned32, or
           // (c) the uses are truncating and the result is in the safe
           //     integer range.
           VisitWord32TruncatingBinop(node);
           if (lower()) ChangeToPureOp(node, Int32Op(node));
           return;
         }
         // Try to use type feedback.
         BinaryOperationHints::Hint hint = BinaryOperationHintOf(node->op());
 
+        // Determine if one of the inputs is a constant integer > 0.
+        Type* input0_type = NodeProperties::GetType(node->InputAt(0));
+        Type* input1_type = NodeProperties::GetType(node->InputAt(1));

[Jarin, 2016/07/17 18:24:41]

You can use TypeOf here (instead of NodeProperties::GetType).

[mvstanton, 2016/07/18 08:48:58]

Done.

+        bool positive_range = false;
+        if ((input0_type->IsRange() && input0_type->AsRange()->Min() > 0) ||
+            (input1_type->IsRange() && input1_type->AsRange()->Min() > 0)) {

[Jarin, 2016/07/17 16:37:47]

Maybe it is better to not refer to ranges here and just say:

type->Is(Type::OrderedNumber()) && type->Min() > 0

[Benedikt Meurer, 2016/07/17 17:44:07]

Yes, please. And I'd prefer to have this inline below instead of the bool
variable.

[mvstanton, 2016/07/18 08:48:58]

No problemo

[mvstanton, 2016/07/18 08:48:58]

Done.

+          positive_range = true;
+        }
+
+        // If one of the inputs is positive and/or truncation is being applied,
+        // there is no need to return -0.
+        CheckForMinusZeroMode mz_mode =
+            (truncation.TruncatesToWord32() || positive_range)
+                ? CheckForMinusZeroMode::kDontCheckForMinusZero
+                : CheckForMinusZeroMode::kCheckForMinusZero;

[Jarin, 2016/07/17 18:24:41]

Looking at this again, this logic is only used when lowering and only if we are
changing to Int32MulWithOverflow.

Perhaps it would be better to move this into ChangeToInt32MulWithOverflowOp?
(And perhaps rename to LowerToInt32MulWithOverflow.)

WDYT?

[mvstanton, 2016/07/18 08:48:58]

Good idea, done!

+
         // Handle the case when no int32 checks on inputs are necessary
         // (but an overflow check is needed on the output).
         if (BothInputsAre(node, Type::Signed32())) {
           // If both the inputs the feedback are int32, use the overflow op.
           if (hint == BinaryOperationHints::kSignedSmall ||
               hint == BinaryOperationHints::kSigned32) {
             VisitBinop(node, UseInfo::TruncatingWord32(),
                        MachineRepresentation::kWord32, Type::Signed32());
-            if (lower()) ChangeToInt32OverflowOp(node);
+            if (lower()) ChangeToInt32MulWithOverflowOp(node, mz_mode);
             return;
           }
         }
 
         if (hint == BinaryOperationHints::kSignedSmall ||
             hint == BinaryOperationHints::kSigned32) {
           VisitBinop(node, UseInfo::CheckedSigned32AsWord32(),
                      MachineRepresentation::kWord32, Type::Signed32());
-          if (lower()) ChangeToInt32OverflowOp(node);
+          if (lower()) ChangeToInt32MulWithOverflowOp(node, mz_mode);
           return;
         }
 
         // Checked float64 x float64 => float64
         VisitBinop(node, UseInfo::CheckedNumberOrOddballAsFloat64(),
                    MachineRepresentation::kFloat64, Type::Number());
         if (lower()) ChangeToPureOp(node, Float64Op(node));
         return;
       }
       case IrOpcode::kNumberMultiply: {
@@ skipping 1981 matching lines @@
         isolate(), graph()->zone(), callable.descriptor(), 0, flags,
         Operator::kNoProperties);
     to_number_operator_.set(common()->Call(desc));
   }
   return to_number_operator_.get();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8