Replace OVERRIDE->override and FINAL->final since we now require C++11.

src/compiler/instruction.h

 // 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.
 
 #ifndef V8_COMPILER_INSTRUCTION_H_
 #define V8_COMPILER_INSTRUCTION_H_
 
 #include <deque>
 #include <iosfwd>
 #include <map>
@@ skipping 383 matching lines @@
   bool InstructionOperand::Is##SubKind() const {             \
     return IsAllocated() &&                                  \
            AllocatedOperand::cast(this)->allocated_kind() == \
                AllocatedOperand::kOperandKind;               \
   }
 ALLOCATED_OPERAND_LIST(ALLOCATED_OPERAND_IS)
 #undef ALLOCATED_OPERAND_IS
 
 
 #define ALLOCATED_OPERAND_CLASS(SubKind, kOperandKind)                       \
-  class SubKind##Operand FINAL : public AllocatedOperand {                   \
+  class SubKind##Operand final : public AllocatedOperand {                   \
    public:                                                                   \
     explicit SubKind##Operand(int index)                                     \
         : AllocatedOperand(kOperandKind, index) {}                           \
                                                                              \
     static SubKind##Operand* New(Zone* zone, int index) {                    \
       return InstructionOperand::New(zone, SubKind##Operand(index));         \
     }                                                                        \
                                                                              \
     static SubKind##Operand* cast(InstructionOperand* op) {                  \
       DCHECK_EQ(kOperandKind, AllocatedOperand::cast(op)->allocated_kind()); \
       return reinterpret_cast<SubKind##Operand*>(op);                        \
     }                                                                        \
                                                                              \
     static const SubKind##Operand* cast(const InstructionOperand* op) {      \
       DCHECK_EQ(kOperandKind, AllocatedOperand::cast(op)->allocated_kind()); \
       return reinterpret_cast<const SubKind##Operand*>(op);                  \
     }                                                                        \
                                                                              \
     static SubKind##Operand cast(const InstructionOperand& op) {             \
       DCHECK_EQ(kOperandKind, AllocatedOperand::cast(op).allocated_kind());  \
       return *static_cast<const SubKind##Operand*>(&op);                     \
     }                                                                        \
   };
 ALLOCATED_OPERAND_LIST(ALLOCATED_OPERAND_CLASS)
 #undef ALLOCATED_OPERAND_CLASS
 
 
