[Turbofan] Make the -0 deopt case more efficient in multiplication.

test/unittests/compiler/machine-operator-reducer-unittest.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/machine-operator-reducer.h"
 #include "src/base/bits.h"
 #include "src/base/division-by-constant.h"
 #include "src/base/ieee754.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/typer.h"
@@ skipping 271 matching lines @@
 TEST_F(MachineOperatorReducerTest,
        ChangeFloat64ToInt32WithChangeInt32ToFloat64) {
   Node* value = Parameter(0);
   Reduction reduction = Reduce(graph()->NewNode(
       machine()->ChangeFloat64ToInt32(),
       graph()->NewNode(machine()->ChangeInt32ToFloat64(), value)));
   ASSERT_TRUE(reduction.Changed());
   EXPECT_EQ(value, reduction.replacement());
 }
 
-
 TEST_F(MachineOperatorReducerTest, ChangeFloat64ToInt32WithConstant) {
   TRACED_FOREACH(int32_t, x, kInt32Values) {
     Reduction reduction = Reduce(graph()->NewNode(
         machine()->ChangeFloat64ToInt32(), Float64Constant(FastI2D(x))));
     ASSERT_TRUE(reduction.Changed());
     EXPECT_THAT(reduction.replacement(), IsInt32Constant(x));
   }
 }
 
 
@@ skipping 1196 matching lines @@
                   IsInt32Constant(base::bits::SignedMulOverflow32(x, y, &z)));
 
       r = Reduce(graph()->NewNode(common()->Projection(0), mul, control));
       ASSERT_TRUE(r.Changed());
       EXPECT_THAT(r.replacement(), IsInt32Constant(z));
     }
   }
 }
 
 // -----------------------------------------------------------------------------
+// Int32LessThan
+
+TEST_F(MachineOperatorReducerTest, Int32LessThanWithWord32Or) {
+  // Node* control = graph()->start();

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

Nit: Remove this line.

+  Node* const p0 = Parameter(0);
+  TRACED_FOREACH(int32_t, x, kInt32Values) {
+    Node* word32_or =
+        graph()->NewNode(machine()->Word32Or(), p0, Int32Constant(x));
+    Node* less_than = graph()->NewNode(machine()->Int32LessThan(), word32_or,
+                                       Int32Constant(0));
+    Reduction r = Reduce(less_than);
+    if (x < 0) {
+      ASSERT_TRUE(r.Changed());
+      EXPECT_THAT(r.replacement(), IsInt32Constant(1));
+    } else {
+      ASSERT_FALSE(r.Changed());
+    }
+  }
+}
+
+// -----------------------------------------------------------------------------
 // Uint32LessThan
 
 TEST_F(MachineOperatorReducerTest, Uint32LessThanWithWord32Sar) {
   Node* const p0 = Parameter(0);
   TRACED_FORRANGE(uint32_t, shift, 1, 3) {
     const uint32_t limit = (kMaxInt >> shift) - 1;
     Node* const node = graph()->NewNode(
         machine()->Uint32LessThan(),
         graph()->NewNode(machine()->Word32Sar(), p0, Uint32Constant(shift)),
         Uint32Constant(limit));
@@ skipping 511 matching lines @@
     Reduction r = Reduce(node);
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(r.replacement(),
                 IsStore(rep, base, index, value, effect, control));
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8