[turbofan] Better representation selection for comparison with Float64.

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 683 matching lines @@
   bool BothInputsAreUnsigned32(Node* node) {
     return BothInputsAre(node, Type::Unsigned32());
   }
 
   bool BothInputsAre(Node* node, Type* type) {
     DCHECK_EQ(2, node->op()->ValueInputCount());
     return GetUpperBound(node->InputAt(0))->Is(type) &&
            GetUpperBound(node->InputAt(1))->Is(type);
   }
 
+  bool IsNodeRepresentationFloat64(Node* node) {
+    MachineRepresentation representation = GetInfo(node)->representation();
+    return representation == MachineRepresentation::kFloat64;
+  }
+
   bool IsNodeRepresentationTagged(Node* node) {
     MachineRepresentation representation = GetInfo(node)->representation();
     return IsAnyTagged(representation);
   }
 
   bool OneInputCannotBe(Node* node, Type* type) {
     DCHECK_EQ(2, node->op()->ValueInputCount());
     return !GetUpperBound(node->InputAt(0))->Maybe(type) ||
            !GetUpperBound(node->InputAt(1))->Maybe(type);
   }
@@ skipping 898 matching lines @@
               DCHECK(lower());
               Node* lhs = node->InputAt(0);
               Node* rhs = node->InputAt(1);
               if (IsNodeRepresentationTagged(lhs) &&
                   IsNodeRepresentationTagged(rhs)) {
                 VisitBinop(node, UseInfo::CheckedSignedSmallAsTaggedSigned(),
                            MachineRepresentation::kBit);
                 ChangeToPureOp(
                     node, changer_->TaggedSignedOperatorFor(node->opcode()));
 
+              } else if (IsNodeRepresentationFloat64(lhs) ||
+                         IsNodeRepresentationFloat64(rhs)) {
+                // If one side is already a Float64, it's pretty expensive to
+                // do the comparison in Word32, since that means we need a
+                // checked conversion from Float64 to Word32. It's cheaper to
+                // just go to Float64 for the comparison.
+                VisitBinop(node, UseInfo::CheckedNumberAsFloat64(),
+                           MachineRepresentation::kBit);
+                ChangeToPureOp(node, Float64Op(node));
               } else {
                 VisitBinop(node, CheckedUseInfoAsWord32FromHint(hint),
                            MachineRepresentation::kBit);
                 ChangeToPureOp(node, Int32Op(node));
               }
             }
             return;
           }
           case NumberOperationHint::kNumberOrOddball:
             // Abstract and strict equality don't perform ToNumber conversions
@@ skipping 1985 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