[turbofan] Machine operators are globally shared singletons.

src/compiler/operator.h

 // Copyright 2013 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_OPERATOR_H_
 #define V8_COMPILER_OPERATOR_H_
 
 #include "src/base/flags.h"
 #include "src/ostreams.h"
 #include "src/unique.h"
@@ skipping 92 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(Operator);
 };
 
 DEFINE_OPERATORS_FOR_FLAGS(Operator::Properties)
 
 OStream& operator<<(OStream& os, const Operator& op);
 
 // An implementation of Operator that has no static parameters. Such operators
 // have just a name, an opcode, and a fixed number of inputs and outputs.
 // They can represented by singletons and shared globally.
-class SimpleOperator FINAL : public Operator {
+class SimpleOperator : public Operator {
  public:
   SimpleOperator(Opcode opcode, Properties properties, int input_count,
                  int output_count, const char* mnemonic);
   ~SimpleOperator();
 
-  virtual bool Equals(const Operator* that) const OVERRIDE {
+  virtual bool Equals(const Operator* that) const FINAL {
     return opcode() == that->opcode();
   }
-  virtual int HashCode() const OVERRIDE { return opcode(); }
-  virtual int InputCount() const OVERRIDE { return input_count_; }
-  virtual int OutputCount() const OVERRIDE { return output_count_; }
+  virtual int HashCode() const FINAL { return opcode(); }
+  virtual int InputCount() const FINAL { return input_count_; }
+  virtual int OutputCount() const FINAL { return output_count_; }
 
  private:
-  virtual OStream& PrintTo(OStream& os) const OVERRIDE {  // NOLINT
+  virtual OStream& PrintTo(OStream& os) const FINAL {  // NOLINT
     return os << mnemonic();
   }
 
   int input_count_;
   int output_count_;
 
   DISALLOW_COPY_AND_ASSIGN(SimpleOperator);
 };
 
 // Template specialization implements a kind of type class for dealing with the
@@ skipping 115 matching lines @@
   virtual OStream& PrintTo(OStream& os) const FINAL {  // NOLINT
     return PrintParameter(os << mnemonic());
   }
 
  private:
   int input_count_;
   int output_count_;
   T parameter_;
 };
 
-// Type definitions for operators with specific types of parameters.
-typedef Operator1<Unique<Name> > NameOperator;
-
 
 // Helper to extract parameters from Operator1<*> operator.
 template <typename T>
 static inline const T& OpParameter(const Operator* op) {
   return reinterpret_cast<const Operator1<T>*>(op)->parameter();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_OPERATOR_H_