[ic] Fix megamorphic stub cache probing on some platforms.

test/cctest/test-api.cc

 // 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 23 matching lines @@
 
 #if V8_OS_POSIX
 #include <unistd.h>  // NOLINT
 #endif
 
 #include "include/v8-util.h"
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/base/platform/platform.h"
 #include "src/base/smart-pointers.h"
+#include "src/code-stubs.h"
 #include "src/compilation-cache.h"
 #include "src/debug/debug.h"
 #include "src/execution.h"
 #include "src/futex-emulation.h"
 #include "src/objects.h"
 #include "src/parsing/parser.h"
 #include "src/profiler/cpu-profiler.h"
 #include "src/unicode-inl.h"
 #include "src/utils.h"
 #include "src/vm-state.h"
@@ skipping 21395 matching lines @@
 const char* kMegamorphicTestProgram =
     "function CreateClass(name) {\n"
     "  var src = \n"
     "    `  function ${name}() {};` +\n"
     "    `  ${name}.prototype.foo = function() {};` +\n"
     "    `  ${name};\\n`;\n"
     "  return (0, eval)(src);\n"
     "}\n"
     "function fooify(obj) { obj.foo(); };\n"
     "var objs = [];\n"
-    "for (var i = 0; i < 6; i++) {\n"
+    "for (var i = 0; i < 50; i++) {\n"
     "  var Class = CreateClass('Class' + i);\n"
     "  var obj = new Class();\n"
     "  objs.push(obj);\n"
     "}\n"
-    "for (var i = 0; i < 10000; i++) {\n"
+    "for (var i = 0; i < 1000; i++) {\n"
     "  for (var obj of objs) {\n"
     "    fooify(obj);\n"
     "  }\n"
     "}\n";
 
-void StubCacheHelper(bool primary) {
+void TestStubCache(bool primary) {
+  // The test does not work with interpreter because bytecode handlers taken
+  // from the snapshot already refer to ICs with disabled counters and there
+  // is no way to trigger bytecode handlers recompilation.
+  if (i::FLAG_ignition) return;
+
   i::FLAG_native_code_counters = true;
   if (primary) {
     i::FLAG_test_primary_stub_cache = true;
   } else {
     i::FLAG_test_secondary_stub_cache = true;
   }
   i::FLAG_crankshaft = false;
   i::FLAG_turbo = false;
   v8::Isolate::CreateParams create_params;
   create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
   create_params.counter_lookup_callback = LookupCounter;
   v8::Isolate* isolate = v8::Isolate::New(create_params);
-  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
 
-  if (!i_isolate->snapshot_available()) {
-    // The test is valid only for no-snapshot mode.
+  {
     v8::Isolate::Scope isolate_scope(isolate);
     LocalContext env(isolate);
     v8::HandleScope scope(isolate);
 
+    {
+      // Enforce recompilation of IC stubs that access megamorphic stub cache
+      // to respect enabled native code counters and stub cache test flags.
+      i::CodeStub::Major code_stub_keys[] = {
+          i::CodeStub::LoadIC,       i::CodeStub::LoadICTrampoline,
+          i::CodeStub::LoadICTF,     i::CodeStub::LoadICTrampolineTF,
+          i::CodeStub::KeyedLoadIC,  i::CodeStub::KeyedLoadICTrampoline,
+          i::CodeStub::StoreIC,      i::CodeStub::StoreICTrampoline,
+          i::CodeStub::KeyedStoreIC, i::CodeStub::KeyedStoreICTrampoline,
+      };
+      i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+      i::Heap* heap = i_isolate->heap();
+      i::Handle<i::UnseededNumberDictionary> dict(heap->code_stubs());
+      for (size_t i = 0; i < arraysize(code_stub_keys); i++) {
+        dict = i::UnseededNumberDictionary::DeleteKey(dict, code_stub_keys[i]);
+      }
+      heap->SetRootCodeStubs(*dict);
+    }
+
     int initial_probes = probes_counter;
     int initial_misses = misses_counter;
     int initial_updates = updates_counter;
     CompileRun(kMegamorphicTestProgram);
     int probes = probes_counter - initial_probes;
     int misses = misses_counter - initial_misses;
     int updates = updates_counter - initial_updates;
-    const int kClassesCount = 6;
+    const int kClassesCount = 50;
+    const int kIterationsCount = 1000;
+    CHECK_LE(kClassesCount, updates);
     // Check that updates and misses counts are bounded.
-    CHECK_LE(kClassesCount, updates);
-    CHECK_LT(updates, kClassesCount * 3);
+    // If there are too many updates then most likely the stub cache does not
+    // work properly.
+    CHECK_LE(updates, kClassesCount * 2);
     CHECK_LE(1, misses);
-    CHECK_LT(misses, kClassesCount * 2);
+    CHECK_LE(misses, kClassesCount * 2);
     // 2 is for PREMONOMORPHIC and MONOMORPHIC states,
     // 4 is for POLYMORPHIC states,
     // and all the others probes are for MEGAMORPHIC state.
-    CHECK_EQ(10000 * kClassesCount - 2 - 4, probes);
+    CHECK_EQ(kIterationsCount * kClassesCount - 2 - 4, probes);
   }
   isolate->Dispose();
 }
 
 }  // namespace
 
-UNINITIALIZED_TEST(PrimaryStubCache) { StubCacheHelper(true); }
+UNINITIALIZED_TEST(PrimaryStubCache) {
+  i::FLAG_tf_load_ic_stub = false;
+  TestStubCache(true);
+}
 
-UNINITIALIZED_TEST(SecondaryStubCache) { StubCacheHelper(false); }
+UNINITIALIZED_TEST(SecondaryStubCache) {
+  i::FLAG_tf_load_ic_stub = false;
+  TestStubCache(false);
+}
+
+UNINITIALIZED_TEST(PrimaryStubCacheTF) {
+  i::FLAG_tf_load_ic_stub = true;
+  TestStubCache(true);
+}
+
+UNINITIALIZED_TEST(SecondaryStubCacheTF) {
+  i::FLAG_tf_load_ic_stub = true;
+  TestStubCache(false);
+}
 
 #endif  // ENABLE_DISASSEMBLER
 
 #ifdef DEBUG
 static int cow_arrays_created_runtime = 0;
 
 
 static int* LookupCounterCOWArrays(const char* name) {
   if (strcmp(name, "c:V8.COWArraysCreatedRuntime") == 0) {
     return &cow_arrays_created_runtime;
@@ skipping 3885 matching lines @@
 
   // Put the function into context1 and call it. Since the access check
   // callback always returns true, the call succeeds even though the tokens
   // are different.
   context1->Enter();
   context1->Global()->Set(context1, v8_str("fun"), fun).FromJust();
   v8::Local<v8::Value> x_value = CompileRun("fun('x')");
   CHECK_EQ(42, x_value->Int32Value(context1).FromJust());
   context1->Exit();
 }