diff --git a/src/header/netdb/host.rs b/src/header/netdb/host.rs
index 1a519507b4..949001f0fa 100644
--- a/src/header/netdb/host.rs
+++ b/src/header/netdb/host.rs
@@ -95,7 +95,7 @@ pub unsafe extern "C" fn gethostent() -> *mut hostent {
     let mut _host_aliases: Vec<Vec<u8>> = iter
         .map(|alias| alias.bytes().chain(Some(b'\0')).collect())
         .collect();
-    *HOST_ALIASES.as_mut_ptr() = Some(_host_aliases);
+    HOST_ALIASES.unsafe_set(Some(_host_aliases));
 
     let mut host_aliases: Vec<*mut c_char> = HOST_ALIASES
         .unsafe_mut()
@@ -106,7 +106,7 @@ pub unsafe extern "C" fn gethostent() -> *mut hostent {
         .chain([ptr::null_mut(), ptr::null_mut()])
         .collect();
 
-    *HOST_NAME.as_mut_ptr() = Some(host_name);
+    HOST_NAME.unsafe_set(Some(host_name));
 
     HOST_ENTRY = hostent {
         h_name: HOST_NAME.unsafe_mut().as_mut().unwrap().as_mut_ptr() as *mut c_char,
@@ -115,7 +115,7 @@ pub unsafe extern "C" fn gethostent() -> *mut hostent {
         h_length: 4,
         h_addr_list: &raw mut HOST_ADDR_LIST as *mut _,
     };
-    *_HOST_ALIASES.as_mut_ptr() = Some(host_aliases);
+    _HOST_ALIASES.unsafe_set(Some(host_aliases));
     if HOST_STAYOPEN == 0 {
         endhostent();
     }
diff --git a/src/header/netdb/mod.rs b/src/header/netdb/mod.rs
index 3ef8b47717..95fea0eb5f 100644
--- a/src/header/netdb/mod.rs
+++ b/src/header/netdb/mod.rs
@@ -267,13 +267,13 @@ pub unsafe extern "C" fn gethostbyaddr(
     _host_aliases.push(vec![b'\0']);
     let mut host_aliases: Vec<*mut c_char> = Vec::new();
     host_aliases.push(ptr::null_mut());
-    *HOST_ALIASES.as_mut_ptr() = Some(_host_aliases);
+    HOST_ALIASES.unsafe_set(Some(_host_aliases));
 
     match lookup_addr(addr).map(|host_names| host_names.into_iter().next()) {
         Ok(Some(host_name)) => {
             _HOST_ADDR_LIST = addr.s_addr.to_ne_bytes();
             HOST_ADDR_LIST = [&raw mut _HOST_ADDR_LIST as *mut c_char, ptr::null_mut()];
-            *HOST_NAME.as_mut_ptr() = Some(host_name);
+            HOST_NAME.unsafe_set(Some(host_name));
             HOST_ENTRY = hostent {
                 h_name: HOST_NAME.unsafe_mut().as_mut().unwrap().as_mut_ptr() as *mut c_char,
                 h_aliases: host_aliases.as_mut_slice().as_mut_ptr(),
@@ -373,7 +373,7 @@ pub unsafe extern "C" fn gethostbyname(name: *const c_char) -> *mut hostent {
     };
 
     let host_name: Vec<u8> = name_cstr.to_bytes().to_vec();
-    *HOST_NAME.as_mut_ptr() = Some(host_name);
+    HOST_NAME.unsafe_set(Some(host_name));
     _HOST_ADDR_LIST = host_addr.s_addr.to_ne_bytes();
     HOST_ADDR_LIST = [&raw mut _HOST_ADDR_LIST as *mut c_char, ptr::null_mut()];
     HOST_ADDR = Some(host_addr);
@@ -384,7 +384,7 @@ pub unsafe extern "C" fn gethostbyname(name: *const c_char) -> *mut hostent {
     let mut host_aliases: Vec<*mut c_char> = Vec::new();
     host_aliases.push(ptr::null_mut());
     host_aliases.push(ptr::null_mut());
-    *HOST_ALIASES.as_mut_ptr() = Some(_host_aliases);
+    HOST_ALIASES.unsafe_set(Some(_host_aliases));
 
     HOST_ENTRY = hostent {
         h_name: HOST_NAME.unsafe_mut().as_mut().unwrap().as_mut_ptr() as *mut c_char,
@@ -449,7 +449,7 @@ pub unsafe extern "C" fn getnetent() -> *mut netent {
     let mut iter: SplitWhitespace = r.split_whitespace();
 
     let net_name = iter.next().unwrap().bytes().chain(Some(b'\0')).collect();
-    *NET_NAME.as_mut_ptr() = Some(net_name);
+    NET_NAME.unsafe_set(Some(net_name));
 
     let addr_vec: Vec<u8> = iter.next().unwrap().bytes().chain(Some(b'\0')).collect();
     let addr_cstr = addr_vec.as_slice().as_ptr() as *const c_char;
@@ -466,7 +466,7 @@ pub unsafe extern "C" fn getnetent() -> *mut netent {
         .map(|x| x.as_mut_ptr() as *mut c_char)
         .chain(Some(ptr::null_mut()))
         .collect();
-    *NET_ALIASES.as_mut_ptr() = Some(_net_aliases);
+    NET_ALIASES.unsafe_set(Some(_net_aliases));
 
     NET_ENTRY = netent {
         n_name: NET_NAME.unsafe_mut().as_mut().unwrap().as_mut_ptr() as *mut c_char,
@@ -573,8 +573,8 @@ pub unsafe extern "C" fn getprotoent() -> *mut protoent {
         .chain(Some(ptr::null_mut()))
         .collect();
 
-    *PROTO_ALIASES.as_mut_ptr() = Some(_proto_aliases);
-    *PROTO_NAME.as_mut_ptr() = Some(proto_name);
+    PROTO_ALIASES.unsafe_set(Some(_proto_aliases));
+    PROTO_NAME.unsafe_set(Some(proto_name));
 
     PROTO_ENTRY = protoent {
         p_name: PROTO_NAME
@@ -718,9 +718,9 @@ pub unsafe extern "C" fn getservent() -> *mut servent {
         serv_aliases.push(ptr::null_mut());
         serv_aliases.push(ptr::null_mut());
 
-        *SERV_ALIASES.as_mut_ptr() = Some(_serv_aliases);
-        *SERV_NAME.as_mut_ptr() = Some(serv_name);
-        *SERV_PROTO.as_mut_ptr() = Some(proto);
+        SERV_ALIASES.unsafe_set(Some(_serv_aliases));
+        SERV_NAME.unsafe_set(Some(serv_name));
+        SERV_PROTO.unsafe_set(Some(proto));
 
         SERV_ENTRY = servent {
             s_name: SERV_NAME
diff --git a/src/header/pwd/mod.rs b/src/header/pwd/mod.rs
index e51ace5bae..d9e625ec53 100644
--- a/src/header/pwd/mod.rs
+++ b/src/header/pwd/mod.rs
@@ -104,7 +104,7 @@ impl OwnedPwd {
     fn into_global(self) -> *mut passwd {
         unsafe {
             PASSWD_BUF = Some(self.buffer);
-            *PASSWD.as_mut_ptr() = self.reference;
+            PASSWD.unsafe_set(self.reference);
             PASSWD.as_mut_ptr()
         }
     }
@@ -224,7 +224,7 @@ unsafe fn mux(
 #[unsafe(no_mangle)]
 pub extern "C" fn endpwent() {
     unsafe {
-        *READER.as_mut_ptr() = None;
+        READER.unsafe_set(None);
     }
 }
 
@@ -240,7 +240,7 @@ pub extern "C" fn getpwent() -> *mut passwd {
             };
             let reader = BufReader::new(file);
             unsafe {
-                *READER.as_mut_ptr() = Some(reader);
+                READER.unsafe_set(Some(reader));
                 READER.unsafe_mut().as_mut().unwrap()
             }
         }
diff --git a/src/header/stdlib/mod.rs b/src/header/stdlib/mod.rs
index 8c77b55f9b..7ea5a9fd59 100644
--- a/src/header/stdlib/mod.rs
+++ b/src/header/stdlib/mod.rs
@@ -548,7 +548,7 @@ pub unsafe extern "C" fn l64a(value: c_long) -> *mut c_char {
     let num_output_digits = usize::try_from(6 - (value_as_i32.leading_zeros() + 4) / 6).unwrap();
 
     // Reset buffer (and have null terminator in place for any result)
-    *L64A_BUFFER.as_mut_ptr() = [0; 7];
+    L64A_BUFFER.unsafe_set([0; 7]);
 
     for i in 0..num_output_digits {
         // Conversion to c_char always succeeds for the range 0..=63
diff --git a/src/ld_so/start.rs b/src/ld_so/start.rs
index ce37e674f7..b76fa2f7db 100644
--- a/src/ld_so/start.rs
+++ b/src/ld_so/start.rs
@@ -182,21 +182,22 @@ pub unsafe extern "C" fn relibc_ld_so_start(sp: &'static mut Stack, ld_entry: us
     };
 
     unsafe {
-        *crate::platform::OUR_ENVIRON.as_mut_ptr() = envs
-            .iter()
-            .map(|(k, v)| {
-                let mut var = Vec::with_capacity(k.len() + v.len() + 2);
-                var.extend(k.as_bytes());
-                var.push(b'=');
-                var.extend(v.as_bytes());
-                var.push(b'\0');
-                let mut var = var.into_boxed_slice();
-                let ptr = var.as_mut_ptr();
-                core::mem::forget(var);
-                ptr.cast()
-            })
-            .chain(core::iter::once(core::ptr::null_mut()))
-            .collect::<Vec<_>>();
+        crate::platform::OUR_ENVIRON.unsafe_set(
+            envs.iter()
+                .map(|(k, v)| {
+                    let mut var = Vec::with_capacity(k.len() + v.len() + 2);
+                    var.extend(k.as_bytes());
+                    var.push(b'=');
+                    var.extend(v.as_bytes());
+                    var.push(b'\0');
+                    let mut var = var.into_boxed_slice();
+                    let ptr = var.as_mut_ptr();
+                    core::mem::forget(var);
+                    ptr.cast()
+                })
+                .chain(core::iter::once(core::ptr::null_mut()))
+                .collect::<Vec<_>>(),
+        );
 
         crate::platform::environ = crate::platform::OUR_ENVIRON.unsafe_mut().as_mut_ptr();
     }
diff --git a/src/platform/redox/ptrace.rs b/src/platform/redox/ptrace.rs
index f5b60802b8..34a35346ec 100644
--- a/src/platform/redox/ptrace.rs
+++ b/src/platform/redox/ptrace.rs
@@ -51,7 +51,7 @@ pub fn init_state() -> &'static State {
     // Safe due to STATE being thread_local (TODO: is it though?)
     unsafe {
         if STATE.unsafe_ref().is_none() {
-            *STATE.as_mut_ptr() = Some(State::new())
+            STATE.unsafe_set(Some(State::new()));
         }
         let state_ptr = STATE.unsafe_ref().as_ref().unwrap() as *const State;
         &*state_ptr
diff --git a/src/raw_cell.rs b/src/raw_cell.rs
index e0858a8298..091bfe6662 100644
--- a/src/raw_cell.rs
+++ b/src/raw_cell.rs
@@ -30,6 +30,10 @@ impl<T> RawCell<T> {
         &*self.inner.get()
     }
     #[inline]
+    pub unsafe fn unsafe_set(&self, t: T) {
+        *self.inner.get() = t;
+    }
+    #[inline]
     pub unsafe fn unsafe_mut(&self) -> &mut T {
         &mut *self.inner.get()
     }
diff --git a/src/start.rs b/src/start.rs
index c406bf69fd..b42f7f74e4 100644
--- a/src/start.rs
+++ b/src/start.rs
@@ -184,7 +184,7 @@ pub unsafe extern "C" fn relibc_start_v1(
     // Set up argc and argv
     let argc = sp.argc;
     let argv = sp.argv();
-    *platform::inner_argv.as_mut_ptr() = copy_string_array(argv, argc as usize);
+    platform::inner_argv.unsafe_set(copy_string_array(argv, argc as usize));
     platform::argv = platform::inner_argv.unsafe_mut().as_mut_ptr();
     // Special code for program_invocation_name and program_invocation_short_name
     if let Some(arg) = platform::inner_argv.unsafe_ref().get(0) {
@@ -201,7 +201,7 @@ pub unsafe extern "C" fn relibc_start_v1(
         while !(*envp.add(len)).is_null() {
             len += 1;
         }
-        *platform::OUR_ENVIRON.as_mut_ptr() = copy_string_array(envp, len);
+        platform::OUR_ENVIRON.unsafe_set(copy_string_array(envp, len));
         platform::environ = platform::OUR_ENVIRON.unsafe_mut().as_mut_ptr();
     }