[turbofan] Allow OptionalOperator to return a placeholder.

src/compiler/machine-operator.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/machine-operator.h"
 
 #include "src/base/lazy-instance.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 
@@ skipping 583 matching lines @@
          word == MachineRepresentation::kWord64);
 }
 
 
 #define PURE(Name, properties, value_input_count, control_input_count, \
              output_count)                                             \
   const Operator* MachineOperatorBuilder::Name() { return &cache_.k##Name; }
 PURE_OP_LIST(PURE)
 #undef PURE
 
-#define PURE(Name, properties, value_input_count, control_input_count,     \
-             output_count)                                                 \
-  const OptionalOperator MachineOperatorBuilder::Name() {                  \
-    return OptionalOperator(flags_ & k##Name ? &cache_.k##Name : nullptr); \
+#define PURE(Name, properties, value_input_count, control_input_count, \
+             output_count)                                             \
+  const OptionalOperator MachineOperatorBuilder::Name() {              \
+    return OptionalOperator(flags_ & k##Name, &cache_.k##Name);        \
   }
 PURE_OPTIONAL_OP_LIST(PURE)
 #undef PURE
 
 #define OVERFLOW_OP(Name, properties) \
   const Operator* MachineOperatorBuilder::Name() { return &cache_.k##Name; }
 OVERFLOW_OP_LIST(OVERFLOW_OP)
 #undef OVERFLOW_OP
 
 const Operator* MachineOperatorBuilder::Load(LoadRepresentation rep) {
@@ skipping 73 matching lines @@
     MACHINE_REPRESENTATION_LIST(STORE)
 #undef STORE
     case MachineRepresentation::kBit:
     case MachineRepresentation::kNone:
       break;
   }
   UNREACHABLE();
   return nullptr;
 }
 
-// On 32 bit platforms we need to get a reference to optional operators of
-// 64-bit instructions for later Int64Lowering, even though 32 bit platforms
-// don't support the original 64-bit instruction.
-const Operator* MachineOperatorBuilder::Word64PopcntPlaceholder() {
-  return &cache_.kWord64Popcnt;
-}
-
-// On 32 bit platforms we need to get a reference to optional operators of
-// 64-bit instructions for later Int64Lowering, even though 32 bit platforms
-// don't support the original 64-bit instruction.
-const Operator* MachineOperatorBuilder::Word64CtzPlaceholder() {
-  return &cache_.kWord64Ctz;
-}
-
 const Operator* MachineOperatorBuilder::AtomicLoad(LoadRepresentation rep) {
 #define LOAD(Type)                    \
   if (rep == MachineType::Type()) {   \
     return &cache_.kAtomicLoad##Type; \
   }
   ATOMIC_TYPE_LIST(LOAD)
 #undef LOAD
   UNREACHABLE();
   return nullptr;
 }
 
 const Operator* MachineOperatorBuilder::AtomicStore(MachineRepresentation rep) {
 #define STORE(kRep)                         \
   if (rep == MachineRepresentation::kRep) { \
     return &cache_.kAtomicStore##kRep;      \
   }
   ATOMIC_REPRESENTATION_LIST(STORE)
 #undef STORE
   UNREACHABLE();
   return nullptr;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8