--- a/src/share/vm/memory/sharedHeap.cpp	Tue Apr 01 14:09:03 2014 +0200
+++ b/src/share/vm/memory/sharedHeap.cpp	Tue Apr 01 13:57:07 2014 +0200
@@ -137,8 +137,10 @@
 }
 
 void SharedHeap::process_strong_roots(bool activate_scope,
+                                      bool is_scavenging,
                                       ScanningOption so,
                                       OopClosure* roots,
+                                      CodeBlobClosure* code_roots,
                                       KlassClosure* klass_closure) {
   StrongRootsScope srs(this, activate_scope);
 
@@ -155,17 +157,13 @@
   if (!_process_strong_tasks->is_task_claimed(SH_PS_JNIHandles_oops_do))
     JNIHandles::oops_do(roots);
 
-  CodeBlobToOopClosure code_roots(roots, true);
-
+  // All threads execute this; the individual threads are task groups.
   CLDToOopClosure roots_from_clds(roots);
-  // If we limit class scanning to SO_SystemClasses we need to apply a CLD closure to
-  // CLDs which are strongly reachable from the thread stacks.
-  CLDToOopClosure* roots_from_clds_p = ((so & SO_SystemClasses) ? &roots_from_clds : NULL);
-  // All threads execute this; the individual threads are task groups.
+  CLDToOopClosure* roots_from_clds_p = (is_scavenging ? NULL : &roots_from_clds);
   if (CollectedHeap::use_parallel_gc_threads()) {
-    Threads::possibly_parallel_oops_do(roots, roots_from_clds_p, &code_roots);
+    Threads::possibly_parallel_oops_do(roots, roots_from_clds_p, code_roots);
   } else {
-    Threads::oops_do(roots, roots_from_clds_p, &code_roots);
+    Threads::oops_do(roots, roots_from_clds_p, code_roots);
   }
 
   if (!_process_strong_tasks-> is_task_claimed(SH_PS_ObjectSynchronizer_oops_do))
@@ -189,9 +187,9 @@
 
   if (!_process_strong_tasks->is_task_claimed(SH_PS_ClassLoaderDataGraph_oops_do)) {
     if (so & SO_AllClasses) {
-      ClassLoaderDataGraph::oops_do(roots, klass_closure, /* must_claim */ false);
+      ClassLoaderDataGraph::oops_do(roots, klass_closure, !is_scavenging);
     } else if (so & SO_SystemClasses) {
-      ClassLoaderDataGraph::always_strong_oops_do(roots, klass_closure, /* must_claim */ true);
+      ClassLoaderDataGraph::always_strong_oops_do(roots, klass_closure, !is_scavenging);
     }
   }
 
@@ -206,18 +204,17 @@
   }
 
   if (!_process_strong_tasks->is_task_claimed(SH_PS_CodeCache_oops_do)) {
-    if (so & SO_ScavengeCodeCache) {
-      assert(&code_roots != NULL, "must supply closure for code cache");
+    if (so & SO_CodeCache) {
+      assert(code_roots != NULL, "must supply closure for code cache");
 
-      // We only visit parts of the CodeCache when scavenging.
-      CodeCache::scavenge_root_nmethods_do(&code_roots);
-    }
-    if (so & SO_AllCodeCache) {
-      assert(&code_roots != NULL, "must supply closure for code cache");
-
-      // CMSCollector uses this to do intermediate-strength collections.
-      // We scan the entire code cache, since CodeCache::do_unloading is not called.
-      CodeCache::blobs_do(&code_roots);
+      if (is_scavenging) {
+        // We only visit parts of the CodeCache when scavenging.
+        CodeCache::scavenge_root_nmethods_do(code_roots);
+      } else {
+        // CMSCollector uses this to do intermediate-strength collections.
+        // We scan the entire code cache, since CodeCache::do_unloading is not called.
+        CodeCache::blobs_do(code_roots);
+      }
     }
     // Verify that the code cache contents are not subject to
     // movement by a scavenging collection.
@@ -234,9 +231,13 @@
 };
 static AlwaysTrueClosure always_true;
 
-void SharedHeap::process_weak_roots(OopClosure* root_closure) {
+void SharedHeap::process_weak_roots(OopClosure* root_closure,
+                                    CodeBlobClosure* code_roots) {
   // Global (weak) JNI handles
   JNIHandles::weak_oops_do(&always_true, root_closure);
+
+  CodeCache::blobs_do(code_roots);
+  StringTable::oops_do(root_closure);
 }
 
 void SharedHeap::set_barrier_set(BarrierSet* bs) {