[turbofan] Introduce CheckHole and CheckHoleNaN operators.

src/compiler/simplified-operator.cc

Index: src/compiler/simplified-operator.cc
diff --git a/src/compiler/simplified-operator.cc b/src/compiler/simplified-operator.cc
index d533edb32df7b8bddf0029148d84ae95a910b5ba..01f965d02bd402b6a3182e325e58086dd6d76d43 100644
--- a/src/compiler/simplified-operator.cc
+++ b/src/compiler/simplified-operator.cc
@@ -172,6 +172,25 @@ const ElementAccess& ElementAccessOf(const Operator* op) {
   return OpParameter<ElementAccess>(op);
 }
 
+size_t hash_value(CheckHoleMode mode) { return static_cast<size_t>(mode); }
+
+std::ostream& operator<<(std::ostream& os, CheckHoleMode mode) {
+  switch (mode) {
+    case CheckHoleMode::kAllowReturnHole:
+      return os << "allow-return-hole";
+    case CheckHoleMode::kNeverReturnHole:
+      return os << "never-return-hole";
+  }
+  UNREACHABLE();
+  return os;
+}
+
+CheckHoleMode CheckHoleModeOf(const Operator* op) {
+  DCHECK(op->opcode() == IrOpcode::kCheckHole ||
+         op->opcode() == IrOpcode::kCheckHoleNaN);
+  return OpParameter<CheckHoleMode>(op);
+}
+
 Type* TypeOf(const Operator* op) {
   DCHECK_EQ(IrOpcode::kTypeGuard, op->opcode());
   return OpParameter<Type*>(op);
@@ -214,9 +233,7 @@ BinaryOperationHints::Hint BinaryOperationHintOf(const Operator* op) {
   V(NumberTrunc, Operator::kNoProperties, 1)               \
   V(NumberToInt32, Operator::kNoProperties, 1)             \
   V(NumberToUint32, Operator::kNoProperties, 1)            \
-  V(NumberIsHoleNaN, Operator::kNoProperties, 1)           \
   V(NumberSilenceNaN, Operator::kNoProperties, 1)          \
-  V(NumberConvertHoleNaN, Operator::kNoProperties, 1)      \
   V(StringFromCharCode, Operator::kNoProperties, 1)        \
   V(StringToNumber, Operator::kNoProperties, 1)            \
   V(PlainPrimitiveToNumber, Operator::kNoProperties, 1)    \
@@ -271,6 +288,28 @@ struct SimplifiedOperatorGlobalCache final {
   CHECKED_OP_LIST(CHECKED)
 #undef CHECKED
 
+  template <CheckHoleMode kMode>
+  struct CheckHoleOperator final : public Operator1<CheckHoleMode> {
+    CheckHoleOperator()
+        : Operator1<CheckHoleMode>(IrOpcode::kCheckHole, Operator::kFoldable,
+                                   "CheckHole", 1, 1, 1, 1, 1, 0, kMode) {}
+  };
+  CheckHoleOperator<CheckHoleMode::kAllowReturnHole>
+      kCheckHoleAllowReturnHoleOperator;
+  CheckHoleOperator<CheckHoleMode::kNeverReturnHole>
+      kCheckHoleNeverReturnHoleOperator;
+
+  template <CheckHoleMode kMode>
+  struct CheckHoleNaNOperatortor final : public Operator1<CheckHoleMode> {
+    CheckHoleNaNOperatortor()
+        : Operator1<CheckHoleMode>(IrOpcode::kCheckHoleNaN, Operator::kFoldable,
+                                   "CheckHoleNaN", 1, 1, 1, 1, 1, 0, kMode) {}
+  };
+  CheckHoleNaNOperatortor<CheckHoleMode::kAllowReturnHole>
+      kCheckHoleNaNAllowReturnHoleOperator;
+  CheckHoleNaNOperatortor<CheckHoleMode::kNeverReturnHole>
+      kCheckHoleNaNNeverReturnHoleOperator;
+
   struct CheckIfOperator final : public Operator {
     CheckIfOperator()
         : Operator(IrOpcode::kCheckIf, Operator::kFoldable, "CheckIf", 1, 1, 1,
@@ -326,6 +365,28 @@ PURE_OP_LIST(GET_FROM_CACHE)
 CHECKED_OP_LIST(GET_FROM_CACHE)
 #undef GET_FROM_CACHE
 
+const Operator* SimplifiedOperatorBuilder::CheckHole(CheckHoleMode mode) {
+  switch (mode) {
+    case CheckHoleMode::kAllowReturnHole:
+      return &cache_.kCheckHoleAllowReturnHoleOperator;
+    case CheckHoleMode::kNeverReturnHole:
+      return &cache_.kCheckHoleNeverReturnHoleOperator;
+  }
+  UNREACHABLE();
+  return nullptr;
+}
+
+const Operator* SimplifiedOperatorBuilder::CheckHoleNaN(CheckHoleMode mode) {
+  switch (mode) {
+    case CheckHoleMode::kAllowReturnHole:
+      return &cache_.kCheckHoleNaNAllowReturnHoleOperator;
+    case CheckHoleMode::kNeverReturnHole:
+      return &cache_.kCheckHoleNaNNeverReturnHoleOperator;
+  }
+  UNREACHABLE();
+  return nullptr;
+}
+
 const Operator* SimplifiedOperatorBuilder::CheckIf() {
   return &cache_.kCheckIf;
 }