[turbofan] Introduce CheckedUint32Div and CheckUint32Mod operators.

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 165 matching lines @@
 };
 
 #endif  // DEBUG
 
 }  // namespace
 
 
 class RepresentationSelector {
  public:
   // Information for each node tracked during the fixpoint.
-  class NodeInfo {
+  class NodeInfo final {
    public:
     // Adds new use to the node. Returns true if something has changed
     // and the node has to be requeued.
     bool AddUse(UseInfo info) {
       Truncation old_truncation = truncation_;
       truncation_ = Truncation::Generalize(truncation_, info.truncation());
       return truncation_ != old_truncation;
     }
 
     void set_queued() { state_ = kQueued; }
     void set_visited() { state_ = kVisited; }
     void set_pushed() { state_ = kPushed; }
     void reset_state() { state_ = kUnvisited; }
     bool visited() const { return state_ == kVisited; }
     bool queued() const { return state_ == kQueued; }
     bool unvisited() const { return state_ == kUnvisited; }
     Truncation truncation() const { return truncation_; }
     void set_output(MachineRepresentation output) { representation_ = output; }
 
     MachineRepresentation representation() const { return representation_; }
 
     // Helpers for feedback typing.
     void set_feedback_type(Type* type) { feedback_type_ = type; }
-    Type* feedback_type() { return feedback_type_; }
+    Type* feedback_type() const { return feedback_type_; }
     void set_weakened() { weakened_ = true; }
-    bool weakened() { return weakened_; }
-    TypeCheckKind type_check() { return type_check_; }
-    void set_type_check(TypeCheckKind type_check) { type_check_ = type_check; }
+    bool weakened() const { return weakened_; }
+    void set_restriction_type(Type* type) { restriction_type_ = type; }
+    Type* restriction_type() const { return restriction_type_; }
 
    private:
     enum State : uint8_t { kUnvisited, kPushed, kVisited, kQueued };
     State state_ = kUnvisited;
     MachineRepresentation representation_ =
         MachineRepresentation::kNone;             // Output representation.
     Truncation truncation_ = Truncation::None();  // Information about uses.
-    TypeCheckKind type_check_ = TypeCheckKind::kNone;  // Runtime check kind.
 
+    Type* restriction_type_ = Type::Any();
     Type* feedback_type_ = nullptr;
     bool weakened_ = false;
   };
 
   RepresentationSelector(JSGraph* jsgraph, Zone* zone,
                          RepresentationChanger* changer,
                          SourcePositionTable* source_positions)
       : jsgraph_(jsgraph),
         zone_(zone),
         count_(jsgraph->graph()->NodeCount()),
@@ skipping 102 matching lines @@
       type = op_typer_.Merge(type, FeedbackTypeOf(node->InputAt(i)));
     }
     return type;
   }
 
   Type* TypeSelect(Node* node) {
     return op_typer_.Merge(FeedbackTypeOf(node->InputAt(1)),
                            FeedbackTypeOf(node->InputAt(2)));
   }
 
