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

test/cctest/test-code-stub-assembler.cc

 // Copyright 2015 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.
 
 #include "src/base/utils/random-number-generator.h"
 #include "src/ic/stub-cache.h"
 #include "src/isolate.h"
 #include "test/cctest/compiler/code-assembler-tester.h"
 #include "test/cctest/compiler/function-tester.h"
 
@@ skipping 1085 matching lines @@
     m.Bind(&block3);
     var_object.Bind(m.IntPtrConstant(66));
     m.Goto(&block1);
   }
   m.Bind(&block1);
   CHECK(!m.GenerateCode().is_null());
 }
 
 namespace {
 
-void TestStubCacheOffsetCalculation(StubCache::Table table,
-                                    Code::Kind handler_kind) {
+void TestStubCacheOffsetCalculation(StubCache::Table table) {
   Isolate* isolate(CcTest::InitIsolateOnce());
   const int kNumParams = 2;
   CodeStubAssemblerTester m(isolate, kNumParams);
 
-  Code::Flags code_flags =
-      Code::RemoveHolderFromFlags(Code::ComputeHandlerFlags(handler_kind));
   {
     Node* name = m.Parameter(0);
     Node* map = m.Parameter(1);
-    Node* primary_offset = m.StubCachePrimaryOffset(name, code_flags, map);
+    Node* primary_offset = m.StubCachePrimaryOffset(name, map);
     Node* result;
     if (table == StubCache::kPrimary) {
       result = primary_offset;
     } else {
       CHECK_EQ(StubCache::kSecondary, table);
-      result = m.StubCacheSecondaryOffset(name, code_flags, primary_offset);
+      result = m.StubCacheSecondaryOffset(name, primary_offset);
     }
     m.Return(m.SmiFromWord32(result));
   }
 
   Handle<Code> code = m.GenerateCode();
   FunctionTester ft(code, kNumParams);
 
   Factory* factory = isolate->factory();
   Handle<Name> names[] = {
       factory->NewSymbol(),
@@ skipping 22 matching lines @@
       factory->sloppy_arguments_elements_map(),
   };
 
   for (int name_index = 0; name_index < arraysize(names); name_index++) {
     Handle<Name> name = names[name_index];
     for (int map_index = 0; map_index < arraysize(maps); map_index++) {
       Handle<Map> map = maps[map_index];
 
       int expected_result;
       {
-        int primary_offset =
-            StubCache::PrimaryOffsetForTesting(*name, code_flags, *map);
+        int primary_offset = StubCache::PrimaryOffsetForTesting(*name, *map);
         if (table == StubCache::kPrimary) {
           expected_result = primary_offset;
         } else {
-          expected_result = StubCache::SecondaryOffsetForTesting(
-              *name, code_flags, primary_offset);
+          expected_result =
+              StubCache::SecondaryOffsetForTesting(*name, primary_offset);
         }
       }
       Handle<Object> result = ft.Call(name, map).ToHandleChecked();
 
       Smi* expected = Smi::FromInt(expected_result & Smi::kMaxValue);
       CHECK_EQ(expected, Smi::cast(*result));
     }
   }
 }
 
 }  // namespace
 
-TEST(StubCachePrimaryOffsetLoadIC) {
-  TestStubCacheOffsetCalculation(StubCache::kPrimary, Code::LOAD_IC);
+TEST(StubCachePrimaryOffset) {
+  TestStubCacheOffsetCalculation(StubCache::kPrimary);
 }
 
-TEST(StubCachePrimaryOffsetStoreIC) {
-  TestStubCacheOffsetCalculation(StubCache::kPrimary, Code::STORE_IC);
-}
-
-TEST(StubCacheSecondaryOffsetLoadIC) {
-  TestStubCacheOffsetCalculation(StubCache::kSecondary, Code::LOAD_IC);
-}
-
-TEST(StubCacheSecondaryOffsetStoreIC) {
-  TestStubCacheOffsetCalculation(StubCache::kSecondary, Code::STORE_IC);
+TEST(StubCacheSecondaryOffset) {
+  TestStubCacheOffsetCalculation(StubCache::kSecondary);
 }
 
 namespace {
 
 Handle<Code> CreateCodeWithFlags(Code::Flags flags) {
   Isolate* isolate(CcTest::InitIsolateOnce());
   CodeStubAssemblerTester m(isolate, flags);
   m.Return(m.UndefinedConstant());
   return m.GenerateCodeCloseAndEscape();
 }
 
 }  // namespace
 
 TEST(TryProbeStubCache) {
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
   Isolate* isolate(CcTest::InitIsolateOnce());
   const int kNumParams = 3;
   CodeStubAssemblerTester m(isolate, kNumParams);
 
   Code::Kind ic_kind = Code::LOAD_IC;
-  Code::Flags flags_to_query =
-      Code::RemoveHolderFromFlags(Code::ComputeHandlerFlags(ic_kind));
-
   StubCache stub_cache(isolate, ic_kind);
   stub_cache.Clear();
 
   {
     Node* receiver = m.Parameter(0);
     Node* name = m.Parameter(1);
     Node* expected_handler = m.Parameter(2);
 
     Label passed(&m), failed(&m);
 
@@ skipping 59 matching lines @@
   }
 
   // Generate some number of receiver maps and receivers.
   for (int i = 0; i < StubCache::kSecondaryTableSize / 2; i++) {
     Handle<Map> map = Map::Create(isolate, 0);
     receivers.push_back(factory->NewJSObjectFromMap(map));
   }
 
   // Generate some number of handlers.
   for (int i = 0; i < 30; i++) {
-    Code::Kind code_kind;
-    switch (rand_gen.NextInt(4)) {
-      case 0:
-        code_kind = Code::LOAD_IC;
-        break;
-      case 1:
-        code_kind = Code::KEYED_LOAD_IC;
-        break;
-      case 2:
-        code_kind = Code::STORE_IC;
-        break;
-      case 3:
-        code_kind = Code::KEYED_STORE_IC;
-        break;
-      default:
-        UNREACHABLE();
-    }
     Code::Flags flags =
-        Code::RemoveHolderFromFlags(Code::ComputeHandlerFlags(code_kind));
+        Code::RemoveHolderFromFlags(Code::ComputeHandlerFlags(ic_kind));
     handlers.push_back(CreateCodeWithFlags(flags));
   }
 
   // Ensure that GC does happen because from now on we are going to fill our
   // own stub cache instance with raw values.
   DisallowHeapAllocation no_gc;
 
   // Populate {stub_cache}.
   const int N = StubCache::kPrimaryTableSize + StubCache::kSecondaryTableSize;
   for (int i = 0; i < N; i++) {
     int index = rand_gen.NextInt();
     Handle<Name> name = names[index % names.size()];
     Handle<JSObject> receiver = receivers[index % receivers.size()];
     Handle<Code> handler = handlers[index % handlers.size()];
     stub_cache.Set(*name, receiver->map(), *handler);
   }
 
   // Perform some queries.
   bool queried_existing = false;
   bool queried_non_existing = false;
   for (int i = 0; i < N; i++) {
     int index = rand_gen.NextInt();
     Handle<Name> name = names[index % names.size()];
     Handle<JSObject> receiver = receivers[index % receivers.size()];
-    Code* handler = stub_cache.Get(*name, receiver->map(), flags_to_query);
+    Code* handler = stub_cache.Get(*name, receiver->map());
     if (handler == nullptr) {
       queried_non_existing = true;
     } else {
       queried_existing = true;
     }
 
     Handle<Code> expected_handler(handler, isolate);
     ft.CheckTrue(receiver, name, expected_handler);
   }
 
   for (int i = 0; i < N; i++) {
     int index1 = rand_gen.NextInt();
     int index2 = rand_gen.NextInt();
     Handle<Name> name = names[index1 % names.size()];
     Handle<JSObject> receiver = receivers[index2 % receivers.size()];
-    Code* handler = stub_cache.Get(*name, receiver->map(), flags_to_query);
+    Code* handler = stub_cache.Get(*name, receiver->map());
     if (handler == nullptr) {
       queried_non_existing = true;
     } else {
       queried_existing = true;
     }
 
     Handle<Code> expected_handler(handler, isolate);
     ft.CheckTrue(receiver, name, expected_handler);
   }
   // Ensure we performed both kind of queries.
   CHECK(queried_existing && queried_non_existing);
 }
 
 }  // namespace internal
 }  // namespace v8