Revert of [ic] [stubs] Don't use Code::flags in megamorphic stub cache hash computations.

src/ic/stub-cache.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_STUB_CACHE_H_
 #define V8_STUB_CACHE_H_
 
 #include "src/macro-assembler.h"
 
 namespace v8 {
@@ skipping 23 matching lines @@
  public:
   struct Entry {
     Name* key;
     Code* value;
     Map* map;
   };
 
   void Initialize();
   // Access cache for entry hash(name, map).
   Code* Set(Name* name, Map* map, Code* code);
-  Code* Get(Name* name, Map* map);
+  Code* Get(Name* name, Map* map, Code::Flags flags);
   // Clear the lookup table (@ mark compact collection).
   void Clear();
-  // Collect all maps that match the name.
+  // Collect all maps that match the name and flags.
   void CollectMatchingMaps(SmallMapList* types, Handle<Name> name,
-                           Handle<Context> native_context, Zone* zone);
+                           Code::Flags flags, Handle<Context> native_context,
+                           Zone* zone);
   // Generate code for probing the stub cache table.
   // Arguments extra, extra2 and extra3 may be used to pass additional scratch
   // registers. Set to no_reg if not needed.
   // If leave_frame is true, then exit a frame before the tail call.
   void GenerateProbe(MacroAssembler* masm, Register receiver, Register name,
                      Register scratch, Register extra, Register extra2 = no_reg,
                      Register extra3 = no_reg);
 
   enum Table { kPrimary, kSecondary };
 
@@ skipping 29 matching lines @@
   // Setting the entry size such that the index is shifted by Name::kHashShift
   // is convenient; shifting down the length field (to extract the hash code)
   // automatically discards the hash bit field.
   static const int kCacheIndexShift = Name::kHashShift;
 
   static const int kPrimaryTableBits = 11;
   static const int kPrimaryTableSize = (1 << kPrimaryTableBits);
   static const int kSecondaryTableBits = 9;
   static const int kSecondaryTableSize = (1 << kSecondaryTableBits);
 
-  static int PrimaryOffsetForTesting(Name* name, Map* map) {
-    return PrimaryOffset(name, map);
+  static int PrimaryOffsetForTesting(Name* name, Code::Flags flags, Map* map) {
+    return PrimaryOffset(name, flags, map);
   }
 
-  static int SecondaryOffsetForTesting(Name* name, int seed) {
-    return SecondaryOffset(name, seed);
+  static int SecondaryOffsetForTesting(Name* name, Code::Flags flags,
+                                       int seed) {
+    return SecondaryOffset(name, flags, seed);
   }
 
   // The constructor is made public only for the purposes of testing.
   StubCache(Isolate* isolate, Code::Kind ic_kind);
 
  private:
   // The stub cache has a primary and secondary level.  The two levels have
   // different hashing algorithms in order to avoid simultaneous collisions
   // in both caches.  Unlike a probing strategy (quadratic or otherwise) the
   // update strategy on updates is fairly clear and simple:  Any existing entry
   // in the primary cache is moved to the secondary cache, and secondary cache
   // entries are overwritten.
 
   // Hash algorithm for the primary table.  This algorithm is replicated in
   // assembler for every architecture.  Returns an index into the table that
   // is scaled by 1 << kCacheIndexShift.
-  static int PrimaryOffset(Name* name, Map* map) {
+  static int PrimaryOffset(Name* name, Code::Flags flags, Map* map) {
     STATIC_ASSERT(kCacheIndexShift == Name::kHashShift);
     // Compute the hash of the name (use entire hash field).
     DCHECK(name->HasHashCode());
     uint32_t field = name->hash_field();
     // Using only the low bits in 64-bit mode is unlikely to increase the
     // risk of collision even if the heap is spread over an area larger than
     // 4Gb (and not at all if it isn't).
     uint32_t map_low32bits =
         static_cast<uint32_t>(reinterpret_cast<uintptr_t>(map));
-    // Base the offset on a simple combination of name and map.
-    uint32_t key = map_low32bits + field;
+    // We always set the in_loop bit to zero when generating the lookup code
+    // so do it here too so the hash codes match.
+    uint32_t iflags =
+        (static_cast<uint32_t>(flags) & ~Code::kFlagsNotUsedInLookup);
+    // Base the offset on a simple combination of name, flags, and map.
+    uint32_t key = (map_low32bits + field) ^ iflags;
     return key & ((kPrimaryTableSize - 1) << kCacheIndexShift);
   }
 
   // Hash algorithm for the secondary table.  This algorithm is replicated in
   // assembler for every architecture.  Returns an index into the table that
   // is scaled by 1 << kCacheIndexShift.
-  static int SecondaryOffset(Name* name, int seed) {
+  static int SecondaryOffset(Name* name, Code::Flags flags, int seed) {
     // Use the seed from the primary cache in the secondary cache.
     uint32_t name_low32bits =
         static_cast<uint32_t>(reinterpret_cast<uintptr_t>(name));
-    uint32_t key = (seed - name_low32bits);
+    // We always set the in_loop bit to zero when generating the lookup code
+    // so do it here too so the hash codes match.
+    uint32_t iflags =
+        (static_cast<uint32_t>(flags) & ~Code::kFlagsNotUsedInLookup);
+    uint32_t key = (seed - name_low32bits) + iflags;
     return key & ((kSecondaryTableSize - 1) << kCacheIndexShift);
   }
 
   // Compute the entry for a given offset in exactly the same way as
   // we do in generated code.  We generate an hash code that already
   // ends in Name::kHashShift 0s.  Then we multiply it so it is a multiple
   // of sizeof(Entry).  This makes it easier to avoid making mistakes
   // in the hashed offset computations.
   static Entry* entry(Entry* table, int offset) {
     const int multiplier = sizeof(*table) >> Name::kHashShift;
     return reinterpret_cast<Entry*>(reinterpret_cast<Address>(table) +
                                     offset * multiplier);
   }
 
  private:
   Entry primary_[kPrimaryTableSize];
   Entry secondary_[kSecondaryTableSize];
   Isolate* isolate_;
   Code::Kind ic_kind_;
 
   friend class Isolate;
   friend class SCTableReference;
 
   DISALLOW_COPY_AND_ASSIGN(StubCache);
 };
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_STUB_CACHE_H_