[turbofan] Remove minus zero check for rhs of CheckedInt32Sub.

src/compiler/representation-change.h

 // 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.
 
 #ifndef V8_COMPILER_REPRESENTATION_CHANGE_H_
 #define V8_COMPILER_REPRESENTATION_CHANGE_H_
 
 #include "src/compiler/js-graph.h"
 #include "src/compiler/simplified-operator.h"
 
@@ skipping 90 matching lines @@
   UNREACHABLE();
   return os;
 }
 
 // The {UseInfo} class is used to describe a use of an input of a node.
 //
 // This information is used in two different ways, based on the phase:
 //
 // 1. During propagation, the use info is used to inform the input node
 //    about what part of the input is used (we call this truncation) and what
-//    is the preferred representation.
+//    is the preferred representation. For conversions that will require
+//    checks, we also keep track of whether a minus zero check is needed.
 //
 // 2. During lowering, the use info is used to properly convert the input
 //    to the preferred representation. The preferred representation might be
 //    insufficient to do the conversion (e.g. word32->float64 conv), so we also
 //    need the signedness information to produce the correct value.
 class UseInfo {
  public:
   UseInfo(MachineRepresentation representation, Truncation truncation,
-          TypeCheckKind type_check = TypeCheckKind::kNone)
+          TypeCheckKind type_check = TypeCheckKind::kNone,
+          CheckForMinusZeroMode minus_zero_check =
+              CheckForMinusZeroMode::kCheckForMinusZero)
       : representation_(representation),
         truncation_(truncation),
-        type_check_(type_check) {}
+        type_check_(type_check),
+        minus_zero_check_(minus_zero_check) {}
   static UseInfo TruncatingWord32() {
     return UseInfo(MachineRepresentation::kWord32, Truncation::Word32());
   }
   static UseInfo TruncatingWord64() {
     return UseInfo(MachineRepresentation::kWord64, Truncation::Word64());
   }
   static UseInfo Bool() {
     return UseInfo(MachineRepresentation::kBit, Truncation::Bool());
   }
   static UseInfo TruncatingFloat32() {
@@ skipping 13 matching lines @@
   }
   static UseInfo TaggedPointer() {
     return UseInfo(MachineRepresentation::kTaggedPointer, Truncation::Any());
   }
 
   // Possibly deoptimizing conversions.
   static UseInfo CheckedSignedSmallAsTaggedSigned() {
     return UseInfo(MachineRepresentation::kTaggedSigned, Truncation::Any(),
                    TypeCheckKind::kSignedSmall);
   }
-  static UseInfo CheckedSignedSmallAsWord32() {
+  static UseInfo CheckedSignedSmallAsWord32(
+      CheckForMinusZeroMode minus_zero_mode =
+          CheckForMinusZeroMode::kCheckForMinusZero) {
     return UseInfo(MachineRepresentation::kWord32, Truncation::Any(),
-                   TypeCheckKind::kSignedSmall);
+                   TypeCheckKind::kSignedSmall, minus_zero_mode);
   }
-  static UseInfo CheckedSigned32AsWord32() {
+  static UseInfo CheckedSigned32AsWord32(
+      CheckForMinusZeroMode minus_zero_mode =
+          CheckForMinusZeroMode::kCheckForMinusZero) {
     return UseInfo(MachineRepresentation::kWord32, Truncation::Any(),
-                   TypeCheckKind::kSigned32);
+                   TypeCheckKind::kSigned32, minus_zero_mode);
   }
   static UseInfo CheckedNumberAsFloat64() {
     return UseInfo(MachineRepresentation::kFloat64, Truncation::Float64(),
                    TypeCheckKind::kNumber);
   }
   static UseInfo CheckedNumberAsWord32() {
     return UseInfo(MachineRepresentation::kWord32, Truncation::Word32(),
                    TypeCheckKind::kNumber);
   }
   static UseInfo CheckedNumberOrOddballAsFloat64() {
@@ skipping 14 matching lines @@
   }
 
   // Value not used.
   static UseInfo None() {
     return UseInfo(MachineRepresentation::kNone, Truncation::None());
   }
 
   MachineRepresentation representation() const { return representation_; }
   Truncation truncation() const { return truncation_; }
   TypeCheckKind type_check() const { return type_check_; }
+  CheckForMinusZeroMode minus_zero_check() const { return minus_zero_check_; }
 
  private:
   MachineRepresentation representation_;
   Truncation truncation_;
   TypeCheckKind type_check_;
+  // TODO(jarin) Integrate with truncations.
+  CheckForMinusZeroMode minus_zero_check_;
 };
 
 // Contains logic related to changing the representation of values for constants
 // and other nodes, as well as lowering Simplified->Machine operators.
 // Eagerly folds any representation changes for constants.
 class RepresentationChanger final {
  public:
   RepresentationChanger(JSGraph* jsgraph, Isolate* isolate)
       : jsgraph_(jsgraph),
         isolate_(isolate),
@@ skipping 72 matching lines @@
   Factory* factory() const { return isolate()->factory(); }
   SimplifiedOperatorBuilder* simplified() { return jsgraph()->simplified(); }
   MachineOperatorBuilder* machine() { return jsgraph()->machine(); }
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_REPRESENTATION_CHANGE_H_