[turbofan] Reduce some Float64 division to multiplication

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/base/ieee754.h"
 #include "src/codegen.h"
@@ skipping 394 matching lines @@
     }
     case IrOpcode::kFloat64Mul: {
       Float64BinopMatcher m(node);
       if (m.right().Is(-1)) {  // x * -1.0 => -0.0 - x
         node->ReplaceInput(0, Float64Constant(-0.0));
         node->ReplaceInput(1, m.left().node());
         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().Is(2)) {                                 // x * 2.0 => x + x

[Benedikt Meurer, 2016/09/15 17:20:52]

This should come after the m.IsFoldable case below.

+        node->ReplaceInput(1, m.left().node());
+        NodeProperties::ChangeOp(node, machine()->Float64Add());
+        return Changed(node);
+      }
       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;
     }
     case IrOpcode::kFloat64Div: {
       Float64BinopMatcher m(node);
       if (m.right().Is(1)) return Replace(m.left().node());  // x / 1.0 => x
+      if (m.right().Is(-1)) {                                // x / -1.0 => -x

[Benedikt Meurer, 2016/09/15 17:20:52]

Move this below the m.IsFoldable case.

+        node->RemoveInput(1);
+        NodeProperties::ChangeOp(node, machine()->Float64Neg());
+        return Changed(node);
+      }
       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());
       }
+      if (m.right().HasValue()) {
+        Double k = Double(m.right().Value());

[Benedikt Meurer, 2016/09/15 17:20:52]

Can you add this as a IsPowerOfTwo methd to the Float64Matcher?
Also what is the rationale to do this for power of two?

[martyn.capewell, 2016/09/15 17:41:19]

The idea is that all reciprocals of non-denormal powers of two can be
represented exactly, and are quick to identify, so any division by a power of
two can be reduced to a multiplication by its reciprocal and still give the same
result. I can add this as a comment.

[Benedikt Meurer, 2016/09/15 18:20:05]

Aye, thanks. Please add a comment.

+        if (!k.IsSpecial() && !k.IsDenormal() &&
+            ((k.AsUint64() & Double::kSignificandMask) == 0)) {
+          // x / K => x * (1 / K) for power-of-two K
+          node->ReplaceInput(1, Float64Constant(1.0 / k.value()));
+          NodeProperties::ChangeOp(node, machine()->Float64Mul());
+          return Changed(node);
+        }
+      }
       break;
     }
     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());
       }
@@ skipping 926 matching lines @@
 MachineOperatorBuilder* MachineOperatorReducer::machine() const {
   return jsgraph()->machine();
 }
 
 
 Graph* MachineOperatorReducer::graph() const { return jsgraph()->graph(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8