Restructure and rename thread local things in std.
This commit is contained in:
Mara Bos
parent
8763965a2c
commit
fba5cfe482
@ -1,13 +1,14 @@
|
||||
use super::lazy::LazyKeyInner;
|
||||
use crate::cell::Cell;
|
||||
use crate::sys::thread_local_dtor::register_dtor;
|
||||
use crate::{fmt, mem, panic};
|
||||
|
||||
#[doc(hidden)]
|
||||
#[macro_export]
|
||||
#[allow_internal_unstable(
|
||||
thread_local_internals,
|
||||
cfg_target_thread_local,
|
||||
thread_local,
|
||||
libstd_thread_internals
|
||||
)]
|
||||
#[allow_internal_unstable(thread_local_internals, cfg_target_thread_local, thread_local)]
|
||||
#[allow_internal_unsafe]
|
||||
macro_rules! __thread_local_inner {
|
||||
#[unstable(feature = "thread_local_internals", issue = "none")]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro thread_local_inner {
|
||||
// used to generate the `LocalKey` value for const-initialized thread locals
|
||||
(@key $t:ty, const $init:expr) => {{
|
||||
#[cfg_attr(not(bootstrap), inline)]
|
||||
@ -49,7 +50,7 @@ macro_rules! __thread_local_inner {
|
||||
// 0 == we haven't registered a destructor, so do
|
||||
// so now.
|
||||
0 => {
|
||||
$crate::thread::__LocalKeyInner::<$t>::register_dtor(
|
||||
$crate::thread::local_impl::Key::<$t>::register_dtor(
|
||||
$crate::ptr::addr_of_mut!(VAL) as *mut $crate::primitive::u8,
|
||||
destroy,
|
||||
);
|
||||
@ -69,7 +70,7 @@ macro_rules! __thread_local_inner {
|
||||
unsafe {
|
||||
$crate::thread::LocalKey::new(__getit)
|
||||
}
|
||||
}};
|
||||
}},
|
||||
|
||||
// used to generate the `LocalKey` value for `thread_local!`
|
||||
(@key $t:ty, $init:expr) => {
|
||||
@ -82,8 +83,8 @@ macro_rules! __thread_local_inner {
|
||||
init: $crate::option::Option<&mut $crate::option::Option<$t>>,
|
||||
) -> $crate::option::Option<&'static $t> {
|
||||
#[thread_local]
|
||||
static __KEY: $crate::thread::__LocalKeyInner<$t> =
|
||||
$crate::thread::__LocalKeyInner::<$t>::new();
|
||||
static __KEY: $crate::thread::local_impl::Key<$t> =
|
||||
$crate::thread::local_impl::Key::<$t>::new();
|
||||
|
||||
// FIXME: remove the #[allow(...)] marker when macros don't
|
||||
// raise warning for missing/extraneous unsafe blocks anymore.
|
||||
@ -107,148 +108,140 @@ macro_rules! __thread_local_inner {
|
||||
$crate::thread::LocalKey::new(__getit)
|
||||
}
|
||||
}
|
||||
};
|
||||
},
|
||||
($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $($init:tt)*) => {
|
||||
$(#[$attr])* $vis const $name: $crate::thread::LocalKey<$t> =
|
||||
$crate::__thread_local_inner!(@key $t, $($init)*);
|
||||
}
|
||||
$crate::thread::local_impl::thread_local_inner!(@key $t, $($init)*);
|
||||
},
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
pub mod fast {
|
||||
use super::super::lazy::LazyKeyInner;
|
||||
use crate::cell::Cell;
|
||||
use crate::sys::thread_local_dtor::register_dtor;
|
||||
use crate::{fmt, mem, panic};
|
||||
#[derive(Copy, Clone)]
|
||||
enum DtorState {
|
||||
Unregistered,
|
||||
Registered,
|
||||
RunningOrHasRun,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
enum DtorState {
|
||||
Unregistered,
|
||||
Registered,
|
||||
RunningOrHasRun,
|
||||
}
|
||||
|
||||
// This data structure has been carefully constructed so that the fast path
|
||||
// only contains one branch on x86. That optimization is necessary to avoid
|
||||
// duplicated tls lookups on OSX.
|
||||
// This data structure has been carefully constructed so that the fast path
|
||||
// only contains one branch on x86. That optimization is necessary to avoid
|
||||
// duplicated tls lookups on OSX.
|
||||
//
|
||||
// LLVM issue: https://bugs.llvm.org/show_bug.cgi?id=41722
|
||||
pub struct Key<T> {
|
||||
// If `LazyKeyInner::get` returns `None`, that indicates either:
|
||||
// * The value has never been initialized
|
||||
// * The value is being recursively initialized
|
||||
// * The value has already been destroyed or is being destroyed
|
||||
// To determine which kind of `None`, check `dtor_state`.
|
||||
//
|
||||
// This is very optimizer friendly for the fast path - initialized but
|
||||
// not yet dropped.
|
||||
inner: LazyKeyInner<T>,
|
||||
|
||||
// Metadata to keep track of the state of the destructor. Remember that
|
||||
// this variable is thread-local, not global.
|
||||
dtor_state: Cell<DtorState>,
|
||||
}
|
||||
|
||||
impl<T> fmt::Debug for Key<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
f.debug_struct("Key").finish_non_exhaustive()
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Key<T> {
|
||||
pub const fn new() -> Key<T> {
|
||||
Key { inner: LazyKeyInner::new(), dtor_state: Cell::new(DtorState::Unregistered) }
|
||||
}
|
||||
|
||||
// note that this is just a publicly-callable function only for the
|
||||
// const-initialized form of thread locals, basically a way to call the
|
||||
// free `register_dtor` function defined elsewhere in std.
|
||||
pub unsafe fn register_dtor(a: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
|
||||
unsafe {
|
||||
register_dtor(a, dtor);
|
||||
}
|
||||
}
|
||||
|
||||
pub unsafe fn get<F: FnOnce() -> T>(&self, init: F) -> Option<&'static T> {
|
||||
// SAFETY: See the definitions of `LazyKeyInner::get` and
|
||||
// `try_initialize` for more information.
|
||||
//
|
||||
// The caller must ensure no mutable references are ever active to
|
||||
// the inner cell or the inner T when this is called.
|
||||
// The `try_initialize` is dependant on the passed `init` function
|
||||
// for this.
|
||||
unsafe {
|
||||
match self.inner.get() {
|
||||
Some(val) => Some(val),
|
||||
None => self.try_initialize(init),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// `try_initialize` is only called once per fast thread local variable,
|
||||
// except in corner cases where thread_local dtors reference other
|
||||
// thread_local's, or it is being recursively initialized.
|
||||
//
|
||||
// Macos: Inlining this function can cause two `tlv_get_addr` calls to
|
||||
// be performed for every call to `Key::get`.
|
||||
// LLVM issue: https://bugs.llvm.org/show_bug.cgi?id=41722
|
||||
pub struct Key<T> {
|
||||
// If `LazyKeyInner::get` returns `None`, that indicates either:
|
||||
// * The value has never been initialized
|
||||
// * The value is being recursively initialized
|
||||
// * The value has already been destroyed or is being destroyed
|
||||
// To determine which kind of `None`, check `dtor_state`.
|
||||
//
|
||||
// This is very optimizer friendly for the fast path - initialized but
|
||||
// not yet dropped.
|
||||
inner: LazyKeyInner<T>,
|
||||
|
||||
// Metadata to keep track of the state of the destructor. Remember that
|
||||
// this variable is thread-local, not global.
|
||||
dtor_state: Cell<DtorState>,
|
||||
}
|
||||
|
||||
impl<T> fmt::Debug for Key<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
f.debug_struct("Key").finish_non_exhaustive()
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Key<T> {
|
||||
pub const fn new() -> Key<T> {
|
||||
Key { inner: LazyKeyInner::new(), dtor_state: Cell::new(DtorState::Unregistered) }
|
||||
}
|
||||
|
||||
// note that this is just a publicly-callable function only for the
|
||||
// const-initialized form of thread locals, basically a way to call the
|
||||
// free `register_dtor` function defined elsewhere in std.
|
||||
pub unsafe fn register_dtor(a: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
|
||||
unsafe {
|
||||
register_dtor(a, dtor);
|
||||
}
|
||||
}
|
||||
|
||||
pub unsafe fn get<F: FnOnce() -> T>(&self, init: F) -> Option<&'static T> {
|
||||
// SAFETY: See the definitions of `LazyKeyInner::get` and
|
||||
// `try_initialize` for more information.
|
||||
//
|
||||
// The caller must ensure no mutable references are ever active to
|
||||
// the inner cell or the inner T when this is called.
|
||||
// The `try_initialize` is dependant on the passed `init` function
|
||||
// for this.
|
||||
unsafe {
|
||||
match self.inner.get() {
|
||||
Some(val) => Some(val),
|
||||
None => self.try_initialize(init),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// `try_initialize` is only called once per fast thread local variable,
|
||||
// except in corner cases where thread_local dtors reference other
|
||||
// thread_local's, or it is being recursively initialized.
|
||||
//
|
||||
// Macos: Inlining this function can cause two `tlv_get_addr` calls to
|
||||
// be performed for every call to `Key::get`.
|
||||
// LLVM issue: https://bugs.llvm.org/show_bug.cgi?id=41722
|
||||
#[inline(never)]
|
||||
unsafe fn try_initialize<F: FnOnce() -> T>(&self, init: F) -> Option<&'static T> {
|
||||
#[inline(never)]
|
||||
unsafe fn try_initialize<F: FnOnce() -> T>(&self, init: F) -> Option<&'static T> {
|
||||
// SAFETY: See comment above (this function doc).
|
||||
if !mem::needs_drop::<T>() || unsafe { self.try_register_dtor() } {
|
||||
// SAFETY: See comment above (this function doc).
|
||||
if !mem::needs_drop::<T>() || unsafe { self.try_register_dtor() } {
|
||||
// SAFETY: See comment above (this function doc).
|
||||
Some(unsafe { self.inner.initialize(init) })
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
// `try_register_dtor` is only called once per fast thread local
|
||||
// variable, except in corner cases where thread_local dtors reference
|
||||
// other thread_local's, or it is being recursively initialized.
|
||||
unsafe fn try_register_dtor(&self) -> bool {
|
||||
match self.dtor_state.get() {
|
||||
DtorState::Unregistered => {
|
||||
// SAFETY: dtor registration happens before initialization.
|
||||
// Passing `self` as a pointer while using `destroy_value<T>`
|
||||
// is safe because the function will build a pointer to a
|
||||
// Key<T>, which is the type of self and so find the correct
|
||||
// size.
|
||||
unsafe { register_dtor(self as *const _ as *mut u8, destroy_value::<T>) };
|
||||
self.dtor_state.set(DtorState::Registered);
|
||||
true
|
||||
}
|
||||
DtorState::Registered => {
|
||||
// recursively initialized
|
||||
true
|
||||
}
|
||||
DtorState::RunningOrHasRun => false,
|
||||
}
|
||||
Some(unsafe { self.inner.initialize(init) })
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
unsafe extern "C" fn destroy_value<T>(ptr: *mut u8) {
|
||||
let ptr = ptr as *mut Key<T>;
|
||||
|
||||
// SAFETY:
|
||||
//
|
||||
// The pointer `ptr` has been built just above and comes from
|
||||
// `try_register_dtor` where it is originally a Key<T> coming from `self`,
|
||||
// making it non-NUL and of the correct type.
|
||||
//
|
||||
// Right before we run the user destructor be sure to set the
|
||||
// `Option<T>` to `None`, and `dtor_state` to `RunningOrHasRun`. This
|
||||
// causes future calls to `get` to run `try_initialize_drop` again,
|
||||
// which will now fail, and return `None`.
|
||||
//
|
||||
// Wrap the call in a catch to ensure unwinding is caught in the event
|
||||
// a panic takes place in a destructor.
|
||||
if let Err(_) = panic::catch_unwind(panic::AssertUnwindSafe(|| unsafe {
|
||||
let value = (*ptr).inner.take();
|
||||
(*ptr).dtor_state.set(DtorState::RunningOrHasRun);
|
||||
drop(value);
|
||||
})) {
|
||||
rtabort!("thread local panicked on drop");
|
||||
// `try_register_dtor` is only called once per fast thread local
|
||||
// variable, except in corner cases where thread_local dtors reference
|
||||
// other thread_local's, or it is being recursively initialized.
|
||||
unsafe fn try_register_dtor(&self) -> bool {
|
||||
match self.dtor_state.get() {
|
||||
DtorState::Unregistered => {
|
||||
// SAFETY: dtor registration happens before initialization.
|
||||
// Passing `self` as a pointer while using `destroy_value<T>`
|
||||
// is safe because the function will build a pointer to a
|
||||
// Key<T>, which is the type of self and so find the correct
|
||||
// size.
|
||||
unsafe { register_dtor(self as *const _ as *mut u8, destroy_value::<T>) };
|
||||
self.dtor_state.set(DtorState::Registered);
|
||||
true
|
||||
}
|
||||
DtorState::Registered => {
|
||||
// recursively initialized
|
||||
true
|
||||
}
|
||||
DtorState::RunningOrHasRun => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
unsafe extern "C" fn destroy_value<T>(ptr: *mut u8) {
|
||||
let ptr = ptr as *mut Key<T>;
|
||||
|
||||
// SAFETY:
|
||||
//
|
||||
// The pointer `ptr` has been built just above and comes from
|
||||
// `try_register_dtor` where it is originally a Key<T> coming from `self`,
|
||||
// making it non-NUL and of the correct type.
|
||||
//
|
||||
// Right before we run the user destructor be sure to set the
|
||||
// `Option<T>` to `None`, and `dtor_state` to `RunningOrHasRun`. This
|
||||
// causes future calls to `get` to run `try_initialize_drop` again,
|
||||
// which will now fail, and return `None`.
|
||||
//
|
||||
// Wrap the call in a catch to ensure unwinding is caught in the event
|
||||
// a panic takes place in a destructor.
|
||||
if let Err(_) = panic::catch_unwind(panic::AssertUnwindSafe(|| unsafe {
|
||||
let value = (*ptr).inner.take();
|
||||
(*ptr).dtor_state.set(DtorState::RunningOrHasRun);
|
||||
drop(value);
|
||||
})) {
|
||||
rtabort!("thread local panicked on drop");
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,35 +1,24 @@
|
||||
//! The following module declarations are outside cfg_if because the internal
|
||||
//! `__thread_local_internal` macro does not seem to be exported properly when using cfg_if
|
||||
#![unstable(feature = "thread_local_internals", reason = "should not be necessary", issue = "none")]
|
||||
|
||||
#[cfg(all(target_thread_local, not(all(target_family = "wasm", not(target_feature = "atomics")))))]
|
||||
mod fast_local;
|
||||
#[cfg(all(
|
||||
not(target_thread_local),
|
||||
not(all(target_family = "wasm", not(target_feature = "atomics")))
|
||||
))]
|
||||
mod os_local;
|
||||
#[cfg(all(target_family = "wasm", not(target_feature = "atomics")))]
|
||||
mod static_local;
|
||||
|
||||
#[cfg(not(test))]
|
||||
cfg_if::cfg_if! {
|
||||
if #[cfg(all(target_family = "wasm", not(target_feature = "atomics")))] {
|
||||
#[doc(hidden)]
|
||||
pub use static_local::statik::Key;
|
||||
} else if #[cfg(all(target_thread_local, not(all(target_family = "wasm", not(target_feature = "atomics")))))] {
|
||||
mod static_local;
|
||||
#[doc(hidden)]
|
||||
pub use fast_local::fast::Key;
|
||||
} else if #[cfg(all(not(target_thread_local), not(all(target_family = "wasm", not(target_feature = "atomics")))))] {
|
||||
pub use static_local::{Key, thread_local_inner};
|
||||
} else if #[cfg(all(target_thread_local))] {
|
||||
#[doc(hidden)]
|
||||
pub use os_local::os::Key;
|
||||
mod fast_local;
|
||||
#[doc(hidden)]
|
||||
pub use fast_local::{Key, thread_local_inner};
|
||||
} else {
|
||||
#[doc(hidden)]
|
||||
mod os_local;
|
||||
#[doc(hidden)]
|
||||
pub use os_local::{Key, thread_local_inner};
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
#[cfg(test)]
|
||||
pub use realstd::thread::__LocalKeyInner as Key;
|
||||
|
||||
mod lazy {
|
||||
use crate::cell::UnsafeCell;
|
||||
use crate::hint;
|
||||
|
||||
@ -1,13 +1,14 @@
|
||||
use super::lazy::LazyKeyInner;
|
||||
use crate::cell::Cell;
|
||||
use crate::sys_common::thread_local_key::StaticKey as OsStaticKey;
|
||||
use crate::{fmt, marker, panic, ptr};
|
||||
|
||||
#[doc(hidden)]
|
||||
#[macro_export]
|
||||
#[allow_internal_unstable(
|
||||
thread_local_internals,
|
||||
cfg_target_thread_local,
|
||||
thread_local,
|
||||
libstd_thread_internals
|
||||
)]
|
||||
#[allow_internal_unstable(thread_local_internals)]
|
||||
#[allow_internal_unsafe]
|
||||
macro_rules! __thread_local_inner {
|
||||
#[unstable(feature = "thread_local_internals", issue = "none")]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro thread_local_inner {
|
||||
// used to generate the `LocalKey` value for const-initialized thread locals
|
||||
(@key $t:ty, const $init:expr) => {{
|
||||
#[cfg_attr(not(bootstrap), inline)]
|
||||
@ -21,8 +22,8 @@ macro_rules! __thread_local_inner {
|
||||
// same implementation as below for os thread locals.
|
||||
#[inline]
|
||||
const fn __init() -> $t { INIT_EXPR }
|
||||
static __KEY: $crate::thread::__LocalKeyInner<$t> =
|
||||
$crate::thread::__LocalKeyInner::new();
|
||||
static __KEY: $crate::thread::local_impl::Key<$t> =
|
||||
$crate::thread::local_impl::Key::new();
|
||||
#[allow(unused_unsafe)]
|
||||
unsafe {
|
||||
__KEY.get(move || {
|
||||
@ -41,7 +42,7 @@ macro_rules! __thread_local_inner {
|
||||
unsafe {
|
||||
$crate::thread::LocalKey::new(__getit)
|
||||
}
|
||||
}};
|
||||
}},
|
||||
|
||||
// used to generate the `LocalKey` value for `thread_local!`
|
||||
(@key $t:ty, $init:expr) => {
|
||||
@ -55,8 +56,8 @@ macro_rules! __thread_local_inner {
|
||||
unsafe fn __getit(
|
||||
init: $crate::option::Option<&mut $crate::option::Option<$t>>,
|
||||
) -> $crate::option::Option<&'static $t> {
|
||||
static __KEY: $crate::thread::__LocalKeyInner<$t> =
|
||||
$crate::thread::__LocalKeyInner::new();
|
||||
static __KEY: $crate::thread::local_impl::Key<$t> =
|
||||
$crate::thread::local_impl::Key::new();
|
||||
|
||||
// FIXME: remove the #[allow(...)] marker when macros don't
|
||||
// raise warning for missing/extraneous unsafe blocks anymore.
|
||||
@ -80,118 +81,110 @@ macro_rules! __thread_local_inner {
|
||||
$crate::thread::LocalKey::new(__getit)
|
||||
}
|
||||
}
|
||||
};
|
||||
},
|
||||
($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $($init:tt)*) => {
|
||||
$(#[$attr])* $vis const $name: $crate::thread::LocalKey<$t> =
|
||||
$crate::__thread_local_inner!(@key $t, $($init)*);
|
||||
$crate::thread::local_impl::thread_local_inner!(@key $t, $($init)*);
|
||||
},
|
||||
}
|
||||
|
||||
/// Use a regular global static to store this key; the state provided will then be
|
||||
/// thread-local.
|
||||
pub struct Key<T> {
|
||||
// OS-TLS key that we'll use to key off.
|
||||
os: OsStaticKey,
|
||||
marker: marker::PhantomData<Cell<T>>,
|
||||
}
|
||||
|
||||
impl<T> fmt::Debug for Key<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
f.debug_struct("Key").finish_non_exhaustive()
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
pub mod os {
|
||||
use super::super::lazy::LazyKeyInner;
|
||||
use crate::cell::Cell;
|
||||
use crate::sys_common::thread_local_key::StaticKey as OsStaticKey;
|
||||
use crate::{fmt, marker, panic, ptr};
|
||||
unsafe impl<T> Sync for Key<T> {}
|
||||
|
||||
/// Use a regular global static to store this key; the state provided will then be
|
||||
/// thread-local.
|
||||
pub struct Key<T> {
|
||||
// OS-TLS key that we'll use to key off.
|
||||
os: OsStaticKey,
|
||||
marker: marker::PhantomData<Cell<T>>,
|
||||
struct Value<T: 'static> {
|
||||
inner: LazyKeyInner<T>,
|
||||
key: &'static Key<T>,
|
||||
}
|
||||
|
||||
impl<T: 'static> Key<T> {
|
||||
#[rustc_const_unstable(feature = "thread_local_internals", issue = "none")]
|
||||
pub const fn new() -> Key<T> {
|
||||
Key { os: OsStaticKey::new(Some(destroy_value::<T>)), marker: marker::PhantomData }
|
||||
}
|
||||
|
||||
impl<T> fmt::Debug for Key<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
f.debug_struct("Key").finish_non_exhaustive()
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl<T> Sync for Key<T> {}
|
||||
|
||||
struct Value<T: 'static> {
|
||||
inner: LazyKeyInner<T>,
|
||||
key: &'static Key<T>,
|
||||
}
|
||||
|
||||
impl<T: 'static> Key<T> {
|
||||
#[rustc_const_unstable(feature = "thread_local_internals", issue = "none")]
|
||||
pub const fn new() -> Key<T> {
|
||||
Key { os: OsStaticKey::new(Some(destroy_value::<T>)), marker: marker::PhantomData }
|
||||
}
|
||||
|
||||
/// It is a requirement for the caller to ensure that no mutable
|
||||
/// reference is active when this method is called.
|
||||
pub unsafe fn get(&'static self, init: impl FnOnce() -> T) -> Option<&'static T> {
|
||||
// SAFETY: See the documentation for this method.
|
||||
let ptr = unsafe { self.os.get() as *mut Value<T> };
|
||||
if ptr.addr() > 1 {
|
||||
// SAFETY: the check ensured the pointer is safe (its destructor
|
||||
// is not running) + it is coming from a trusted source (self).
|
||||
if let Some(ref value) = unsafe { (*ptr).inner.get() } {
|
||||
return Some(value);
|
||||
}
|
||||
/// It is a requirement for the caller to ensure that no mutable
|
||||
/// reference is active when this method is called.
|
||||
pub unsafe fn get(&'static self, init: impl FnOnce() -> T) -> Option<&'static T> {
|
||||
// SAFETY: See the documentation for this method.
|
||||
let ptr = unsafe { self.os.get() as *mut Value<T> };
|
||||
if ptr.addr() > 1 {
|
||||
// SAFETY: the check ensured the pointer is safe (its destructor
|
||||
// is not running) + it is coming from a trusted source (self).
|
||||
if let Some(ref value) = unsafe { (*ptr).inner.get() } {
|
||||
return Some(value);
|
||||
}
|
||||
// SAFETY: At this point we are sure we have no value and so
|
||||
// initializing (or trying to) is safe.
|
||||
unsafe { self.try_initialize(init) }
|
||||
}
|
||||
|
||||
// `try_initialize` is only called once per os thread local variable,
|
||||
// except in corner cases where thread_local dtors reference other
|
||||
// thread_local's, or it is being recursively initialized.
|
||||
unsafe fn try_initialize(&'static self, init: impl FnOnce() -> T) -> Option<&'static T> {
|
||||
// SAFETY: No mutable references are ever handed out meaning getting
|
||||
// the value is ok.
|
||||
let ptr = unsafe { self.os.get() as *mut Value<T> };
|
||||
if ptr.addr() == 1 {
|
||||
// destructor is running
|
||||
return None;
|
||||
}
|
||||
|
||||
let ptr = if ptr.is_null() {
|
||||
// If the lookup returned null, we haven't initialized our own
|
||||
// local copy, so do that now.
|
||||
let ptr = Box::into_raw(Box::new(Value { inner: LazyKeyInner::new(), key: self }));
|
||||
// SAFETY: At this point we are sure there is no value inside
|
||||
// ptr so setting it will not affect anyone else.
|
||||
unsafe {
|
||||
self.os.set(ptr as *mut u8);
|
||||
}
|
||||
ptr
|
||||
} else {
|
||||
// recursive initialization
|
||||
ptr
|
||||
};
|
||||
|
||||
// SAFETY: ptr has been ensured as non-NUL just above an so can be
|
||||
// dereferenced safely.
|
||||
unsafe { Some((*ptr).inner.initialize(init)) }
|
||||
}
|
||||
// SAFETY: At this point we are sure we have no value and so
|
||||
// initializing (or trying to) is safe.
|
||||
unsafe { self.try_initialize(init) }
|
||||
}
|
||||
|
||||
unsafe extern "C" fn destroy_value<T: 'static>(ptr: *mut u8) {
|
||||
// SAFETY:
|
||||
//
|
||||
// The OS TLS ensures that this key contains a null value when this
|
||||
// destructor starts to run. We set it back to a sentinel value of 1 to
|
||||
// ensure that any future calls to `get` for this thread will return
|
||||
// `None`.
|
||||
//
|
||||
// Note that to prevent an infinite loop we reset it back to null right
|
||||
// before we return from the destructor ourselves.
|
||||
//
|
||||
// Wrap the call in a catch to ensure unwinding is caught in the event
|
||||
// a panic takes place in a destructor.
|
||||
if let Err(_) = panic::catch_unwind(|| unsafe {
|
||||
let ptr = Box::from_raw(ptr as *mut Value<T>);
|
||||
let key = ptr.key;
|
||||
key.os.set(ptr::invalid_mut(1));
|
||||
drop(ptr);
|
||||
key.os.set(ptr::null_mut());
|
||||
}) {
|
||||
rtabort!("thread local panicked on drop");
|
||||
// `try_initialize` is only called once per os thread local variable,
|
||||
// except in corner cases where thread_local dtors reference other
|
||||
// thread_local's, or it is being recursively initialized.
|
||||
unsafe fn try_initialize(&'static self, init: impl FnOnce() -> T) -> Option<&'static T> {
|
||||
// SAFETY: No mutable references are ever handed out meaning getting
|
||||
// the value is ok.
|
||||
let ptr = unsafe { self.os.get() as *mut Value<T> };
|
||||
if ptr.addr() == 1 {
|
||||
// destructor is running
|
||||
return None;
|
||||
}
|
||||
|
||||
let ptr = if ptr.is_null() {
|
||||
// If the lookup returned null, we haven't initialized our own
|
||||
// local copy, so do that now.
|
||||
let ptr = Box::into_raw(Box::new(Value { inner: LazyKeyInner::new(), key: self }));
|
||||
// SAFETY: At this point we are sure there is no value inside
|
||||
// ptr so setting it will not affect anyone else.
|
||||
unsafe {
|
||||
self.os.set(ptr as *mut u8);
|
||||
}
|
||||
ptr
|
||||
} else {
|
||||
// recursive initialization
|
||||
ptr
|
||||
};
|
||||
|
||||
// SAFETY: ptr has been ensured as non-NUL just above an so can be
|
||||
// dereferenced safely.
|
||||
unsafe { Some((*ptr).inner.initialize(init)) }
|
||||
}
|
||||
}
|
||||
|
||||
unsafe extern "C" fn destroy_value<T: 'static>(ptr: *mut u8) {
|
||||
// SAFETY:
|
||||
//
|
||||
// The OS TLS ensures that this key contains a null value when this
|
||||
// destructor starts to run. We set it back to a sentinel value of 1 to
|
||||
// ensure that any future calls to `get` for this thread will return
|
||||
// `None`.
|
||||
//
|
||||
// Note that to prevent an infinite loop we reset it back to null right
|
||||
// before we return from the destructor ourselves.
|
||||
//
|
||||
// Wrap the call in a catch to ensure unwinding is caught in the event
|
||||
// a panic takes place in a destructor.
|
||||
if let Err(_) = panic::catch_unwind(|| unsafe {
|
||||
let ptr = Box::from_raw(ptr as *mut Value<T>);
|
||||
let key = ptr.key;
|
||||
key.os.set(ptr::invalid_mut(1));
|
||||
drop(ptr);
|
||||
key.os.set(ptr::null_mut());
|
||||
}) {
|
||||
rtabort!("thread local panicked on drop");
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,13 +1,12 @@
|
||||
use super::lazy::LazyKeyInner;
|
||||
use crate::fmt;
|
||||
|
||||
#[doc(hidden)]
|
||||
#[macro_export]
|
||||
#[allow_internal_unstable(
|
||||
thread_local_internals,
|
||||
cfg_target_thread_local,
|
||||
thread_local,
|
||||
libstd_thread_internals
|
||||
)]
|
||||
#[allow_internal_unstable(thread_local_internals)]
|
||||
#[allow_internal_unsafe]
|
||||
macro_rules! __thread_local_inner {
|
||||
#[unstable(feature = "thread_local_internals", issue = "none")]
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
pub macro thread_local_inner {
|
||||
// used to generate the `LocalKey` value for const-initialized thread locals
|
||||
(@key $t:ty, const $init:expr) => {{
|
||||
#[inline] // see comments below
|
||||
@ -30,7 +29,7 @@ macro_rules! __thread_local_inner {
|
||||
unsafe {
|
||||
$crate::thread::LocalKey::new(__getit)
|
||||
}
|
||||
}};
|
||||
}},
|
||||
|
||||
// used to generate the `LocalKey` value for `thread_local!`
|
||||
(@key $t:ty, $init:expr) => {
|
||||
@ -41,8 +40,8 @@ macro_rules! __thread_local_inner {
|
||||
unsafe fn __getit(
|
||||
init: $crate::option::Option<&mut $crate::option::Option<$t>>,
|
||||
) -> $crate::option::Option<&'static $t> {
|
||||
static __KEY: $crate::thread::__LocalKeyInner<$t> =
|
||||
$crate::thread::__LocalKeyInner::new();
|
||||
static __KEY: $crate::thread::local_impl::Key<$t> =
|
||||
$crate::thread::local_impl::Key::new();
|
||||
|
||||
// FIXME: remove the #[allow(...)] marker when macros don't
|
||||
// raise warning for missing/extraneous unsafe blocks anymore.
|
||||
@ -66,50 +65,45 @@ macro_rules! __thread_local_inner {
|
||||
$crate::thread::LocalKey::new(__getit)
|
||||
}
|
||||
}
|
||||
};
|
||||
},
|
||||
($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $($init:tt)*) => {
|
||||
$(#[$attr])* $vis const $name: $crate::thread::LocalKey<$t> =
|
||||
$crate::__thread_local_inner!(@key $t, $($init)*);
|
||||
}
|
||||
$crate::thread::local_impl::thread_local_inner!(@key $t, $($init)*);
|
||||
},
|
||||
}
|
||||
|
||||
/// On some targets like wasm there's no threads, so no need to generate
|
||||
/// thread locals and we can instead just use plain statics!
|
||||
#[doc(hidden)]
|
||||
pub mod statik {
|
||||
use super::super::lazy::LazyKeyInner;
|
||||
use crate::fmt;
|
||||
|
||||
pub struct Key<T> {
|
||||
inner: LazyKeyInner<T>,
|
||||
}
|
||||
pub struct Key<T> {
|
||||
inner: LazyKeyInner<T>,
|
||||
}
|
||||
|
||||
unsafe impl<T> Sync for Key<T> {}
|
||||
unsafe impl<T> Sync for Key<T> {}
|
||||
|
||||
impl<T> fmt::Debug for Key<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
f.debug_struct("Key").finish_non_exhaustive()
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Key<T> {
|
||||
pub const fn new() -> Key<T> {
|
||||
Key { inner: LazyKeyInner::new() }
|
||||
}
|
||||
|
||||
pub unsafe fn get(&self, init: impl FnOnce() -> T) -> Option<&'static T> {
|
||||
// SAFETY: The caller must ensure no reference is ever handed out to
|
||||
// the inner cell nor mutable reference to the Option<T> inside said
|
||||
// cell. This make it safe to hand a reference, though the lifetime
|
||||
// of 'static is itself unsafe, making the get method unsafe.
|
||||
let value = unsafe {
|
||||
match self.inner.get() {
|
||||
Some(ref value) => value,
|
||||
None => self.inner.initialize(init),
|
||||
}
|
||||
};
|
||||
|
||||
Some(value)
|
||||
}
|
||||
impl<T> fmt::Debug for Key<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
f.debug_struct("Key").finish_non_exhaustive()
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Key<T> {
|
||||
pub const fn new() -> Key<T> {
|
||||
Key { inner: LazyKeyInner::new() }
|
||||
}
|
||||
|
||||
pub unsafe fn get(&self, init: impl FnOnce() -> T) -> Option<&'static T> {
|
||||
// SAFETY: The caller must ensure no reference is ever handed out to
|
||||
// the inner cell nor mutable reference to the Option<T> inside said
|
||||
// cell. This make it safe to hand a reference, though the lifetime
|
||||
// of 'static is itself unsafe, making the get method unsafe.
|
||||
let value = unsafe {
|
||||
match self.inner.get() {
|
||||
Some(ref value) => value,
|
||||
None => self.inner.initialize(init),
|
||||
}
|
||||
};
|
||||
|
||||
Some(value)
|
||||
}
|
||||
}
|
||||
|
||||
@ -153,23 +153,23 @@ macro_rules! thread_local {
|
||||
() => {};
|
||||
|
||||
($(#[$attr:meta])* $vis:vis static $name:ident: $t:ty = const { $init:expr }; $($rest:tt)*) => (
|
||||
$crate::__thread_local_inner!($(#[$attr])* $vis $name, $t, const $init);
|
||||
$crate::thread::local_impl::thread_local_inner!($(#[$attr])* $vis $name, $t, const $init);
|
||||
$crate::thread_local!($($rest)*);
|
||||
);
|
||||
|
||||
($(#[$attr:meta])* $vis:vis static $name:ident: $t:ty = const { $init:expr }) => (
|
||||
$crate::__thread_local_inner!($(#[$attr])* $vis $name, $t, const $init);
|
||||
$crate::thread::local_impl::thread_local_inner!($(#[$attr])* $vis $name, $t, const $init);
|
||||
);
|
||||
|
||||
// process multiple declarations
|
||||
($(#[$attr:meta])* $vis:vis static $name:ident: $t:ty = $init:expr; $($rest:tt)*) => (
|
||||
$crate::__thread_local_inner!($(#[$attr])* $vis $name, $t, $init);
|
||||
$crate::thread::local_impl::thread_local_inner!($(#[$attr])* $vis $name, $t, $init);
|
||||
$crate::thread_local!($($rest)*);
|
||||
);
|
||||
|
||||
// handle a single declaration
|
||||
($(#[$attr:meta])* $vis:vis static $name:ident: $t:ty = $init:expr) => (
|
||||
$crate::__thread_local_inner!($(#[$attr])* $vis $name, $t, $init);
|
||||
$crate::thread::local_impl::thread_local_inner!($(#[$attr])* $vis $name, $t, $init);
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
@ -204,9 +204,12 @@ pub use self::local::{AccessError, LocalKey};
|
||||
// by the elf linker. "static" is for single-threaded platforms where a global
|
||||
// static is sufficient.
|
||||
|
||||
// Implementation details used by the thread_local!{} macro.
|
||||
#[doc(hidden)]
|
||||
#[unstable(feature = "libstd_thread_internals", issue = "none")]
|
||||
pub use crate::sys::common::thread_local::Key as __LocalKeyInner;
|
||||
#[unstable(feature = "thread_local_internals", issue = "none")]
|
||||
pub mod local_impl {
|
||||
pub use crate::sys::common::thread_local::{thread_local_inner, Key};
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Builder
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user