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

src/objects.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 68 matching lines @@
 //             - JSDate
 //           - JSMessageObject
 //         - JSProxy
 //           - JSFunctionProxy
 //       - FixedArrayBase
 //         - ByteArray
 //         - FixedArray
 //           - DescriptorArray
 //           - HashTable
 //             - Dictionary
-//               - NameDictionary
-//               - SeededNumberDictionary
-//               - UnseededNumberDictionary
-//             - ObjectHashSet
-//             - ObjectHashTable
 //             - StringTable
 //             - CompilationCacheTable
 //             - CodeCacheHashTable
 //             - MapCache
 //           - Context
 //           - JSFunctionResultCache
 //           - ScopeInfo
 //           - TransitionArray
 //         - FixedDoubleArray
 //         - ExternalArray
@@ skipping 1430 matching lines @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(Object);
 };
 
 
 // Smi represents integer Numbers that can be stored in 31 bits.
 // Smis are immediate which means they are NOT allocated in the heap.
 // The this pointer has the following format: [31 bit signed int] 0
 // For long smis it has the following format:
 //     [32 bit signed int] [31 bits zero padding] 0
 // Smi stands for small integer.
-class Smi V8_FINAL : public Object {
+class Smi: public Object {
  public:
   // Returns the integer value.
   inline int value();
 
   // Convert a value to a Smi object.
   static inline Smi* FromInt(int value);
 
   static inline Smi* FromIntptr(intptr_t value);
 
   // Returns whether value can be represented in a Smi.
@@ skipping 40 matching lines @@
 //
 // The next three bits, 4-6, are an allocation space tag 'sss'.  The
 // allocation space tag is 000 for all failure types except
 // RETRY_AFTER_GC.  For RETRY_AFTER_GC, the possible values are the
 // allocation spaces (the encoding is found in globals.h).
 
 // Failure type tag info.
 const int kFailureTypeTagSize = 2;
 const int kFailureTypeTagMask = (1 << kFailureTypeTagSize) - 1;
 
-class Failure V8_FINAL : public MaybeObject {
+class Failure: public MaybeObject {
  public:
   // RuntimeStubs assumes EXCEPTION = 1 in the compiler-generated code.
   enum Type {
     RETRY_AFTER_GC = 0,
     EXCEPTION = 1,       // Returning this marker tells the real exception
                          // is in Isolate::pending_exception.
     INTERNAL_ERROR = 2,
     OUT_OF_MEMORY_EXCEPTION = 3
   };
 
@@ skipping 29 matching lines @@
   static inline Failure* Construct(Type type, intptr_t value = 0);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(Failure);
 };
 
 
 // Heap objects typically have a map pointer in their first word.  However,
 // during GC other data (e.g. mark bits, forwarding addresses) is sometimes
 // encoded in the first word.  The class MapWord is an abstraction of the
 // value in a heap object's first word.
-class MapWord V8_FINAL BASE_EMBEDDED {
+class MapWord BASE_EMBEDDED {
  public:
   // Normal state: the map word contains a map pointer.
 
   // Create a map word from a map pointer.
   static inline MapWord FromMap(Map* map);
 
   // View this map word as a map pointer.
   inline Map* ToMap();
 
 
@@ skipping 24 matching lines @@
   friend class HeapObject;
 
   explicit MapWord(uintptr_t value) : value_(value) {}
 
   uintptr_t value_;
 };
 
 
 // HeapObject is the superclass for all classes describing heap allocated
 // objects.
-class HeapObject : public Object {
+class HeapObject: public Object {
  public:
   // [map]: Contains a map which contains the object's reflective
   // information.
   inline Map* map();
   inline void set_map(Map* value);
   // The no-write-barrier version.  This is OK if the object is white and in
   // new space, or if the value is an immortal immutable object, like the maps
   // of primitive (non-JS) objects like strings, heap numbers etc.
   inline void set_map_no_write_barrier(Map* value);
 
@@ skipping 123 matching lines @@
   template<typename StaticVisitor>
   static inline void IterateBody(HeapObject* obj, int object_size) {
     StaticVisitor::VisitPointers(HeapObject::RawField(obj, start_offset),
                                  HeapObject::RawField(obj, object_size));
   }
 };
 
 
 // The HeapNumber class describes heap allocated numbers that cannot be
 // represented in a Smi (small integer)
-class HeapNumber V8_FINAL : public HeapObject {
+class HeapNumber: public HeapObject {
  public:
   // [value]: number value.
   inline double value();
   inline void set_value(double value);
 
   // Casting.
   static inline HeapNumber* cast(Object* obj);
 
   // Dispatched behavior.
   bool HeapNumberBooleanValue();
@@ skipping 54 matching lines @@
 
 // Indicator for one component of an AccessorPair.
 enum AccessorComponent {
   ACCESSOR_GETTER,
   ACCESSOR_SETTER
 };
 
 
 // JSReceiver includes types on which properties can be defined, i.e.,
 // JSObject and JSProxy.
-class JSReceiver : public HeapObject {
+class JSReceiver: public HeapObject {
  public:
   enum DeleteMode {
     NORMAL_DELETION,
     STRICT_DELETION,
     FORCE_DELETION
   };
 
   // A non-keyed store is of the form a.x = foo or a["x"] = foo whereas
   // a keyed store is of the form a[expression] = foo.
   enum StoreFromKeyed {
@@ skipping 112 matching lines @@
                                                    Name* name,
                                                    bool continue_search);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSReceiver);
 };
 
 // The JSObject describes real heap allocated JavaScript objects with
 // properties.
 // Note that the map of JSObject changes during execution to enable inline
 // caching.
-class JSObject : public JSReceiver {
+class JSObject: public JSReceiver {
  public:
   // [properties]: Backing storage for properties.
   // properties is a FixedArray in the fast case and a Dictionary in the
   // slow case.
   DECL_ACCESSORS(properties, FixedArray)  // Get and set fast properties.
   inline void initialize_properties();
   inline bool HasFastProperties();
   inline NameDictionary* property_dictionary();  // Gets slow properties.
 
   // [elements]: The elements (properties with names that are integers).
@@ skipping 611 matching lines @@
 #endif
 
   void PrintElementsTransition(
       FILE* file, ElementsKind from_kind, FixedArrayBase* from_elements,
       ElementsKind to_kind, FixedArrayBase* to_elements);
 
   void PrintInstanceMigration(FILE* file, Map* original_map, Map* new_map);
 
 #ifdef DEBUG
   // Structure for collecting spill information about JSObjects.
-  class SpillInformation V8_FINAL {
+  class SpillInformation {
    public:
     void Clear();
     void Print();
     int number_of_objects_;
     int number_of_objects_with_fast_properties_;
     int number_of_objects_with_fast_elements_;
     int number_of_fast_used_fields_;
     int number_of_fast_unused_fields_;
     int number_of_slow_used_properties_;
     int number_of_slow_unused_properties_;
@@ skipping 40 matching lines @@
   // to the same object requires fewer allocations and copies.
   static const int kFieldsAdded = 3;
 
   // Layout description.
   static const int kPropertiesOffset = HeapObject::kHeaderSize;
   static const int kElementsOffset = kPropertiesOffset + kPointerSize;
   static const int kHeaderSize = kElementsOffset + kPointerSize;
 
   STATIC_CHECK(kHeaderSize == Internals::kJSObjectHeaderSize);
 
-  class BodyDescriptor V8_FINAL
-      : public FlexibleBodyDescriptor<kPropertiesOffset> {
+  class BodyDescriptor : public FlexibleBodyDescriptor<kPropertiesOffset> {
    public:
     static inline int SizeOf(Map* map, HeapObject* object);
   };
 
   // Enqueue change record for Object.observe. May cause GC.
   static void EnqueueChangeRecord(Handle<JSObject> object,
                                   const char* type,
                                   Handle<Name> name,
                                   Handle<Object> old_value);
 
@@ skipping 123 matching lines @@
   // the inline-stored identity hash.
   MUST_USE_RESULT MaybeObject* SetHiddenPropertiesHashTable(
       Object* value);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSObject);
 };
 
 
 // Common superclass for FixedArrays that allow implementations to share
 // common accessors and some code paths.
-class FixedArrayBase : public HeapObject {
+class FixedArrayBase: public HeapObject {
  public:
   // [length]: length of the array.
   inline int length();
   inline void set_length(int value);
 
   inline static FixedArrayBase* cast(Object* object);
 
   // Layout description.
   // Length is smi tagged when it is stored.
   static const int kLengthOffset = HeapObject::kHeaderSize;
   static const int kHeaderSize = kLengthOffset + kPointerSize;
 };
 
 
 class FixedDoubleArray;
 class IncrementalMarking;
 
 
 // FixedArray describes fixed-sized arrays with element type Object*.
-class FixedArray : public FixedArrayBase {
+class FixedArray: public FixedArrayBase {
  public:
   // Setter and getter for elements.
   inline Object* get(int index);
   // Setter that uses write barrier.
   inline void set(int index, Object* value);
   inline bool is_the_hole(int index);
 
   // Setter that doesn't need write barrier.
   inline void set(int index, Smi* value);
   // Setter with explicit barrier mode.
@@ skipping 54 matching lines @@
   // Swap two elements in a pair of arrays.  If this array and the
   // numbers array are the same object, the elements are only swapped
   // once.
   void SwapPairs(FixedArray* numbers, int i, int j);
 
   // Sort prefix of this array and the numbers array as pairs wrt. the
   // numbers.  If the numbers array and the this array are the same
   // object, the prefix of this array is sorted.
   void SortPairs(FixedArray* numbers, uint32_t len);
 
-  class BodyDescriptor V8_FINAL : public FlexibleBodyDescriptor<kHeaderSize> {
+  class BodyDescriptor : public FlexibleBodyDescriptor<kHeaderSize> {
    public:
     static inline int SizeOf(Map* map, HeapObject* object) {
       return SizeFor(reinterpret_cast<FixedArray*>(object)->length());
     }
   };
 
  protected:
   // Set operation on FixedArray without using write barriers. Can
   // only be used for storing old space objects or smis.
   static inline void NoWriteBarrierSet(FixedArray* array,
                                        int index,
                                        Object* value);
 
   // Set operation on FixedArray without incremental write barrier. Can
   // only be used if the object is guaranteed to be white (whiteness witness
   // is present).
   static inline void NoIncrementalWriteBarrierSet(FixedArray* array,
                                                   int index,
                                                   Object* value);
 
  private:
   STATIC_CHECK(kHeaderSize == Internals::kFixedArrayHeaderSize);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(FixedArray);
 };
 
 
 // FixedDoubleArray describes fixed-sized arrays with element type double.
-class FixedDoubleArray V8_FINAL : public FixedArrayBase {
+class FixedDoubleArray: public FixedArrayBase {
  public:
   // Setter and getter for elements.
   inline double get_scalar(int index);
   inline int64_t get_representation(int index);
   MUST_USE_RESULT inline MaybeObject* get(int index);
   inline void set(int index, double value);
   inline void set_the_hole(int index);
 
   // Checking for the hole.
   inline bool is_the_hole(int index);
@@ skipping 36 matching lines @@
 
 
 // DescriptorArrays are fixed arrays used to hold instance descriptors.
 // The format of the these objects is:
 //   [0]: Number of descriptors
 //   [1]: Either Smi(0) if uninitialized, or a pointer to small fixed array:
 //          [0]: pointer to fixed array with enum cache
 //          [1]: either Smi(0) or pointer to fixed array with indices
 //   [2]: first key
 //   [2 + number of descriptors * kDescriptorSize]: start of slack
-class DescriptorArray V8_FINAL : public FixedArray {
+class DescriptorArray: public FixedArray {
  public:
   // WhitenessWitness is used to prove that a descriptor array is white
   // (unmarked), so incremental write barriers can be skipped because the
   // marking invariant cannot be broken and slots pointing into evacuation
   // candidates will be discovered when the object is scanned. A witness is
   // always stack-allocated right after creating an array. By allocating a
   // witness, incremental marking is globally disabled. The witness is then
   // passed along wherever needed to statically prove that the array is known to
   // be white.
-  class WhitenessWitness V8_FINAL {
+  class WhitenessWitness {
    public:
     inline explicit WhitenessWitness(FixedArray* array);
     inline ~WhitenessWitness();
 
    private:
     IncrementalMarking* marking_;
   };
 
   // Returns true for both shared empty_descriptor_array and for smis, which the
   // map uses to encode additional bit fields when the descriptor array is not
@@ skipping 187 matching lines @@
   static const int kMaxNumberOfDescriptors = 1024 + 512;
 
   // Returns the fixed array length required to hold number_of_descriptors
   // descriptors.
   static int LengthFor(int number_of_descriptors) {
     return ToKeyIndex(number_of_descriptors);
   }
 
  private:
   // An entry in a DescriptorArray, represented as an (array, index) pair.
-  class Entry V8_FINAL {
+  class Entry {
    public:
     inline explicit Entry(DescriptorArray* descs, int index) :
         descs_(descs), index_(index) { }
 
     inline PropertyType type() { return descs_->GetType(index_); }
     inline Object* GetCallbackObject() { return descs_->GetValue(index_); }
 
    private:
     DescriptorArray* descs_;
     int index_;
@@ skipping 78 matching lines @@
     return Hash(key);
   }
   static uint32_t HashForObject(Key key, Object* object) { return 0; }
   static uint32_t SeededHashForObject(Key key, uint32_t seed, Object* object) {
     ASSERT(UsesSeed);
     return HashForObject(key, object);
   }
 };
 
 template<typename Shape, typename Key>
-class HashTable : public FixedArray {
+class HashTable: public FixedArray {
  public:
   enum MinimumCapacity {
     USE_DEFAULT_MINIMUM_CAPACITY,
     USE_CUSTOM_MINIMUM_CAPACITY
   };
 
   // Wrapper methods
   inline uint32_t Hash(Key key) {
     if (Shape::UsesSeed) {
       return Shape::SeededHash(key,
@@ skipping 166 matching lines @@
   // Returns the hash value for object.
   virtual uint32_t HashForObject(Object* key) = 0;
   // Returns the key object for storing into the hash table.
   // If allocations fails a failure object is returned.
   MUST_USE_RESULT virtual MaybeObject* AsObject(Heap* heap) = 0;
   // Required.
   virtual ~HashTableKey() {}
 };
 
 
-class StringTableShape V8_FINAL : public BaseShape<HashTableKey*> {
+class StringTableShape : public BaseShape<HashTableKey*> {
  public:
   static inline bool IsMatch(HashTableKey* key, Object* value) {
     return key->IsMatch(value);
   }
   static inline uint32_t Hash(HashTableKey* key) {
     return key->Hash();
   }
   static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
     return key->HashForObject(object);
   }
   MUST_USE_RESULT static inline MaybeObject* AsObject(Heap* heap,
                                                       HashTableKey* key) {
     return key->AsObject(heap);
   }
 
   static const int kPrefixSize = 0;
   static const int kEntrySize = 1;
 };
 
 class SeqOneByteString;
 
 // StringTable.
 //
 // No special elements in the prefix and the element size is 1
 // because only the string itself (the key) needs to be stored.
-class StringTable V8_FINAL : public HashTable<StringTableShape, HashTableKey*> {
+class StringTable: public HashTable<StringTableShape, HashTableKey*> {
  public:
   // Find string in the string table.  If it is not there yet, it is
   // added.  The return value is the string table which might have
   // been enlarged.  If the return value is not a failure, the string
   // pointer *s is set to the string found.
   MUST_USE_RESULT MaybeObject* LookupUtf8String(
       Vector<const char> str,
       Object** s);
   MUST_USE_RESULT MaybeObject* LookupOneByteString(
       Vector<const uint8_t> str,
@@ skipping 19 matching lines @@
 
  private:
   MUST_USE_RESULT MaybeObject* LookupKey(HashTableKey* key, Object** s);
 
   template <bool seq_ascii> friend class JsonParser;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StringTable);
 };
 
 
-class MapCacheShape V8_FINAL : public BaseShape<HashTableKey*> {
+class MapCacheShape : public BaseShape<HashTableKey*> {
  public:
   static inline bool IsMatch(HashTableKey* key, Object* value) {
     return key->IsMatch(value);
   }
   static inline uint32_t Hash(HashTableKey* key) {
     return key->Hash();
   }
 
   static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
     return key->HashForObject(object);
   }
 
   MUST_USE_RESULT static inline MaybeObject* AsObject(Heap* heap,
                                                       HashTableKey* key) {
     return key->AsObject(heap);
   }
 
   static const int kPrefixSize = 0;
   static const int kEntrySize = 2;
 };
 
 
 // MapCache.
 //
 // Maps keys that are a fixed array of unique names to a map.
 // Used for canonicalize maps for object literals.
-class MapCache V8_FINAL : public HashTable<MapCacheShape, HashTableKey*> {
+class MapCache: public HashTable<MapCacheShape, HashTableKey*> {
  public:
   // Find cached value for a name key, otherwise return null.
   Object* Lookup(FixedArray* key);
   MUST_USE_RESULT MaybeObject* Put(FixedArray* key, Map* value);
   static inline MapCache* cast(Object* obj);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(MapCache);
 };
 
 
 template <typename Shape, typename Key>
-class Dictionary : public HashTable<Shape, Key> {
+class Dictionary: public HashTable<Shape, Key> {
  public:
   static inline Dictionary<Shape, Key>* cast(Object* obj) {
     return reinterpret_cast<Dictionary<Shape, Key>*>(obj);
   }
 
   // Returns the value at entry.
   Object* ValueAt(int entry) {
     return this->get(HashTable<Shape, Key>::EntryToIndex(entry) + 1);
   }
 
@@ skipping 93 matching lines @@
                                         uint32_t hash);
 
   // Generate new enumeration indices to avoid enumeration index overflow.
   MUST_USE_RESULT MaybeObject* GenerateNewEnumerationIndices();
   static const int kMaxNumberKeyIndex =
       HashTable<Shape, Key>::kPrefixStartIndex;
   static const int kNextEnumerationIndexIndex = kMaxNumberKeyIndex + 1;
 };
 
 
-class NameDictionaryShape V8_FINAL : public BaseShape<Name*> {
+class NameDictionaryShape : public BaseShape<Name*> {
  public:
   static inline bool IsMatch(Name* key, Object* other);
   static inline uint32_t Hash(Name* key);
   static inline uint32_t HashForObject(Name* key, Object* object);
   MUST_USE_RESULT static inline MaybeObject* AsObject(Heap* heap,
                                                       Name* key);
   static const int kPrefixSize = 2;
   static const int kEntrySize = 3;
   static const bool kIsEnumerable = true;
 };
 
 
-class NameDictionary V8_FINAL : public Dictionary<NameDictionaryShape, Name*> {
+class NameDictionary: public Dictionary<NameDictionaryShape, Name*> {
  public:
   static inline NameDictionary* cast(Object* obj) {
     ASSERT(obj->IsDictionary());
     return reinterpret_cast<NameDictionary*>(obj);
   }
 
   // Copies enumerable keys to preallocated fixed array.
   FixedArray* CopyEnumKeysTo(FixedArray* storage);
   static void DoGenerateNewEnumerationIndices(
       Handle<NameDictionary> dictionary);
@@ skipping 12 matching lines @@
 class NumberDictionaryShape : public BaseShape<uint32_t> {
  public:
   static inline bool IsMatch(uint32_t key, Object* other);
   MUST_USE_RESULT static inline MaybeObject* AsObject(Heap* heap,
                                                       uint32_t key);
   static const int kEntrySize = 3;
   static const bool kIsEnumerable = false;
 };
 
 
-class SeededNumberDictionaryShape V8_FINAL : public NumberDictionaryShape {
+class SeededNumberDictionaryShape : public NumberDictionaryShape {
  public:
   static const bool UsesSeed = true;
   static const int kPrefixSize = 2;
 
   static inline uint32_t SeededHash(uint32_t key, uint32_t seed);
   static inline uint32_t SeededHashForObject(uint32_t key,
                                              uint32_t seed,
                                              Object* object);
 };
 
 
-class UnseededNumberDictionaryShape V8_FINAL : public NumberDictionaryShape {
+class UnseededNumberDictionaryShape : public NumberDictionaryShape {
  public:
   static const int kPrefixSize = 0;
 
   static inline uint32_t Hash(uint32_t key);
   static inline uint32_t HashForObject(uint32_t key, Object* object);
 };
 
 
-class SeededNumberDictionary V8_FINAL
+class SeededNumberDictionary
     : public Dictionary<SeededNumberDictionaryShape, uint32_t> {
  public:
   static SeededNumberDictionary* cast(Object* obj) {
     ASSERT(obj->IsDictionary());
     return reinterpret_cast<SeededNumberDictionary*>(obj);
   }
 
   // Type specific at put (default NONE attributes is used when adding).
   MUST_USE_RESULT MaybeObject* AtNumberPut(uint32_t key, Object* value);
   MUST_USE_RESULT MaybeObject* AddNumberEntry(uint32_t key,
@@ skipping 27 matching lines @@
   // requires_slow_elements returns false.
   inline uint32_t max_number_key();
 
   // Bit masks.
   static const int kRequiresSlowElementsMask = 1;
   static const int kRequiresSlowElementsTagSize = 1;
   static const uint32_t kRequiresSlowElementsLimit = (1 << 29) - 1;
 };
 
 
-class UnseededNumberDictionary V8_FINAL
+class UnseededNumberDictionary
     : public Dictionary<UnseededNumberDictionaryShape, uint32_t> {
  public:
   static UnseededNumberDictionary* cast(Object* obj) {
     ASSERT(obj->IsDictionary());
     return reinterpret_cast<UnseededNumberDictionary*>(obj);
   }
 
   // Type specific at put (default NONE attributes is used when adding).
   MUST_USE_RESULT MaybeObject* AtNumberPut(uint32_t key, Object* value);
   MUST_USE_RESULT MaybeObject* AddNumberEntry(uint32_t key, Object* value);
 
   // Set an existing entry or add a new one if needed.
   // Return the updated dictionary.
   MUST_USE_RESULT static Handle<UnseededNumberDictionary> Set(
       Handle<UnseededNumberDictionary> dictionary,
       uint32_t index,
       Handle<Object> value);
 
   MUST_USE_RESULT MaybeObject* Set(uint32_t key, Object* value);
 };
 
 
 template <int entrysize>
-class ObjectHashTableShape V8_FINAL : public BaseShape<Object*> {
+class ObjectHashTableShape : public BaseShape<Object*> {
  public:
   static inline bool IsMatch(Object* key, Object* other);
   static inline uint32_t Hash(Object* key);
   static inline uint32_t HashForObject(Object* key, Object* object);
   MUST_USE_RESULT static inline MaybeObject* AsObject(Heap* heap,
                                                       Object* key);
   static const int kPrefixSize = 0;
   static const int kEntrySize = entrysize;
 };
 
 
 // ObjectHashSet holds keys that are arbitrary objects by using the identity
 // hash of the key for hashing purposes.
-class ObjectHashSet V8_FINAL
-    : public HashTable<ObjectHashTableShape<1>, Object*> {
+class ObjectHashSet: public HashTable<ObjectHashTableShape<1>, Object*> {
  public:
   static inline ObjectHashSet* cast(Object* obj) {
     ASSERT(obj->IsHashTable());
     return reinterpret_cast<ObjectHashSet*>(obj);
   }
 
   // Looks up whether the given key is part of this hash set.
   bool Contains(Object* key);
 
   // Adds the given key to this hash set.
   MUST_USE_RESULT MaybeObject* Add(Object* key);
 
   // Removes the given key from this hash set.
   MUST_USE_RESULT MaybeObject* Remove(Object* key);
 };
 
 
 // ObjectHashTable maps keys that are arbitrary objects to object values by
 // using the identity hash of the key for hashing purposes.
-class ObjectHashTable V8_FINAL
-    : public HashTable<ObjectHashTableShape<2>, Object*> {
+class ObjectHashTable: public HashTable<ObjectHashTableShape<2>, Object*> {
  public:
   static inline ObjectHashTable* cast(Object* obj) {
     ASSERT(obj->IsHashTable());
     return reinterpret_cast<ObjectHashTable*>(obj);
   }
 
   // Looks up the value associated with the given key. The hole value is
   // returned in case the key is not present.
   Object* Lookup(Object* key);
 
@@ skipping 14 matching lines @@
 };
 
 
 // JSFunctionResultCache caches results of some JSFunction invocation.
 // It is a fixed array with fixed structure:
 //   [0]: factory function
 //   [1]: finger index
 //   [2]: current cache size
 //   [3]: dummy field.
 // The rest of array are key/value pairs.
-class JSFunctionResultCache V8_FINAL : public FixedArray {
+class JSFunctionResultCache: public FixedArray {
  public:
   static const int kFactoryIndex = 0;
   static const int kFingerIndex = kFactoryIndex + 1;
   static const int kCacheSizeIndex = kFingerIndex + 1;
   static const int kDummyIndex = kCacheSizeIndex + 1;
   static const int kEntriesIndex = kDummyIndex + 1;
 
   static const int kEntrySize = 2;  // key + value
 
   static const int kFactoryOffset = kHeaderSize;
@@ skipping 15 matching lines @@
 };
 
 
 // ScopeInfo represents information about different scopes of a source
 // program  and the allocation of the scope's variables. Scope information
 // is stored in a compressed form in ScopeInfo objects and is used
 // at runtime (stack dumps, deoptimization, etc.).
 
 // This object provides quick access to scope info details for runtime
 // routines.
-class ScopeInfo V8_FINAL : public FixedArray {
+class ScopeInfo : public FixedArray {
  public:
   static inline ScopeInfo* cast(Object* object);
 
   // Return the type of this scope.
   ScopeType scope_type();
 
   // Does this scope call eval?
   bool CallsEval();
 
   // Return the language mode of this scope.
@@ skipping 183 matching lines @@
   // BitFields representing the encoded information for context locals in the
   // ContextLocalInfoEntries part.
   class ContextLocalMode:      public BitField<VariableMode,         0, 3> {};
   class ContextLocalInitFlag:  public BitField<InitializationFlag,   3, 1> {};
 };
 
 
 // The cache for maps used by normalized (dictionary mode) objects.
 // Such maps do not have property descriptors, so a typical program
 // needs very limited number of distinct normalized maps.
-class NormalizedMapCache V8_FINAL : public FixedArray {
+class NormalizedMapCache: public FixedArray {
  public:
   static const int kEntries = 64;
 
   MUST_USE_RESULT MaybeObject* Get(JSObject* object,
                                    PropertyNormalizationMode mode);
 
   void Clear();
 
   // Casting
   static inline NormalizedMapCache* cast(Object* obj);
 
   DECLARE_VERIFIER(NormalizedMapCache)
 };
 
 
 // ByteArray represents fixed sized byte arrays.  Used for the relocation info
 // that is attached to code objects.
-class ByteArray V8_FINAL : public FixedArrayBase {
+class ByteArray: public FixedArrayBase {
  public:
   inline int Size() { return RoundUp(length() + kHeaderSize, kPointerSize); }
 
   // Setter and getter.
   inline byte get(int index);
   inline void set(int index, byte value);
 
   // Treat contents as an int array.
   inline int get_int(int index);
 
@@ skipping 34 matching lines @@
   // Maximal length of a single ByteArray.
   static const int kMaxLength = kMaxSize - kHeaderSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ByteArray);
 };
 
 
 // FreeSpace represents fixed sized areas of the heap that are not currently in
 // use.  Used by the heap and GC.
-class FreeSpace V8_FINAL : public HeapObject {
+class FreeSpace: public HeapObject {
  public:
   // [size]: size of the free space including the header.
   inline int size();
   inline void set_size(int value);
 
   inline int Size() { return size(); }
 
   // Casting.
   static inline FreeSpace* cast(Object* obj);
 
@@ skipping 17 matching lines @@
 // which live outside the JavaScript heap. Its subclasses are used to
 // implement the CanvasArray types being defined in the WebGL
 // specification. As of this writing the first public draft is not yet
 // available, but Khronos members can access the draft at:
 //   https://cvs.khronos.org/svn/repos/3dweb/trunk/doc/spec/WebGL-spec.html
 //
 // The semantics of these arrays differ from CanvasPixelArray.
 // Out-of-range values passed to the setter are converted via a C
 // cast, not clamping. Out-of-range indices cause exceptions to be
 // raised rather than being silently ignored.
-class ExternalArray : public FixedArrayBase {
+class ExternalArray: public FixedArrayBase {
  public:
   inline bool is_the_hole(int index) { return false; }
 
   // [external_pointer]: The pointer to the external memory area backing this
   // external array.
   DECL_ACCESSORS(external_pointer, void)  // Pointer to the data store.
 
   // Casting.
   static inline ExternalArray* cast(Object* obj);
 
@@ skipping 12 matching lines @@
 
 
 // A ExternalPixelArray represents a fixed-size byte array with special
 // semantics used for implementing the CanvasPixelArray object. Please see the
 // specification at:
 
 // http://www.whatwg.org/specs/web-apps/current-work/
 //                      multipage/the-canvas-element.html#canvaspixelarray
 // In particular, write access clamps the value written to 0 or 255 if the
 // value written is outside this range.
-class ExternalPixelArray V8_FINAL : public ExternalArray {
+class ExternalPixelArray: public ExternalArray {
  public:
   inline uint8_t* external_pixel_pointer();
 
   // Setter and getter.
   inline uint8_t get_scalar(int index);
   MUST_USE_RESULT inline MaybeObject* get(int index);
   inline void set(int index, uint8_t value);
 
   // This accessor applies the correct conversion from Smi, HeapNumber and
   // undefined and clamps the converted value between 0 and 255.
   Object* SetValue(uint32_t index, Object* value);
 
   // Casting.
   static inline ExternalPixelArray* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(ExternalPixelArray)
   DECLARE_VERIFIER(ExternalPixelArray)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalPixelArray);
 };
 
 
-class ExternalByteArray V8_FINAL : public ExternalArray {
+class ExternalByteArray: public ExternalArray {
  public:
   // Setter and getter.
   inline int8_t get_scalar(int index);
   MUST_USE_RESULT inline MaybeObject* get(int index);
   inline void set(int index, int8_t value);
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
   MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
 
   // Casting.
   static inline ExternalByteArray* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(ExternalByteArray)
   DECLARE_VERIFIER(ExternalByteArray)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalByteArray);
 };
 
 
-class ExternalUnsignedByteArray V8_FINAL : public ExternalArray {
+class ExternalUnsignedByteArray: public ExternalArray {
  public:
   // Setter and getter.
   inline uint8_t get_scalar(int index);
   MUST_USE_RESULT inline MaybeObject* get(int index);
   inline void set(int index, uint8_t value);
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
   MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
 
   // Casting.
   static inline ExternalUnsignedByteArray* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(ExternalUnsignedByteArray)
   DECLARE_VERIFIER(ExternalUnsignedByteArray)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalUnsignedByteArray);
 };
 
 
-class ExternalShortArray V8_FINAL : public ExternalArray {
+class ExternalShortArray: public ExternalArray {
  public:
   // Setter and getter.
   inline int16_t get_scalar(int index);
   MUST_USE_RESULT inline MaybeObject* get(int index);
   inline void set(int index, int16_t value);
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
   MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
 
   // Casting.
   static inline ExternalShortArray* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(ExternalShortArray)
   DECLARE_VERIFIER(ExternalShortArray)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalShortArray);
 };
 
 
-class ExternalUnsignedShortArray V8_FINAL : public ExternalArray {
+class ExternalUnsignedShortArray: public ExternalArray {
  public:
   // Setter and getter.
   inline uint16_t get_scalar(int index);
   MUST_USE_RESULT inline MaybeObject* get(int index);
   inline void set(int index, uint16_t value);
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
   MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
 
   // Casting.
   static inline ExternalUnsignedShortArray* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(ExternalUnsignedShortArray)
   DECLARE_VERIFIER(ExternalUnsignedShortArray)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalUnsignedShortArray);
 };
 
 
-class ExternalIntArray V8_FINAL : public ExternalArray {
+class ExternalIntArray: public ExternalArray {
  public:
   // Setter and getter.
   inline int32_t get_scalar(int index);
   MUST_USE_RESULT inline MaybeObject* get(int index);
   inline void set(int index, int32_t value);
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
   MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
 
   // Casting.
   static inline ExternalIntArray* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(ExternalIntArray)
   DECLARE_VERIFIER(ExternalIntArray)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalIntArray);
 };
 
 
-class ExternalUnsignedIntArray V8_FINAL : public ExternalArray {
+class ExternalUnsignedIntArray: public ExternalArray {
  public:
   // Setter and getter.
   inline uint32_t get_scalar(int index);
   MUST_USE_RESULT inline MaybeObject* get(int index);
   inline void set(int index, uint32_t value);
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
   MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
 
   // Casting.
   static inline ExternalUnsignedIntArray* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(ExternalUnsignedIntArray)
   DECLARE_VERIFIER(ExternalUnsignedIntArray)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalUnsignedIntArray);
 };
 
 
-class ExternalFloatArray V8_FINAL : public ExternalArray {
+class ExternalFloatArray: public ExternalArray {
  public:
   // Setter and getter.
   inline float get_scalar(int index);
   MUST_USE_RESULT inline MaybeObject* get(int index);
   inline void set(int index, float value);
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
   MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
 
   // Casting.
   static inline ExternalFloatArray* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(ExternalFloatArray)
   DECLARE_VERIFIER(ExternalFloatArray)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalFloatArray);
 };
 
 
-class ExternalDoubleArray V8_FINAL : public ExternalArray {
+class ExternalDoubleArray: public ExternalArray {
  public:
   // Setter and getter.
   inline double get_scalar(int index);
   MUST_USE_RESULT inline MaybeObject* get(int index);
   inline void set(int index, double value);
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
   MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
 
   // Casting.
   static inline ExternalDoubleArray* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(ExternalDoubleArray)
   DECLARE_VERIFIER(ExternalDoubleArray)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalDoubleArray);
 };
 
 
 // DeoptimizationInputData is a fixed array used to hold the deoptimization
 // data for code generated by the Hydrogen/Lithium compiler.  It also
 // contains information about functions that were inlined.  If N different
 // functions were inlined then first N elements of the literal array will
 // contain these functions.
 //
 // It can be empty.
-class DeoptimizationInputData V8_FINAL : public FixedArray {
+class DeoptimizationInputData: public FixedArray {
  public:
   // Layout description.  Indices in the array.
   static const int kTranslationByteArrayIndex = 0;
   static const int kInlinedFunctionCountIndex = 1;
   static const int kLiteralArrayIndex = 2;
   static const int kOsrAstIdIndex = 3;
   static const int kOsrPcOffsetIndex = 4;
   static const int kFirstDeoptEntryIndex = 5;
 
   // Offsets of deopt entry elements relative to the start of the entry.
@@ skipping 68 matching lines @@
     return IndexForEntry(entry_count);
   }
 };
 
 
 // DeoptimizationOutputData is a fixed array used to hold the deoptimization
 // data for code generated by the full compiler.
 // The format of the these objects is
 //   [i * 2]: Ast ID for ith deoptimization.
 //   [i * 2 + 1]: PC and state of ith deoptimization
-class DeoptimizationOutputData V8_FINAL : public FixedArray {
+class DeoptimizationOutputData: public FixedArray {
  public:
   int DeoptPoints() { return length() / 2; }
 
   BailoutId AstId(int index) {
     return BailoutId(Smi::cast(get(index * 2))->value());
   }
 
   void SetAstId(int index, BailoutId id) {
     set(index * 2, Smi::FromInt(id.ToInt()));
   }
@@ skipping 20 matching lines @@
 
 // Forward declaration.
 class Cell;
 class PropertyCell;
 
 // TypeFeedbackCells is a fixed array used to hold the association between
 // cache cells and AST ids for code generated by the full compiler.
 // The format of the these objects is
 //   [i * 2]: Global property cell of ith cache cell.
 //   [i * 2 + 1]: Ast ID for ith cache cell.
-class TypeFeedbackCells V8_FINAL : public FixedArray {
+class TypeFeedbackCells: public FixedArray {
  public:
   int CellCount() { return length() / 2; }
   static int LengthOfFixedArray(int cell_count) { return cell_count * 2; }
 
   // Accessors for AST ids associated with cache values.
   inline TypeFeedbackId AstId(int index);
   inline void SetAstId(int index, TypeFeedbackId id);
 
   // Accessors for global property cells holding the cache values.
   inline Cell* GetCell(int index);
@@ skipping 20 matching lines @@
   static const int kForInFastCaseMarker = 0;
   static const int kForInSlowCaseMarker = 1;
 };
 
 
 // Forward declaration.
 class SafepointEntry;
 class TypeFeedbackInfo;
 
 // Code describes objects with on-the-fly generated machine code.
-class Code V8_FINAL : public HeapObject {
+class Code: public HeapObject {
  public:
   // Opaque data type for encapsulating code flags like kind, inline
   // cache state, and arguments count.
   typedef uint32_t Flags;
 
 #define NON_IC_KIND_LIST(V) \
   V(FUNCTION)               \
   V(OPTIMIZED_FUNCTION)     \
   V(STUB)                   \
   V(BUILTIN)                \
@@ skipping 550 matching lines @@
 // The first n elements are Smis, each of them specifies the number of codes
 // in the corresponding group. The subsequent elements contain grouped code
 // objects. The suffix of the array can be filled with the undefined value if
 // the number of codes is less than the length of the array. The order of the
 // code objects within a group is not preserved.
 //
 // All code indexes used in the class are counted starting from the first
 // code object of the first group. In other words, code index 0 corresponds
 // to array index n = kCodesStartIndex.
 
-class DependentCode V8_FINAL : public FixedArray {
+class DependentCode: public FixedArray {
  public:
   enum DependencyGroup {
     // Group of code that weakly embed this map and depend on being
     // deoptimized when the map is garbage collected.
     kWeaklyEmbeddedGroup,
     // Group of code that embed a transition to this map, and depend on being
     // deoptimized when the transition is replaced by a new version.
     kTransitionGroup,
     // Group of code that omit run-time prototype checks for prototypes
     // described by this map. The group is deoptimized whenever an object
     // described by this map changes shape (and transitions to a new map),
     // possibly invalidating the assumptions embedded in the code.
     kPrototypeCheckGroup,
     // Group of code that depends on elements not being added to objects with
     // this map.
     kElementsCantBeAddedGroup,
     // Group of code that depends on global property values in property cells
     // not being changed.
     kPropertyCellChangedGroup,
     kGroupCount = kPropertyCellChangedGroup + 1
   };
 
   // Array for holding the index of the first code object of each group.
   // The last element stores the total number of code objects.
-  class GroupStartIndexes V8_FINAL {
+  class GroupStartIndexes {
    public:
     explicit GroupStartIndexes(DependentCode* entries);
     void Recompute(DependentCode* entries);
     int at(int i) { return start_indexes_[i]; }
     int number_of_entries() { return start_indexes_[kGroupCount]; }
    private:
     int start_indexes_[kGroupCount + 1];
   };
 
   bool Contains(DependencyGroup group, Code* code);
@@ skipping 31 matching lines @@
   // code objects of the subsequent groups.
   inline void ExtendGroup(DependencyGroup group);
   static const int kCodesStartIndex = kGroupCount;
 };
 
 
 // All heap objects have a Map that describes their structure.
 //  A Map contains information about:
 //  - Size information about the object
 //  - How to iterate over an object (for garbage collection)
-class Map : public HeapObject {
+class Map: public HeapObject {
  public:
   // Instance size.
   // Size in bytes or kVariableSizeSentinel if instances do not have
   // a fixed size.
   inline int instance_size();
   inline void set_instance_size(int value);
 
   // Count of properties allocated in the object.
   inline int inobject_properties();
   inline void set_inobject_properties(int value);
@@ skipping 633 matching lines @@
 // It doesn't carry much functionality but allows struct classes to be
 // identified in the type system.
 class Struct: public HeapObject {
  public:
   inline void InitializeBody(int object_size);
   static inline Struct* cast(Object* that);
 };
 
 
 // A simple one-element struct, useful where smis need to be boxed.
-class Box V8_FINAL : public Struct {
+class Box : public Struct {
  public:
   // [value]: the boxed contents.
   DECL_ACCESSORS(value, Object)
 
   static inline Box* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(Box)
   DECLARE_VERIFIER(Box)
 
   static const int kValueOffset = HeapObject::kHeaderSize;
   static const int kSize = kValueOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(Box);
 };
 
 
 // Script describes a script which has been added to the VM.
-class Script V8_FINAL : public Struct {
+class Script: public Struct {
  public:
   // Script types.
   enum Type {
     TYPE_NATIVE = 0,
     TYPE_EXTENSION = 1,
     TYPE_NORMAL = 2
   };
 
   // Script compilation types.
   enum CompilationType {
@@ skipping 148 matching lines @@
 #undef DECLARE_FUNCTION_ID
   // Fake id for a special case of Math.pow. Note, it continues the
   // list of math functions.
   kMathPowHalf,
   kFirstMathFunctionId = kMathFloor
 };
 
 
 // SharedFunctionInfo describes the JSFunction information that can be
 // shared by multiple instances of the function.
-class SharedFunctionInfo V8_FINAL : public HeapObject {
+class SharedFunctionInfo: public HeapObject {
  public:
   // [name]: Function name.
   DECL_ACCESSORS(name, Object)
 
   // [code]: Function code.
   DECL_ACCESSORS(code, Code)
   inline void ReplaceCode(Code* code);
 
   // [optimized_code_map]: Map from native context to optimized code
   // and a shared literals array or Smi(0) if none.
@@ skipping 558 matching lines @@
       ((kNative + kCompilerHintsSmiTagSize) / kBitsPerByte);
 #else
 #error Unknown byte ordering
 #endif
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(SharedFunctionInfo);
 };
 
 
-class JSGeneratorObject V8_FINAL : public JSObject {
+class JSGeneratorObject: public JSObject {
  public:
   // [function]: The function corresponding to this generator object.
   DECL_ACCESSORS(function, JSFunction)
 
   // [context]: The context of the suspended computation.
   DECL_ACCESSORS(context, Context)
 
   // [receiver]: The receiver of the suspended computation.
   DECL_ACCESSORS(receiver, Object)
 
@@ skipping 47 matching lines @@
   static const int kResultDonePropertyOffset =
       kResultValuePropertyOffset + kPointerSize;
   static const int kResultSize = kResultDonePropertyOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSGeneratorObject);
 };
 
 
 // Representation for module instance objects.
-class JSModule V8_FINAL : public JSObject {
+class JSModule: public JSObject {
  public:
   // [context]: the context holding the module's locals, or undefined if none.
   DECL_ACCESSORS(context, Object)
 
   // [scope_info]: Scope info.
   DECL_ACCESSORS(scope_info, ScopeInfo)
 
   // Casting.
   static inline JSModule* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(JSModule)
   DECLARE_VERIFIER(JSModule)
 
   // Layout description.
   static const int kContextOffset = JSObject::kHeaderSize;
   static const int kScopeInfoOffset = kContextOffset + kPointerSize;
   static const int kSize = kScopeInfoOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSModule);
 };
 
 
 // JSFunction describes JavaScript functions.
-class JSFunction V8_FINAL : public JSObject {
+class JSFunction: public JSObject {
  public:
   // [prototype_or_initial_map]:
   DECL_ACCESSORS(prototype_or_initial_map, Object)
 
   // [shared]: The information about the function that
   // can be shared by instances.
   DECL_ACCESSORS(shared, SharedFunctionInfo)
 
   // [context]: The context for this function.
   inline Context* context();
@@ skipping 166 matching lines @@
 
 
 // JSGlobalProxy's prototype must be a JSGlobalObject or null,
 // and the prototype is hidden. JSGlobalProxy always delegates
 // property accesses to its prototype if the prototype is not null.
 //
 // A JSGlobalProxy can be reinitialized which will preserve its identity.
 //
 // Accessing a JSGlobalProxy requires security check.
 
-class JSGlobalProxy V8_FINAL : public JSObject {
+class JSGlobalProxy : public JSObject {
  public:
   // [native_context]: the owner native context of this global proxy object.
   // It is null value if this object is not used by any context.
   DECL_ACCESSORS(native_context, Object)
 
   // Casting.
   static inline JSGlobalProxy* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(JSGlobalProxy)
   DECLARE_VERIFIER(JSGlobalProxy)
 
   // Layout description.
   static const int kNativeContextOffset = JSObject::kHeaderSize;
   static const int kSize = kNativeContextOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSGlobalProxy);
 };
 
 
 // Forward declaration.
 class JSBuiltinsObject;
 
 // Common super class for JavaScript global objects and the special
 // builtins global objects.
-class GlobalObject : public JSObject {
+class GlobalObject: public JSObject {
  public:
   // [builtins]: the object holding the runtime routines written in JS.
   DECL_ACCESSORS(builtins, JSBuiltinsObject)
 
   // [native context]: the natives corresponding to this global object.
   DECL_ACCESSORS(native_context, Context)
 
   // [global context]: the most recent (i.e. innermost) global context.
   DECL_ACCESSORS(global_context, Context)
 
@@ skipping 25 matching lines @@
   static const int kGlobalContextOffset = kNativeContextOffset + kPointerSize;
   static const int kGlobalReceiverOffset = kGlobalContextOffset + kPointerSize;
   static const int kHeaderSize = kGlobalReceiverOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(GlobalObject);
 };
 
 
 // JavaScript global object.
-class JSGlobalObject V8_FINAL : public GlobalObject {
+class JSGlobalObject: public GlobalObject {
  public:
   // Casting.
   static inline JSGlobalObject* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(JSGlobalObject)
   DECLARE_VERIFIER(JSGlobalObject)
 
   // Layout description.
   static const int kSize = GlobalObject::kHeaderSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSGlobalObject);
 };
 
 
 // Builtins global object which holds the runtime routines written in
 // JavaScript.
-class JSBuiltinsObject V8_FINAL : public GlobalObject {
+class JSBuiltinsObject: public GlobalObject {
  public:
   // Accessors for the runtime routines written in JavaScript.
   inline Object* javascript_builtin(Builtins::JavaScript id);
   inline void set_javascript_builtin(Builtins::JavaScript id, Object* value);
 
   // Accessors for code of the runtime routines written in JavaScript.
   inline Code* javascript_builtin_code(Builtins::JavaScript id);
   inline void set_javascript_builtin_code(Builtins::JavaScript id, Code* value);
 
   // Casting.
@@ skipping 20 matching lines @@
   static int OffsetOfCodeWithId(Builtins::JavaScript id) {
     return kJSBuiltinsCodeOffset + id * kPointerSize;
   }
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSBuiltinsObject);
 };
 
 
 // Representation for JS Wrapper objects, String, Number, Boolean, etc.
-class JSValue V8_FINAL : public JSObject {
+class JSValue: public JSObject {
  public:
   // [value]: the object being wrapped.
   DECL_ACCESSORS(value, Object)
 
   // Casting.
   static inline JSValue* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(JSValue)
   DECLARE_VERIFIER(JSValue)
 
   // Layout description.
   static const int kValueOffset = JSObject::kHeaderSize;
   static const int kSize = kValueOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSValue);
 };
 
 
 class DateCache;
 
 // Representation for JS date objects.
-class JSDate V8_FINAL : public JSObject {
+class JSDate: public JSObject {
  public:
   // If one component is NaN, all of them are, indicating a NaN time value.
   // [value]: the time value.
   DECL_ACCESSORS(value, Object)
   // [year]: caches year. Either undefined, smi, or NaN.
   DECL_ACCESSORS(year, Object)
   // [month]: caches month. Either undefined, smi, or NaN.
   DECL_ACCESSORS(month, Object)
   // [day]: caches day. Either undefined, smi, or NaN.
   DECL_ACCESSORS(day, Object)
@@ skipping 76 matching lines @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSDate);
 };
 
 
 // Representation of message objects used for error reporting through
 // the API. The messages are formatted in JavaScript so this object is
 // a real JavaScript object. The information used for formatting the
 // error messages are not directly accessible from JavaScript to
 // prevent leaking information to user code called during error
 // formatting.
-class JSMessageObject V8_FINAL : public JSObject {
+class JSMessageObject: public JSObject {
  public:
   // [type]: the type of error message.
   DECL_ACCESSORS(type, String)
 
   // [arguments]: the arguments for formatting the error message.
   DECL_ACCESSORS(arguments, JSArray)
 
   // [script]: the script from which the error message originated.
   DECL_ACCESSORS(script, Object)
 
@@ skipping 43 matching lines @@
 // - reference to the original flag string
 // If it is an atom regexp
 // - a reference to a literal string to search for
 // If it is an irregexp regexp:
 // - a reference to code for ASCII inputs (bytecode or compiled), or a smi
 // used for tracking the last usage (used for code flushing).
 // - a reference to code for UC16 inputs (bytecode or compiled), or a smi
 // used for tracking the last usage (used for code flushing)..
 // - max number of registers used by irregexp implementations.
 // - number of capture registers (output values) of the regexp.
-class JSRegExp V8_FINAL : public JSObject {
+class JSRegExp: public JSObject {
  public:
   // Meaning of Type:
   // NOT_COMPILED: Initial value. No data has been stored in the JSRegExp yet.
   // ATOM: A simple string to match against using an indexOf operation.
   // IRREGEXP: Compiled with Irregexp.
   // IRREGEXP_NATIVE: Compiled to native code with Irregexp.
   enum Type { NOT_COMPILED, ATOM, IRREGEXP };
   enum Flag { NONE = 0, GLOBAL = 1, IGNORE_CASE = 2, MULTILINE = 4 };
 
   class Flags {
@@ skipping 102 matching lines @@
   // object is in the saved code field.
   static const int kCompilationErrorValue = -2;
 
   // When we store the sweep generation at which we moved the code from the
   // code index to the saved code index we mask it of to be in the [0:255]
   // range.
   static const int kCodeAgeMask = 0xff;
 };
 
 
-class CompilationCacheShape V8_FINAL  : public BaseShape<HashTableKey*> {
+class CompilationCacheShape : public BaseShape<HashTableKey*> {
  public:
   static inline bool IsMatch(HashTableKey* key, Object* value) {
     return key->IsMatch(value);
   }
 
   static inline uint32_t Hash(HashTableKey* key) {
     return key->Hash();
   }
 
   static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
     return key->HashForObject(object);
   }
 
   MUST_USE_RESULT static MaybeObject* AsObject(Heap* heap,
                                                HashTableKey* key) {
     return key->AsObject(heap);
   }
 
   static const int kPrefixSize = 0;
   static const int kEntrySize = 2;
 };
 
 
-class CompilationCacheTable V8_FINAL : public HashTable<CompilationCacheShape,
-                                                     HashTableKey*> {
+class CompilationCacheTable: public HashTable<CompilationCacheShape,
+                                              HashTableKey*> {
  public:
   // Find cached value for a string key, otherwise return null.
   Object* Lookup(String* src, Context* context);
   Object* LookupEval(String* src,
                      Context* context,
                      LanguageMode language_mode,
                      int scope_position);
   Object* LookupRegExp(String* source, JSRegExp::Flags flags);
   MUST_USE_RESULT MaybeObject* Put(String* src,
                                    Context* context,
                                    Object* value);
   MUST_USE_RESULT MaybeObject* PutEval(String* src,
                                        Context* context,
                                        SharedFunctionInfo* value,
                                        int scope_position);
   MUST_USE_RESULT MaybeObject* PutRegExp(String* src,
                                          JSRegExp::Flags flags,
                                          FixedArray* value);
 
   // Remove given value from cache.
   void Remove(Object* value);
 
   static inline CompilationCacheTable* cast(Object* obj);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(CompilationCacheTable);
 };
 
 
-class CodeCache V8_FINAL : public Struct {
+class CodeCache: public Struct {
  public:
   DECL_ACCESSORS(default_cache, FixedArray)
   DECL_ACCESSORS(normal_type_cache, Object)
 
   // Add the code object to the cache.
   MUST_USE_RESULT MaybeObject* Update(Name* name, Code* code);
 
   // Lookup code object in the cache. Returns code object if found and undefined
   // if not.
   Object* Lookup(Name* name, Code::Flags flags);
@@ skipping 27 matching lines @@
   // Code cache layout of the default cache. Elements are alternating name and
   // code objects for non normal load/store/call IC's.
   static const int kCodeCacheEntrySize = 2;
   static const int kCodeCacheEntryNameOffset = 0;
   static const int kCodeCacheEntryCodeOffset = 1;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CodeCache);
 };
 
 
-class CodeCacheHashTableShape V8_FINAL : public BaseShape<HashTableKey*> {
+class CodeCacheHashTableShape : public BaseShape<HashTableKey*> {
  public:
   static inline bool IsMatch(HashTableKey* key, Object* value) {
     return key->IsMatch(value);
   }
 
   static inline uint32_t Hash(HashTableKey* key) {
     return key->Hash();
   }
 
   static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
     return key->HashForObject(object);
   }
 
   MUST_USE_RESULT static MaybeObject* AsObject(Heap* heap,
                                                HashTableKey* key) {
     return key->AsObject(heap);
   }
 
   static const int kPrefixSize = 0;
   static const int kEntrySize = 2;
 };
 
 
-class CodeCacheHashTable V8_FINAL : public HashTable<CodeCacheHashTableShape,
-                                                  HashTableKey*> {
+class CodeCacheHashTable: public HashTable<CodeCacheHashTableShape,
+                                           HashTableKey*> {
  public:
   Object* Lookup(Name* name, Code::Flags flags);
   MUST_USE_RESULT MaybeObject* Put(Name* name, Code* code);
 
   int GetIndex(Name* name, Code::Flags flags);
   void RemoveByIndex(int index);
 
   static inline CodeCacheHashTable* cast(Object* obj);
 
   // Initial size of the fixed array backing the hash table.
   static const int kInitialSize = 64;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(CodeCacheHashTable);
 };
 
 
-class PolymorphicCodeCache V8_FINAL : public Struct {
+class PolymorphicCodeCache: public Struct {
  public:
   DECL_ACCESSORS(cache, Object)
 
   static void Update(Handle<PolymorphicCodeCache> cache,
                      MapHandleList* maps,
                      Code::Flags flags,
                      Handle<Code> code);
 
   MUST_USE_RESULT MaybeObject* Update(MapHandleList* maps,
                                       Code::Flags flags,
                                       Code* code);
 
   // Returns an undefined value if the entry is not found.
   Handle<Object> Lookup(MapHandleList* maps, Code::Flags flags);
 
   static inline PolymorphicCodeCache* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(PolymorphicCodeCache)
   DECLARE_VERIFIER(PolymorphicCodeCache)
 
   static const int kCacheOffset = HeapObject::kHeaderSize;
   static const int kSize = kCacheOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PolymorphicCodeCache);
 };
 
 
-class PolymorphicCodeCacheHashTable V8_FINAL
+class PolymorphicCodeCacheHashTable
     : public HashTable<CodeCacheHashTableShape, HashTableKey*> {
  public:
   Object* Lookup(MapHandleList* maps, int code_kind);
 
   MUST_USE_RESULT MaybeObject* Put(MapHandleList* maps,
                                    int code_kind,
                                    Code* code);
 
   static inline PolymorphicCodeCacheHashTable* cast(Object* obj);
 
   static const int kInitialSize = 64;
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PolymorphicCodeCacheHashTable);
 };
 
 
-class TypeFeedbackInfo V8_FINAL : public Struct {
+class TypeFeedbackInfo: public Struct {
  public:
   inline int ic_total_count();
   inline void set_ic_total_count(int count);
 
   inline int ic_with_type_info_count();
   inline void change_ic_with_type_info_count(int count);
 
   inline void initialize_storage();
 
   inline void change_own_type_change_checksum();
@@ skipping 33 matching lines @@
 };
 
 
 enum AllocationSiteMode {
   DONT_TRACK_ALLOCATION_SITE,
   TRACK_ALLOCATION_SITE,
   LAST_ALLOCATION_SITE_MODE = TRACK_ALLOCATION_SITE
 };
 
 
-class AllocationSite V8_FINAL : public Struct {
+class AllocationSite: public Struct {
  public:
   static const uint32_t kMaximumArrayBytesToPretransition = 8 * 1024;
 
   DECL_ACCESSORS(transition_info, Object)
   DECL_ACCESSORS(weak_next, Object)
 
   void Initialize() {
     SetElementsKind(GetInitialFastElementsKind());
   }
 
@@ skipping 27 matching lines @@
 
   typedef FixedBodyDescriptor<HeapObject::kHeaderSize,
                               kTransitionInfoOffset + kPointerSize,
                               kSize> BodyDescriptor;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(AllocationSite);
 };
 
 
-class AllocationMemento V8_FINAL : public Struct {
+class AllocationMemento: public Struct {
  public:
   static const int kAllocationSiteOffset = HeapObject::kHeaderSize;
   static const int kSize = kAllocationSiteOffset + kPointerSize;
 
   DECL_ACCESSORS(allocation_site, Object)
 
   bool IsValid() { return allocation_site()->IsAllocationSite(); }
   AllocationSite* GetAllocationSite() {
     ASSERT(IsValid());
     return AllocationSite::cast(allocation_site());
@@ skipping 12 matching lines @@
 
 
 // Representation of a slow alias as part of a non-strict arguments objects.
 // For fast aliases (if HasNonStrictArgumentsElements()):
 // - the parameter map contains an index into the context
 // - all attributes of the element have default values
 // For slow aliases (if HasDictionaryArgumentsElements()):
 // - the parameter map contains no fast alias mapping (i.e. the hole)
 // - this struct (in the slow backing store) contains an index into the context
 // - all attributes are available as part if the property details
-class AliasedArgumentsEntry V8_FINAL : public Struct {
+class AliasedArgumentsEntry: public Struct {
  public:
   inline int aliased_context_slot();
   inline void set_aliased_context_slot(int count);
 
   static inline AliasedArgumentsEntry* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(AliasedArgumentsEntry)
   DECLARE_VERIFIER(AliasedArgumentsEntry)
 
@@ skipping 67 matching lines @@
 // few bits of information is moderately expensive, involving two memory
 // loads where the second is dependent on the first.  To improve efficiency
 // the shape of the string is given its own class so that it can be retrieved
 // once and used for several string operations.  A StringShape is small enough
 // to be passed by value and is immutable, but be aware that flattening a
 // string can potentially alter its shape.  Also be aware that a GC caused by
 // something else can alter the shape of a string due to ConsString
 // shortcutting.  Keeping these restrictions in mind has proven to be error-
 // prone and so we no longer put StringShapes in variables unless there is a
 // concrete performance benefit at that particular point in the code.
-class StringShape V8_FINAL BASE_EMBEDDED {
+class StringShape BASE_EMBEDDED {
  public:
   inline explicit StringShape(String* s);
   inline explicit StringShape(Map* s);
   inline explicit StringShape(InstanceType t);
   inline bool IsSequential();
   inline bool IsExternal();
   inline bool IsCons();
   inline bool IsSliced();
   inline bool IsIndirect();
   inline bool IsExternalAscii();
@@ skipping 19 matching lines @@
   inline void set_valid() { valid_ = true; }
   bool valid_;
 #else
   inline void set_valid() { }
 #endif
 };
 
 
 // The Name abstract class captures anything that can be used as a property
 // name, i.e., strings and symbols.  All names store a hash value.
-class Name : public HeapObject {
+class Name: public HeapObject {
  public:
   // Get and set the hash field of the name.
   inline uint32_t hash_field();
   inline void set_hash_field(uint32_t value);
 
   // Tells whether the hash code has been computed.
   inline bool HasHashCode();
 
   // Returns a hash value used for the property table
   inline uint32_t Hash();
@@ skipping 64 matching lines @@
 
  protected:
   static inline bool IsHashFieldComputed(uint32_t field);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(Name);
 };
 
 
 // ES6 symbols.
-class Symbol V8_FINAL : public Name {
+class Symbol: public Name {
  public:
   // [name]: the print name of a symbol, or undefined if none.
   DECL_ACCESSORS(name, Object)
 
   // Casting.
   static inline Symbol* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(Symbol)
   DECLARE_VERIFIER(Symbol)
@@ skipping 13 matching lines @@
 class ConsString;
 
 // The String abstract class captures JavaScript string values:
 //
 // Ecma-262:
 //  4.3.16 String Value
 //    A string value is a member of the type String and is a finite
 //    ordered sequence of zero or more 16-bit unsigned integer values.
 //
 // All string values have a length field.
-class String : public Name {
+class String: public Name {
  public:
   enum Encoding { ONE_BYTE_ENCODING, TWO_BYTE_ENCODING };
 
   // Representation of the flat content of a String.
   // A non-flat string doesn't have flat content.
   // A flat string has content that's encoded as a sequence of either
   // ASCII chars or two-byte UC16.
   // Returned by String::GetFlatContent().
   class FlatContent {
    public:
@@ skipping 294 matching lines @@
   bool SlowAsArrayIndex(uint32_t* index);
 
   // Compute and set the hash code.
   uint32_t ComputeAndSetHash();
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(String);
 };
 
 
 // The SeqString abstract class captures sequential string values.
-class SeqString : public String {
+class SeqString: public String {
  public:
   // Casting.
   static inline SeqString* cast(Object* obj);
 
   // Layout description.
   static const int kHeaderSize = String::kSize;
 
   // Truncate the string in-place if possible and return the result.
   // In case of new_length == 0, the empty string is returned without
   // truncating the original string.
   MUST_USE_RESULT static Handle<String> Truncate(Handle<SeqString> string,
                                                  int new_length);
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(SeqString);
 };
 
 
 // The AsciiString class captures sequential ASCII string objects.
 // Each character in the AsciiString is an ASCII character.
-class SeqOneByteString V8_FINAL : public SeqString {
+class SeqOneByteString: public SeqString {
  public:
   static const bool kHasAsciiEncoding = true;
 
   // Dispatched behavior.
   inline uint16_t SeqOneByteStringGet(int index);
   inline void SeqOneByteStringSet(int index, uint16_t value);
 
   // Get the address of the characters in this string.
   inline Address GetCharsAddress();
 
@@ skipping 18 matching lines @@
   // Q.v. String::kMaxLength which is the maximal size of concatenated strings.
   static const int kMaxLength = (kMaxSize - kHeaderSize);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(SeqOneByteString);
 };
 
 
 // The TwoByteString class captures sequential unicode string objects.
 // Each character in the TwoByteString is a two-byte uint16_t.
-class SeqTwoByteString V8_FINAL : public SeqString {
+class SeqTwoByteString: public SeqString {
  public:
   static const bool kHasAsciiEncoding = false;
 
   // Dispatched behavior.
   inline uint16_t SeqTwoByteStringGet(int index);
   inline void SeqTwoByteStringSet(int index, uint16_t value);
 
   // Get the address of the characters in this string.
   inline Address GetCharsAddress();
 
@@ skipping 27 matching lines @@
 
 
 // The ConsString class describes string values built by using the
 // addition operator on strings.  A ConsString is a pair where the
 // first and second components are pointers to other string values.
 // One or both components of a ConsString can be pointers to other
 // ConsStrings, creating a binary tree of ConsStrings where the leaves
 // are non-ConsString string values.  The string value represented by
 // a ConsString can be obtained by concatenating the leaf string
 // values in a left-to-right depth-first traversal of the tree.
-class ConsString V8_FINAL : public String {
+class ConsString: public String {
  public:
   // First string of the cons cell.
   inline String* first();
   // Doesn't check that the result is a string, even in debug mode.  This is
   // useful during GC where the mark bits confuse the checks.
   inline Object* unchecked_first();
   inline void set_first(String* first,
                         WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
 
   // Second string of the cons cell.
@@ skipping 33 matching lines @@
 // a substring.  A Sliced String is described as a pointer to the parent,
 // the offset from the start of the parent string and the length.  Using
 // a Sliced String therefore requires unpacking of the parent string and
 // adding the offset to the start address.  A substring of a Sliced String
 // are not nested since the double indirection is simplified when creating
 // such a substring.
 // Currently missing features are:
 //  - handling externalized parent strings
 //  - external strings as parent
 //  - truncating sliced string to enable otherwise unneeded parent to be GC'ed.
-class SlicedString V8_FINAL : public String {
+class SlicedString: public String {
  public:
   inline String* parent();
   inline void set_parent(String* parent,
                          WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
   inline int offset();
   inline void set_offset(int offset);
 
   // Dispatched behavior.
   uint16_t SlicedStringGet(int index);
 
@@ skipping 21 matching lines @@
 
 // The ExternalString class describes string values that are backed by
 // a string resource that lies outside the V8 heap.  ExternalStrings
 // consist of the length field common to all strings, a pointer to the
 // external resource.  It is important to ensure (externally) that the
 // resource is not deallocated while the ExternalString is live in the
 // V8 heap.
 //
 // The API expects that all ExternalStrings are created through the
 // API.  Therefore, ExternalStrings should not be used internally.
-class ExternalString : public String {
+class ExternalString: public String {
  public:
   // Casting
   static inline ExternalString* cast(Object* obj);
 
   // Layout description.
   static const int kResourceOffset = POINTER_SIZE_ALIGN(String::kSize);
   static const int kShortSize = kResourceOffset + kPointerSize;
   static const int kResourceDataOffset = kResourceOffset + kPointerSize;
   static const int kSize = kResourceDataOffset + kPointerSize;
 
   static const int kMaxShortLength =
       (kShortSize - SeqString::kHeaderSize) / kCharSize;
 
   // Return whether external string is short (data pointer is not cached).
   inline bool is_short();
 
   STATIC_CHECK(kResourceOffset == Internals::kStringResourceOffset);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalString);
 };
 
 
 // The ExternalAsciiString class is an external string backed by an
 // ASCII string.
-class ExternalAsciiString V8_FINAL : public ExternalString {
+class ExternalAsciiString: public ExternalString {
  public:
   static const bool kHasAsciiEncoding = true;
 
   typedef v8::String::ExternalAsciiStringResource Resource;
 
   // The underlying resource.
   inline const Resource* resource();
   inline void set_resource(const Resource* buffer);
 
   // Update the pointer cache to the external character array.
@@ skipping 16 matching lines @@
   template<typename StaticVisitor>
   inline void ExternalAsciiStringIterateBody();
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalAsciiString);
 };
 
 
 // The ExternalTwoByteString class is an external string backed by a UTF-16
 // encoded string.
-class ExternalTwoByteString V8_FINAL : public ExternalString {
+class ExternalTwoByteString: public ExternalString {
  public:
   static const bool kHasAsciiEncoding = false;
 
   typedef v8::String::ExternalStringResource Resource;
 
   // The underlying string resource.
   inline const Resource* resource();
   inline void set_resource(const Resource* buffer);
 
   // Update the pointer cache to the external character array.
@@ skipping 43 matching lines @@
   static char* Iterate(ObjectVisitor* v, char* t);
  private:
   Isolate* isolate_;
   Relocatable* prev_;
 };
 
 
 // A flat string reader provides random access to the contents of a
 // string independent of the character width of the string.  The handle
 // must be valid as long as the reader is being used.
-class FlatStringReader V8_FINAL : public Relocatable {
+class FlatStringReader : public Relocatable {
  public:
   FlatStringReader(Isolate* isolate, Handle<String> str);
   FlatStringReader(Isolate* isolate, Vector<const char> input);
   void PostGarbageCollection();
   inline uc32 Get(int index);
   int length() { return length_; }
  private:
   String** str_;
   bool is_ascii_;
   int length_;
   const void* start_;
 };
 
 
 // A ConsStringOp that returns null.
 // Useful when the operation to apply on a ConsString
 // requires an expensive data structure.
-class ConsStringNullOp V8_FINAL {
+class ConsStringNullOp {
  public:
   inline ConsStringNullOp() {}
   static inline String* Operate(String*, unsigned*, int32_t*, unsigned*);
  private:
   DISALLOW_COPY_AND_ASSIGN(ConsStringNullOp);
 };
 
 
 // This maintains an off-stack representation of the stack frames required
 // to traverse a ConsString, allowing an entirely iterative and restartable
 // traversal of the entire string
 // Note: this class is not GC-safe.
-class ConsStringIteratorOp V8_FINAL {
+class ConsStringIteratorOp {
  public:
   inline ConsStringIteratorOp() {}
   String* Operate(String* string,
                   unsigned* offset_out,
                   int32_t* type_out,
                   unsigned* length_out);
   inline String* ContinueOperation(int32_t* type_out, unsigned* length_out);
   inline void Reset();
   inline bool HasMore();
 
@@ skipping 19 matching lines @@
   // Stack must always contain only frames for which right traversal
   // has not yet been performed.
   ConsString* frames_[kStackSize];
   unsigned consumed_;
   ConsString* root_;
   DISALLOW_COPY_AND_ASSIGN(ConsStringIteratorOp);
 };
 
 
 // Note: this class is not GC-safe.
-class StringCharacterStream V8_FINAL {
+class StringCharacterStream {
  public:
   inline StringCharacterStream(String* string,
                                ConsStringIteratorOp* op,
                                unsigned offset = 0);
   inline uint16_t GetNext();
   inline bool HasMore();
   inline void Reset(String* string, unsigned offset = 0);
   inline void VisitOneByteString(const uint8_t* chars, unsigned length);
   inline void VisitTwoByteString(const uint16_t* chars, unsigned length);
 
  private:
   bool is_one_byte_;
   union {
     const uint8_t* buffer8_;
     const uint16_t* buffer16_;
   };
   const uint8_t* end_;
   ConsStringIteratorOp* op_;
   DISALLOW_COPY_AND_ASSIGN(StringCharacterStream);
 };
 
 
 template <typename T>
-class VectorIterator V8_FINAL {
+class VectorIterator {
  public:
   VectorIterator(T* d, int l) : data_(Vector<const T>(d, l)), index_(0) { }
   explicit VectorIterator(Vector<const T> data) : data_(data), index_(0) { }
   T GetNext() { return data_[index_++]; }
   bool has_more() { return index_ < data_.length(); }
  private:
   Vector<const T> data_;
   int index_;
 };
 
 
 // The Oddball describes objects null, undefined, true, and false.
-class Oddball V8_FINAL : public HeapObject {
+class Oddball: public HeapObject {
  public:
   // [to_string]: Cached to_string computed at startup.
   DECL_ACCESSORS(to_string, String)
 
   // [to_number]: Cached to_number computed at startup.
   DECL_ACCESSORS(to_number, Object)
 
   inline byte kind();
   inline void set_kind(byte kind);
 
@@ skipping 30 matching lines @@
 
   STATIC_CHECK(kKindOffset == Internals::kOddballKindOffset);
   STATIC_CHECK(kNull == Internals::kNullOddballKind);
   STATIC_CHECK(kUndefined == Internals::kUndefinedOddballKind);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(Oddball);
 };
 
 
-class Cell : public HeapObject {
+class Cell: public HeapObject {
  public:
   // [value]: value of the global property.
   DECL_ACCESSORS(value, Object)
 
   // Casting.
   static inline Cell* cast(Object* obj);
 
   static inline Cell* FromValueAddress(Address value) {
     Object* result = FromAddress(value - kValueOffset);
     ASSERT(result->IsCell() || result->IsPropertyCell());
@@ skipping 14 matching lines @@
 
   typedef FixedBodyDescriptor<kValueOffset,
                               kValueOffset + kPointerSize,
                               kSize> BodyDescriptor;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(Cell);
 };
 
 
-class PropertyCell V8_FINAL : public Cell {
+class PropertyCell: public Cell {
  public:
   // [type]: type of the global property.
   Type* type();
   void set_type(Type* value, WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
 
   // [dependent_code]: dependent code that depends on the type of the global
   // property.
   DECL_ACCESSORS(dependent_code, DependentCode)
 
   // Sets the value of the cell and updates the type field to be the union
@@ skipping 34 matching lines @@
   static Type* UpdateType(Handle<PropertyCell> cell,
                           Handle<Object> value);
 
  private:
   DECL_ACCESSORS(type_raw, Object)
   DISALLOW_IMPLICIT_CONSTRUCTORS(PropertyCell);
 };
 
 
 // The JSProxy describes EcmaScript Harmony proxies
-class JSProxy : public JSReceiver {
+class JSProxy: public JSReceiver {
  public:
   // [handler]: The handler property.
   DECL_ACCESSORS(handler, Object)
 
   // [hash]: The hash code property (undefined if not initialized yet).
   DECL_ACCESSORS(hash, Object)
 
   // Casting.
   static inline JSProxy* cast(Object* obj);
 
@@ skipping 80 matching lines @@
                                                   Handle<Name> name,
                                                   DeleteMode mode);
   static Handle<Object> DeleteElementWithHandler(Handle<JSProxy> object,
                                                  uint32_t index,
                                                  DeleteMode mode);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSProxy);
 };
 
 
-class JSFunctionProxy V8_FINAL : public JSProxy {
+class JSFunctionProxy: public JSProxy {
  public:
   // [call_trap]: The call trap.
   DECL_ACCESSORS(call_trap, Object)
 
   // [construct_trap]: The construct trap.
   DECL_ACCESSORS(construct_trap, Object)
 
   // Casting.
   static inline JSFunctionProxy* cast(Object* obj);
 
@@ skipping 13 matching lines @@
   typedef FixedBodyDescriptor<kHandlerOffset,
                               kConstructTrapOffset + kPointerSize,
                               kSize> BodyDescriptor;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSFunctionProxy);
 };
 
 
 // The JSSet describes EcmaScript Harmony sets
-class JSSet V8_FINAL : public JSObject {
+class JSSet: public JSObject {
  public:
   // [set]: the backing hash set containing keys.
   DECL_ACCESSORS(table, Object)
 
   // Casting.
   static inline JSSet* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(JSSet)
   DECLARE_VERIFIER(JSSet)
 
   static const int kTableOffset = JSObject::kHeaderSize;
   static const int kSize = kTableOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSSet);
 };
 
 
 // The JSMap describes EcmaScript Harmony maps
-class JSMap V8_FINAL : public JSObject {
+class JSMap: public JSObject {
  public:
   // [table]: the backing hash table mapping keys to values.
   DECL_ACCESSORS(table, Object)
 
   // Casting.
   static inline JSMap* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(JSMap)
   DECLARE_VERIFIER(JSMap)
 
   static const int kTableOffset = JSObject::kHeaderSize;
   static const int kSize = kTableOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSMap);
 };
 
 
 // Base class for both JSWeakMap and JSWeakSet
-class JSWeakCollection : public JSObject {
+class JSWeakCollection: public JSObject {
  public:
   // [table]: the backing hash table mapping keys to values.
   DECL_ACCESSORS(table, Object)
 
   // [next]: linked list of encountered weak maps during GC.
   DECL_ACCESSORS(next, Object)
 
   static const int kTableOffset = JSObject::kHeaderSize;
   static const int kNextOffset = kTableOffset + kPointerSize;
   static const int kSize = kNextOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSWeakCollection);
 };
 
 
 // The JSWeakMap describes EcmaScript Harmony weak maps
-class JSWeakMap V8_FINAL : public JSWeakCollection {
+class JSWeakMap: public JSWeakCollection {
  public:
   // Casting.
   static inline JSWeakMap* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(JSWeakMap)
   DECLARE_VERIFIER(JSWeakMap)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSWeakMap);
 };
 
 
 // The JSWeakSet describes EcmaScript Harmony weak sets
-class JSWeakSet V8_FINAL : public JSWeakCollection {
+class JSWeakSet: public JSWeakCollection {
  public:
   // Casting.
   static inline JSWeakSet* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(JSWeakSet)
   DECLARE_VERIFIER(JSWeakSet)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSWeakSet);
 };
 
 
-class JSArrayBuffer : public JSObject {
+class JSArrayBuffer: public JSObject {
  public:
   // [backing_store]: backing memory for this array
   DECL_ACCESSORS(backing_store, void)
 
   // [byte_length]: length in bytes
   DECL_ACCESSORS(byte_length, Object)
 
   // [flags]
   DECL_ACCESSORS(flag, Smi)
 
@@ skipping 27 matching lines @@
       kSize + v8::ArrayBuffer::kInternalFieldCount * kPointerSize;
 
  private:
   // Bit position in a flag
   static const int kIsExternalBit = 0;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSArrayBuffer);
 };
 
 
-class JSArrayBufferView : public JSObject {
+class JSArrayBufferView: public JSObject {
  public:
   // [buffer]: ArrayBuffer that this typed array views.
   DECL_ACCESSORS(buffer, Object)
 
   // [byte_length]: offset of typed array in bytes.
   DECL_ACCESSORS(byte_offset, Object)
 
   // [byte_length]: length of typed array in bytes.
   DECL_ACCESSORS(byte_length, Object)
 
@@ skipping 12 matching lines @@
   static const int kViewSize = kWeakNextOffset + kPointerSize;
 
  protected:
   void NeuterView();
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSArrayBufferView);
 };
 
 
-class JSTypedArray V8_FINAL : public JSArrayBufferView {
+class JSTypedArray: public JSArrayBufferView {
  public:
   // [length]: length of typed array in elements.
   DECL_ACCESSORS(length, Object)
 
   // Neutering. Only neuters this typed array.
   void Neuter();
 
   // Casting.
   static inline JSTypedArray* cast(Object* obj);
 
   ExternalArrayType type();
   size_t element_size();
 
   // Dispatched behavior.
   DECLARE_PRINTER(JSTypedArray)
   DECLARE_VERIFIER(JSTypedArray)
 
   static const int kLengthOffset = kViewSize + kPointerSize;
   static const int kSize = kLengthOffset + kPointerSize;
 
   static const int kSizeWithInternalFields =
       kSize + v8::ArrayBufferView::kInternalFieldCount * kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSTypedArray);
 };
 
 
-class JSDataView V8_FINAL : public JSArrayBufferView {
+class JSDataView: public JSArrayBufferView {
  public:
   // Only neuters this DataView
   void Neuter();
 
   // Casting.
   static inline JSDataView* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(JSDataView)
   DECLARE_VERIFIER(JSDataView)
 
   static const int kSize = kViewSize;
 
   static const int kSizeWithInternalFields =
       kSize + v8::ArrayBufferView::kInternalFieldCount * kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSDataView);
 };
 
 
 // Foreign describes objects pointing from JavaScript to C structures.
 // Since they cannot contain references to JS HeapObjects they can be
 // placed in old_data_space.
-class Foreign V8_FINAL : public HeapObject {
+class Foreign: public HeapObject {
  public:
   // [address]: field containing the address.
   inline Address foreign_address();
   inline void set_foreign_address(Address value);
 
   // Casting.
   static inline Foreign* cast(Object* obj);
 
   // Dispatched behavior.
   inline void ForeignIterateBody(ObjectVisitor* v);
@@ skipping 15 matching lines @@
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(Foreign);
 };
 
 
 // The JSArray describes JavaScript Arrays
 //  Such an array can be in one of two modes:
 //    - fast, backing storage is a FixedArray and length <= elements.length();
 //       Please note: push and pop can be used to grow and shrink the array.
 //    - slow, backing storage is a HashTable with numbers as keys.
-class JSArray : public JSObject {
+class JSArray: public JSObject {
  public:
   // [length]: The length property.
   DECL_ACCESSORS(length, Object)
 
   // Overload the length setter to skip write barrier when the length
   // is set to a smi. This matches the set function on FixedArray.
   inline void set_length(Smi* length);
 
   MUST_USE_RESULT MaybeObject* JSArrayUpdateLengthFromIndex(uint32_t index,
                                                             Object* value);
@@ skipping 41 matching lines @@
 Handle<Object> CacheInitialJSArrayMaps(Handle<Context> native_context,
                                        Handle<Map> initial_map);
 
 
 // JSRegExpResult is just a JSArray with a specific initial map.
 // This initial map adds in-object properties for "index" and "input"
 // properties, as assigned by RegExp.prototype.exec, which allows
 // faster creation of RegExp exec results.
 // This class just holds constants used when creating the result.
 // After creation the result must be treated as a JSArray in all regards.
-class JSRegExpResult V8_FINAL : public JSArray {
+class JSRegExpResult: public JSArray {
  public:
   // Offsets of object fields.
   static const int kIndexOffset = JSArray::kSize;
   static const int kInputOffset = kIndexOffset + kPointerSize;
   static const int kSize = kInputOffset + kPointerSize;
   // Indices of in-object properties.
   static const int kIndexIndex = 0;
   static const int kInputIndex = 1;
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSRegExpResult);
 };
 
 
-class AccessorInfo : public Struct {
+class AccessorInfo: public Struct {
  public:
   DECL_ACCESSORS(name, Object)
   DECL_ACCESSORS(flag, Smi)
   DECL_ACCESSORS(expected_receiver_type, Object)
 
   inline bool all_can_read();
   inline void set_all_can_read(bool value);
 
   inline bool all_can_write();
   inline void set_all_can_write(bool value);
@@ skipping 76 matching lines @@
     struct PrimitiveValueDescriptor primitive_value_descriptor;
     struct ObjectDerefenceDescriptor object_dereference_descriptor;
     struct PointerShiftDescriptor pointer_shift_descriptor;
   };
 };
 
 
 class DeclaredAccessorDescriptor;
 
 
-class DeclaredAccessorDescriptorIterator V8_FINAL {
+class DeclaredAccessorDescriptorIterator {
  public:
   explicit DeclaredAccessorDescriptorIterator(
       DeclaredAccessorDescriptor* descriptor);
   const DeclaredAccessorDescriptorData* Next();
   bool Complete() const { return length_ == offset_; }
  private:
   uint8_t* array_;
   const int length_;
   int offset_;
   DISALLOW_IMPLICIT_CONSTRUCTORS(DeclaredAccessorDescriptorIterator);
 };
 
 
-class DeclaredAccessorDescriptor V8_FINAL : public Struct {
+class DeclaredAccessorDescriptor: public Struct {
  public:
   DECL_ACCESSORS(serialized_data, ByteArray)
 
   static inline DeclaredAccessorDescriptor* cast(Object* obj);
 
   static Handle<DeclaredAccessorDescriptor> Create(
       Isolate* isolate,
       const DeclaredAccessorDescriptorData& data,
       Handle<DeclaredAccessorDescriptor> previous);
 
   // Dispatched behavior.
   DECLARE_PRINTER(DeclaredAccessorDescriptor)
   DECLARE_VERIFIER(DeclaredAccessorDescriptor)
 
   static const int kSerializedDataOffset = HeapObject::kHeaderSize;
   static const int kSize = kSerializedDataOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(DeclaredAccessorDescriptor);
 };
 
 
-class DeclaredAccessorInfo V8_FINAL : public AccessorInfo {
+class DeclaredAccessorInfo: public AccessorInfo {
  public:
   DECL_ACCESSORS(descriptor, DeclaredAccessorDescriptor)
 
   static inline DeclaredAccessorInfo* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(DeclaredAccessorInfo)
   DECLARE_VERIFIER(DeclaredAccessorInfo)
 
   static const int kDescriptorOffset = AccessorInfo::kSize;
   static const int kSize = kDescriptorOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(DeclaredAccessorInfo);
 };
 
 
 // An accessor must have a getter, but can have no setter.
 //
 // When setting a property, V8 searches accessors in prototypes.
 // If an accessor was found and it does not have a setter,
 // the request is ignored.
 //
 // If the accessor in the prototype has the READ_ONLY property attribute, then
 // a new value is added to the local object when the property is set.
 // This shadows the accessor in the prototype.
-class ExecutableAccessorInfo V8_FINAL : public AccessorInfo {
+class ExecutableAccessorInfo: public AccessorInfo {
  public:
   DECL_ACCESSORS(getter, Object)
   DECL_ACCESSORS(setter, Object)
   DECL_ACCESSORS(data, Object)
 
   static inline ExecutableAccessorInfo* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(ExecutableAccessorInfo)
   DECLARE_VERIFIER(ExecutableAccessorInfo)
 
   static const int kGetterOffset = AccessorInfo::kSize;
   static const int kSetterOffset = kGetterOffset + kPointerSize;
   static const int kDataOffset = kSetterOffset + kPointerSize;
   static const int kSize = kDataOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExecutableAccessorInfo);
 };
 
 
 // Support for JavaScript accessors: A pair of a getter and a setter. Each
 // accessor can either be
 //   * a pointer to a JavaScript function or proxy: a real accessor
 //   * undefined: considered an accessor by the spec, too, strangely enough
 //   * the hole: an accessor which has not been set
 //   * a pointer to a map: a transition used to ensure map sharing
-class AccessorPair V8_FINAL : public Struct {
+class AccessorPair: public Struct {
  public:
   DECL_ACCESSORS(getter, Object)
   DECL_ACCESSORS(setter, Object)
 
   static inline AccessorPair* cast(Object* obj);
 
   static Handle<AccessorPair> Copy(Handle<AccessorPair> pair);
 
   Object* get(AccessorComponent component) {
     return component == ACCESSOR_GETTER ? getter() : setter();
@@ skipping 35 matching lines @@
   //    Object.defineProperty(obj, "foo", {get: undefined});
   //    assertTrue("foo" in obj);
   bool IsJSAccessor(Object* obj) {
     return obj->IsSpecFunction() || obj->IsUndefined();
   }
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(AccessorPair);
 };
 
 
-class AccessCheckInfo V8_FINAL : public Struct {
+class AccessCheckInfo: public Struct {
  public:
   DECL_ACCESSORS(named_callback, Object)
   DECL_ACCESSORS(indexed_callback, Object)
   DECL_ACCESSORS(data, Object)
 
   static inline AccessCheckInfo* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(AccessCheckInfo)
   DECLARE_VERIFIER(AccessCheckInfo)
 
   static const int kNamedCallbackOffset   = HeapObject::kHeaderSize;
   static const int kIndexedCallbackOffset = kNamedCallbackOffset + kPointerSize;
   static const int kDataOffset = kIndexedCallbackOffset + kPointerSize;
   static const int kSize = kDataOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(AccessCheckInfo);
 };
 
 
-class InterceptorInfo V8_FINAL : public Struct {
+class InterceptorInfo: public Struct {
  public:
   DECL_ACCESSORS(getter, Object)
   DECL_ACCESSORS(setter, Object)
   DECL_ACCESSORS(query, Object)
   DECL_ACCESSORS(deleter, Object)
   DECL_ACCESSORS(enumerator, Object)
   DECL_ACCESSORS(data, Object)
 
   static inline InterceptorInfo* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(InterceptorInfo)
   DECLARE_VERIFIER(InterceptorInfo)
 
   static const int kGetterOffset = HeapObject::kHeaderSize;
   static const int kSetterOffset = kGetterOffset + kPointerSize;
   static const int kQueryOffset = kSetterOffset + kPointerSize;
   static const int kDeleterOffset = kQueryOffset + kPointerSize;
   static const int kEnumeratorOffset = kDeleterOffset + kPointerSize;
   static const int kDataOffset = kEnumeratorOffset + kPointerSize;
   static const int kSize = kDataOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(InterceptorInfo);
 };
 
 
-class CallHandlerInfo V8_FINAL : public Struct {
+class CallHandlerInfo: public Struct {
  public:
   DECL_ACCESSORS(callback, Object)
   DECL_ACCESSORS(data, Object)
 
   static inline CallHandlerInfo* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(CallHandlerInfo)
   DECLARE_VERIFIER(CallHandlerInfo)
 
@@ skipping 15 matching lines @@
 
   static const int kTagOffset          = HeapObject::kHeaderSize;
   static const int kPropertyListOffset = kTagOffset + kPointerSize;
   static const int kHeaderSize         = kPropertyListOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(TemplateInfo);
 };
 
 
-class FunctionTemplateInfo V8_FINAL : public TemplateInfo {
+class FunctionTemplateInfo: public TemplateInfo {
  public:
   DECL_ACCESSORS(serial_number, Object)
   DECL_ACCESSORS(call_code, Object)
   DECL_ACCESSORS(property_accessors, Object)
   DECL_ACCESSORS(prototype_template, Object)
   DECL_ACCESSORS(parent_template, Object)
   DECL_ACCESSORS(named_property_handler, Object)
   DECL_ACCESSORS(indexed_property_handler, Object)
   DECL_ACCESSORS(instance_template, Object)
   DECL_ACCESSORS(class_name, Object)
@@ skipping 45 matching lines @@
   // Bit position in the flag, from least significant bit position.
   static const int kHiddenPrototypeBit   = 0;
   static const int kUndetectableBit      = 1;
   static const int kNeedsAccessCheckBit  = 2;
   static const int kReadOnlyPrototypeBit = 3;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(FunctionTemplateInfo);
 };
 
 
-class ObjectTemplateInfo V8_FINAL : public TemplateInfo {
+class ObjectTemplateInfo: public TemplateInfo {
  public:
   DECL_ACCESSORS(constructor, Object)
   DECL_ACCESSORS(internal_field_count, Object)
 
   static inline ObjectTemplateInfo* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(ObjectTemplateInfo)
   DECLARE_VERIFIER(ObjectTemplateInfo)
 
   static const int kConstructorOffset = TemplateInfo::kHeaderSize;
   static const int kInternalFieldCountOffset =
       kConstructorOffset + kPointerSize;
   static const int kSize = kInternalFieldCountOffset + kPointerSize;
 };
 
 
-class SignatureInfo V8_FINAL : public Struct {
+class SignatureInfo: public Struct {
  public:
   DECL_ACCESSORS(receiver, Object)
   DECL_ACCESSORS(args, Object)
 
   static inline SignatureInfo* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(SignatureInfo)
   DECLARE_VERIFIER(SignatureInfo)
 
   static const int kReceiverOffset = Struct::kHeaderSize;
   static const int kArgsOffset     = kReceiverOffset + kPointerSize;
   static const int kSize           = kArgsOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(SignatureInfo);
 };
 
 
-class TypeSwitchInfo V8_FINAL : public Struct {
+class TypeSwitchInfo: public Struct {
  public:
   DECL_ACCESSORS(types, Object)
 
   static inline TypeSwitchInfo* cast(Object* obj);
 
   // Dispatched behavior.
   DECLARE_PRINTER(TypeSwitchInfo)
   DECLARE_VERIFIER(TypeSwitchInfo)
 
   static const int kTypesOffset = Struct::kHeaderSize;
   static const int kSize        = kTypesOffset + kPointerSize;
 };
 
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
 // The DebugInfo class holds additional information for a function being
 // debugged.
-class DebugInfo V8_FINAL : public Struct {
+class DebugInfo: public Struct {
  public:
   // The shared function info for the source being debugged.
   DECL_ACCESSORS(shared, SharedFunctionInfo)
   // Code object for the original code.
   DECL_ACCESSORS(original_code, Code)
   // Code object for the patched code. This code object is the code object
   // currently active for the function.
   DECL_ACCESSORS(code, Code)
   // Fixed array holding status information for each active break point.
   DECL_ACCESSORS(break_points, FixedArray)
@@ skipping 39 matching lines @@
   // Lookup the index in the break_points array for a code position.
   int GetBreakPointInfoIndex(int code_position);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(DebugInfo);
 };
 
 
 // The BreakPointInfo class holds information for break points set in a
 // function. The DebugInfo object holds a BreakPointInfo object for each code
 // position with one or more break points.
-class BreakPointInfo V8_FINAL : public Struct {
+class BreakPointInfo: public Struct {
  public:
   // The position in the code for the break point.
   DECL_ACCESSORS(code_position, Smi)
   // The position in the source for the break position.
   DECL_ACCESSORS(source_position, Smi)
   // The position in the source for the last statement before this break
   // position.
   DECL_ACCESSORS(statement_position, Smi)
   // List of related JavaScript break points.
   DECL_ACCESSORS(break_point_objects, Object)
@@ skipping 44 matching lines @@
   V(kRelocatable, "relocatable", "(Relocatable)")                       \
   V(kDebug, "debug", "(Debugger)")                                      \
   V(kCompilationCache, "compilationcache", "(Compilation cache)")       \
   V(kHandleScope, "handlescope", "(Handle scope)")                      \
   V(kBuiltins, "builtins", "(Builtins)")                                \
   V(kGlobalHandles, "globalhandles", "(Global handles)")                \
   V(kEternalHandles, "eternalhandles", "(Eternal handles)")             \
   V(kThreadManager, "threadmanager", "(Thread manager)")                \
   V(kExtensions, "Extensions", "(Extensions)")
 
-class VisitorSynchronization V8_FINAL : public AllStatic {
+class VisitorSynchronization : public AllStatic {
  public:
 #define DECLARE_ENUM(enum_item, ignore1, ignore2) enum_item,
   enum SyncTag {
     VISITOR_SYNCHRONIZATION_TAGS_LIST(DECLARE_ENUM)
     kNumberOfSyncTags
   };
 #undef DECLARE_ENUM
 
   static const char* const kTags[kNumberOfSyncTags];
   static const char* const kTagNames[kNumberOfSyncTags];
@@ skipping 57 matching lines @@
   // Visits a handle that has an embedder-assigned class ID.
   virtual void VisitEmbedderReference(Object** p, uint16_t class_id) {}
 
   // Intended for serialization/deserialization checking: insert, or
   // check for the presence of, a tag at this position in the stream.
   // Also used for marking up GC roots in heap snapshots.
   virtual void Synchronize(VisitorSynchronization::SyncTag tag) {}
 };
 
 
-class StructBodyDescriptor V8_FINAL : public
+class StructBodyDescriptor : public
   FlexibleBodyDescriptor<HeapObject::kHeaderSize> {
  public:
   static inline int SizeOf(Map* map, HeapObject* object) {
     return map->instance_size();
   }
 };
 
 
 // BooleanBit is a helper class for setting and getting a bit in an
 // integer or Smi.
-class BooleanBit V8_FINAL : public AllStatic {
+class BooleanBit : public AllStatic {
  public:
   static inline bool get(Smi* smi, int bit_position) {
     return get(smi->value(), bit_position);
   }
 
   static inline bool get(int value, int bit_position) {
     return (value & (1 << bit_position)) != 0;
   }
 
   static inline Smi* set(Smi* smi, int bit_position, bool v) {
     return Smi::FromInt(set(smi->value(), bit_position, v));
   }
 
   static inline int set(int value, int bit_position, bool v) {
     if (v) {
       value |= (1 << bit_position);
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_