Use Chrome compatible naming for compiler specifics.

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 <map>
 #include <set>
@@ skipping 249 matching lines @@
   }
 
   // [lifetime]: Only for non-FIXED_SLOT.
   bool IsUsedAtStart() {
     DCHECK(basic_policy() == EXTENDED_POLICY);
     return LifetimeField::decode(value_) == USED_AT_START;
   }
 };
 
 
-class MoveOperands V8_FINAL {
+class MoveOperands FINAL {
  public:
   MoveOperands(InstructionOperand* source, InstructionOperand* destination)
       : source_(source), destination_(destination) {}
 
   InstructionOperand* source() const { return source_; }
   void set_source(InstructionOperand* operand) { source_ = operand; }
 
   InstructionOperand* destination() const { return destination_; }
   void set_destination(InstructionOperand* operand) { destination_ = operand; }
 
@@ skipping 25 matching lines @@
   }
 
  private:
   InstructionOperand* source_;
   InstructionOperand* destination_;
 };
 
 OStream& operator<<(OStream& os, const MoveOperands& mo);
 
 template <InstructionOperand::Kind kOperandKind, int kNumCachedOperands>
-class SubKindOperand V8_FINAL : public InstructionOperand {
+class SubKindOperand FINAL : public InstructionOperand {
  public:
   static SubKindOperand* Create(int index, Zone* zone) {
     DCHECK(index >= 0);
     if (index < kNumCachedOperands) return &cache[index];
     return new (zone) SubKindOperand(index);
   }
 
   static SubKindOperand* cast(InstructionOperand* op) {
     DCHECK(op->kind() == kOperandKind);
     return reinterpret_cast<SubKindOperand*>(op);
@@ skipping 10 matching lines @@
       : InstructionOperand(kOperandKind, index) {}
 };
 
 
 #define INSTRUCTION_TYPEDEF_SUBKIND_OPERAND_CLASS(name, type, number) \
   typedef SubKindOperand<InstructionOperand::type, number> name##Operand;
 INSTRUCTION_OPERAND_LIST(INSTRUCTION_TYPEDEF_SUBKIND_OPERAND_CLASS)
 #undef INSTRUCTION_TYPEDEF_SUBKIND_OPERAND_CLASS
 
 
-class ParallelMove V8_FINAL : public ZoneObject {
+class ParallelMove FINAL : public ZoneObject {
  public:
   explicit ParallelMove(Zone* zone) : move_operands_(4, zone) {}
 
   void AddMove(InstructionOperand* from, InstructionOperand* to, Zone* zone) {
     move_operands_.Add(MoveOperands(from, to), zone);
   }
 
   bool IsRedundant() const;
 
   ZoneList<MoveOperands>* move_operands() { return &move_operands_; }
   const ZoneList<MoveOperands>* move_operands() const {
     return &move_operands_;
   }
 
  private:
   ZoneList<MoveOperands> move_operands_;
 };
 
 OStream& operator<<(OStream& os, const ParallelMove& pm);
 
-class PointerMap V8_FINAL : public ZoneObject {
+class PointerMap FINAL : public ZoneObject {
  public:
   explicit PointerMap(Zone* zone)
       : pointer_operands_(8, zone),
         untagged_operands_(0, zone),
         instruction_position_(-1) {}
 
   const ZoneList<InstructionOperand*>* GetNormalizedOperands() {
     for (int i = 0; i < untagged_operands_.length(); ++i) {
       RemovePointer(untagged_operands_[i]);
     }
@@ skipping 211 matching lines @@
 
  private:
   friend OStream& operator<<(OStream& os, const Instruction& instr);
   ParallelMove* parallel_moves_[LAST_INNER_POSITION + 1];
 };
 
 
 // This special kind of gap move instruction represents the beginning of a
 // block of code.
 // TODO(titzer): move code_start and code_end from BasicBlock to here.
-class BlockStartInstruction V8_FINAL : public GapInstruction {
+class BlockStartInstruction FINAL : public GapInstruction {
  public:
   BasicBlock* block() const { return block_; }
   Label* label() { return &label_; }
 
   static BlockStartInstruction* New(Zone* zone, BasicBlock* block) {
     void* buffer = zone->New(sizeof(BlockStartInstruction));
     return new (buffer) BlockStartInstruction(block);
   }
 
   static BlockStartInstruction* cast(Instruction* instr) {
     DCHECK(instr->IsBlockStart());
     return static_cast<BlockStartInstruction*>(instr);
   }
 
  private:
   explicit BlockStartInstruction(BasicBlock* block)
       : GapInstruction(kBlockStartInstruction), block_(block) {}
 
   BasicBlock* block_;
   Label label_;
 };
 
 
-class SourcePositionInstruction V8_FINAL : public Instruction {
+class SourcePositionInstruction FINAL : public Instruction {
  public:
   static SourcePositionInstruction* New(Zone* zone, SourcePosition position) {
     void* buffer = zone->New(sizeof(SourcePositionInstruction));
     return new (buffer) SourcePositionInstruction(position);
   }
 
   SourcePosition source_position() const { return source_position_; }
 
   static SourcePositionInstruction* cast(Instruction* instr) {
     DCHECK(instr->IsSourcePosition());
@@ skipping 10 matching lines @@
       : Instruction(kSourcePositionInstruction),
         source_position_(source_position) {
     DCHECK(!source_position_.IsInvalid());
     DCHECK(!source_position_.IsUnknown());
   }
 
   SourcePosition source_position_;
 };
 
 
-class Constant V8_FINAL {
+class Constant FINAL {
  public:
   enum Type { kInt32, kInt64, kFloat64, kExternalReference, kHeapObject };
 
   explicit Constant(int32_t v) : type_(kInt32), value_(v) {}
   explicit Constant(int64_t v) : type_(kInt64), value_(v) {}
   explicit Constant(double v) : type_(kFloat64), value_(BitCast<int64_t>(v)) {}
   explicit Constant(ExternalReference ref)
       : type_(kExternalReference), value_(BitCast<intptr_t>(ref)) {}
   explicit Constant(Handle<HeapObject> obj)
       : type_(kHeapObject), value_(BitCast<intptr_t>(obj)) {}
@@ skipping 68 matching lines @@
 typedef std::map<int, Constant, std::less<int>,
                  zone_allocator<std::pair<int, Constant> > > ConstantMap;
 
 typedef ZoneDeque<Instruction*> InstructionDeque;
 typedef ZoneDeque<PointerMap*> PointerMapDeque;
 typedef ZoneVector<FrameStateDescriptor*> DeoptimizationVector;
 
 // Represents architecture-specific generated code before, during, and after
 // register allocation.
 // TODO(titzer): s/IsDouble/IsFloat64/
-class InstructionSequence V8_FINAL {
+class InstructionSequence FINAL {
  public:
   InstructionSequence(Linkage* linkage, Graph* graph, Schedule* schedule)
       : graph_(graph),
         linkage_(linkage),
         schedule_(schedule),
         constants_(ConstantMap::key_compare(),
                    ConstantMap::allocator_type(zone())),
         immediates_(zone()),
         instructions_(zone()),
         next_virtual_register_(graph->NodeCount()),
@@ skipping 122 matching lines @@
   DeoptimizationVector deoptimization_entries_;
 };
 
 OStream& operator<<(OStream& os, const InstructionSequence& code);
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INSTRUCTION_H_