[compiler] merge binary-operator-reducer

src/compiler/machine-operator-reducer.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/codegen.h"
 #include "src/compiler/diamond.h"
@@ skipping 332 matching lines @@
         NodeProperties::ChangeOp(node, machine()->Float64Sub());
         return Changed(node);
       }
       if (m.right().Is(1)) return Replace(m.left().node());  // x * 1.0 => x
       if (m.right().IsNaN()) {                               // x * NaN => NaN
         return Replace(m.right().node());
       }
       if (m.IsFoldable()) {  // K * K => K
         return ReplaceFloat64(m.left().Value() * m.right().Value());
       }
-      break;
+      return ReduceFloat52Mul(node);
     }
     case IrOpcode::kFloat64Div: {
       Float64BinopMatcher m(node);
       if (m.right().Is(1)) return Replace(m.left().node());  // x / 1.0 => x
       if (m.right().IsNaN()) {                               // x / NaN => NaN
         return Replace(m.right().node());
       }
       if (m.left().IsNaN()) {  // NaN / x => NaN
         return Replace(m.left().node());
       }
       if (m.IsFoldable()) {  // K / K => K
         return ReplaceFloat64(m.left().Value() / m.right().Value());
       }
-      break;
+      return ReduceFloat52Div(node);
     }
     case IrOpcode::kFloat64Mod: {
       Float64BinopMatcher m(node);
       if (m.right().Is(0)) {  // x % 0 => NaN
         return ReplaceFloat64(std::numeric_limits<double>::quiet_NaN());
       }
       if (m.right().IsNaN()) {  // x % NaN => NaN
         return Replace(m.right().node());
       }
       if (m.left().IsNaN()) {  // NaN % x => NaN
@@ skipping 695 matching lines @@
     node->ReplaceInput(
         1, m.right().HasValue()
                ? Float32Constant(static_cast<float>(m.right().Value()))
                : m.right().InputAt(0));
     return Changed(node);
   }
   return NoChange();
 }
 
 
+Reduction MachineOperatorReducer::ReduceFloat52Mul(Node* node) {
+  if (!machine()->Is64()) return NoChange();
+
+  Float64BinopMatcher m(node);
+  if (!m.left().IsChangeInt32ToFloat64() ||
+      !m.right().IsChangeInt32ToFloat64()) {
+    return NoChange();
+  }
+
+  Type* type = NodeProperties::GetType(node);

[Benedikt Meurer, 2015/11/25 20:09:10]

The MachineOperatorReducer must not look at the types. The invariant is that it
should function even on a completely untyped graph.

+  Type::RangeType* range = type->GetRange();
+
+  // JavaScript has 52 bit precision in multiplication
+  if (range == nullptr || range->Min() < 0.0 ||
+      range->Max() > 0xFFFFFFFFFFFFFULL) {
+    return NoChange();
+  }
+
+  Node* mul = graph()->NewNode(machine()->Int64Mul(), m.left().InputAt(0),
+                               m.right().InputAt(0));
+
+  Type* range_type = Type::Range(range->Min(), range->Max(), graph()->zone());
+
+  // TODO(indutny): Is Type::Number() a proper thing here? It looks like
+  // every other place is using Type:Internal() for int64 values.
+  // Should we off-load range propagation to Typer?
+  NodeProperties::SetType(
+      mul, Type::Intersect(range_type, Type::Number(), graph()->zone()));
+
+  Node* out = graph()->NewNode(machine()->RoundInt64ToFloat64(), mul);
+  return Replace(out);
+}
+
+
+Reduction MachineOperatorReducer::ReduceFloat52Div(Node* node) {
+  if (!machine()->Is64()) return NoChange();
+
+  Float64BinopMatcher m(node);
+  if (!m.left().IsRoundInt64ToFloat64()) return NoChange();
+
+  // Right value should be positive...
+  if (!m.right().HasValue() || m.right().Value() <= 0) return NoChange();
+
+  // ...integer...
+  int64_t value = static_cast<int64_t>(m.right().Value());
+  if (value != static_cast<int64_t>(m.right().Value())) return NoChange();
+
+  // ...and should be a power of two.
+  if (!base::bits::IsPowerOfTwo64(value)) return NoChange();
+
+  Node* left = m.left().InputAt(0);
+  Type::RangeType* range = NodeProperties::GetType(left)->GetRange();
+
+  // The RoundInt64ToFloat64 input should fit into 52bit integer
+  if (range == nullptr || range->Min() < 0 ||
+      range->Max() > 0xFFFFFFFFFFFFFULL) {
+    return NoChange();
+  }
+
+  // The result should fit into 32bit word
+  int64_t min = static_cast<int64_t>(range->Min()) / value;
+  int64_t max = static_cast<int64_t>(range->Max()) / value;
+  if (min < 0 || max > 0xFFFFFFFLL) {
+    return NoChange();
+  }
+
+  int64_t shift = WhichPowerOf2_64(static_cast<int64_t>(m.right().Value()));
+
+  // Replace division with 64bit right shift
+  Node* shr =
+      graph()->NewNode(machine()->Word64Shr(), left,
+                       graph()->NewNode(common()->Int64Constant(shift)));
+
+  Type* range_type = Type::Range(min, max, graph()->zone());
+  NodeProperties::SetType(
+      shr, Type::Intersect(range_type, Type::Number(), graph()->zone()));
+
+  Node* out = graph()->NewNode(machine()->RoundInt64ToFloat64(), shr);
+  return Replace(out);
+}
+
+
 CommonOperatorBuilder* MachineOperatorReducer::common() const {
   return jsgraph()->common();
 }
 
 
 MachineOperatorBuilder* MachineOperatorReducer::machine() const {
   return jsgraph()->machine();
 }
 
 
 Graph* MachineOperatorReducer::graph() const { return jsgraph()->graph(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8