[turbofan] Introduce CheckHole and CheckHoleNaN operators.

src/compiler/simplified-operator.cc

 // Copyright 2012 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-operator.h"
 
 #include "src/base/lazy-instance.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/types.h"
@@ skipping 154 matching lines @@
 }
 
 
 const ElementAccess& ElementAccessOf(const Operator* op) {
   DCHECK_NOT_NULL(op);
   DCHECK(op->opcode() == IrOpcode::kLoadElement ||
          op->opcode() == IrOpcode::kStoreElement);
   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);
 }
 
 BinaryOperationHints::Hint BinaryOperationHintOf(const Operator* op) {
   DCHECK(op->opcode() == IrOpcode::kSpeculativeNumberAdd ||
          op->opcode() == IrOpcode::kSpeculativeNumberSubtract);
   return OpParameter<BinaryOperationHints::Hint>(op);
 }
@@ skipping 22 matching lines @@
   V(NumberFround, Operator::kNoProperties, 1)              \
   V(NumberAtan, Operator::kNoProperties, 1)                \
   V(NumberAtan2, Operator::kNoProperties, 2)               \
   V(NumberLog, Operator::kNoProperties, 1)                 \
   V(NumberLog1p, Operator::kNoProperties, 1)               \
   V(NumberRound, Operator::kNoProperties, 1)               \
   V(NumberSqrt, Operator::kNoProperties, 1)                \
   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)    \
   V(PlainPrimitiveToWord32, Operator::kNoProperties, 1)    \
   V(PlainPrimitiveToFloat64, Operator::kNoProperties, 1)   \
   V(ChangeTaggedSignedToInt32, Operator::kNoProperties, 1) \
   V(ChangeTaggedToInt32, Operator::kNoProperties, 1)       \
   V(ChangeTaggedToUint32, Operator::kNoProperties, 1)      \
   V(ChangeTaggedToFloat64, Operator::kNoProperties, 1)     \
   V(ChangeInt31ToTaggedSigned, Operator::kNoProperties, 1) \
@@ skipping 34 matching lines @@
 #define CHECKED(Name)                                                        \
   struct Name##Operator final : public Operator {                            \
     Name##Operator()                                                         \
         : Operator(IrOpcode::k##Name, Operator::kNoThrow, #Name, 1, 1, 1, 1, \
                    1, 1) {}                                                  \
   };                                                                         \
   Name##Operator k##Name;
   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,
                    0, 1, 1) {}
   };
   CheckIfOperator kCheckIf;
 
   template <PretenureFlag kPretenure>
   struct AllocateOperator final : public Operator1<PretenureFlag> {
     AllocateOperator()
@@ skipping 35 matching lines @@
 #define GET_FROM_CACHE(Name, properties, input_count) \
   const Operator* SimplifiedOperatorBuilder::Name() { return &cache_.k##Name; }
 PURE_OP_LIST(GET_FROM_CACHE)
 #undef GET_FROM_CACHE
 
 #define GET_FROM_CACHE(Name) \
   const Operator* SimplifiedOperatorBuilder::Name() { return &cache_.k##Name; }
 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;
 }
 
 const Operator* SimplifiedOperatorBuilder::ReferenceEqual(Type* type) {
   return new (zone()) Operator(IrOpcode::kReferenceEqual,
                                Operator::kCommutative | Operator::kPure,
                                "ReferenceEqual", 2, 0, 0, 1, 0, 0);
 }
 
@@ skipping 79 matching lines @@
         Operator1<Type>(IrOpcode::k##Name, Operator::kNoThrow | properties,    \
                         #Name, value_input_count, 1, control_input_count,      \
                         output_count, 1, 0, access);                           \
   }
 ACCESS_OP_LIST(ACCESS)
 #undef ACCESS
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8