--- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp	Wed Feb 05 11:05:13 2014 +0100
+++ b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp	Thu Feb 13 17:44:39 2014 +0100
@@ -3035,7 +3035,6 @@
                                 true,   // activate StrongRootsScope
                                 SharedHeap::ScanningOption(roots_scanning_options()),
                                 &notOlder,
-                                true,   // walk code active on stacks
                                 NULL,
                                 NULL); // SSS: Provide correct closure
 
@@ -3102,7 +3101,6 @@
                                 true,   // activate StrongRootsScope
                                 SharedHeap::ScanningOption(roots_scanning_options()),
                                 &notOlder,
-                                true,   // walk code active on stacks
                                 NULL,
                                 &klass_closure);
 
@@ -3680,12 +3678,6 @@
   ResourceMark rm;
   HandleMark  hm;
 
-  FalseClosure falseClosure;
-  // In the case of a synchronous collection, we will elide the
-  // remark step, so it's important to catch all the nmethod oops
-  // in this step.
-  // The final 'true' flag to gen_process_strong_roots will ensure this.
-  // If 'async' is true, we can relax the nmethod tracing.
   MarkRefsIntoClosure notOlder(_span, &_markBitMap);
   GenCollectedHeap* gch = GenCollectedHeap::heap();
 
@@ -3738,7 +3730,6 @@
                                     true,   // activate StrongRootsScope
                                     SharedHeap::ScanningOption(roots_scanning_options()),
                                     &notOlder,
-                                    true,   // walk all of code cache if (so & SO_AllCodeCache)
                                     NULL,
                                     &klass_closure);
     }
@@ -5237,7 +5228,6 @@
                                 false,     // this is parallel code
                                 SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()),
                                 &par_mri_cl,
-                                true,   // walk all of code cache if (so & SO_AllCodeCache)
                                 NULL,
                                 &klass_closure);
   assert(_collector->should_unload_classes()
@@ -5373,7 +5363,6 @@
                                 false,     // this is parallel code
                                 SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()),
                                 &par_mrias_cl,
-                                true,   // walk all of code cache if (so & SO_AllCodeCache)
                                 NULL,
                                 NULL);     // The dirty klasses will be handled below
   assert(_collector->should_unload_classes()
@@ -5963,7 +5952,6 @@
                                   false, // use the local StrongRootsScope
                                   SharedHeap::ScanningOption(roots_scanning_options()),
                                   &mrias_cl,
-                                  true,   // walk code active on stacks
                                   NULL,
                                   NULL);  // The dirty klasses will be handled below
 

--- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp	Wed Feb 05 11:05:13 2014 +0100
+++ b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp	Thu Feb 13 17:44:39 2014 +0100
@@ -1383,13 +1383,6 @@
 // Closures of various sorts used by CMS to accomplish its work
 //
 
