test/hotspot/gtest/code/test_dependencyContext.cpp

  *
  */
 
 #include "precompiled.hpp"
 #include "code/dependencyContext.hpp"
+#include "code/nmethod.hpp"
 #include "unittest.hpp"
 
 class TestDependencyContext {
  public:
-  nmethod* _nmethods[3];
+  nmethod _nmethods[3];
 
-  intptr_t _dependency_context;
+  nmethodBucket* volatile _dependency_context;
+  volatile uint64_t _last_cleanup;
 
   DependencyContext dependencies() {
-    DependencyContext depContext(&_dependency_context);
+    DependencyContext depContext(&_dependency_context, &_last_cleanup);
     return depContext;
   }
 
-  TestDependencyContext() : _dependency_context(DependencyContext::EMPTY) {
+  TestDependencyContext()
+    : _dependency_context(NULL),
+      _last_cleanup(0) {
     CodeCache_lock->lock_without_safepoint_check();
 
-    _nmethods[0] = reinterpret_cast<nmethod*>(0x8 * 0);
-    _nmethods[1] = reinterpret_cast<nmethod*>(0x8 * 1);
-    _nmethods[2] = reinterpret_cast<nmethod*>(0x8 * 2);
-
-    dependencies().add_dependent_nmethod(_nmethods[2]);
-    dependencies().add_dependent_nmethod(_nmethods[1]);
-    dependencies().add_dependent_nmethod(_nmethods[0]);
+    _nmethods[0].clear_unloading_state();
+    _nmethods[1].clear_unloading_state();
+    _nmethods[2].clear_unloading_state();
+
+    dependencies().add_dependent_nmethod(&_nmethods[2]);
+    dependencies().add_dependent_nmethod(&_nmethods[1]);
+    dependencies().add_dependent_nmethod(&_nmethods[0]);
   }
 
   ~TestDependencyContext() {
     wipe();
     CodeCache_lock->unlock();
   }
 
-  static bool has_stale_entries(DependencyContext ctx) {
-    return ctx.has_stale_entries();
-  }
-
-#ifndef PRODUCT
-  static bool find_stale_entries(DependencyContext ctx) {
-    return ctx.find_stale_entries();
-  }
-#endif
-
   void wipe() {
-    DependencyContext ctx(&_dependency_context);
+    DependencyContext ctx(&_dependency_context, &_last_cleanup);
     nmethodBucket* b = ctx.dependencies();
     ctx.set_dependencies(NULL);
-    ctx.set_has_stale_entries(false);
     while (b != NULL) {
       nmethodBucket* next = b->next();
       delete b;
       b = next;
     }
   }
 };
 
-static void test_remove_dependent_nmethod(int id, bool delete_immediately) {
+static void test_remove_dependent_nmethod(int id) {
   TestDependencyContext c;
   DependencyContext depContext = c.dependencies();
-  NOT_PRODUCT(ASSERT_FALSE(TestDependencyContext::find_stale_entries(depContext)));
-  ASSERT_FALSE(TestDependencyContext::has_stale_entries(depContext));
-
-  nmethod* nm = c._nmethods[id];
-  depContext.remove_dependent_nmethod(nm, delete_immediately);
 
-  if (!delete_immediately) {
-    NOT_PRODUCT(ASSERT_TRUE(TestDependencyContext::find_stale_entries(depContext)));
-    ASSERT_TRUE(TestDependencyContext::has_stale_entries(depContext));
-    NOT_PRODUCT(ASSERT_TRUE(depContext.is_dependent_nmethod(nm)));
-    depContext.expunge_stale_entries();
-  }
+  nmethod* nm = &c._nmethods[id];
+  depContext.remove_dependent_nmethod(nm);
 
-  NOT_PRODUCT(ASSERT_FALSE(TestDependencyContext::find_stale_entries(depContext)));
-  ASSERT_FALSE(TestDependencyContext::has_stale_entries(depContext));
   NOT_PRODUCT(ASSERT_FALSE(depContext.is_dependent_nmethod(nm)));
 }
 
 TEST_VM(code, dependency_context) {
-  test_remove_dependent_nmethod(0, false);
-  test_remove_dependent_nmethod(1, false);
-  test_remove_dependent_nmethod(2, false);
-
-  test_remove_dependent_nmethod(0, true);
-  test_remove_dependent_nmethod(1, true);
-  test_remove_dependent_nmethod(2, true);
+  test_remove_dependent_nmethod(0);
+  test_remove_dependent_nmethod(1);
+  test_remove_dependent_nmethod(2);
 }