1 files changed, 17 insertions, 17 deletions

diff --git a/compiler/rustc_thread_pool/src/registry.rs b/compiler/rustc_thread_pool/src/registry.rs
index 2848556aab6..03a01aa29d2 100644
--- a/compiler/rustc_thread_pool/src/registry.rs
+++ b/compiler/rustc_thread_pool/src/registry.rs
@@ -533,16 +533,16 @@ impl Registry {
                 |injected| {
                     let worker_thread = WorkerThread::current();
                     assert!(injected && !worker_thread.is_null());
-                    op(&*worker_thread, true)
+                    op(unsafe { &*worker_thread }, true)
                 },
                 LatchRef::new(l),
             );
-            self.inject(job.as_job_ref());
+            self.inject(unsafe { job.as_job_ref() });
             self.release_thread();
             job.latch.wait_and_reset(); // Make sure we can use the same latch again next time.
             self.acquire_thread();
 
-            job.into_result()
+            unsafe { job.into_result() }
         })
     }
 
@@ -561,13 +561,13 @@ impl Registry {
             |injected| {
                 let worker_thread = WorkerThread::current();
                 assert!(injected && !worker_thread.is_null());
-                op(&*worker_thread, true)
+                op(unsafe { &*worker_thread }, true)
             },
             latch,
         );
-        self.inject(job.as_job_ref());
-        current_thread.wait_until(&job.latch);
-        job.into_result()
+        self.inject(unsafe { job.as_job_ref() });
+        unsafe { current_thread.wait_until(&job.latch) };
+        unsafe { job.into_result() }
     }
 
     /// Increments the terminate counter. This increment should be
@@ -759,7 +759,7 @@ impl WorkerThread {
 
     #[inline]
     pub(super) unsafe fn push_fifo(&self, job: JobRef) {
-        self.push(self.fifo.push(job));
+        unsafe { self.push(self.fifo.push(job)) };
     }
 
     #[inline]
@@ -798,7 +798,7 @@ impl WorkerThread {
     pub(super) unsafe fn wait_until<L: AsCoreLatch + ?Sized>(&self, latch: &L) {
         let latch = latch.as_core_latch();
         if !latch.probe() {
-            self.wait_until_cold(latch);
+            unsafe { self.wait_until_cold(latch) };
         }
     }
 
@@ -815,7 +815,7 @@ impl WorkerThread {
             // Check for local work *before* we start marking ourself idle,
             // especially to avoid modifying shared sleep state.
             if let Some(job) = self.take_local_job() {
-                self.execute(job);
+                unsafe { self.execute(job) };
                 continue;
             }
 
@@ -823,7 +823,7 @@ impl WorkerThread {
             while !latch.probe() {
                 if let Some(job) = self.find_work() {
                     self.registry.sleep.work_found();
-                    self.execute(job);
+                    unsafe { self.execute(job) };
                     // The job might have injected local work, so go back to the outer loop.
                     continue 'outer;
                 } else {
@@ -846,13 +846,13 @@ impl WorkerThread {
         let index = self.index;
 
         registry.acquire_thread();
-        self.wait_until(&registry.thread_infos[index].terminate);
+        unsafe { self.wait_until(&registry.thread_infos[index].terminate) };
 
         // Should not be any work left in our queue.
         debug_assert!(self.take_local_job().is_none());
 
         // Let registry know we are done
-        Latch::set(&registry.thread_infos[index].stopped);
+        unsafe { Latch::set(&registry.thread_infos[index].stopped) };
     }
 
     fn find_work(&self) -> Option<JobRef> {
@@ -886,7 +886,7 @@ impl WorkerThread {
 
     #[inline]
     pub(super) unsafe fn execute(&self, job: JobRef) {
-        job.execute();
+        unsafe { job.execute() };
     }
 
     /// Try to steal a single job and return it.
@@ -932,12 +932,12 @@ impl WorkerThread {
 
 unsafe fn main_loop(thread: ThreadBuilder) {
     let worker_thread = &WorkerThread::from(thread);
-    WorkerThread::set_current(worker_thread);
+    unsafe { WorkerThread::set_current(worker_thread) };
     let registry = &*worker_thread.registry;
     let index = worker_thread.index;
 
     // let registry know we are ready to do work
-    Latch::set(&registry.thread_infos[index].primed);
+    unsafe { Latch::set(&registry.thread_infos[index].primed) };
 
     // Worker threads should not panic. If they do, just abort, as the
     // internal state of the threadpool is corrupted. Note that if
@@ -949,7 +949,7 @@ unsafe fn main_loop(thread: ThreadBuilder) {
         registry.catch_unwind(|| handler(index));
     }
 
-    worker_thread.wait_until_out_of_work();
+    unsafe { worker_thread.wait_until_out_of_work() };
 
     // Normal termination, do not abort.
     mem::forget(abort_guard);