-// This closure is used to check that a certain set of oops is empty.
-class FalseClosure: public OopClosure {
- public:
-  void do_oop(oop* p)       { guarantee(false, "Should be an empty set"); }
-  void do_oop(narrowOop* p) { guarantee(false, "Should be an empty set"); }
-};
-
 // This closure is used to do concurrent marking from the roots
 // following the first checkpoint.
 class MarkFromRootsClosure: public BitMapClosure {

--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp	Wed Feb 05 11:05:13 2014 +0100
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp	Thu Feb 13 17:44:39 2014 +0100
@@ -3394,13 +3394,12 @@
 
     if (!silent) { gclog_or_tty->print("Roots "); }
     VerifyRootsClosure rootsCl(vo);
-    G1VerifyCodeRootOopClosure codeRootsCl(this, &rootsCl, vo);
-    G1VerifyCodeRootBlobClosure blobsCl(&codeRootsCl);
     VerifyKlassClosure klassCl(this, &rootsCl);
 
     // We apply the relevant closures to all the oops in the
-    // system dictionary, the string table and the code cache.
-    const int so = SO_AllClasses | SO_Strings | SO_AllCodeCache;
+    // system dictionary, class loader data graph and the string table.
+    // Don't verify the code cache here, since it's verified below.
+    const int so = SO_AllClasses | SO_Strings;
 
     // Need cleared claim bits for the strong roots processing
     ClassLoaderDataGraph::clear_claimed_marks();
@@ -3408,10 +3407,14 @@
     process_strong_roots(true,      // activate StrongRootsScope
                          ScanningOption(so),  // roots scanning options
                          &rootsCl,
-                         &blobsCl,
                          &klassCl
                          );
 
+    // Verify the nmethods in the code cache.
+    G1VerifyCodeRootOopClosure codeRootsCl(this, &rootsCl, vo);
+    G1VerifyCodeRootBlobClosure blobsCl(&codeRootsCl);
+    CodeCache::blobs_do(&blobsCl);
+
     bool failures = rootsCl.failures() || codeRootsCl.failures();
 
     if (vo != VerifyOption_G1UseMarkWord) {
@@ -5115,12 +5118,9 @@
 
   BufferingOopClosure buf_scan_non_heap_roots(scan_non_heap_roots);
 
-  CodeBlobToOopClosure scan_code_roots(&buf_scan_non_heap_roots, true /* do_marking */);
-
   process_strong_roots(false, // no scoping; this is parallel code
                        so,
                        &buf_scan_non_heap_roots,
-                       &scan_code_roots,
                        scan_klasses
                        );
 
@@ -5180,12 +5180,6 @@
   _process_strong_tasks->all_tasks_completed();
 }
 
-void
-G1CollectedHeap::g1_process_weak_roots(OopClosure* root_closure) {
-  CodeBlobToOopClosure roots_in_blobs(root_closure, /*do_marking=*/ false);
-  SharedHeap::process_weak_roots(root_closure, &roots_in_blobs);
-}
-
 class G1StringSymbolTableUnlinkTask : public AbstractGangTask {
 private:
   BoolObjectClosure* _is_alive;

--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp	Wed Feb 05 11:05:13 2014 +0100
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp	Thu Feb 13 17:44:39 2014 +0100
@@ -833,11 +833,6 @@
                                G1KlassScanClosure* scan_klasses,
                                int worker_i);
 
-  // Apply "blk" to all the weak roots of the system.  These include
-  // JNI weak roots, the code cache, system dictionary, symbol table,
-  // string table, and referents of reachable weak refs.
-  void g1_process_weak_roots(OopClosure* root_closure);
-
   // Frees a non-humongous region by initializing its contents and
   // adding it to the free list that's passed as a parameter (this is
   // usually a local list which will be appended to the master free

--- a/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp	Wed Feb 05 11:05:13 2014 +0100
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp	Thu Feb 13 17:44:39 2014 +0100
@@ -133,7 +133,6 @@
   sh->process_strong_roots(true,  // activate StrongRootsScope
                            SharedHeap::SO_SystemClasses,
                            &GenMarkSweep::follow_root_closure,
-                           &GenMarkSweep::follow_code_root_closure,
                            &GenMarkSweep::follow_klass_closure);
 
   // Process reference objects found during marking
@@ -307,9 +306,8 @@
   ClassLoaderDataGraph::clear_claimed_marks();
 
   sh->process_strong_roots(true,  // activate StrongRootsScope
-                           SharedHeap::SO_AllClasses,
+                           SharedHeap::SO_AllClasses | SharedHeap::SO_AllCodeCache,
                            &GenMarkSweep::adjust_pointer_closure,
-                           NULL,  // do not touch code cache here
                            &GenMarkSweep::adjust_klass_closure);
 
   assert(GenMarkSweep::ref_processor() == g1h->ref_processor_stw(), "Sanity");
@@ -317,7 +315,7 @@
 
   // Now adjust pointers in remaining weak roots.  (All of which should
   // have been cleared if they pointed to non-surviving objects.)
-  g1h->g1_process_weak_roots(&GenMarkSweep::adjust_pointer_closure);
+  sh->process_weak_roots(&GenMarkSweep::adjust_pointer_closure);
 
   GenMarkSweep::adjust_marks();
 

--- a/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp	Wed Feb 05 11:05:13 2014 +0100
+++ b/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp	Thu Feb 13 17:44:39 2014 +0100
@@ -621,7 +621,6 @@
                                 false, // no scope; this is parallel code
                                 SharedHeap::ScanningOption(so),
                                 &par_scan_state.to_space_root_closure(),
-                                true,   // walk *all* scavengable nmethods
                                 &par_scan_state.older_gen_closure(),
                                 &klass_scan_closure);
   par_scan_state.end_strong_roots();

--- a/hotspot/src/share/vm/gc_implementation/shared/markSweep.cpp	Wed Feb 05 11:05:13 2014 +0100
+++ b/hotspot/src/share/vm/gc_implementation/shared/markSweep.cpp	Thu Feb 13 17:44:39 2014 +0100
@@ -47,7 +47,6 @@
 SerialOldTracer*        MarkSweep::_gc_tracer       = NULL;
 
 MarkSweep::FollowRootClosure  MarkSweep::follow_root_closure;
-CodeBlobToOopClosure MarkSweep::follow_code_root_closure(&MarkSweep::follow_root_closure, /*do_marking=*/ true);
 
 void MarkSweep::FollowRootClosure::do_oop(oop* p)       { follow_root(p); }
 void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); }

