Revert of [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