-  static Type* TypeOfSpeculativeOp(TypeCheckKind type_check) {
-    switch (type_check) {
-      case TypeCheckKind::kNone:
-        return Type::Any();
-      case TypeCheckKind::kSigned32:
-        return Type::Signed32();
-      case TypeCheckKind::kNumber:
-        return Type::Number();
-      // Unexpected cases.
-      case TypeCheckKind::kNumberOrUndefined:
-        FATAL("Unexpected checked type.");
-        break;
-    }
-    UNREACHABLE();
-    return nullptr;
-  }
-
   bool UpdateFeedbackType(Node* node) {
     if (node->op()->ValueOutputCount() == 0) return false;
 
     NodeInfo* info = GetInfo(node);
     Type* type = info->feedback_type();
     Type* new_type = type;
 
     // For any non-phi node just wait until we get all inputs typed. We only
     // allow untyped inputs for phi nodes because phis are the only places
     // where cycles need to be broken.
     if (node->opcode() != IrOpcode::kPhi) {
       for (int i = 0; i < node->op()->ValueInputCount(); i++) {
         if (GetInfo(node->InputAt(i))->feedback_type() == nullptr) {
           return false;
         }
       }
     }
 
     switch (node->opcode()) {
+      case IrOpcode::kNumberAdd:
       case IrOpcode::kSpeculativeNumberAdd: {
         // TODO(jarin) The ToNumber conversion is too conservative here,
         // e.g. it will treat true as 1 even though the number check will
         // fail on a boolean. OperationTyper should have a function that
         // computes a more precise type.
         Type* lhs = op_typer_.ToNumber(FeedbackTypeOf(node->InputAt(0)));
         Type* rhs = op_typer_.ToNumber(FeedbackTypeOf(node->InputAt(1)));
-        Type* static_type = op_typer_.NumberAdd(lhs, rhs);
-        if (info->type_check() == TypeCheckKind::kNone) {
-          new_type = static_type;
-        } else {
-          Type* feedback_type = TypeOfSpeculativeOp(info->type_check());
-          new_type = Type::Intersect(static_type, feedback_type, graph_zone());
-        }
+        Type* computed_type = op_typer_.NumberAdd(lhs, rhs);
+        new_type = Type::Intersect(computed_type, info->restriction_type(),
+                                   graph_zone());
         break;
       }
 
+      case IrOpcode::kNumberSubtract:
       case IrOpcode::kSpeculativeNumberSubtract: {
         // TODO(jarin) The ToNumber conversion is too conservative here,
         // e.g. it will treat true as 1 even though the number check will
         // fail on a boolean. OperationTyper should have a function that
         // computes a more precise type.
         Type* lhs = op_typer_.ToNumber(FeedbackTypeOf(node->InputAt(0)));
         Type* rhs = op_typer_.ToNumber(FeedbackTypeOf(node->InputAt(1)));
-        Type* static_type = op_typer_.NumberSubtract(lhs, rhs);
-        if (info->type_check() == TypeCheckKind::kNone) {
-          new_type = static_type;
-        } else {
-          Type* feedback_type = TypeOfSpeculativeOp(info->type_check());
-          new_type = Type::Intersect(static_type, feedback_type, graph_zone());
-        }
+        Type* computed_type = op_typer_.NumberSubtract(lhs, rhs);
+        new_type = Type::Intersect(computed_type, info->restriction_type(),
+                                   graph_zone());
         break;
       }
 
+      case IrOpcode::kNumberMultiply:
       case IrOpcode::kSpeculativeNumberMultiply: {
         // TODO(jarin) The ToNumber conversion is too conservative here,
         // e.g. it will treat true as 1 even though the number check will
         // fail on a boolean. OperationTyper should have a function that
         // computes a more precise type.
         Type* lhs = op_typer_.ToNumber(FeedbackTypeOf(node->InputAt(0)));
         Type* rhs = op_typer_.ToNumber(FeedbackTypeOf(node->InputAt(1)));
-        Type* static_type = op_typer_.NumberMultiply(lhs, rhs);
-        if (info->type_check() == TypeCheckKind::kNone) {
-          new_type = static_type;
-        } else {
-          Type* feedback_type = TypeOfSpeculativeOp(info->type_check());
-          new_type = Type::Intersect(static_type, feedback_type, graph_zone());
-        }
+        Type* computed_type = op_typer_.NumberMultiply(lhs, rhs);
+        new_type = Type::Intersect(computed_type, info->restriction_type(),
+                                   graph_zone());
         break;
       }
 
+      case IrOpcode::kNumberDivide:
       case IrOpcode::kSpeculativeNumberDivide: {
         // TODO(jarin) The ToNumber conversion is too conservative here,
         // e.g. it will treat true as 1 even though the number check will
         // fail on a boolean. OperationTyper should have a function that
         // computes a more precise type.
         Type* lhs = op_typer_.ToNumber(FeedbackTypeOf(node->InputAt(0)));
         Type* rhs = op_typer_.ToNumber(FeedbackTypeOf(node->InputAt(1)));
-        Type* static_type = op_typer_.NumberDivide(lhs, rhs);
-        if (info->type_check() == TypeCheckKind::kNone) {
-          new_type = static_type;
-        } else {
-          Type* feedback_type = TypeOfSpeculativeOp(info->type_check());
-          new_type = Type::Intersect(static_type, feedback_type, graph_zone());
-        }
+        Type* computed_type = op_typer_.NumberDivide(lhs, rhs);
+        new_type = Type::Intersect(computed_type, info->restriction_type(),
+                                   graph_zone());
         break;
       }
 
+      case IrOpcode::kNumberModulus:
       case IrOpcode::kSpeculativeNumberModulus: {
         // TODO(jarin) The ToNumber conversion is too conservative here,
         // e.g. it will treat true as 1 even though the number check will
         // fail on a boolean. OperationTyper should have a function that
         // computes a more precise type.
         Type* lhs = op_typer_.ToNumber(FeedbackTypeOf(node->InputAt(0)));
         Type* rhs = op_typer_.ToNumber(FeedbackTypeOf(node->InputAt(1)));
-        Type* static_type = op_typer_.NumberModulus(lhs, rhs);
-        if (info->type_check() == TypeCheckKind::kNone) {
-          new_type = static_type;
-        } else {
-          Type* feedback_type = TypeOfSpeculativeOp(info->type_check());
-          new_type = Type::Intersect(static_type, feedback_type, graph_zone());
-        }
+        Type* computed_type = op_typer_.NumberModulus(lhs, rhs);
+        new_type = Type::Intersect(computed_type, info->restriction_type(),
+                                   graph_zone());
         break;
       }
 
       case IrOpcode::kNumberAbs: {
         new_type = op_typer_.NumberAbs(FeedbackTypeOf(node->InputAt(0)));
         break;
       }
 
       case IrOpcode::kPhi: {
         new_type = TypePhi(node);
@@ skipping 176 matching lines @@
       }
       PrintTruncation(info->truncation());
     }
   }
 
   bool lower() const { return phase_ == LOWER; }
   bool retype() const { return phase_ == RETYPE; }
   bool propagate() const { return phase_ == PROPAGATE; }
 
   void SetOutput(Node* node, MachineRepresentation representation,
-                 TypeCheckKind type_check = TypeCheckKind::kNone) {
+                 Type* restriction_type = Type::Any()) {
     NodeInfo* const info = GetInfo(node);
     switch (phase_) {
       case PROPAGATE:
-        info->set_type_check(type_check);
+        info->set_restriction_type(restriction_type);
         break;
       case RETYPE:
-        DCHECK_EQ(info->type_check(), type_check);
+        DCHECK(info->restriction_type()->Is(restriction_type));
+        DCHECK(restriction_type->Is(info->restriction_type()));
         info->set_output(representation);
         break;
       case LOWER:
-        DCHECK_EQ(info->type_check(), type_check);
         DCHECK_EQ(info->representation(), representation);
+        DCHECK(info->restriction_type()->Is(restriction_type));
+        DCHECK(restriction_type->Is(info->restriction_type()));
         break;
     }
   }
 