--- a/hotspot/src/share/vm/gc_implementation/shared/markSweep.hpp	Wed Feb 05 11:05:13 2014 +0100
+++ b/hotspot/src/share/vm/gc_implementation/shared/markSweep.hpp	Thu Feb 13 17:44:39 2014 +0100
@@ -143,7 +143,6 @@
   // Public closures
   static IsAliveClosure       is_alive;
   static FollowRootClosure    follow_root_closure;
-  static CodeBlobToOopClosure follow_code_root_closure; // => follow_root_closure
   static MarkAndPushClosure   mark_and_push_closure;
   static FollowKlassClosure   follow_klass_closure;
   static FollowStackClosure   follow_stack_closure;

--- a/hotspot/src/share/vm/memory/defNewGeneration.cpp	Wed Feb 05 11:05:13 2014 +0100
+++ b/hotspot/src/share/vm/memory/defNewGeneration.cpp	Thu Feb 13 17:44:39 2014 +0100
@@ -626,7 +626,6 @@
                                 true,  // activate StrongRootsScope
                                 SharedHeap::ScanningOption(so),
                                 &fsc_with_no_gc_barrier,
-                                true,   // walk *all* scavengable nmethods
                                 &fsc_with_gc_barrier,
                                 &klass_scan_closure);
 

--- a/hotspot/src/share/vm/memory/genCollectedHeap.cpp	Wed Feb 05 11:05:13 2014 +0100
+++ b/hotspot/src/share/vm/memory/genCollectedHeap.cpp	Thu Feb 13 17:44:39 2014 +0100
@@ -594,20 +594,12 @@
                          bool activate_scope,
                          SharedHeap::ScanningOption so,
                          OopsInGenClosure* not_older_gens,
-                         bool do_code_roots,
                          OopsInGenClosure* older_gens,
                          KlassClosure* klass_closure) {
   // General strong roots.
 
-  if (!do_code_roots) {
-    SharedHeap::process_strong_roots(activate_scope, so,
-                                     not_older_gens, NULL, klass_closure);
-  } else {
-    bool do_code_marking = (activate_scope || nmethod::oops_do_marking_is_active());
-    CodeBlobToOopClosure code_roots(not_older_gens, /*do_marking=*/ do_code_marking);
-    SharedHeap::process_strong_roots(activate_scope, so,
-                                     not_older_gens, &code_roots, klass_closure);
-  }
+  SharedHeap::process_strong_roots(activate_scope, so,
+                                   not_older_gens, klass_closure);
 
   if (younger_gens_as_roots) {
     if (!_gen_process_strong_tasks->is_task_claimed(GCH_PS_younger_gens)) {
@@ -629,9 +621,8 @@
   _gen_process_strong_tasks->all_tasks_completed();
 }
 
-void GenCollectedHeap::gen_process_weak_roots(OopClosure* root_closure,
-                                              CodeBlobClosure* code_roots) {
-  SharedHeap::process_weak_roots(root_closure, code_roots);
+void GenCollectedHeap::gen_process_weak_roots(OopClosure* root_closure) {
+  SharedHeap::process_weak_roots(root_closure);
   // "Local" "weak" refs
   for (int i = 0; i < _n_gens; i++) {
     _gens[i]->ref_processor()->weak_oops_do(root_closure);

--- a/hotspot/src/share/vm/memory/genCollectedHeap.hpp	Wed Feb 05 11:05:13 2014 +0100
+++ b/hotspot/src/share/vm/memory/genCollectedHeap.hpp	Thu Feb 13 17:44:39 2014 +0100
@@ -414,15 +414,13 @@
                                 bool activate_scope,
                                 SharedHeap::ScanningOption so,
                                 OopsInGenClosure* not_older_gens,
-                                bool do_code_roots,
                                 OopsInGenClosure* older_gens,
                                 KlassClosure* klass_closure);
 
-  // Apply "blk" to all the weak roots of the system.  These include
-  // JNI weak roots, the code cache, system dictionary, symbol table,
-  // string table, and referents of reachable weak refs.
-  void gen_process_weak_roots(OopClosure* root_closure,
-                              CodeBlobClosure* code_roots);
+  // Apply "root_closure" to all the weak roots of the system.
+  // These include JNI weak roots, string table,
+  // and referents of reachable weak refs.
+  void gen_process_weak_roots(OopClosure* root_closure);
 
   // Set the saved marks of generations, if that makes sense.
   // In particular, if any generation might iterate over the oops

--- a/hotspot/src/share/vm/memory/genMarkSweep.cpp	Wed Feb 05 11:05:13 2014 +0100
+++ b/hotspot/src/share/vm/memory/genMarkSweep.cpp	Thu Feb 13 17:44:39 2014 +0100
@@ -212,7 +212,6 @@
                                 true,  // activate StrongRootsScope
                                 SharedHeap::SO_SystemClasses,
                                 &follow_root_closure,
-                                true,   // walk code active on stacks
                                 &follow_root_closure,
                                 &follow_klass_closure);
 
@@ -295,18 +294,12 @@
   gch->gen_process_strong_roots(level,
                                 false, // Younger gens are not roots.
                                 true,  // activate StrongRootsScope
-                                SharedHeap::SO_AllClasses,
+                                SharedHeap::SO_AllClasses | SharedHeap::SO_AllCodeCache,
                                 &adjust_pointer_closure,
-                                false, // do not walk code
                                 &adjust_pointer_closure,
                                 &adjust_klass_closure);
 
-  // Now adjust pointers in remaining weak roots.  (All of which should
-  // have been cleared if they pointed to non-surviving objects.)
-  CodeBlobToOopClosure adjust_code_pointer_closure(&adjust_pointer_closure,
-                                                   /*do_marking=*/ false);
-  gch->gen_process_weak_roots(&adjust_pointer_closure,
-                              &adjust_code_pointer_closure);
+  gch->gen_process_weak_roots(&adjust_pointer_closure);
 
   adjust_marks();
   GenAdjustPointersClosure blk;

--- a/hotspot/src/share/vm/memory/sharedHeap.cpp	Wed Feb 05 11:05:13 2014 +0100
+++ b/hotspot/src/share/vm/memory/sharedHeap.cpp	Thu Feb 13 17:44:39 2014 +0100
@@ -139,7 +139,6 @@
 void SharedHeap::process_strong_roots(bool activate_scope,
                                       ScanningOption so,
                                       OopClosure* roots,
-                                      CodeBlobClosure* code_roots,
                                       KlassClosure* klass_closure) {
   StrongRootsScope srs(this, activate_scope);
 
@@ -156,15 +155,17 @@
   if (!_process_strong_tasks->is_task_claimed(SH_PS_JNIHandles_oops_do))
     JNIHandles::oops_do(roots);
 
+  CodeBlobToOopClosure code_roots(roots, true);
+
   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.
   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))
@@ -206,17 +207,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");
+      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);
+      CodeCache::scavenge_root_nmethods_do(&code_roots);
     }
     if (so & SO_AllCodeCache) {
-      assert(code_roots != NULL, "must supply closure for code cache");
+      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);
+      CodeCache::blobs_do(&code_roots);
     }
     // Verify that the code cache contents are not subject to
     // movement by a scavenging collection.
