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

src/objects.cc

 // Copyright 2013 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 7014 matching lines @@
 void Map::RemoveFromCodeCache(Name* name, Code* code, int index) {
   // No GC is supposed to happen between a call to IndexInCodeCache and
   // RemoveFromCodeCache so the code cache must be there.
   ASSERT(!code_cache()->IsFixedArray());
   CodeCache::cast(code_cache())->RemoveByIndex(name, code, index);
 }
 
 
 // An iterator over all map transitions in an descriptor array, reusing the map
 // field of the contens array while it is running.
-class IntrusiveMapTransitionIterator V8_FINAL {
+class IntrusiveMapTransitionIterator {
  public:
   explicit IntrusiveMapTransitionIterator(TransitionArray* transition_array)
       : transition_array_(transition_array) { }
 
   void Start() {
     ASSERT(!IsIterating());
     *TransitionArrayHeader() = Smi::FromInt(0);
   }
 
   bool IsIterating() {
@@ skipping 17 matching lines @@
   Object** TransitionArrayHeader() {
     return HeapObject::RawField(transition_array_, TransitionArray::kMapOffset);
   }
 
   TransitionArray* transition_array_;
 };
 
 
 // An iterator over all prototype transitions, reusing the map field of the
 // underlying array while it is running.
-class IntrusivePrototypeTransitionIterator V8_FINAL {
+class IntrusivePrototypeTransitionIterator {
  public:
   explicit IntrusivePrototypeTransitionIterator(HeapObject* proto_trans)
       : proto_trans_(proto_trans) { }
 
   void Start() {
     ASSERT(!IsIterating());
     *Header() = Smi::FromInt(0);
   }
 
   bool IsIterating() {
@@ skipping 52 matching lines @@
 //        the current index in the map of the FixedArray of the desciptor
 //        array's contents, and restore it to the fixed array map afterwards.
 //        Note that a single descriptor can have 0, 1, or 2 transitions.
 //
 //    (b) If we currently follow prototype transitions, we temporarily store
 //        the current index in the map of the FixedArray holding the prototype
 //        transitions, and restore it to the fixed array map afterwards.
 //
 // Note that the child iterator is just a concatenation of two iterators: One
 // iterating over map transitions and one iterating over prototype transisitons.
-class TraversableMap V8_FINAL : public Map {
+class TraversableMap : public Map {
  public:
   // Record the parent in the traversal within this map. Note that this destroys
   // this map's map!
   void SetParent(TraversableMap* parent) { set_map_no_write_barrier(parent); }
 
   // Reset the current map's map, returning the parent previously stored in it.
   TraversableMap* GetAndResetParent() {
     TraversableMap* old_parent = static_cast<TraversableMap*>(map());
     set_map_no_write_barrier(GetHeap()->meta_map());
     return old_parent;
@@ skipping 227 matching lines @@
     array->set_null(index - 1);  // Name.
     array->set_null(index);  // Code.
   }
 }
 
 
 // The key in the code cache hash table consists of the property name and the
 // code object. The actual match is on the name and the code flags. If a key
 // is created using the flags and not a code object it can only be used for
 // lookup not to create a new entry.
-class CodeCacheHashTableKey V8_FINAL : public HashTableKey {
+class CodeCacheHashTableKey : public HashTableKey {
  public:
   CodeCacheHashTableKey(Name* name, Code::Flags flags)
       : name_(name), flags_(flags), code_(NULL) { }
 
   CodeCacheHashTableKey(Name* name, Code* code)
       : name_(name),
         flags_(code->flags()),
         code_(code) { }
 
 
@@ skipping 134 matching lines @@
     return Handle<Object>(hash_table->Lookup(maps, flags), GetIsolate());
   } else {
     return GetIsolate()->factory()->undefined_value();
   }
 }
 
 
 // Despite their name, object of this class are not stored in the actual
 // hash table; instead they're temporarily used for lookups. It is therefore
 // safe to have a weak (non-owning) pointer to a MapList as a member field.
-class PolymorphicCodeCacheHashTableKey V8_FINAL : public HashTableKey {
+class PolymorphicCodeCacheHashTableKey : public HashTableKey {
  public:
   // Callers must ensure that |maps| outlives the newly constructed object.
   PolymorphicCodeCacheHashTableKey(MapHandleList* maps, int code_flags)
       : maps_(maps),
         code_flags_(code_flags) {}
 
   bool IsMatch(Object* other) {
     MapHandleList other_maps(kDefaultListAllocationSize);
     int other_flags;
     FromObject(other, &other_flags, &other_maps);
@@ skipping 979 matching lines @@
   for (; i < length; i++) {
     if (a[i] != b[i]) {
       return false;
     }
   }
   return true;
 }
 
 
 template<typename Chars1, typename Chars2>
-class RawStringComparator V8_FINAL : public AllStatic {
+class RawStringComparator : public AllStatic {
  public:
   static inline bool compare(const Chars1* a, const Chars2* b, int len) {
     ASSERT(sizeof(Chars1) != sizeof(Chars2));
     for (int i = 0; i < len; i++) {
       if (a[i] != b[i]) {
         return false;
       }
     }
     return true;
   }
 };
 
 
 template<>
-class RawStringComparator<uint16_t, uint16_t> V8_FINAL {
+class RawStringComparator<uint16_t, uint16_t> {
  public:
   static inline bool compare(const uint16_t* a, const uint16_t* b, int len) {
     return CompareRawStringContents(a, b, len);
   }
 };
 
 
 template<>
-class RawStringComparator<uint8_t, uint8_t> V8_FINAL {
+class RawStringComparator<uint8_t, uint8_t> {
  public:
   static inline bool compare(const uint8_t* a, const uint8_t* b, int len) {
     return CompareRawStringContents(a, b, len);
   }
 };
 
 
-class StringComparator V8_FINAL {
-  class State V8_FINAL {
+class StringComparator {
+  class State {
    public:
     explicit inline State(ConsStringIteratorOp* op)
       : op_(op), is_one_byte_(true), length_(0), buffer8_(NULL) {}
 
     inline void Init(String* string, unsigned len) {
       op_->Reset();
       int32_t type = string->map()->instance_type();
       String::Visit(string, 0, *this, *op_, type, len);
     }
 
@@ skipping 215 matching lines @@
   if (content.IsTwoByte()) {
     return CompareChars(content.ToUC16Vector().start(), str.start(), slen) == 0;
   }
   for (int i = 0; i < slen; i++) {
     if (Get(i) != str[i]) return false;
   }
   return true;
 }
 
 
-class IteratingStringHasher V8_FINAL : public StringHasher {
+class IteratingStringHasher: public StringHasher {
  public:
   static inline uint32_t Hash(String* string, uint32_t seed) {
     const unsigned len = static_cast<unsigned>(string->length());
     IteratingStringHasher hasher(len, seed);
     if (hasher.has_trivial_hash()) {
       return hasher.GetHashField();
     }
     int32_t type = string->map()->instance_type();
     ConsStringNullOp null_op;
     String::Visit(string, 0, hasher, null_op, type, len);
@@ skipping 4443 matching lines @@
 }
 
 
 int JSObject::GetEnumElementKeys(FixedArray* storage) {
   return GetLocalElementKeys(storage,
                              static_cast<PropertyAttributes>(DONT_ENUM));
 }
 
 
 // StringKey simply carries a string object as key.
-class StringKey V8_FINAL : public HashTableKey {
+class StringKey : public HashTableKey {
  public:
   explicit StringKey(String* string) :
       string_(string),
       hash_(HashForObject(string)) { }
 
   bool IsMatch(Object* string) {
     // We know that all entries in a hash table had their hash keys created.
     // Use that knowledge to have fast failure.
     if (hash_ != HashForObject(string)) {
       return false;
     }
     return string_->Equals(String::cast(string));
   }
 
   uint32_t Hash() { return hash_; }
 
   uint32_t HashForObject(Object* other) { return String::cast(other)->Hash(); }
 
   Object* AsObject(Heap* heap) { return string_; }
 
   String* string_;
   uint32_t hash_;
 };
 
 
 // StringSharedKeys are used as keys in the eval cache.
-class StringSharedKey V8_FINAL : public HashTableKey {
+class StringSharedKey : public HashTableKey {
  public:
   StringSharedKey(String* source,
                   SharedFunctionInfo* shared,
                   LanguageMode language_mode,
                   int scope_position)
       : source_(source),
         shared_(shared),
         language_mode_(language_mode),
         scope_position_(scope_position) { }
 
@@ skipping 68 matching lines @@
 
  private:
   String* source_;
   SharedFunctionInfo* shared_;
   LanguageMode language_mode_;
   int scope_position_;
 };
 
 
 // RegExpKey carries the source and flags of a regular expression as key.
-class RegExpKey V8_FINAL : public HashTableKey {
+class RegExpKey : public HashTableKey {
  public:
   RegExpKey(String* string, JSRegExp::Flags flags)
       : string_(string),
         flags_(Smi::FromInt(flags.value())) { }
 
   // Rather than storing the key in the hash table, a pointer to the
   // stored value is stored where the key should be.  IsMatch then
   // compares the search key to the found object, rather than comparing
   // a key to a key.
   bool IsMatch(Object* obj) {
@@ skipping 20 matching lines @@
   static uint32_t RegExpHash(String* string, Smi* flags) {
     return string->Hash() + flags->value();
   }
 
   String* string_;
   Smi* flags_;
 };
 
 
 // Utf8StringKey carries a vector of chars as key.
-class Utf8StringKey V8_FINAL : public HashTableKey {
+class Utf8StringKey : public HashTableKey {
  public:
   explicit Utf8StringKey(Vector<const char> string, uint32_t seed)
       : string_(string), hash_field_(0), seed_(seed) { }
 
   bool IsMatch(Object* string) {
     return String::cast(string)->IsUtf8EqualTo(string_);
   }
 
   uint32_t Hash() {
     if (hash_field_ != 0) return hash_field_ >> String::kHashShift;
@@ skipping 42 matching lines @@
     return String::cast(other)->Hash();
   }
 
   Vector<const Char> string_;
   uint32_t hash_field_;
   uint32_t seed_;
 };
 
 
 
-class OneByteStringKey V8_FINAL : public SequentialStringKey<uint8_t> {
+class OneByteStringKey : public SequentialStringKey<uint8_t> {
  public:
   OneByteStringKey(Vector<const uint8_t> str, uint32_t seed)
       : SequentialStringKey<uint8_t>(str, seed) { }
 
   bool IsMatch(Object* string) {
     return String::cast(string)->IsOneByteEqualTo(string_);
   }
 
   MaybeObject* AsObject(Heap* heap) {
     if (hash_field_ == 0) Hash();
     return heap->AllocateOneByteInternalizedString(string_, hash_field_);
   }
 };
 
 
-class SubStringOneByteStringKey V8_FINAL : public HashTableKey {
+class SubStringOneByteStringKey : public HashTableKey {
  public:
   explicit SubStringOneByteStringKey(Handle<SeqOneByteString> string,
                                      int from,
                                      int length)
       : string_(string), from_(from), length_(length) { }
 
   uint32_t Hash() {
     ASSERT(length_ >= 0);
     ASSERT(from_ + length_ <= string_->length());
     uint8_t* chars = string_->GetChars() + from_;
@@ skipping 21 matching lines @@
   }
 
  private:
   Handle<SeqOneByteString> string_;
   int from_;
   int length_;
   uint32_t hash_field_;
 };
 
 
-class TwoByteStringKey V8_FINAL : public SequentialStringKey<uc16> {
+class TwoByteStringKey : public SequentialStringKey<uc16> {
  public:
   explicit TwoByteStringKey(Vector<const uc16> str, uint32_t seed)
       : SequentialStringKey<uc16>(str, seed) { }
 
   bool IsMatch(Object* string) {
     return String::cast(string)->IsTwoByteEqualTo(string_);
   }
 
   MaybeObject* AsObject(Heap* heap) {
     if (hash_field_ == 0) Hash();
     return heap->AllocateTwoByteInternalizedString(string_, hash_field_);
   }
 };
 
 
 // InternalizedStringKey carries a string/internalized-string object as key.
-class InternalizedStringKey V8_FINAL : public HashTableKey {
+class InternalizedStringKey : public HashTableKey {
  public:
   explicit InternalizedStringKey(String* string)
       : string_(string) { }
 
   bool IsMatch(Object* string) {
     return String::cast(string)->Equals(string_);
   }
 
   uint32_t Hash() { return string_->Hash(); }
 
@@ skipping 829 matching lines @@
   InternalizedStringKey key(string);
   return LookupKey(&key, s);
 }
 
 
 // This class is used for looking up two character strings in the string table.
 // If we don't have a hit we don't want to waste much time so we unroll the
 // string hash calculation loop here for speed.  Doesn't work if the two
 // characters form a decimal integer, since such strings have a different hash
 // algorithm.
-class TwoCharHashTableKey V8_FINAL : public HashTableKey {
+class TwoCharHashTableKey : public HashTableKey {
  public:
   TwoCharHashTableKey(uint16_t c1, uint16_t c2, uint32_t seed)
     : c1_(c1), c2_(c2) {
     // Char 1.
     uint32_t hash = seed;
     hash += c1;
     hash += hash << 10;
     hash ^= hash >> 6;
     // Char 2.
     hash += c2;
@@ skipping 268 matching lines @@
       NoWriteBarrierSet(this, entry_index, the_hole_value);
       NoWriteBarrierSet(this, value_index, the_hole_value);
       ElementRemoved();
     }
   }
   return;
 }
 
 
 // StringsKey used for HashTable where key is array of internalized strings.
-class StringsKey V8_FINAL : public HashTableKey {
+class StringsKey : public HashTableKey {
  public:
   explicit StringsKey(FixedArray* strings) : strings_(strings) { }
 
   bool IsMatch(Object* strings) {
     FixedArray* o = FixedArray::cast(strings);
     int len = strings_->length();
     if (o->length() != len) return false;
     for (int i = 0; i < len; i++) {
       if (o->get(i) != strings_->get(i)) return false;
     }
@@ skipping 1280 matching lines @@
 #define ERROR_MESSAGES_TEXTS(C, T) T,
   static const char* error_messages_[] = {
       ERROR_MESSAGES_LIST(ERROR_MESSAGES_TEXTS)
   };
 #undef ERROR_MESSAGES_TEXTS
   return error_messages_[reason];
 }
 
 
 } }  // namespace v8::internal