SGX: Fix fuzzy provenance casts with AtomicUsize

Author: thaliaarchi

library/std/src/sys/args/sgx.rs

@@ -1,16 +1,14 @@
-#![allow(fuzzy_provenance_casts)] // FIXME: this module systematically confuses pointers and integers
-
 use crate::ffi::OsString;
-use crate::sync::atomic::{AtomicUsize, Ordering};
+use crate::sync::atomic::{AtomicPtr, Ordering};
 use crate::sys::os_str::Buf;
 use crate::sys::pal::abi::usercalls::alloc;
 use crate::sys::pal::abi::usercalls::raw::ByteBuffer;
 use crate::sys_common::FromInner;
-use crate::{fmt, slice};
+use crate::{fmt, ptr, slice};
 
 #[cfg_attr(test, linkage = "available_externally")]
 #[unsafe(export_name = "_ZN16__rust_internals3std3sys3sgx4args4ARGSE")]
-static ARGS: AtomicUsize = AtomicUsize::new(0);
+static ARGS: AtomicPtr<ArgsStore> = AtomicPtr::new(ptr::null_mut());
 type ArgsStore = Vec<OsString>;
 
 #[cfg_attr(test, allow(dead_code))]
@@ -21,12 +19,12 @@ pub unsafe fn init(argc: isize, argv: *const *const u8) {
             .iter()
             .map(|a| OsString::from_inner(Buf { inner: a.copy_user_buffer() }))
             .collect::<ArgsStore>();
-        ARGS.store(Box::into_raw(Box::new(args)) as _, Ordering::Relaxed);
+        ARGS.store(Box::into_raw(Box::new(args)), Ordering::Relaxed);
     }
 }
 
 pub fn args() -> Args {
-    let args = unsafe { (ARGS.load(Ordering::Relaxed) as *const ArgsStore).as_ref() };
+    let args = unsafe { ARGS.load(Ordering::Relaxed).as_ref() };
     if let Some(args) = args { Args(args.iter()) } else { Args([].iter()) }
 }
 

library/std/src/sys/pal/sgx/os.rs

@@ -1,14 +1,16 @@
+#![forbid(fuzzy_provenance_casts)]
+
 use fortanix_sgx_abi::{Error, RESULT_SUCCESS};
 
 use crate::collections::HashMap;
 use crate::error::Error as StdError;
 use crate::ffi::{OsStr, OsString};
 use crate::marker::PhantomData;
 use crate::path::{self, PathBuf};
-use crate::sync::atomic::{AtomicUsize, Ordering};
+use crate::sync::atomic::{AtomicPtr, Ordering};
 use crate::sync::{Mutex, Once};
 use crate::sys::{decode_error_kind, sgx_ineffective, unsupported};
-use crate::{fmt, io, str, vec};
+use crate::{fmt, io, ptr, str, vec};
 
 pub fn errno() -> i32 {
     RESULT_SUCCESS
@@ -75,21 +77,20 @@ pub fn current_exe() -> io::Result<PathBuf> {
 
 #[cfg_attr(test, linkage = "available_externally")]
 #[unsafe(export_name = "_ZN16__rust_internals3std3sys3sgx2os3ENVE")]
-static ENV: AtomicUsize = AtomicUsize::new(0);
+static ENV: AtomicPtr<EnvStore> = AtomicPtr::new(ptr::null_mut());
 #[cfg_attr(test, linkage = "available_externally")]
 #[unsafe(export_name = "_ZN16__rust_internals3std3sys3sgx2os8ENV_INITE")]
 static ENV_INIT: Once = Once::new();
 type EnvStore = Mutex<HashMap<OsString, OsString>>;
 
 fn get_env_store() -> Option<&'static EnvStore> {
-    unsafe { (ENV.load(Ordering::Relaxed) as *const EnvStore).as_ref() }
+    unsafe { ENV.load(Ordering::Relaxed).as_ref() }
 }
 
 fn create_env_store() -> &'static EnvStore {
-    ENV_INIT.call_once(|| {
-        ENV.store(Box::into_raw(Box::new(EnvStore::default())) as _, Ordering::Relaxed)
-    });
-    unsafe { &*(ENV.load(Ordering::Relaxed) as *const EnvStore) }
+    ENV_INIT
+        .call_once(|| ENV.store(Box::into_raw(Box::new(EnvStore::default())), Ordering::Relaxed));
+    unsafe { &*ENV.load(Ordering::Relaxed) }
 }
 
 pub struct Env {