-  void ResetOutput(Node* node, MachineRepresentation representation,
-                   TypeCheckKind type_check = TypeCheckKind::kNone) {
-    NodeInfo* info = GetInfo(node);
-    info->set_output(representation);
-    info->set_type_check(type_check);
-  }
-
   Type* GetUpperBound(Node* node) { return NodeProperties::GetType(node); }
 
   bool InputCannotBe(Node* node, Type* type) {
     DCHECK_EQ(1, node->op()->ValueInputCount());
     return !GetUpperBound(node->InputAt(0))->Maybe(type);
   }
 
   bool InputIs(Node* node, Type* type) {
     DCHECK_EQ(1, node->op()->ValueInputCount());
     return GetUpperBound(node->InputAt(0))->Is(type);
@@ skipping 76 matching lines @@
     }
     // Only enqueue other inputs (framestates, effects, control).
     for (int i = tagged_count; i < node->InputCount(); i++) {
       EnqueueInput(node, i);
     }
   }
 
   // Helper for binops of the R x L -> O variety.
   void VisitBinop(Node* node, UseInfo left_use, UseInfo right_use,
                   MachineRepresentation output,
-                  TypeCheckKind type_check = TypeCheckKind::kNone) {
+                  Type* restriction_type = Type::Any()) {
     DCHECK_EQ(2, node->op()->ValueInputCount());
     ProcessInput(node, 0, left_use);
     ProcessInput(node, 1, right_use);
     for (int i = 2; i < node->InputCount(); i++) {
       EnqueueInput(node, i);
     }
-    SetOutput(node, output, type_check);
+    SetOutput(node, output, restriction_type);
   }
 
   // Helper for binops of the I x I -> O variety.
   void VisitBinop(Node* node, UseInfo input_use, MachineRepresentation output,
-                  TypeCheckKind type_check = TypeCheckKind::kNone) {
-    VisitBinop(node, input_use, input_use, output, type_check);
+                  Type* restriction_type = Type::Any()) {
+    VisitBinop(node, input_use, input_use, output, restriction_type);
   }
 
   // Helper for unops of the I -> O variety.
   void VisitUnop(Node* node, UseInfo input_use, MachineRepresentation output) {
     DCHECK_EQ(1, node->op()->ValueInputCount());
     ProcessInput(node, 0, input_use);
     ProcessRemainingInputs(node, 1);
     SetOutput(node, output);
   }
 