-class MoveOperands FINAL : public ZoneObject {
+class MoveOperands final : public ZoneObject {
  public:
   MoveOperands(const InstructionOperand& source,
                const InstructionOperand& destination)
       : source_(source), destination_(destination) {
     DCHECK(!source.IsInvalid() && !destination.IsInvalid());
   }
 
   const InstructionOperand& source() const { return source_; }
   InstructionOperand& source() { return source_; }
   void set_source(const InstructionOperand& operand) { source_ = operand; }
@@ skipping 40 matching lines @@
 
 struct PrintableMoveOperands {
   const RegisterConfiguration* register_configuration_;
   const MoveOperands* move_operands_;
 };
 
 
 std::ostream& operator<<(std::ostream& os, const PrintableMoveOperands& mo);
 
 
-class ParallelMove FINAL : public ZoneVector<MoveOperands*>, public ZoneObject {
+class ParallelMove final : public ZoneVector<MoveOperands*>, public ZoneObject {
  public:
   explicit ParallelMove(Zone* zone) : ZoneVector<MoveOperands*>(zone) {
     reserve(4);
   }
 
   MoveOperands* AddMove(const InstructionOperand& from,
                         const InstructionOperand& to) {
     auto zone = get_allocator().zone();
     auto move = new (zone) MoveOperands(from, to);
     push_back(move);
@@ skipping 14 matching lines @@
 
 struct PrintableParallelMove {
   const RegisterConfiguration* register_configuration_;
   const ParallelMove* parallel_move_;
 };
 
 
 std::ostream& operator<<(std::ostream& os, const PrintableParallelMove& pm);
 
 
-class ReferenceMap FINAL : public ZoneObject {
+class ReferenceMap final : public ZoneObject {
  public:
   explicit ReferenceMap(Zone* zone)
       : reference_operands_(8, zone), instruction_position_(-1) {}
 
   const ZoneVector<InstructionOperand>& reference_operands() const {
     return reference_operands_;
   }
   int instruction_position() const { return instruction_position_; }
 
   void set_instruction_position(int pos) {
@@ skipping 162 matching lines @@
 };
 
 
 struct PrintableInstruction {
   const RegisterConfiguration* register_configuration_;
   const Instruction* instr_;
 };
 std::ostream& operator<<(std::ostream& os, const PrintableInstruction& instr);
 
 
-class RpoNumber FINAL {
+class RpoNumber final {
  public:
   static const int kInvalidRpoNumber = -1;
   int ToInt() const {
     DCHECK(IsValid());
     return index_;
   }
   size_t ToSize() const {
     DCHECK(IsValid());
     return static_cast<size_t>(index_);
   }
@@ skipping 12 matching lines @@
 
  private:
   explicit RpoNumber(int32_t index) : index_(index) {}
   int32_t index_;
 };
 
 
 std::ostream& operator<<(std::ostream&, const RpoNumber&);
 
 
-class Constant FINAL {
+class Constant final {
  public:
   enum Type {
     kInt32,
     kInt64,
     kFloat32,
     kFloat64,
     kExternalReference,
     kHeapObject,
     kRpoNumber
   };
@@ skipping 89 matching lines @@
   size_t locals_count_;
   size_t stack_count_;
   ZoneVector<MachineType> types_;
   FrameStateDescriptor* outer_state_;
   MaybeHandle<JSFunction> jsfunction_;
 };
 
 std::ostream& operator<<(std::ostream& os, const Constant& constant);
 
 
-class PhiInstruction FINAL : public ZoneObject {
+class PhiInstruction final : public ZoneObject {
  public:
   typedef ZoneVector<InstructionOperand> Inputs;
 
   PhiInstruction(Zone* zone, int virtual_register, size_t input_count);
 
   void SetInput(size_t offset, int virtual_register);
 
   int virtual_register() const { return virtual_register_; }
   const IntVector& operands() const { return operands_; }
 
   // TODO(dcarney): this has no real business being here, since it's internal to
   // the register allocator, but putting it here was convenient.
   const InstructionOperand& output() const { return output_; }
   InstructionOperand& output() { return output_; }
 
  private:
   const int virtual_register_;
   InstructionOperand output_;
   IntVector operands_;
 };
 
 
 // Analogue of BasicBlock for Instructions instead of Nodes.
-class InstructionBlock FINAL : public ZoneObject {
+class InstructionBlock final : public ZoneObject {
  public:
   InstructionBlock(Zone* zone, RpoNumber rpo_number, RpoNumber loop_header,
                    RpoNumber loop_end, bool deferred);
 
   // Instruction indexes (used by the register allocator).
   int first_instruction_index() const {
     DCHECK(code_start_ >= 0);
     DCHECK(code_end_ > 0);
     DCHECK(code_end_ >= code_start_);
     return code_start_;
@@ skipping 60 matching lines @@
 typedef ZoneDeque<ReferenceMap*> ReferenceMapDeque;
 typedef ZoneVector<FrameStateDescriptor*> DeoptimizationVector;
 typedef ZoneVector<InstructionBlock*> InstructionBlocks;
 
 struct PrintableInstructionSequence;
 
 
 // Represents architecture-specific generated code before, during, and after
 // register allocation.
 // TODO(titzer): s/IsDouble/IsFloat64/
-class InstructionSequence FINAL : public ZoneObject {
+class InstructionSequence final : public ZoneObject {
  public:
   static InstructionBlocks* InstructionBlocksFor(Zone* zone,
                                                  const Schedule* schedule);
   // Puts the deferred blocks last.
   static void ComputeAssemblyOrder(InstructionBlocks* blocks);
 
   InstructionSequence(Isolate* isolate, Zone* zone,
                       InstructionBlocks* instruction_blocks);
 
   int NextVirtualRegister();
@@ skipping 144 matching lines @@
 
 
 std::ostream& operator<<(std::ostream& os,
                          const PrintableInstructionSequence& code);
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INSTRUCTION_H_