[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 LowerToCheckedInt32MulWithOverflowOp(Node* node, Truncation truncation,

[Benedikt Meurer, 2016/07/18 08:55:38]

Nit: Just LowerToCheckedInt32Mul.

+                                            Type* input0_type,
+                                            Type* input1_type) {
+    // 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() ||
+                (input0_type->Is(Type::OrderedNumber()) &&
+                 input0_type->Min() > 0) ||
+                (input1_type->Is(Type::OrderedNumber()) &&
+                 input1_type->Min() > 0)
+            ? CheckForMinusZeroMode::kDontCheckForMinusZero
+            : CheckForMinusZeroMode::kCheckForMinusZero;
+
+    NodeProperties::ChangeOp(node, simplified()->CheckedInt32Mul(mz_mode));
+  }
+
   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 236 matching lines @@
           // (a) the output is either known to be Signed32, or
           // (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());
+        Type* input0_type = TypeOf(node->InputAt(0));
+        Type* input1_type = TypeOf(node->InputAt(1));
 
         // 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()) {
+              LowerToCheckedInt32MulWithOverflowOp(node, truncation,
+                                                   input0_type, input1_type);
+            }
             return;
           }
         }
 
         if (hint == BinaryOperationHints::kSignedSmall ||
             hint == BinaryOperationHints::kSigned32) {
           VisitBinop(node, UseInfo::CheckedSigned32AsWord32(),
                      MachineRepresentation::kWord32, Type::Signed32());
-          if (lower()) ChangeToInt32OverflowOp(node);
+          if (lower()) {
+            LowerToCheckedInt32MulWithOverflowOp(node, truncation, input0_type,
+                                                 input1_type);
+          }
           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