@@ -233,12 +234,10 @@
 };
 static AlwaysTrueClosure always_true;
 
-void SharedHeap::process_weak_roots(OopClosure* root_closure,
-                                    CodeBlobClosure* code_roots) {
+void SharedHeap::process_weak_roots(OopClosure* root_closure) {
   // Global (weak) JNI handles
   JNIHandles::weak_oops_do(&always_true, root_closure);
 
-  CodeCache::blobs_do(code_roots);
   StringTable::oops_do(root_closure);
 }
 

--- a/hotspot/src/share/vm/memory/sharedHeap.hpp	Wed Feb 05 11:05:13 2014 +0100
+++ b/hotspot/src/share/vm/memory/sharedHeap.hpp	Thu Feb 13 17:44:39 2014 +0100
@@ -238,14 +238,11 @@
   void process_strong_roots(bool activate_scope,
                             ScanningOption so,
                             OopClosure* roots,
-                            CodeBlobClosure* code_roots,
                             KlassClosure* klass_closure);
 
-  // Apply "blk" to all the weak roots of the system.  These include
-  // JNI weak roots, the code cache, system dictionary, symbol table,
-  // string table.
-  void process_weak_roots(OopClosure* root_closure,
-                          CodeBlobClosure* code_roots);
+  // Apply "root_closure" to all the weak roots of the system.
+  // These include JNI weak roots and string table.
+  void process_weak_roots(OopClosure* root_closure);
 
   // The functions below are helper functions that a subclass of
   // "SharedHeap" can use in the implementation of its virtual
@@ -275,4 +272,8 @@
                              size_t capacity);
 };
 
+inline SharedHeap::ScanningOption operator|(SharedHeap::ScanningOption so0, SharedHeap::ScanningOption so1) {
+  return static_cast<SharedHeap::ScanningOption>(static_cast<int>(so0) | static_cast<int>(so1));
+}
+
 #endif // SHARE_VM_MEMORY_SHAREDHEAP_HPP