[turbofan] First step of Operator refactoring.

src/compiler/common-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_COMMON_OPERATOR_H_
 #define V8_COMPILER_COMMON_OPERATOR_H_
 
 #include "src/v8.h"
 
 #include "src/assembler.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/unique.h"
 
 namespace v8 {
 namespace internal {
 
 class OStream;
 
 namespace compiler {
 
-class ControlOperator : public Operator1<int> {
+class ControlOperator FINAL : public Operator1<int> {
  public:
-  ControlOperator(IrOpcode::Value opcode, uint16_t properties, int inputs,
+  ControlOperator(IrOpcode::Value opcode, Properties properties, int inputs,
                   int outputs, int controls, const char* mnemonic)
       : Operator1<int>(opcode, properties, inputs, outputs, mnemonic,
                        controls) {}
 
-  virtual OStream& PrintParameter(OStream& os) const { return os; }  // NOLINT
+  virtual OStream& PrintParameter(OStream& os) const OVERRIDE {  // NOLINT
+    return os;
+  }
   int ControlInputCount() const { return parameter(); }
 };
 
-class CallOperator : public Operator1<CallDescriptor*> {
+class CallOperator FINAL : public Operator1<CallDescriptor*> {
  public:
   CallOperator(CallDescriptor* descriptor, const char* mnemonic)
       : Operator1<CallDescriptor*>(
             IrOpcode::kCall, descriptor->properties(),
             descriptor->InputCount() + descriptor->FrameStateCount(),
             descriptor->ReturnCount(), mnemonic, descriptor) {}
 
-  virtual OStream& PrintParameter(OStream& os) const {  // NOLINT
+  virtual OStream& PrintParameter(OStream& os) const OVERRIDE {  // NOLINT
     return os << "[" << *parameter() << "]";
   }
 };
 
 // Flag that describes how to combine the current environment with
 // the output of a node to obtain a framestate for lazy bailout.
 enum OutputFrameStateCombine {
   kPushOutput,   // Push the output on the expression stack.
   kIgnoreOutput  // Use the frame state as-is.
 };
@@ skipping 31 matching lines @@
                                        outputs, 0, "Start");
   }
   Operator* Dead() { CONTROL_OP(Dead, 0, 0); }
   Operator* End() { CONTROL_OP(End, 0, 1); }
   Operator* Branch() { CONTROL_OP(Branch, 1, 1); }
   Operator* IfTrue() { CONTROL_OP(IfTrue, 0, 1); }
   Operator* IfFalse() { CONTROL_OP(IfFalse, 0, 1); }
   Operator* Throw() { CONTROL_OP(Throw, 1, 1); }
 
   Operator* Return() {
-    return new (zone_) ControlOperator(IrOpcode::kReturn, 0, 1, 0, 1, "Return");
+    return new (zone_) ControlOperator(
+        IrOpcode::kReturn, Operator::kNoProperties, 1, 0, 1, "Return");
   }
 
   Operator* Merge(int controls) {
     return new (zone_) ControlOperator(IrOpcode::kMerge, Operator::kFoldable, 0,
                                        0, controls, "Merge");
   }
 
   Operator* Loop(int controls) {
     return new (zone_) ControlOperator(IrOpcode::kLoop, Operator::kFoldable, 0,
                                        0, controls, "Loop");
@@ skipping 201 matching lines @@
 
 template <typename T>
 inline T ValueOf(Operator* op) {
   return CommonOperatorTraits<T>::ValueOf(op);
 }
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_COMMON_OPERATOR_H_