Reland "Use V8_FINAL and V8_OVERRIDE in various places, fixing bugs revealed by them.".

src/lithium.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 25 matching lines @@
 namespace internal {
 
 #define LITHIUM_OPERAND_LIST(V)         \
   V(ConstantOperand, CONSTANT_OPERAND)  \
   V(StackSlot,       STACK_SLOT)        \
   V(DoubleStackSlot, DOUBLE_STACK_SLOT) \
   V(Register,        REGISTER)          \
   V(DoubleRegister,  DOUBLE_REGISTER)
 
 
-class LOperand: public ZoneObject {
+class LOperand : public ZoneObject {
  public:
   enum Kind {
     INVALID,
     UNALLOCATED,
     CONSTANT_OPERAND,
     STACK_SLOT,
     DOUBLE_STACK_SLOT,
     REGISTER,
     DOUBLE_REGISTER,
     ARGUMENT
@@ skipping 26 matching lines @@
  protected:
   static const int kKindFieldWidth = 3;
   class KindField : public BitField<Kind, 0, kKindFieldWidth> { };
 
   LOperand(Kind kind, int index) { ConvertTo(kind, index); }
 
   unsigned value_;
 };
 
 
-class LUnallocated: public LOperand {
+class LUnallocated : public LOperand {
  public:
   enum BasicPolicy {
     FIXED_SLOT,
     EXTENDED_POLICY
   };
 
   enum ExtendedPolicy {
     NONE,
     ANY,
     FIXED_REGISTER,
@@ skipping 160 matching lines @@
   }
 
   // [lifetime]: Only for non-FIXED_SLOT.
   bool IsUsedAtStart() {
     ASSERT(basic_policy() == EXTENDED_POLICY);
     return LifetimeField::decode(value_) == USED_AT_START;
   }
 };
 
 
-class LMoveOperands BASE_EMBEDDED {
+class LMoveOperands V8_FINAL BASE_EMBEDDED {
  public:
   LMoveOperands(LOperand* source, LOperand* destination)
       : source_(source), destination_(destination) {
   }
 
   LOperand* source() const { return source_; }
   void set_source(LOperand* operand) { source_ = operand; }
 
   LOperand* destination() const { return destination_; }
   void set_destination(LOperand* operand) { destination_ = operand; }
@@ skipping 25 matching lines @@
     ASSERT(source_ != NULL || destination_ == NULL);
     return source_ == NULL;
   }
 
  private:
   LOperand* source_;
   LOperand* destination_;
 };
 
 
-class LConstantOperand: public LOperand {
+class LConstantOperand V8_FINAL : public LOperand {
  public:
   static LConstantOperand* Create(int index, Zone* zone) {
     ASSERT(index >= 0);
     if (index < kNumCachedOperands) return &cache[index];
     return new(zone) LConstantOperand(index);
   }
 
   static LConstantOperand* cast(LOperand* op) {
     ASSERT(op->IsConstantOperand());
     return reinterpret_cast<LConstantOperand*>(op);
   }
 
   static void SetUpCache();
   static void TearDownCache();
 
  private:
   static const int kNumCachedOperands = 128;
   static LConstantOperand* cache;
 
   LConstantOperand() : LOperand() { }
   explicit LConstantOperand(int index) : LOperand(CONSTANT_OPERAND, index) { }
 };
 
 
-class LArgument: public LOperand {
+class LArgument V8_FINAL : public LOperand {
  public:
   explicit LArgument(int index) : LOperand(ARGUMENT, index) { }
 
   static LArgument* cast(LOperand* op) {
     ASSERT(op->IsArgument());
     return reinterpret_cast<LArgument*>(op);
   }
 };
 
 
-class LStackSlot: public LOperand {
+class LStackSlot V8_FINAL : public LOperand {
  public:
   static LStackSlot* Create(int index, Zone* zone) {
     ASSERT(index >= 0);
     if (index < kNumCachedOperands) return &cache[index];
     return new(zone) LStackSlot(index);
   }
 
   static LStackSlot* cast(LOperand* op) {
     ASSERT(op->IsStackSlot());
     return reinterpret_cast<LStackSlot*>(op);
   }
 
   static void SetUpCache();
   static void TearDownCache();
 
  private:
   static const int kNumCachedOperands = 128;
   static LStackSlot* cache;
 
   LStackSlot() : LOperand() { }
   explicit LStackSlot(int index) : LOperand(STACK_SLOT, index) { }
 };
 
 
-class LDoubleStackSlot: public LOperand {
+class LDoubleStackSlot V8_FINAL : public LOperand {
  public:
   static LDoubleStackSlot* Create(int index, Zone* zone) {
     ASSERT(index >= 0);
     if (index < kNumCachedOperands) return &cache[index];
     return new(zone) LDoubleStackSlot(index);
   }
 
   static LDoubleStackSlot* cast(LOperand* op) {
     ASSERT(op->IsStackSlot());
     return reinterpret_cast<LDoubleStackSlot*>(op);
   }
 
   static void SetUpCache();
   static void TearDownCache();
 
  private:
   static const int kNumCachedOperands = 128;
   static LDoubleStackSlot* cache;
 
   LDoubleStackSlot() : LOperand() { }
   explicit LDoubleStackSlot(int index) : LOperand(DOUBLE_STACK_SLOT, index) { }
 };
 
 
-class LRegister: public LOperand {
+class LRegister V8_FINAL : public LOperand {
  public:
   static LRegister* Create(int index, Zone* zone) {
     ASSERT(index >= 0);
     if (index < kNumCachedOperands) return &cache[index];
     return new(zone) LRegister(index);
   }
 
   static LRegister* cast(LOperand* op) {
     ASSERT(op->IsRegister());
     return reinterpret_cast<LRegister*>(op);
   }
 
   static void SetUpCache();
   static void TearDownCache();
 
  private:
   static const int kNumCachedOperands = 16;
   static LRegister* cache;
 
   LRegister() : LOperand() { }
   explicit LRegister(int index) : LOperand(REGISTER, index) { }
 };
 
 
-class LDoubleRegister: public LOperand {
+class LDoubleRegister V8_FINAL : public LOperand {
  public:
   static LDoubleRegister* Create(int index, Zone* zone) {
     ASSERT(index >= 0);
     if (index < kNumCachedOperands) return &cache[index];
     return new(zone) LDoubleRegister(index);
   }
 
   static LDoubleRegister* cast(LOperand* op) {
     ASSERT(op->IsDoubleRegister());
     return reinterpret_cast<LDoubleRegister*>(op);
   }
 
   static void SetUpCache();
   static void TearDownCache();
 
  private:
   static const int kNumCachedOperands = 16;
   static LDoubleRegister* cache;
 
   LDoubleRegister() : LOperand() { }
   explicit LDoubleRegister(int index) : LOperand(DOUBLE_REGISTER, index) { }
 };
 
 
-class LParallelMove : public ZoneObject {
+class LParallelMove V8_FINAL : public ZoneObject {
  public:
   explicit LParallelMove(Zone* zone) : move_operands_(4, zone) { }
 
   void AddMove(LOperand* from, LOperand* to, Zone* zone) {
     move_operands_.Add(LMoveOperands(from, to), zone);
   }
 
   bool IsRedundant() const;
 
   const ZoneList<LMoveOperands>* move_operands() const {
     return &move_operands_;
   }
 
   void PrintDataTo(StringStream* stream) const;
 
  private:
   ZoneList<LMoveOperands> move_operands_;
 };
 
 
-class LPointerMap: public ZoneObject {
+class LPointerMap V8_FINAL : public ZoneObject {
  public:
   explicit LPointerMap(int position, Zone* zone)
       : pointer_operands_(8, zone),
         untagged_operands_(0, zone),
         position_(position),
         lithium_position_(-1) { }
 
   const ZoneList<LOperand*>* GetNormalizedOperands() {
     for (int i = 0; i < untagged_operands_.length(); ++i) {
       RemovePointer(untagged_operands_[i]);
@@ skipping 15 matching lines @@
   void PrintTo(StringStream* stream);
 
  private:
   ZoneList<LOperand*> pointer_operands_;
   ZoneList<LOperand*> untagged_operands_;
   int position_;
   int lithium_position_;
 };
 
 
-class LEnvironment: public ZoneObject {
+class LEnvironment V8_FINAL : public ZoneObject {
  public:
   LEnvironment(Handle<JSFunction> closure,
                FrameType frame_type,
                BailoutId ast_id,
                int parameter_count,
                int argument_count,
                int value_count,
                LEnvironment* outer,
                HEnterInlined* entry,
                Zone* zone)
@@ skipping 124 matching lines @@
   // Map with encoded information about materialization_marker operands.
   ZoneList<uint32_t> object_mapping_;
 
   LEnvironment* outer_;
   HEnterInlined* entry_;
   Zone* zone_;
 };
 
 
 // Iterates over the non-null, non-constant operands in an environment.
-class ShallowIterator BASE_EMBEDDED {
+class ShallowIterator V8_FINAL BASE_EMBEDDED {
  public:
   explicit ShallowIterator(LEnvironment* env)
       : env_(env),
         limit_(env != NULL ? env->values()->length() : 0),
         current_(0) {
     SkipUninteresting();
   }
 
   bool Done() { return current_ >= limit_; }
 
@@ skipping 23 matching lines @@
     }
   }
 
   LEnvironment* env_;
   int limit_;
   int current_;
 };
 
 
 // Iterator for non-null, non-constant operands incl. outer environments.
-class DeepIterator BASE_EMBEDDED {
+class DeepIterator V8_FINAL BASE_EMBEDDED {
  public:
   explicit DeepIterator(LEnvironment* env)
       : current_iterator_(env) {
     SkipUninteresting();
   }
 
   bool Done() { return current_iterator_.Done(); }
 
   LOperand* Current() {
     ASSERT(!current_iterator_.Done());
@@ skipping 16 matching lines @@
   ShallowIterator current_iterator_;
 };
 
 
 class LPlatformChunk;
 class LGap;
 class LLabel;
 
 // Superclass providing data and behavior common to all the
 // arch-specific LPlatformChunk classes.
-class LChunk: public ZoneObject {
+class LChunk : public ZoneObject {
  public:
   static LChunk* NewChunk(HGraph* graph);
 
   void AddInstruction(LInstruction* instruction, HBasicBlock* block);
   LConstantOperand* DefineConstantOperand(HConstant* constant);
   HConstant* LookupConstant(LConstantOperand* operand) const;
   Representation LookupLiteralRepresentation(LConstantOperand* operand) const;
 
   int ParameterAt(int index);
   int GetParameterStackSlot(int index) const;
@@ skipping 63 matching lines @@
  private:
   LChunk* chunk_;
 
   DISALLOW_COPY_AND_ASSIGN(LPhase);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_LITHIUM_H_