diff --git a/src/memory_manager.rs b/src/memory_manager.rs
index 836635384c..b413c30a51 100644
--- a/src/memory_manager.rs
+++ b/src/memory_manager.rs
@@ -819,7 +819,7 @@ pub fn harness_begin<VM: VMBinding>(mmtk: &MMTK<VM>, tls: VMMutatorThread) {
 ///
 /// Arguments:
 /// * `mmtk`: A reference to an MMTk instance.
-pub fn harness_end<VM: VMBinding>(mmtk: &'static MMTK<VM>) {
+pub fn harness_end<VM: VMBinding>(mmtk: &MMTK<VM>) {
     mmtk.harness_end();
 }
 
@@ -831,7 +831,7 @@ pub fn harness_end<VM: VMBinding>(mmtk: &'static MMTK<VM>) {
 /// * `mmtk`: A reference to an MMTk instance
 /// * `object`: The object that has a finalizer
 pub fn add_finalizer<VM: VMBinding>(
-    mmtk: &'static MMTK<VM>,
+    mmtk: &MMTK<VM>,
     object: <VM::VMReferenceGlue as ReferenceGlue<VM>>::FinalizableType,
 ) {
     if *mmtk.options.no_finalizer {
@@ -891,7 +891,7 @@ pub fn is_pinned(object: ObjectReference) -> bool {
 /// Arguments:
 /// * `mmtk`: A reference to an MMTk instance.
 pub fn get_finalized_object<VM: VMBinding>(
-    mmtk: &'static MMTK<VM>,
+    mmtk: &MMTK<VM>,
 ) -> Option<<VM::VMReferenceGlue as ReferenceGlue<VM>>::FinalizableType> {
     if *mmtk.options.no_finalizer {
         warn!("get_finalized_object() is called when no_finalizer = true");
@@ -911,7 +911,7 @@ pub fn get_finalized_object<VM: VMBinding>(
 /// Arguments:
 /// * `mmtk`: A reference to an MMTk instance.
 pub fn get_all_finalizers<VM: VMBinding>(
-    mmtk: &'static MMTK<VM>,
+    mmtk: &MMTK<VM>,
 ) -> Vec<<VM::VMReferenceGlue as ReferenceGlue<VM>>::FinalizableType> {
     if *mmtk.options.no_finalizer {
         warn!("get_all_finalizers() is called when no_finalizer = true");
@@ -930,7 +930,7 @@ pub fn get_all_finalizers<VM: VMBinding>(
 /// * `mmtk`: A reference to an MMTk instance.
 /// * `object`: the given object that MMTk will pop its finalizers
 pub fn get_finalizers_for<VM: VMBinding>(
-    mmtk: &'static MMTK<VM>,
+    mmtk: &MMTK<VM>,
     object: ObjectReference,
 ) -> Vec<<VM::VMReferenceGlue as ReferenceGlue<VM>>::FinalizableType> {
     if *mmtk.options.no_finalizer {
@@ -949,7 +949,7 @@ pub fn get_finalizers_for<VM: VMBinding>(
 ///
 /// Arguments:
 /// * `mmtk`: A reference to an MMTk instance.
-pub fn num_of_workers<VM: VMBinding>(mmtk: &'static MMTK<VM>) -> usize {
+pub fn num_of_workers<VM: VMBinding>(mmtk: &MMTK<VM>) -> usize {
     mmtk.scheduler.num_workers()
 }
 
@@ -961,7 +961,7 @@ pub fn num_of_workers<VM: VMBinding>(mmtk: &'static MMTK<VM>) -> usize {
 /// * `bucket`: Which work bucket to add this packet to.
 /// * `packet`: The work packet to be added.
 pub fn add_work_packet<VM: VMBinding, W: GCWork<VM>>(
-    mmtk: &'static MMTK<VM>,
+    mmtk: &MMTK<VM>,
     bucket: WorkBucketStage,
     packet: W,
 ) {
@@ -976,7 +976,7 @@ pub fn add_work_packet<VM: VMBinding, W: GCWork<VM>>(
 /// * `bucket`: Which work bucket to add these packets to.
 /// * `packet`: The work packets to be added.
 pub fn add_work_packets<VM: VMBinding>(
-    mmtk: &'static MMTK<VM>,
+    mmtk: &MMTK<VM>,
     bucket: WorkBucketStage,
     packets: Vec<Box<dyn GCWork<VM>>>,
 ) {
diff --git a/src/mmtk.rs b/src/mmtk.rs
index 7931d18e06..d93e632081 100644
--- a/src/mmtk.rs
+++ b/src/mmtk.rs
@@ -289,7 +289,7 @@ impl<VM: VMBinding> MMTK<VM> {
     /// is only safe for the VM to call `fork()` after the underlying **native threads** of the GC
     /// threads have exited.  After calling this function, the VM should wait for their underlying
     /// native threads to exit in VM-specific manner before calling `fork()`.
-    pub fn prepare_to_fork(&'static self) {
+    pub fn prepare_to_fork(&self) {
         assert!(
             self.state.is_initialized(),
             "MMTk collection has not been initialized, yet (was initialize_collection() called before?)"
@@ -307,7 +307,7 @@ impl<VM: VMBinding> MMTK<VM> {
     /// *   `tls`: The thread that wants to respawn MMTk threads after forking. This value will be
     ///     passed back to the VM in `Collection::spawn_gc_thread()` so that the VM knows the
     ///     context.
-    pub fn after_fork(&'static self, tls: VMThread) {
+    pub fn after_fork(&self, tls: VMThread) {
         assert!(
             self.state.is_initialized(),
             "MMTk collection has not been initialized, yet (was initialize_collection() called before?)"
@@ -330,7 +330,7 @@ impl<VM: VMBinding> MMTK<VM> {
     /// Generic hook to allow benchmarks to be harnessed. MMTk will stop collecting
     /// statistics, and print out the collected statistics in a defined format.
     /// This is usually called by the benchmark harness right after the actual benchmark.
-    pub fn harness_end(&'static self) {
+    pub fn harness_end(&self) {
         self.stats.stop_all(self);
         self.state.inside_harness.store(false, Ordering::SeqCst);
         probe!(mmtk, harness_end);
diff --git a/src/plan/compressor/gc_work.rs b/src/plan/compressor/gc_work.rs
index 242e291808..5c04dc0b5a 100644
--- a/src/plan/compressor/gc_work.rs
+++ b/src/plan/compressor/gc_work.rs
@@ -17,7 +17,7 @@ pub struct GenerateWork<VM: VMBinding, F: Fn(&'static CompressorSpace<VM>) + Sen
 impl<VM: VMBinding, F: Fn(&'static CompressorSpace<VM>) + Send + 'static> GCWork<VM>
     for GenerateWork<VM, F>
 {
-    fn do_work(&mut self, _worker: &mut GCWorker<VM>, _mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, _worker: &mut GCWorker<VM>, _mmtk: &MMTK<VM>) {
         (self.f)(self.compressor_space);
     }
 }
@@ -40,7 +40,7 @@ pub struct UpdateReferences<VM: VMBinding> {
 unsafe impl<VM: VMBinding> Send for UpdateReferences<VM> {}
 
 impl<VM: VMBinding> GCWork<VM> for UpdateReferences<VM> {
-    fn do_work(&mut self, _worker: &mut GCWorker<VM>, mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, _worker: &mut GCWorker<VM>, mmtk: &MMTK<VM>) {
         // The following needs to be done right before the second round of root scanning
         VM::VMScanning::prepare_for_roots_re_scanning();
         mmtk.state.prepare_for_stack_scanning();
@@ -71,7 +71,7 @@ pub struct AfterCompact<VM: VMBinding> {
 }
 
 impl<VM: VMBinding> GCWork<VM> for AfterCompact<VM> {
-    fn do_work(&mut self, worker: &mut GCWorker<VM>, _mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<VM>, _mmtk: &MMTK<VM>) {
         self.compressor_space.after_compact(worker, self.los);
     }
 }
diff --git a/src/plan/concurrent/concurrent_marking_work.rs b/src/plan/concurrent/concurrent_marking_work.rs
index b0bb979e40..26f7b61381 100644
--- a/src/plan/concurrent/concurrent_marking_work.rs
+++ b/src/plan/concurrent/concurrent_marking_work.rs
@@ -113,7 +113,7 @@ unsafe impl<VM: VMBinding, P: ConcurrentPlan<VM = VM> + PlanTraceObject<VM>, con
 impl<VM: VMBinding, P: ConcurrentPlan<VM = VM> + PlanTraceObject<VM>, const KIND: TraceKind>
     GCWork<VM> for ConcurrentTraceObjects<VM, P, KIND>
 {
-    fn do_work(&mut self, worker: &mut GCWorker<VM>, _mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<VM>, _mmtk: &MMTK<VM>) {
         self.worker = worker;
         let mut num_objects = 0;
         let mut num_next_objects = 0;
@@ -175,17 +175,17 @@ impl<VM: VMBinding, P: ConcurrentPlan<VM = VM> + PlanTraceObject<VM>, const KIND
 impl<VM: VMBinding, P: ConcurrentPlan<VM = VM> + PlanTraceObject<VM>, const KIND: TraceKind>
     GCWork<VM> for ProcessModBufSATB<VM, P, KIND>
 {
-    fn do_work(&mut self, worker: &mut GCWorker<VM>, mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<VM>, _mmtk: &MMTK<VM>) {
         let mut w = if let Some(nodes) = self.nodes.take() {
             if nodes.is_empty() {
                 return;
             }
 
-            ConcurrentTraceObjects::<VM, P, KIND>::new(nodes, mmtk)
+            ConcurrentTraceObjects::<VM, P, KIND>::new(nodes, worker.mmtk)
         } else {
             return;
         };
-        GCWork::do_work(&mut w, worker, mmtk);
+        GCWork::do_work(&mut w, worker, worker.mmtk);
     }
 }
 
diff --git a/src/plan/gc_work.rs b/src/plan/gc_work.rs
index 4998d1101c..c9d1638b2d 100644
--- a/src/plan/gc_work.rs
+++ b/src/plan/gc_work.rs
@@ -8,11 +8,7 @@ pub(super) struct SetCommonPlanUnlogBits<VM: VMBinding> {
 }
 
 impl<VM: VMBinding> GCWork<VM> for SetCommonPlanUnlogBits<VM> {
-    fn do_work(
-        &mut self,
-        _worker: &mut crate::scheduler::GCWorker<VM>,
-        _mmtk: &'static crate::MMTK<VM>,
-    ) {
+    fn do_work(&mut self, _worker: &mut crate::scheduler::GCWorker<VM>, _mmtk: &crate::MMTK<VM>) {
         self.common_plan.set_side_log_bits();
     }
 }
@@ -22,11 +18,7 @@ pub(super) struct ClearCommonPlanUnlogBits<VM: VMBinding> {
 }
 
 impl<VM: VMBinding> GCWork<VM> for ClearCommonPlanUnlogBits<VM> {
-    fn do_work(
-        &mut self,
-        _worker: &mut crate::scheduler::GCWorker<VM>,
-        _mmtk: &'static crate::MMTK<VM>,
-    ) {
+    fn do_work(&mut self, _worker: &mut crate::scheduler::GCWorker<VM>, _mmtk: &crate::MMTK<VM>) {
         self.common_plan.clear_side_log_bits();
     }
 }
diff --git a/src/plan/generational/gc_work.rs b/src/plan/generational/gc_work.rs
index 51e0324934..c5b9741b65 100644
--- a/src/plan/generational/gc_work.rs
+++ b/src/plan/generational/gc_work.rs
@@ -108,7 +108,7 @@ impl<E: ProcessEdgesWork> ProcessModBuf<E> {
 }
 
 impl<E: ProcessEdgesWork> GCWork<E::VM> for ProcessModBuf<E> {
-    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, mmtk: &'static MMTK<E::VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, mmtk: &MMTK<E::VM>) {
         // Process and scan modbuf only if the current GC is a nursery GC
         let gen = mmtk.get_plan().generational().unwrap();
         if gen.is_current_gc_nursery() {
@@ -157,7 +157,7 @@ impl<E: ProcessEdgesWork> ProcessRegionModBuf<E> {
 }
 
 impl<E: ProcessEdgesWork> GCWork<E::VM> for ProcessRegionModBuf<E> {
-    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, mmtk: &'static MMTK<E::VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, mmtk: &MMTK<E::VM>) {
         // Scan modbuf only if the current GC is a nursery GC
         if mmtk
             .get_plan()
@@ -174,7 +174,7 @@ impl<E: ProcessEdgesWork> GCWork<E::VM> for ProcessRegionModBuf<E> {
             }
             // Forward entries
             GCWork::do_work(
-                &mut E::new(slots, false, mmtk, WorkBucketStage::Closure),
+                &mut E::new(slots, false, worker.mmtk, WorkBucketStage::Closure),
                 worker,
                 mmtk,
             )
diff --git a/src/plan/markcompact/gc_work.rs b/src/plan/markcompact/gc_work.rs
index 8197eb4e65..4578851e60 100644
--- a/src/plan/markcompact/gc_work.rs
+++ b/src/plan/markcompact/gc_work.rs
@@ -18,7 +18,7 @@ pub struct CalculateForwardingAddress<VM: VMBinding> {
 }
 
 impl<VM: VMBinding> GCWork<VM> for CalculateForwardingAddress<VM> {
-    fn do_work(&mut self, _worker: &mut GCWorker<VM>, _mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, _worker: &mut GCWorker<VM>, _mmtk: &MMTK<VM>) {
         self.mc_space.calculate_forwarding_pointer();
     }
 }
@@ -39,7 +39,7 @@ pub struct UpdateReferences<VM: VMBinding> {
 unsafe impl<VM: VMBinding> Send for UpdateReferences<VM> {}
 
 impl<VM: VMBinding> GCWork<VM> for UpdateReferences<VM> {
-    fn do_work(&mut self, worker: &mut GCWorker<VM>, mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<VM>, mmtk: &MMTK<VM>) {
         // The following needs to be done right before the second round of root scanning
         VM::VMScanning::prepare_for_roots_re_scanning();
         mmtk.state.prepare_for_stack_scanning();
@@ -81,7 +81,7 @@ pub struct Compact<VM: VMBinding> {
 }
 
 impl<VM: VMBinding> GCWork<VM> for Compact<VM> {
-    fn do_work(&mut self, _worker: &mut GCWorker<VM>, _mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, _worker: &mut GCWorker<VM>, _mmtk: &MMTK<VM>) {
         self.mc_space.compact();
     }
 }
diff --git a/src/policy/compressor/compressorspace.rs b/src/policy/compressor/compressorspace.rs
index ada189a903..222e3c9919 100644
--- a/src/policy/compressor/compressorspace.rs
+++ b/src/policy/compressor/compressorspace.rs
@@ -426,7 +426,7 @@ pub struct CalculateOffsetVector<VM: VMBinding> {
 }
 
 impl<VM: VMBinding> GCWork<VM> for CalculateOffsetVector<VM> {
-    fn do_work(&mut self, _worker: &mut GCWorker<VM>, _mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, _worker: &mut GCWorker<VM>, _mmtk: &MMTK<VM>) {
         self.compressor_space
             .calculate_offset_vector_for_region(self.region, self.cursor);
     }
@@ -453,7 +453,7 @@ pub struct Compact<VM: VMBinding> {
 }
 
 impl<VM: VMBinding> GCWork<VM> for Compact<VM> {
-    fn do_work(&mut self, worker: &mut GCWorker<VM>, _mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<VM>, _mmtk: &MMTK<VM>) {
         self.compressor_space.compact_region(worker, self.index);
     }
 }
diff --git a/src/policy/immix/immixspace.rs b/src/policy/immix/immixspace.rs
index f9c83f8f49..c5c42d0711 100644
--- a/src/policy/immix/immixspace.rs
+++ b/src/policy/immix/immixspace.rs
@@ -938,7 +938,7 @@ impl<VM: VMBinding> PrepareBlockState<VM> {
 }
 
 impl<VM: VMBinding> GCWork<VM> for PrepareBlockState<VM> {
-    fn do_work(&mut self, _worker: &mut GCWorker<VM>, mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, _worker: &mut GCWorker<VM>, mmtk: &MMTK<VM>) {
         // Clear object mark table for this chunk
         self.reset_object_mark();
         // Iterate over all blocks in this chunk
@@ -984,7 +984,7 @@ struct SweepChunk<VM: VMBinding> {
 }
 
 impl<VM: VMBinding> GCWork<VM> for SweepChunk<VM> {
-    fn do_work(&mut self, _worker: &mut GCWorker<VM>, mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, _worker: &mut GCWorker<VM>, mmtk: &MMTK<VM>) {
         assert!(self.space.chunk_map.get(self.chunk).unwrap().is_allocated());
 
         let mut histogram = self.space.defrag.new_histogram();
@@ -1199,7 +1199,7 @@ struct ClearVOBitsAfterPrepare {
 
 #[cfg(feature = "vo_bit")]
 impl<VM: VMBinding> GCWork<VM> for ClearVOBitsAfterPrepare {
-    fn do_work(&mut self, _worker: &mut GCWorker<VM>, _mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, _worker: &mut GCWorker<VM>, _mmtk: &MMTK<VM>) {
         match self.scope {
             VOBitsClearingScope::FullGC => {
                 vo_bit::bzero_vo_bit(self.chunk.start(), Chunk::BYTES);
diff --git a/src/policy/marksweepspace/malloc_ms/global.rs b/src/policy/marksweepspace/malloc_ms/global.rs
index cdb89d6ce6..171f4932ca 100644
--- a/src/policy/marksweepspace/malloc_ms/global.rs
+++ b/src/policy/marksweepspace/malloc_ms/global.rs
@@ -899,7 +899,7 @@ pub struct MSSweepChunk<VM: VMBinding> {
 }
 
 impl<VM: VMBinding> GCWork<VM> for MSSweepChunk<VM> {
-    fn do_work(&mut self, _worker: &mut GCWorker<VM>, _mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, _worker: &mut GCWorker<VM>, _mmtk: &MMTK<VM>) {
         self.ms.sweep_chunk(self.chunk);
     }
 }
diff --git a/src/policy/marksweepspace/native_ms/global.rs b/src/policy/marksweepspace/native_ms/global.rs
index ce172b9a82..d7fc10a258 100644
--- a/src/policy/marksweepspace/native_ms/global.rs
+++ b/src/policy/marksweepspace/native_ms/global.rs
@@ -579,7 +579,7 @@ struct PrepareChunkMap<VM: VMBinding> {
 }
 
 impl<VM: VMBinding> GCWork<VM> for PrepareChunkMap<VM> {
-    fn do_work(&mut self, _worker: &mut GCWorker<VM>, _mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, _worker: &mut GCWorker<VM>, _mmtk: &MMTK<VM>) {
         debug_assert!(self.space.chunk_map.get(self.chunk).unwrap().is_allocated());
         // number of allocated blocks.
         let mut n_occupied_blocks = 0;
@@ -609,7 +609,7 @@ struct ReleaseMarkSweepSpace<VM: VMBinding> {
 }
 
 impl<VM: VMBinding> GCWork<VM> for ReleaseMarkSweepSpace<VM> {
-    fn do_work(&mut self, _worker: &mut GCWorker<VM>, _mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, _worker: &mut GCWorker<VM>, _mmtk: &MMTK<VM>) {
         {
             let mut abandoned = self.space.abandoned.lock().unwrap();
             abandoned.sweep_later(self.space);
@@ -629,7 +629,7 @@ struct SweepChunk<VM: VMBinding> {
 }
 
 impl<VM: VMBinding> GCWork<VM> for SweepChunk<VM> {
-    fn do_work(&mut self, _worker: &mut GCWorker<VM>, _mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, _worker: &mut GCWorker<VM>, _mmtk: &MMTK<VM>) {
         assert!(self.space.chunk_map.get(self.chunk).unwrap().is_allocated());
 
         // number of allocated blocks.
diff --git a/src/scheduler/gc_work.rs b/src/scheduler/gc_work.rs
index fefd9ba0fa..f3cd3d4550 100644
--- a/src/scheduler/gc_work.rs
+++ b/src/scheduler/gc_work.rs
@@ -13,7 +13,7 @@ use std::ops::{Deref, DerefMut};
 pub struct ScheduleCollection;
 
 impl<VM: VMBinding> GCWork<VM> for ScheduleCollection {
-    fn do_work(&mut self, worker: &mut GCWorker<VM>, mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<VM>, mmtk: &MMTK<VM>) {
         // Tell GC trigger that GC started.
         mmtk.gc_trigger.policy.on_gc_start(mmtk);
 
@@ -29,7 +29,10 @@ impl<VM: VMBinding> GCWork<VM> for ScheduleCollection {
         mmtk.set_gc_status(GcStatus::GcPrepare);
 
         // Let the plan to schedule collection work
-        mmtk.get_plan().schedule_collection(worker.scheduler());
+        worker
+            .mmtk
+            .get_plan()
+            .schedule_collection(worker.scheduler());
     }
 }
 
@@ -53,7 +56,7 @@ impl<C: GCWorkContext> Prepare<C> {
 }
 
 impl<C: GCWorkContext> GCWork<C::VM> for Prepare<C> {
-    fn do_work(&mut self, worker: &mut GCWorker<C::VM>, mmtk: &'static MMTK<C::VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<C::VM>, mmtk: &MMTK<C::VM>) {
         trace!("Prepare Global");
         // We assume this is the only running work packet that accesses plan at the point of execution
         let plan_mut: &mut C::PlanType = unsafe { &mut *(self.plan as *const _ as *mut _) };
@@ -92,7 +95,7 @@ impl<VM: VMBinding> PrepareMutator<VM> {
 }
 
 impl<VM: VMBinding> GCWork<VM> for PrepareMutator<VM> {
-    fn do_work(&mut self, worker: &mut GCWorker<VM>, _mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<VM>, _mmtk: &MMTK<VM>) {
         trace!("Prepare Mutator");
         self.mutator.prepare(worker.tls);
     }
@@ -103,7 +106,7 @@ impl<VM: VMBinding> GCWork<VM> for PrepareMutator<VM> {
 pub struct PrepareCollector;
 
 impl<VM: VMBinding> GCWork<VM> for PrepareCollector {
-    fn do_work(&mut self, worker: &mut GCWorker<VM>, mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<VM>, mmtk: &MMTK<VM>) {
         trace!("Prepare Collector");
         worker.get_copy_context_mut().prepare();
         mmtk.get_plan().prepare_worker(worker);
@@ -130,7 +133,7 @@ impl<C: GCWorkContext> Release<C> {
 unsafe impl<C: GCWorkContext> Send for Release<C> {}
 
 impl<C: GCWorkContext + 'static> GCWork<C::VM> for Release<C> {
-    fn do_work(&mut self, worker: &mut GCWorker<C::VM>, mmtk: &'static MMTK<C::VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<C::VM>, mmtk: &MMTK<C::VM>) {
         trace!("Release Global");
 
         mmtk.gc_trigger.policy.on_gc_release(mmtk);
@@ -170,7 +173,7 @@ impl<VM: VMBinding> ReleaseMutator<VM> {
 }
 
 impl<VM: VMBinding> GCWork<VM> for ReleaseMutator<VM> {
-    fn do_work(&mut self, worker: &mut GCWorker<VM>, _mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<VM>, _mmtk: &MMTK<VM>) {
         trace!("Release Mutator");
         self.mutator.release(worker.tls);
     }
@@ -181,7 +184,7 @@ impl<VM: VMBinding> GCWork<VM> for ReleaseMutator<VM> {
 pub struct ReleaseCollector;
 
 impl<VM: VMBinding> GCWork<VM> for ReleaseCollector {
-    fn do_work(&mut self, worker: &mut GCWorker<VM>, _mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<VM>, _mmtk: &MMTK<VM>) {
         trace!("Release Collector");
         worker.get_copy_context_mut().release();
     }
@@ -220,7 +223,7 @@ impl<C: GCWorkContext> StopMutators<C> {
 }
 
 impl<C: GCWorkContext> GCWork<C::VM> for StopMutators<C> {
-    fn do_work(&mut self, worker: &mut GCWorker<C::VM>, mmtk: &'static MMTK<C::VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<C::VM>, mmtk: &MMTK<C::VM>) {
         trace!("stop_all_mutators start");
         mmtk.state.prepare_for_stack_scanning();
         <C::VM as VMBinding>::VMCollection::stop_all_mutators(worker.tls, |mutator| {
@@ -348,7 +351,7 @@ impl<E: ProcessEdgesWork> VMProcessWeakRefs<E> {
 }
 
 impl<E: ProcessEdgesWork> GCWork<E::VM> for VMProcessWeakRefs<E> {
-    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, _mmtk: &'static MMTK<E::VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, _mmtk: &MMTK<E::VM>) {
         trace!("VMProcessWeakRefs");
 
         let stage = WorkBucketStage::VMRefClosure;
@@ -391,7 +394,7 @@ impl<E: ProcessEdgesWork> VMForwardWeakRefs<E> {
 }
 
 impl<E: ProcessEdgesWork> GCWork<E::VM> for VMForwardWeakRefs<E> {
-    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, _mmtk: &'static MMTK<E::VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, _mmtk: &MMTK<E::VM>) {
         trace!("VMForwardWeakRefs");
 
         let stage = WorkBucketStage::VMRefForwarding;
@@ -416,7 +419,7 @@ pub struct VMPostForwarding<VM: VMBinding> {
 }
 
 impl<VM: VMBinding> GCWork<VM> for VMPostForwarding<VM> {
-    fn do_work(&mut self, worker: &mut GCWorker<VM>, _mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<VM>, _mmtk: &MMTK<VM>) {
         trace!("VMPostForwarding start");
         <VM as VMBinding>::VMCollection::post_forwarding(worker.tls);
         trace!("VMPostForwarding end");
@@ -426,14 +429,14 @@ impl<VM: VMBinding> GCWork<VM> for VMPostForwarding<VM> {
 pub struct ScanMutatorRoots<C: GCWorkContext>(pub &'static mut Mutator<C::VM>);
 
 impl<C: GCWorkContext> GCWork<C::VM> for ScanMutatorRoots<C> {
-    fn do_work(&mut self, worker: &mut GCWorker<C::VM>, mmtk: &'static MMTK<C::VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<C::VM>, mmtk: &MMTK<C::VM>) {
         trace!("ScanMutatorRoots for mutator {:?}", self.0.get_tls());
         let mutators = <C::VM as VMBinding>::VMActivePlan::number_of_mutators();
         let factory = ProcessEdgesWorkRootsWorkFactory::<
             C::VM,
             C::DefaultProcessEdges,
             C::PinningProcessEdges,
-        >::new(mmtk);
+        >::new(worker.mmtk);
         <C::VM as VMBinding>::VMScanning::scan_roots_in_mutator_thread(
             worker.tls,
             unsafe { &mut *(self.0 as *mut _) },
@@ -460,13 +463,13 @@ impl<C: GCWorkContext> ScanVMSpecificRoots<C> {
 }
 
 impl<C: GCWorkContext> GCWork<C::VM> for ScanVMSpecificRoots<C> {
-    fn do_work(&mut self, worker: &mut GCWorker<C::VM>, mmtk: &'static MMTK<C::VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<C::VM>, _mmtk: &MMTK<C::VM>) {
         trace!("ScanStaticRoots");
         let factory = ProcessEdgesWorkRootsWorkFactory::<
             C::VM,
             C::DefaultProcessEdges,
             C::PinningProcessEdges,
-        >::new(mmtk);
+        >::new(worker.mmtk);
         <C::VM as VMBinding>::VMScanning::scan_vm_specific_roots(worker.tls, factory);
     }
 }
@@ -676,7 +679,7 @@ pub trait ProcessEdgesWork:
 }
 
 impl<E: ProcessEdgesWork> GCWork<E::VM> for E {
-    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, _mmtk: &'static MMTK<E::VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, _mmtk: &MMTK<E::VM>) {
         self.set_worker(worker);
         self.process_slots();
         if !self.nodes.is_empty() {
@@ -848,7 +851,7 @@ pub trait ScanObjectsWork<VM: VMBinding>: GCWork<VM> + Sized {
         &self,
         buffer: &[ObjectReference],
         worker: &mut GCWorker<<Self::E as ProcessEdgesWork>::VM>,
-        mmtk: &'static MMTK<<Self::E as ProcessEdgesWork>::VM>,
+        mmtk: &MMTK<<Self::E as ProcessEdgesWork>::VM>,
     ) {
         let tls = worker.tls;
 
@@ -956,7 +959,7 @@ impl<VM: VMBinding, E: ProcessEdgesWork<VM = VM>> ScanObjectsWork<VM> for ScanOb
 }
 
 impl<E: ProcessEdgesWork> GCWork<E::VM> for ScanObjects<E> {
-    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, mmtk: &'static MMTK<E::VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, mmtk: &MMTK<E::VM>) {
         trace!("ScanObjects");
         self.do_work_common(&self.buffer, worker, mmtk);
         trace!("ScanObjects End");
@@ -1087,7 +1090,7 @@ impl<E: ProcessEdgesWork, P: Plan<VM = E::VM> + PlanTraceObject<E::VM>> ScanObje
 impl<E: ProcessEdgesWork, P: Plan<VM = E::VM> + PlanTraceObject<E::VM>> GCWork<E::VM>
     for PlanScanObjects<E, P>
 {
-    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, mmtk: &'static MMTK<E::VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, mmtk: &MMTK<E::VM>) {
         trace!("PlanScanObjects");
         self.do_work_common(&self.buffer, worker, mmtk);
         trace!("PlanScanObjects End");
@@ -1138,7 +1141,7 @@ impl<VM: VMBinding, R2OPE: ProcessEdgesWork<VM = VM>, O2OPE: ProcessEdgesWork<VM
 impl<VM: VMBinding, R2OPE: ProcessEdgesWork<VM = VM>, O2OPE: ProcessEdgesWork<VM = VM>> GCWork<VM>
     for ProcessRootNodes<VM, R2OPE, O2OPE>
 {
-    fn do_work(&mut self, worker: &mut GCWorker<VM>, mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<VM>, mmtk: &MMTK<VM>) {
         trace!("ProcessRootNodes");
 
         #[cfg(feature = "sanity")]
@@ -1163,8 +1166,12 @@ impl<VM: VMBinding, R2OPE: ProcessEdgesWork<VM = VM>, O2OPE: ProcessEdgesWork<VM
         // first time.  We will create a work packet for scanning those roots.
         let root_objects_to_scan = {
             // We create an instance of E to use its `trace_object` method and its object queue.
-            let mut process_edges_work =
-                R2OPE::new(vec![], true, mmtk, WorkBucketStage::PinningRootsTrace);
+            let mut process_edges_work = R2OPE::new(
+                vec![],
+                true,
+                worker.mmtk,
+                WorkBucketStage::PinningRootsTrace,
+            );
             process_edges_work.set_worker(worker);
 
             for object in self.roots.iter().copied() {
@@ -1185,7 +1192,7 @@ impl<VM: VMBinding, R2OPE: ProcessEdgesWork<VM = VM>, O2OPE: ProcessEdgesWork<VM
         probe!(mmtk, process_root_nodes, num_roots, num_enqueued_nodes);
 
         if !root_objects_to_scan.is_empty() {
-            let mut process_edges_work = O2OPE::new(vec![], true, mmtk, self.bucket);
+            let mut process_edges_work = O2OPE::new(vec![], true, worker.mmtk, self.bucket);
             process_edges_work.set_worker(worker);
             if let Some(work) = process_edges_work.create_scan_work(root_objects_to_scan) {
                 crate::memory_manager::add_work_packet(mmtk, self.bucket, work);
diff --git a/src/scheduler/scheduler.rs b/src/scheduler/scheduler.rs
index 1f2e4abd68..81925c4c7b 100644
--- a/src/scheduler/scheduler.rs
+++ b/src/scheduler/scheduler.rs
@@ -641,7 +641,7 @@ impl<VM: VMBinding> GCWorkScheduler<VM> {
         summary.harness_stat()
     }
 
-    pub fn notify_mutators_paused(&self, mmtk: &'static MMTK<VM>) {
+    pub fn notify_mutators_paused(&self, mmtk: &MMTK<VM>) {
         mmtk.gc_trigger.clear_request();
         let first_stw_bucket = &self.work_buckets[WorkBucketStage::FIRST_STW_STAGE];
         debug_assert!(!first_stw_bucket.is_open());
diff --git a/src/scheduler/stat.rs b/src/scheduler/stat.rs
index 027d3c490c..00a651fd1c 100644
--- a/src/scheduler/stat.rs
+++ b/src/scheduler/stat.rs
@@ -219,7 +219,7 @@ impl<VM: VMBinding> WorkerLocalStat<VM> {
         &mut self,
         work_id: TypeId,
         work_name: &'static str,
-        mmtk: &'static MMTK<VM>,
+        mmtk: &MMTK<VM>,
     ) -> WorkStat {
         let stat = WorkStat {
             type_id: work_id,
@@ -236,7 +236,7 @@ impl<VM: VMBinding> WorkerLocalStat<VM> {
     }
 
     #[allow(unused_variables, unused_mut)]
-    fn counter_set(mmtk: &'static MMTK<VM>) -> Vec<Box<dyn WorkCounter>> {
+    fn counter_set(mmtk: &MMTK<VM>) -> Vec<Box<dyn WorkCounter>> {
         let mut counters: Vec<Box<dyn WorkCounter>> = vec![Box::new(WorkDuration::new())];
         #[cfg(feature = "perf_counter")]
         for e in &mmtk.options.work_perf_events.events {
diff --git a/src/scheduler/work.rs b/src/scheduler/work.rs
index c74506cae6..6e85a1cead 100644
--- a/src/scheduler/work.rs
+++ b/src/scheduler/work.rs
@@ -23,14 +23,14 @@ pub trait GCWork<VM: VMBinding>: 'static + Send {
     /// this is what you intend.  But you should always consider adding the work packet
     /// into a bucket so that other GC workers can execute it in parallel, unless the context-
     /// switching overhead is a problem.
-    fn do_work(&mut self, worker: &mut GCWorker<VM>, mmtk: &'static MMTK<VM>);
+    fn do_work(&mut self, worker: &mut GCWorker<VM>, mmtk: &MMTK<VM>);
 
     /// Do work and collect statistics. This internally calls `do_work()`. In most cases,
     /// this should be called rather than `do_work()` so that MMTk can correctly collect
     /// statistics for the work packets.
     /// If the feature "work_packet_stats" is not enabled, this call simply forwards the call
     /// to `do_work()`.
-    fn do_work_with_stat(&mut self, worker: &mut GCWorker<VM>, mmtk: &'static MMTK<VM>) {
+    fn do_work_with_stat(&mut self, worker: &mut GCWorker<VM>, mmtk: &MMTK<VM>) {
         debug!("{}", std::any::type_name::<Self>());
         debug_assert!(!worker.tls.0.0.is_null(), "TLS must be set correctly for a GC worker before the worker does any work. GC Worker {} has no valid tls.", worker.ordinal);
 
diff --git a/src/util/analysis/gc_count.rs b/src/util/analysis/gc_count.rs
index fe5ca0a081..ff9b56f8a0 100644
--- a/src/util/analysis/gc_count.rs
+++ b/src/util/analysis/gc_count.rs
@@ -19,7 +19,7 @@ impl GcCounter {
 }
 
 impl<VM: VMBinding> RtAnalysis<VM> for GcCounter {
-    fn gc_hook(&mut self, _mmtk: &'static MMTK<VM>) {
+    fn gc_hook(&mut self, _mmtk: &MMTK<VM>) {
         if self.running {
             // The analysis routine simply updates the counter when the allocation hook is called
             self.counter.lock().unwrap().inc();
diff --git a/src/util/analysis/mod.rs b/src/util/analysis/mod.rs
index 4849ef846b..01e30b6538 100644
--- a/src/util/analysis/mod.rs
+++ b/src/util/analysis/mod.rs
@@ -24,7 +24,7 @@ use self::obj_size::PerSizeClassObjectCounter;
 ///
 pub trait RtAnalysis<VM: VMBinding> {
     fn alloc_hook(&mut self, _size: usize, _align: usize, _offset: usize) {}
-    fn gc_hook(&mut self, _mmtk: &'static MMTK<VM>) {}
+    fn gc_hook(&mut self, _mmtk: &MMTK<VM>) {}
     fn set_running(&mut self, running: bool);
 }
 
@@ -32,7 +32,7 @@ pub trait RtAnalysis<VM: VMBinding> {
 pub struct GcHookWork;
 
 impl<VM: VMBinding> GCWork<VM> for GcHookWork {
-    fn do_work(&mut self, _worker: &mut GCWorker<VM>, mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, _worker: &mut GCWorker<VM>, mmtk: &MMTK<VM>) {
         mmtk.analysis_manager.gc_hook(mmtk);
     }
 }
@@ -78,7 +78,7 @@ impl<VM: VMBinding> AnalysisManager<VM> {
         }
     }
 
-    pub fn gc_hook(&self, mmtk: &'static MMTK<VM>) {
+    pub fn gc_hook(&self, mmtk: &MMTK<VM>) {
         let routines = self.routines.lock().unwrap();
         for r in &*routines {
             r.lock().unwrap().gc_hook(mmtk);
diff --git a/src/util/finalizable_processor.rs b/src/util/finalizable_processor.rs
index 41666088a0..944a7e141e 100644
--- a/src/util/finalizable_processor.rs
+++ b/src/util/finalizable_processor.rs
@@ -140,7 +140,7 @@ impl<F: Finalizable> FinalizableProcessor<F> {
 pub struct Finalization<E: ProcessEdgesWork>(PhantomData<E>);
 
 impl<E: ProcessEdgesWork> GCWork<E::VM> for Finalization<E> {
-    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, mmtk: &'static MMTK<E::VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, mmtk: &MMTK<E::VM>) {
         if !*mmtk.options.no_reference_types {
             // Rescan soft and weak references at the end of the transitive closure from resurrected
             // objects.  New soft and weak references may be discovered during this.
@@ -160,7 +160,7 @@ impl<E: ProcessEdgesWork> GCWork<E::VM> for Finalization<E> {
             num_candidates_begin, num_ready_for_finalize_begin
         );
 
-        let mut w = E::new(vec![], false, mmtk, WorkBucketStage::FinalRefClosure);
+        let mut w = E::new(vec![], false, worker.mmtk, WorkBucketStage::FinalRefClosure);
         w.set_worker(worker);
         finalizable_processor.scan(worker.tls, &mut w, is_nursery_gc(mmtk.get_plan()));
 
@@ -191,10 +191,15 @@ impl<E: ProcessEdgesWork> Finalization<E> {
 pub struct ForwardFinalization<E: ProcessEdgesWork>(PhantomData<E>);
 
 impl<E: ProcessEdgesWork> GCWork<E::VM> for ForwardFinalization<E> {
-    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, mmtk: &'static MMTK<E::VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, mmtk: &MMTK<E::VM>) {
         trace!("Forward finalization");
         let mut finalizable_processor = mmtk.finalizable_processor.lock().unwrap();
-        let mut w = E::new(vec![], false, mmtk, WorkBucketStage::FinalizableForwarding);
+        let mut w = E::new(
+            vec![],
+            false,
+            worker.mmtk,
+            WorkBucketStage::FinalizableForwarding,
+        );
         w.set_worker(worker);
         finalizable_processor.forward_candidate(&mut w, is_nursery_gc(mmtk.get_plan()));
 
diff --git a/src/util/heap/gc_trigger.rs b/src/util/heap/gc_trigger.rs
index cb399fc100..d3975a1ca4 100644
--- a/src/util/heap/gc_trigger.rs
+++ b/src/util/heap/gc_trigger.rs
@@ -285,14 +285,14 @@ pub trait GCTriggerPolicy<VM: VMBinding>: Sync + Send {
     /// can never accomodate the pending allocation.
     fn on_pending_allocation(&self, _pages: usize) {}
     /// Inform the triggering policy that a GC starts.
-    fn on_gc_start(&self, _mmtk: &'static MMTK<VM>) {}
+    fn on_gc_start(&self, _mmtk: &MMTK<VM>) {}
     /// Inform the triggering policy that a GC is about to start the release work. This is called
     /// in the global Release work packet. This means we assume a plan
     /// do not schedule any work that reclaims memory before the global `Release` work. The current plans
     /// satisfy this assumption: they schedule other release work in `plan.release()`.
-    fn on_gc_release(&self, _mmtk: &'static MMTK<VM>) {}
+    fn on_gc_release(&self, _mmtk: &MMTK<VM>) {}
     /// Inform the triggering policy that a GC ends.
-    fn on_gc_end(&self, _mmtk: &'static MMTK<VM>) {}
+    fn on_gc_end(&self, _mmtk: &MMTK<VM>) {}
     /// Is a GC required now? The GC trigger may implement its own heuristics to decide when
     /// a GC should be performed. However, we recommend the implementation to do its own checks
     /// first, and always call `plan.collection_required(space_full, space)` at the end as a fallback to see if the plan needs
@@ -489,7 +489,7 @@ impl MemBalancerStats {
     // * allocation = live pages at the start of GC - live pages at the end of last GC
     // * collection = live pages at the end of GC - live pages before release
 
-    fn non_generational_mem_stats_on_gc_start<VM: VMBinding>(&mut self, mmtk: &'static MMTK<VM>) {
+    fn non_generational_mem_stats_on_gc_start<VM: VMBinding>(&mut self, mmtk: &MMTK<VM>) {
         self.allocation_pages = mmtk
             .get_plan()
             .get_reserved_pages()
@@ -501,11 +501,11 @@ impl MemBalancerStats {
             self.allocation_pages
         );
     }
-    fn non_generational_mem_stats_on_gc_release<VM: VMBinding>(&mut self, mmtk: &'static MMTK<VM>) {
+    fn non_generational_mem_stats_on_gc_release<VM: VMBinding>(&mut self, mmtk: &MMTK<VM>) {
         self.gc_release_live_pages = mmtk.get_plan().get_reserved_pages();
         trace!("live before release = {}", self.gc_release_live_pages);
     }
-    fn non_generational_mem_stats_on_gc_end<VM: VMBinding>(&mut self, mmtk: &'static MMTK<VM>) {
+    fn non_generational_mem_stats_on_gc_end<VM: VMBinding>(&mut self, mmtk: &MMTK<VM>) {
         self.gc_end_live_pages = mmtk.get_plan().get_reserved_pages();
         trace!("live pages = {}", self.gc_end_live_pages);
         // Use live pages as an estimate for pages traversed during GC
@@ -534,7 +534,7 @@ impl<VM: VMBinding> GCTriggerPolicy<VM> for MemBalancerTrigger {
         self.pending_pages.fetch_add(pages, Ordering::SeqCst);
     }
 
-    fn on_gc_start(&self, mmtk: &'static MMTK<VM>) {
+    fn on_gc_start(&self, mmtk: &MMTK<VM>) {
         trace!("=== on_gc_start ===");
         self.access_stats(|stats| {
             stats.gc_start_time = Instant::now();
@@ -553,7 +553,7 @@ impl<VM: VMBinding> GCTriggerPolicy<VM> for MemBalancerTrigger {
         });
     }
 
-    fn on_gc_release(&self, mmtk: &'static MMTK<VM>) {
+    fn on_gc_release(&self, mmtk: &MMTK<VM>) {
         trace!("=== on_gc_release ===");
         self.access_stats(|stats| {
             if let Some(plan) = mmtk.get_plan().generational() {
@@ -564,7 +564,7 @@ impl<VM: VMBinding> GCTriggerPolicy<VM> for MemBalancerTrigger {
         });
     }
 
-    fn on_gc_end(&self, mmtk: &'static MMTK<VM>) {
+    fn on_gc_end(&self, mmtk: &MMTK<VM>) {
         trace!("=== on_gc_end ===");
         self.access_stats(|stats| {
             stats.gc_end_time = Instant::now();
diff --git a/src/util/reference_processor.rs b/src/util/reference_processor.rs
index a5be7d3d4d..f18c811356 100644
--- a/src/util/reference_processor.rs
+++ b/src/util/reference_processor.rs
@@ -66,7 +66,7 @@ impl ReferenceProcessors {
     /// However, for some plans like mark compact, at the point we do ref scanning, we do not know
     /// the forwarding addresses yet, thus we cannot do forwarding during scan refs. And for those
     /// plans, this separate step is required.
-    pub fn forward_refs<E: ProcessEdgesWork>(&self, trace: &mut E, mmtk: &'static MMTK<E::VM>) {
+    pub fn forward_refs<E: ProcessEdgesWork>(&self, trace: &mut E, mmtk: &MMTK<E::VM>) {
         debug_assert!(
             mmtk.get_plan().constraints().needs_forward_after_liveness,
             "A plan with needs_forward_after_liveness=false does not need a separate forward step"
@@ -81,23 +81,23 @@ impl ReferenceProcessors {
 
     // Methods for scanning weak references. It needs to be called in a decreasing order of reference strengths, i.e. soft > weak > phantom
 
-    pub fn retain_soft_refs<E: ProcessEdgesWork>(&self, trace: &mut E, mmtk: &'static MMTK<E::VM>) {
+    pub fn retain_soft_refs<E: ProcessEdgesWork>(&self, trace: &mut E, mmtk: &MMTK<E::VM>) {
         self.soft.retain::<E>(trace, is_nursery_gc(mmtk.get_plan()));
     }
 
     /// Scan soft references.
-    pub fn scan_soft_refs<VM: VMBinding>(&self, mmtk: &'static MMTK<VM>) {
+    pub fn scan_soft_refs<VM: VMBinding>(&self, mmtk: &MMTK<VM>) {
         // This will update the references (and the referents).
         self.soft.scan::<VM>(is_nursery_gc(mmtk.get_plan()));
     }
 
     /// Scan weak references.
-    pub fn scan_weak_refs<VM: VMBinding>(&self, mmtk: &'static MMTK<VM>) {
+    pub fn scan_weak_refs<VM: VMBinding>(&self, mmtk: &MMTK<VM>) {
         self.weak.scan::<VM>(is_nursery_gc(mmtk.get_plan()));
     }
 
     /// Scan phantom references.
-    pub fn scan_phantom_refs<VM: VMBinding>(&self, mmtk: &'static MMTK<VM>) {
+    pub fn scan_phantom_refs<VM: VMBinding>(&self, mmtk: &MMTK<VM>) {
         self.phantom.scan::<VM>(is_nursery_gc(mmtk.get_plan()));
     }
 }
@@ -524,7 +524,7 @@ pub(crate) struct RescanReferences<VM: VMBinding> {
 }
 
 impl<VM: VMBinding> GCWork<VM> for RescanReferences<VM> {
-    fn do_work(&mut self, _worker: &mut GCWorker<VM>, mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, _worker: &mut GCWorker<VM>, mmtk: &MMTK<VM>) {
         if self.soft {
             mmtk.reference_processors.scan_soft_refs(mmtk);
         }
@@ -537,7 +537,7 @@ impl<VM: VMBinding> GCWork<VM> for RescanReferences<VM> {
 #[derive(Default)]
 pub(crate) struct SoftRefProcessing<E: ProcessEdgesWork>(PhantomData<E>);
 impl<E: ProcessEdgesWork> GCWork<E::VM> for SoftRefProcessing<E> {
-    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, mmtk: &'static MMTK<E::VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, mmtk: &MMTK<E::VM>) {
         if !mmtk.state.is_emergency_collection() {
             // Postpone the scanning to the end of the transitive closure from strongly reachable
             // soft references.
@@ -550,7 +550,7 @@ impl<E: ProcessEdgesWork> GCWork<E::VM> for SoftRefProcessing<E> {
 
             // Retain soft references.  This will expand the transitive closure.  We create an
             // instance of `E` for this.
-            let mut w = E::new(vec![], false, mmtk, WorkBucketStage::SoftRefClosure);
+            let mut w = E::new(vec![], false, worker.mmtk, WorkBucketStage::SoftRefClosure);
             w.set_worker(worker);
             mmtk.reference_processors.retain_soft_refs(&mut w, mmtk);
             w.flush();
@@ -569,7 +569,7 @@ impl<E: ProcessEdgesWork> SoftRefProcessing<E> {
 #[derive(Default)]
 pub(crate) struct WeakRefProcessing<VM: VMBinding>(PhantomData<VM>);
 impl<VM: VMBinding> GCWork<VM> for WeakRefProcessing<VM> {
-    fn do_work(&mut self, _worker: &mut GCWorker<VM>, mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, _worker: &mut GCWorker<VM>, mmtk: &MMTK<VM>) {
         mmtk.reference_processors.scan_weak_refs(mmtk);
     }
 }
@@ -582,7 +582,7 @@ impl<VM: VMBinding> WeakRefProcessing<VM> {
 #[derive(Default)]
 pub(crate) struct PhantomRefProcessing<VM: VMBinding>(PhantomData<VM>);
 impl<VM: VMBinding> GCWork<VM> for PhantomRefProcessing<VM> {
-    fn do_work(&mut self, _worker: &mut GCWorker<VM>, mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, _worker: &mut GCWorker<VM>, mmtk: &MMTK<VM>) {
         mmtk.reference_processors.scan_phantom_refs(mmtk);
     }
 }
@@ -595,8 +595,8 @@ impl<VM: VMBinding> PhantomRefProcessing<VM> {
 #[derive(Default)]
 pub(crate) struct RefForwarding<E: ProcessEdgesWork>(PhantomData<E>);
 impl<E: ProcessEdgesWork> GCWork<E::VM> for RefForwarding<E> {
-    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, mmtk: &'static MMTK<E::VM>) {
-        let mut w = E::new(vec![], false, mmtk, WorkBucketStage::RefForwarding);
+    fn do_work(&mut self, worker: &mut GCWorker<E::VM>, mmtk: &MMTK<E::VM>) {
+        let mut w = E::new(vec![], false, worker.mmtk, WorkBucketStage::RefForwarding);
         w.set_worker(worker);
         mmtk.reference_processors.forward_refs(&mut w, mmtk);
         w.flush();
@@ -611,7 +611,7 @@ impl<E: ProcessEdgesWork> RefForwarding<E> {
 #[derive(Default)]
 pub(crate) struct RefEnqueue<VM: VMBinding>(PhantomData<VM>);
 impl<VM: VMBinding> GCWork<VM> for RefEnqueue<VM> {
-    fn do_work(&mut self, worker: &mut GCWorker<VM>, mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<VM>, mmtk: &MMTK<VM>) {
         mmtk.reference_processors.enqueue_refs::<VM>(worker.tls);
     }
 }
diff --git a/src/util/sanity/sanity_checker.rs b/src/util/sanity/sanity_checker.rs
index a1283eb84b..090891434c 100644
--- a/src/util/sanity/sanity_checker.rs
+++ b/src/util/sanity/sanity_checker.rs
@@ -60,7 +60,7 @@ impl<P: Plan> ScheduleSanityGC<P> {
 }
 
 impl<P: Plan> GCWork<P::VM> for ScheduleSanityGC<P> {
-    fn do_work(&mut self, worker: &mut GCWorker<P::VM>, mmtk: &'static MMTK<P::VM>) {
+    fn do_work(&mut self, worker: &mut GCWorker<P::VM>, mmtk: &MMTK<P::VM>) {
         let scheduler = worker.scheduler();
         let plan = mmtk.get_plan();
 
@@ -126,7 +126,7 @@ impl<P: Plan> SanityPrepare<P> {
 }
 
 impl<P: Plan> GCWork<P::VM> for SanityPrepare<P> {
-    fn do_work(&mut self, _worker: &mut GCWorker<P::VM>, mmtk: &'static MMTK<P::VM>) {
+    fn do_work(&mut self, _worker: &mut GCWorker<P::VM>, mmtk: &MMTK<P::VM>) {
         info!("Sanity GC prepare");
         {
             let mut sanity_checker = mmtk.sanity_checker.lock().unwrap();
@@ -146,7 +146,7 @@ impl<P: Plan> SanityRelease<P> {
 }
 
 impl<P: Plan> GCWork<P::VM> for SanityRelease<P> {
-    fn do_work(&mut self, _worker: &mut GCWorker<P::VM>, mmtk: &'static MMTK<P::VM>) {
+    fn do_work(&mut self, _worker: &mut GCWorker<P::VM>, mmtk: &MMTK<P::VM>) {
         info!("Sanity GC release");
         mmtk.sanity_checker.lock().unwrap().clear_roots_cache();
         mmtk.sanity_end();
diff --git a/src/util/statistics/stats.rs b/src/util/statistics/stats.rs
index e3a12a730a..b37c50cf77 100644
--- a/src/util/statistics/stats.rs
+++ b/src/util/statistics/stats.rs
@@ -170,7 +170,7 @@ impl Stats {
         self.shared.increment_phase();
     }
 
-    pub fn print_stats<VM: VMBinding>(&self, mmtk: &'static MMTK<VM>) {
+    pub fn print_stats<VM: VMBinding>(&self, mmtk: &MMTK<VM>) {
         println!(
             "============================ MMTk Statistics Totals ============================"
         );
@@ -231,7 +231,7 @@ impl Stats {
         }
     }
 
-    pub fn stop_all<VM: VMBinding>(&self, mmtk: &'static MMTK<VM>) {
+    pub fn stop_all<VM: VMBinding>(&self, mmtk: &MMTK<VM>) {
         self.stop_all_counters();
         self.print_stats(mmtk);
     }