@@ skipping 195 matching lines @@
   }
 
   const Operator* Int32OverflowOp(Node* node) {
     return changer_->Int32OverflowOperatorFor(node->opcode());
   }
 
   const Operator* Uint32Op(Node* node) {
     return changer_->Uint32OperatorFor(node->opcode());
   }
 
+  const Operator* Uint32OverflowOp(Node* node) {
+    return changer_->Uint32OverflowOperatorFor(node->opcode());
+  }
+
   const Operator* Float64Op(Node* node) {
     return changer_->Float64OperatorFor(node->opcode());
   }
 
   WriteBarrierKind WriteBarrierKindFor(
       BaseTaggedness base_taggedness,
       MachineRepresentation field_representation, Type* field_type,
       Node* value) {
     if (base_taggedness == kTaggedBase &&
         field_representation == MachineRepresentation::kTagged) {
@@ skipping 82 matching lines @@
       Node* effect = NodeProperties::GetEffectInput(node);
       ReplaceEffectControlUses(node, effect, control);
       node->TrimInputCount(new_op->ValueInputCount());
     } else {
       DCHECK_EQ(0, node->op()->ControlInputCount());
     }
 
     NodeProperties::ChangeOp(node, new_op);
   }
 
-  void ChangeToInt32OverflowOp(Node* node, const Operator* new_op) {
-    NodeProperties::ChangeOp(node, new_op);
+  void ChangeToInt32OverflowOp(Node* node) {
+    NodeProperties::ChangeOp(node, Int32OverflowOp(node));
+  }
+
+  void ChangeToUint32OverflowOp(Node* node) {
+    NodeProperties::ChangeOp(node, Uint32OverflowOp(node));
   }
 
   void VisitSpeculativeAdditiveOp(Node* node, Truncation truncation,
                                   SimplifiedLowering* lowering) {
     if (BothInputsAre(node, type_cache_.kSigned32OrMinusZero) &&
         NodeProperties::GetType(node)->Is(Type::Signed32())) {
       // int32 + int32 = int32   ==>   signed Int32Add/Sub
       VisitInt32Binop(node);
       if (lower()) ChangeToPureOp(node, Int32Op(node));
       return;
@@ skipping 14 matching lines @@
 
     // Handle the case when no int32 checks on inputs are necessary
     // (but an overflow check is needed on the output).
     if (BothInputsAre(node, Type::Signed32()) ||
         (BothInputsAre(node, type_cache_.kSigned32OrMinusZero) &&
          NodeProperties::GetType(node)->Is(type_cache_.kSafeInteger))) {
       // If both the inputs the feedback are int32, use the overflow op.
       if (hint == BinaryOperationHints::kSignedSmall ||
           hint == BinaryOperationHints::kSigned32) {
         VisitBinop(node, UseInfo::TruncatingWord32(),
-                   MachineRepresentation::kWord32, TypeCheckKind::kSigned32);
-        if (lower()) {
-          ChangeToInt32OverflowOp(node, Int32OverflowOp(node));
-        }
+                   MachineRepresentation::kWord32, Type::Signed32());
+        if (lower()) ChangeToInt32OverflowOp(node);
         return;
       }
     }
 
     if (hint == BinaryOperationHints::kSignedSmall ||
         hint == BinaryOperationHints::kSigned32) {
       VisitBinop(node, UseInfo::CheckedSigned32AsWord32(),
-                 MachineRepresentation::kWord32, TypeCheckKind::kSigned32);
-      if (lower()) {
-        ChangeToInt32OverflowOp(node, Int32OverflowOp(node));
-      }
+                 MachineRepresentation::kWord32, Type::Signed32());
+      if (lower()) ChangeToInt32OverflowOp(node);
       return;
     }
 
     // default case => Float64Add/Sub
     VisitBinop(node, UseInfo::CheckedNumberOrUndefinedAsFloat64(),
-               MachineRepresentation::kFloat64, TypeCheckKind::kNumber);
+               MachineRepresentation::kFloat64, Type::Number());
     if (lower()) {
       ChangeToPureOp(node, Float64Op(node));
     }
     return;
   }
 
   // Dispatching routine for visiting the node {node} with the usage {use}.
   // Depending on the operator, propagate new usage info to the inputs.
   void VisitNode(Node* node, Truncation truncation,
                  SimplifiedLowering* lowering) {
@@ skipping 163 matching lines @@
           if (lower()) NodeProperties::ChangeOp(node, Int32Op(node));
         } else {
           // => Float64Add/Sub
           VisitFloat64Binop(node);
           if (lower()) NodeProperties::ChangeOp(node, Float64Op(node));
         }
         return;
       }
       case IrOpcode::kSpeculativeNumberMultiply:
       case IrOpcode::kNumberMultiply: {
-        if (BothInputsAreSigned32(node)) {
-          if (NodeProperties::GetType(node)->Is(Type::Signed32())) {
-            // Multiply reduces to Int32Mul if the inputs and the output
-            // are integers.
-            VisitInt32Binop(node);
-            if (lower()) ChangeToPureOp(node, Int32Op(node));
-            return;
-          }
-          if (truncation.TruncatesToWord32() &&
+        if (BothInputsAre(node, Type::Integral32()) &&
+            (NodeProperties::GetType(node)->Is(Type::Signed32()) ||
+             NodeProperties::GetType(node)->Is(Type::Unsigned32()) ||
+             (truncation.TruncatesToWord32() &&
               NodeProperties::GetType(node)->Is(
-                  type_cache_.kSafeIntegerOrMinusZero)) {
-            // Multiply reduces to Int32Mul if the inputs are integers,
-            // the uses are truncating and the result is in the safe
-            // integer range.
-            VisitWord32TruncatingBinop(node);
-            if (lower()) ChangeToPureOp(node, Int32Op(node));
-            return;
-          }
+                  type_cache_.kSafeIntegerOrMinusZero)))) {
+          // Multiply reduces to Int32Mul if the inputs are integers, and
+          // (a) the output is either known to be Signed32, or
+          // (b) the output is known to be Unsigned32, or
+          // (c) the uses are truncating and the result is in the safe
+          //     integer range.
+          VisitWord32TruncatingBinop(node);
+          if (lower()) ChangeToPureOp(node, Int32Op(node));
+          return;
         }
         // Number x Number => Float64Mul
         if (BothInputsAre(node, Type::NumberOrUndefined())) {
           VisitFloat64Binop(node);
           if (lower()) ChangeToPureOp(node, Float64Op(node));
           return;
         }
         // Checked float64 x float64 => float64
         DCHECK_EQ(IrOpcode::kSpeculativeNumberMultiply, node->opcode());
         VisitBinop(node, UseInfo::CheckedNumberOrUndefinedAsFloat64(),
-                   MachineRepresentation::kFloat64, TypeCheckKind::kNumber);
+                   MachineRepresentation::kFloat64, Type::Number());
         if (lower()) ChangeToPureOp(node, Float64Op(node));
         return;
       }
       case IrOpcode::kSpeculativeNumberDivide: {
         if (BothInputsAreUnsigned32(node) && truncation.TruncatesToWord32()) {
           // => unsigned Uint32Div
           VisitWord32TruncatingBinop(node);
           if (lower()) DeferReplacement(node, lowering->Uint32Div(node));
           return;
         }
         if (BothInputsAreSigned32(node)) {
           if (NodeProperties::GetType(node)->Is(Type::Signed32())) {
           // => signed Int32Div
           VisitInt32Binop(node);
           if (lower()) DeferReplacement(node, lowering->Int32Div(node));
           return;
           }
           if (truncation.TruncatesToWord32()) {
             // => signed Int32Div
             VisitWord32TruncatingBinop(node);
             if (lower()) DeferReplacement(node, lowering->Int32Div(node));
             return;
           }
         }
 
         // Try to use type feedback.
         BinaryOperationHints::Hint hint = BinaryOperationHintOf(node->op());
 
+        // Handle the case when no uint32 checks on inputs are necessary
+        // (but an overflow check is needed on the output).
+        if (BothInputsAreUnsigned32(node)) {
+          if (hint == BinaryOperationHints::kSignedSmall ||
+              hint == BinaryOperationHints::kSigned32) {
+            VisitBinop(node, UseInfo::TruncatingWord32(),
+                       MachineRepresentation::kWord32, Type::Unsigned32());
+            if (lower()) ChangeToUint32OverflowOp(node);
+            return;
+          }
+        }
+
         // Handle the case when no int32 checks on inputs are necessary
         // (but an overflow check is needed on the output).
-        if (BothInputsAre(node, Type::Signed32())) {
+        if (BothInputsAreSigned32(node)) {
           // If both the inputs the feedback are int32, use the overflow op.
           if (hint == BinaryOperationHints::kSignedSmall ||
               hint == BinaryOperationHints::kSigned32) {
             VisitBinop(node, UseInfo::TruncatingWord32(),
-                       MachineRepresentation::kWord32,
-                       TypeCheckKind::kSigned32);
-            if (lower()) ChangeToInt32OverflowOp(node, Int32OverflowOp(node));
+                       MachineRepresentation::kWord32, Type::Signed32());
+            if (lower()) ChangeToInt32OverflowOp(node);
             return;
           }
         }
 
         if (hint == BinaryOperationHints::kSignedSmall ||
             hint == BinaryOperationHints::kSigned32) {
           // If the result is truncated, we only need to check the inputs.
           if (truncation.TruncatesToWord32()) {
             VisitBinop(node, UseInfo::CheckedSigned32AsWord32(),
                        MachineRepresentation::kWord32);
             if (lower()) DeferReplacement(node, lowering->Int32Div(node));
           } else {
             VisitBinop(node, UseInfo::CheckedSigned32AsWord32(),
-                       MachineRepresentation::kWord32,
-                       TypeCheckKind::kSigned32);
-            if (lower()) ChangeToInt32OverflowOp(node, Int32OverflowOp(node));
+                       MachineRepresentation::kWord32, Type::Signed32());
+            if (lower()) ChangeToInt32OverflowOp(node);
           }
           return;
         }
 
         // default case => Float64Div
         VisitBinop(node, UseInfo::CheckedNumberOrUndefinedAsFloat64(),
-                   MachineRepresentation::kFloat64, TypeCheckKind::kNumber);
+                   MachineRepresentation::kFloat64, Type::Number());
         if (lower()) ChangeToPureOp(node, Float64Op(node));
         return;
       }
       case IrOpcode::kNumberDivide: {
         if (BothInputsAreUnsigned32(node) && truncation.TruncatesToWord32()) {
           // => unsigned Uint32Div
           VisitWord32TruncatingBinop(node);
           if (lower()) DeferReplacement(node, lowering->Uint32Div(node));
           return;
         }
@@ skipping 13 matching lines @@
         }
         // Number x Number => Float64Div
         if (BothInputsAre(node, Type::NumberOrUndefined())) {
           VisitFloat64Binop(node);
           if (lower()) ChangeToPureOp(node, Float64Op(node));
           return;
         }
         // Checked float64 x float64 => float64
         DCHECK_EQ(IrOpcode::kSpeculativeNumberDivide, node->opcode());
         VisitBinop(node, UseInfo::CheckedNumberOrUndefinedAsFloat64(),
-                   MachineRepresentation::kFloat64, TypeCheckKind::kNumber);
+                   MachineRepresentation::kFloat64, Type::Number());
         if (lower()) ChangeToPureOp(node, Float64Op(node));
         return;
       }
       case IrOpcode::kSpeculativeNumberModulus: {
         if (BothInputsAreUnsigned32(node) && truncation.TruncatesToWord32()) {
           // => unsigned Uint32Mod
           VisitWord32TruncatingBinop(node);
           if (lower()) DeferReplacement(node, lowering->Uint32Mod(node));
           return;
         }
         if (BothInputsAreSigned32(node)) {
           if (NodeProperties::GetType(node)->Is(Type::Signed32())) {
             // => signed Int32Mod
             VisitInt32Binop(node);
             if (lower()) DeferReplacement(node, lowering->Int32Mod(node));
             return;
           }
           if (truncation.TruncatesToWord32()) {
             // => signed Int32Mod
             VisitWord32TruncatingBinop(node);
             if (lower()) DeferReplacement(node, lowering->Int32Mod(node));
             return;
           }
         }
 
         // Try to use type feedback.
         BinaryOperationHints::Hint hint = BinaryOperationHintOf(node->op());
 
+        // Handle the case when no uint32 checks on inputs are necessary
+        // (but an overflow check is needed on the output).
+        if (BothInputsAreUnsigned32(node)) {
+          if (hint == BinaryOperationHints::kSignedSmall ||
+              hint == BinaryOperationHints::kSigned32) {
+            VisitBinop(node, UseInfo::TruncatingWord32(),
+                       MachineRepresentation::kWord32, Type::Unsigned32());
+            if (lower()) ChangeToUint32OverflowOp(node);
+            return;
+          }
+        }
+
         // Handle the case when no int32 checks on inputs are necessary
         // (but an overflow check is needed on the output).
         if (BothInputsAre(node, Type::Signed32())) {
           // If both the inputs the feedback are int32, use the overflow op.
           if (hint == BinaryOperationHints::kSignedSmall ||
               hint == BinaryOperationHints::kSigned32) {
             VisitBinop(node, UseInfo::TruncatingWord32(),
-                       MachineRepresentation::kWord32,
-                       TypeCheckKind::kSigned32);
-            if (lower()) ChangeToInt32OverflowOp(node, Int32OverflowOp(node));
+                       MachineRepresentation::kWord32, Type::Signed32());
+            if (lower()) ChangeToInt32OverflowOp(node);
             return;
           }
         }
 
         if (hint == BinaryOperationHints::kSignedSmall ||
             hint == BinaryOperationHints::kSigned32) {
           // If the result is truncated, we only need to check the inputs.
           if (truncation.TruncatesToWord32()) {
             VisitBinop(node, UseInfo::CheckedSigned32AsWord32(),
                        MachineRepresentation::kWord32);
             if (lower()) DeferReplacement(node, lowering->Int32Mod(node));
           } else {
             VisitBinop(node, UseInfo::CheckedSigned32AsWord32(),
-                       MachineRepresentation::kWord32,
-                       TypeCheckKind::kSigned32);
-            if (lower()) ChangeToInt32OverflowOp(node, Int32OverflowOp(node));
+                       MachineRepresentation::kWord32, Type::Signed32());
+            if (lower()) ChangeToInt32OverflowOp(node);
           }
           return;
         }
 
         // default case => Float64Mod
         VisitBinop(node, UseInfo::CheckedNumberOrUndefinedAsFloat64(),
-                   MachineRepresentation::kFloat64, TypeCheckKind::kNumber);
+                   MachineRepresentation::kFloat64, Type::Number());
         if (lower()) ChangeToPureOp(node, Float64Op(node));
         return;
       }
       case IrOpcode::kNumberModulus: {
         if (BothInputsAreUnsigned32(node) && truncation.TruncatesToWord32()) {
           // => unsigned Uint32Mod
           VisitWord32TruncatingBinop(node);
           if (lower()) DeferReplacement(node, lowering->Uint32Mod(node));
           return;
         }
@@ skipping 1742 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