--- old/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp	2015-04-01 12:41:51.051908554 +0200
+++ new/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp	2015-04-01 12:41:50.935908559 +0200
@@ -3071,10 +3071,10 @@
       gch->set_par_threads(n_workers);
       initialize_sequential_subtasks_for_young_gen_rescan(n_workers);
       if (n_workers > 1) {
-        GenCollectedHeap::StrongRootsScope srs(gch);
+        GenCollectedHeap::StrongRootsScope srs;
         workers->run_task(&tsk);
       } else {
-        GenCollectedHeap::StrongRootsScope srs(gch);
+        GenCollectedHeap::StrongRootsScope srs;
         tsk.work(0);
       }
       gch->set_par_threads(0);
@@ -5169,11 +5169,11 @@
     // necessarily be so, since it's possible that we are doing
     // ST marking.
     ReferenceProcessorMTDiscoveryMutator mt(ref_processor(), true);
-    GenCollectedHeap::StrongRootsScope srs(gch);
+    GenCollectedHeap::StrongRootsScope srs;
     workers->run_task(&tsk);
   } else {
     ReferenceProcessorMTDiscoveryMutator mt(ref_processor(), false);
-    GenCollectedHeap::StrongRootsScope srs(gch);
+    GenCollectedHeap::StrongRootsScope srs;
     tsk.work(0);
   }
 
@@ -5241,7 +5241,7 @@
     verify_work_stacks_empty();
 
     gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
-    GenCollectedHeap::StrongRootsScope srs(gch);
+    GenCollectedHeap::StrongRootsScope srs;
 
     gch->gen_process_roots(_cmsGen->level(),
                            true,  // younger gens as roots
--- old/src/share/vm/gc_implementation/g1/concurrentMark.cpp	2015-04-01 12:41:51.359908541 +0200
+++ new/src/share/vm/gc_implementation/g1/concurrentMark.cpp	2015-04-01 12:41:51.243908546 +0200
@@ -2650,7 +2650,7 @@
 
   g1h->ensure_parsability(false);
 
-  G1CollectedHeap::StrongRootsScope srs(g1h);
+  G1CollectedHeap::StrongRootsScope srs;
   // this is remark, so we'll use up all active threads
   uint active_workers = g1h->workers()->active_workers();
   if (active_workers == 0) {
--- old/src/share/vm/gc_implementation/g1/g1RootProcessor.cpp	2015-04-01 12:41:51.611908531 +0200
+++ new/src/share/vm/gc_implementation/g1/g1RootProcessor.cpp	2015-04-01 12:41:51.495908536 +0200
@@ -116,7 +116,7 @@
 G1RootProcessor::G1RootProcessor(G1CollectedHeap* g1h) :
     _g1h(g1h),
     _process_strong_tasks(new SubTasksDone(G1RP_PS_NumElements)),
-    _srs(g1h),
+    _srs(),
     _lock(Mutex::leaf, "G1 Root Scanning barrier lock", false, Monitor::_safepoint_check_never),
     _n_workers_discovered_strong_classes(0) {}
 
--- old/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp	2015-04-01 12:41:51.807908523 +0200
+++ new/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp	2015-04-01 12:41:51.699908527 +0200
@@ -974,10 +974,10 @@
   // in the multi-threaded case, but we special-case n=1 here to get
   // repeatable measurements of the 1-thread overhead of the parallel code.
   if (n_workers > 1) {
-    GenCollectedHeap::StrongRootsScope srs(gch);
+    GenCollectedHeap::StrongRootsScope srs;
     workers->run_task(&tsk);
   } else {
-    GenCollectedHeap::StrongRootsScope srs(gch);
+    GenCollectedHeap::StrongRootsScope srs;
     tsk.work(0);
   }
   thread_state_set.reset(0 /* Bad value in debug if not reset */,
--- old/src/share/vm/memory/genCollectedHeap.cpp	2015-04-01 12:41:52.031908513 +0200
+++ new/src/share/vm/memory/genCollectedHeap.cpp	2015-04-01 12:41:51.919908518 +0200
@@ -596,7 +596,7 @@
                                      CLDClosure* strong_cld_closure,
                                      CLDClosure* weak_cld_closure,
                                      CodeBlobClosure* code_roots) {
-  StrongRootsScope srs(this, activate_scope);
+  StrongRootsScope srs(activate_scope);
 
   // General roots.
   assert(Threads::thread_claim_parity() != 0, "must have called prologue code");
--- old/src/share/vm/memory/sharedHeap.cpp	2015-04-01 12:41:52.243908504 +0200
+++ new/src/share/vm/memory/sharedHeap.cpp	2015-04-01 12:41:52.131908509 +0200
@@ -39,8 +39,8 @@
   CollectedHeap()
 {}
 
-SharedHeap::StrongRootsScope::StrongRootsScope(SharedHeap* heap, bool activate)
-  : MarkScope(activate), _sh(heap)
+SharedHeap::StrongRootsScope::StrongRootsScope(bool activate)
+  : MarkScope(activate)
 {
   if (_active) {
     Threads::change_thread_claim_parity();
--- old/src/share/vm/memory/sharedHeap.hpp	2015-04-01 12:41:52.439908496 +0200
+++ new/src/share/vm/memory/sharedHeap.hpp	2015-04-01 12:41:52.323908501 +0200
@@ -126,10 +126,8 @@
   // strong_roots_prologue calls change_strong_roots_parity, if
   // parallel tasks are enabled.
   class StrongRootsScope : public MarkingCodeBlobClosure::MarkScope {
-    SharedHeap*   _sh;
-
    public:
-    StrongRootsScope(SharedHeap* heap, bool activate = true);
+    StrongRootsScope(bool activate = true);
     ~StrongRootsScope();
   };
  };