[turbofan] Propagate minus-zero truncation in representation inference.

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"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
+enum IdentifyZeros { kIdentifyZeros, kDistinguishZeros };
+
 class Truncation final {
  public:
   // Constructors.
-  static Truncation None() { return Truncation(TruncationKind::kNone); }
-  static Truncation Bool() { return Truncation(TruncationKind::kBool); }
-  static Truncation Word32() { return Truncation(TruncationKind::kWord32); }
-  static Truncation Word64() { return Truncation(TruncationKind::kWord64); }
-  static Truncation Float64() { return Truncation(TruncationKind::kFloat64); }
-  static Truncation Any() { return Truncation(TruncationKind::kAny); }
+  static Truncation None() {
+    return Truncation(TruncationKind::kNone, kIdentifyZeros);
+  }
+  static Truncation Bool() {
+    return Truncation(TruncationKind::kBool, kIdentifyZeros);
+  }
+  static Truncation Word32() {
+    return Truncation(TruncationKind::kWord32, kIdentifyZeros);
+  }
+  static Truncation Word64() {
+    return Truncation(TruncationKind::kWord64, kIdentifyZeros);
+  }
+  static Truncation Float64(IdentifyZeros identify_zeros = kDistinguishZeros) {
+    return Truncation(TruncationKind::kFloat64, identify_zeros);
+  }
+  static Truncation Any(IdentifyZeros identify_zeros = kDistinguishZeros) {
+    return Truncation(TruncationKind::kAny, identify_zeros);
+  }
 
   static Truncation Generalize(Truncation t1, Truncation t2) {
-    return Truncation(Generalize(t1.kind(), t2.kind()));
+    return Truncation(
+        Generalize(t1.kind(), t2.kind()),
+        GeneralizeIdentifyZeros(t1.identify_zeros(), t2.identify_zeros()));
   }
 
   // Queries.
   bool IsUnused() const { return kind_ == TruncationKind::kNone; }
   bool IsUsedAsBool() const {
     return LessGeneral(kind_, TruncationKind::kBool);
   }
   bool IsUsedAsWord32() const {
     return LessGeneral(kind_, TruncationKind::kWord32);
   }
   bool IsUsedAsFloat64() const {
     return LessGeneral(kind_, TruncationKind::kFloat64);
   }
   bool IdentifiesNaNAndZero() {
     return LessGeneral(kind_, TruncationKind::kWord32) ||
            LessGeneral(kind_, TruncationKind::kBool);
   }
   bool IdentifiesUndefinedAndNaNAndZero() {
     return LessGeneral(kind_, TruncationKind::kFloat64) ||
            LessGeneral(kind_, TruncationKind::kWord64);
   }
+  bool IdentifiesZeroAndMinusZero() const {
+    return identify_zeros() == kIdentifyZeros;
+  }
 
   // Operators.
-  bool operator==(Truncation other) const { return kind() == other.kind(); }
+  bool operator==(Truncation other) const {
+    return kind() == other.kind() && identify_zeros() == other.identify_zeros();
+  }
   bool operator!=(Truncation other) const { return !(*this == other); }
 
   // Debug utilities.
   const char* description() const;
   bool IsLessGeneralThan(Truncation other) {
-    return LessGeneral(kind(), other.kind());
+    return LessGeneral(kind(), other.kind()) &&
+           LessGeneralIdentifyZeros(identify_zeros(), other.identify_zeros());
   }
 
+  IdentifyZeros identify_zeros() const { return identify_zeros_; }
+
  private:
   enum class TruncationKind : uint8_t {
     kNone,
     kBool,
     kWord32,
     kWord64,
     kFloat64,
     kAny
   };
 
-  explicit Truncation(TruncationKind kind) : kind_(kind) {}
+  explicit Truncation(TruncationKind kind, IdentifyZeros identify_zeros)
+      : kind_(kind), identify_zeros_(identify_zeros) {
+    DCHECK(kind == TruncationKind::kAny || kind == TruncationKind::kFloat64 ||
+           identify_zeros == kIdentifyZeros);
+  }
   TruncationKind kind() const { return kind_; }
 
   TruncationKind kind_;
+  IdentifyZeros identify_zeros_;
 
   static TruncationKind Generalize(TruncationKind rep1, TruncationKind rep2);
+  static IdentifyZeros GeneralizeIdentifyZeros(IdentifyZeros i1,
+                                               IdentifyZeros i2);
   static bool LessGeneral(TruncationKind rep1, TruncationKind rep2);
+  static bool LessGeneralIdentifyZeros(IdentifyZeros u1, IdentifyZeros u2);
 };
 
 enum class TypeCheckKind : uint8_t {
   kNone,
   kSignedSmall,
   kSigned32,
   kNumber,
   kNumberOrOddball,
   kHeapObject
 };
@@ skipping 26 matching lines @@
 //    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,
-          CheckForMinusZeroMode minus_zero_check =
-              CheckForMinusZeroMode::kCheckForMinusZero)
+          TypeCheckKind type_check = TypeCheckKind::kNone)
       : representation_(representation),
         truncation_(truncation),
-        type_check_(type_check),
-        minus_zero_check_(minus_zero_check) {}
+        type_check_(type_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 Float32() {
@@ skipping 17 matching lines @@
 
   // Possibly deoptimizing conversions.
   static UseInfo CheckedHeapObjectAsTaggedPointer() {
     return UseInfo(MachineRepresentation::kTaggedPointer, Truncation::Any(),
                    TypeCheckKind::kHeapObject);
   }
   static UseInfo CheckedSignedSmallAsTaggedSigned() {
     return UseInfo(MachineRepresentation::kTaggedSigned, Truncation::Any(),
                    TypeCheckKind::kSignedSmall);
   }
-  static UseInfo CheckedSignedSmallAsWord32(
-      CheckForMinusZeroMode minus_zero_mode =
-          CheckForMinusZeroMode::kCheckForMinusZero) {
+  static UseInfo CheckedSignedSmallAsWord32(IdentifyZeros identify_zeros) {
+    return UseInfo(MachineRepresentation::kWord32,
+                   Truncation::Any(identify_zeros),
+                   TypeCheckKind::kSignedSmall);
+  }
+  static UseInfo CheckedSigned32AsWord32(IdentifyZeros identify_zeros) {
     return UseInfo(MachineRepresentation::kWord32, Truncation::Any(),
-                   TypeCheckKind::kSignedSmall, minus_zero_mode);
-  }
-  static UseInfo CheckedSigned32AsWord32(
-      CheckForMinusZeroMode minus_zero_mode =
-          CheckForMinusZeroMode::kCheckForMinusZero) {
-    return UseInfo(MachineRepresentation::kWord32, Truncation::Any(),
-                   TypeCheckKind::kSigned32, minus_zero_mode);
+                   TypeCheckKind::kSigned32);
   }
   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_; }
+  CheckForMinusZeroMode minus_zero_check() const {
+    return truncation().IdentifiesZeroAndMinusZero()
+               ? CheckForMinusZeroMode::kDontCheckForMinusZero
+               : CheckForMinusZeroMode::kCheckForMinusZero;
+  }
 
  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 76 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_