rust/src/shims/tls.rs

178 lines
6.4 KiB
Rust
Raw Normal View History

2019-06-29 07:15:05 -05:00
//! Implement thread-local storage.
use std::collections::BTreeMap;
2017-07-31 06:30:44 -05:00
2018-10-09 15:03:14 -05:00
use rustc_target::abi::LayoutOf;
use rustc::{ty, ty::layout::HasDataLayout, mir};
2018-11-01 02:56:41 -05:00
use crate::{
2019-06-08 15:14:47 -05:00
InterpResult, InterpError, StackPopCleanup,
MPlaceTy, Scalar, Tag,
2019-07-05 03:08:57 -05:00
HelpersEvalContextExt,
2018-10-09 15:03:14 -05:00
};
2017-07-31 06:30:44 -05:00
pub type TlsKey = u128;
2018-10-16 11:01:50 -05:00
#[derive(Copy, Clone, Debug)]
pub struct TlsEntry<'tcx> {
/// The data for this key. None is used to represent NULL.
/// (We normalize this early to avoid having to do a NULL-ptr-test each time we access the data.)
/// Will eventually become a map from thread IDs to `Scalar`s, if we ever support more than one thread.
pub(crate) data: Option<Scalar<Tag>>,
pub(crate) dtor: Option<ty::Instance<'tcx>>,
}
2018-10-16 11:01:50 -05:00
#[derive(Debug)]
pub struct TlsData<'tcx> {
/// The Key to use for the next thread-local allocation.
pub(crate) next_key: TlsKey,
/// pthreads-style thread-local storage.
pub(crate) keys: BTreeMap<TlsKey, TlsEntry<'tcx>>,
}
impl<'tcx> Default for TlsData<'tcx> {
fn default() -> Self {
TlsData {
next_key: 1, // start with 1 as we must not use 0 on Windows
keys: Default::default(),
}
}
2017-07-31 06:30:44 -05:00
}
impl<'tcx> TlsData<'tcx> {
pub fn create_tls_key(
&mut self,
dtor: Option<ty::Instance<'tcx>>,
) -> TlsKey {
let new_key = self.next_key;
self.next_key += 1;
self.keys.insert(
new_key,
TlsEntry {
data: None,
dtor,
},
);
2017-07-31 06:30:44 -05:00
trace!("New TLS key allocated: {} with dtor {:?}", new_key, dtor);
2018-07-10 10:32:38 -05:00
new_key
2017-07-31 06:30:44 -05:00
}
2019-06-08 15:14:47 -05:00
pub fn delete_tls_key(&mut self, key: TlsKey) -> InterpResult<'tcx> {
match self.keys.remove(&key) {
2017-07-31 06:30:44 -05:00
Some(_) => {
trace!("TLS key {} removed", key);
Ok(())
}
None => err!(TlsOutOfBounds),
2018-07-10 10:32:38 -05:00
}
2017-07-31 06:30:44 -05:00
}
pub fn load_tls(
&mut self,
key: TlsKey,
cx: &impl HasDataLayout,
) -> InterpResult<'tcx, Scalar<Tag>> {
match self.keys.get(&key) {
2017-07-31 06:30:44 -05:00
Some(&TlsEntry { data, .. }) => {
trace!("TLS key {} loaded: {:?}", key, data);
Ok(data.unwrap_or_else(|| Scalar::ptr_null(cx).into()))
}
None => err!(TlsOutOfBounds),
2018-07-10 10:32:38 -05:00
}
2017-07-31 06:30:44 -05:00
}
pub fn store_tls(&mut self, key: TlsKey, new_data: Option<Scalar<Tag>>) -> InterpResult<'tcx> {
match self.keys.get_mut(&key) {
2017-07-31 06:30:44 -05:00
Some(&mut TlsEntry { ref mut data, .. }) => {
trace!("TLS key {} stored: {:?}", key, new_data);
*data = new_data;
Ok(())
}
None => err!(TlsOutOfBounds),
2018-07-10 10:32:38 -05:00
}
2017-07-31 06:30:44 -05:00
}
2017-07-31 06:30:44 -05:00
/// Returns a dtor, its argument and its index, if one is supposed to run
///
/// An optional destructor function may be associated with each key value.
/// At thread exit, if a key value has a non-NULL destructor pointer,
/// and the thread has a non-NULL value associated with that key,
/// the value of the key is set to NULL, and then the function pointed
/// to is called with the previously associated value as its sole argument.
/// The order of destructor calls is unspecified if more than one destructor
/// exists for a thread when it exits.
///
/// If, after all the destructors have been called for all non-NULL values
/// with associated destructors, there are still some non-NULL values with
/// associated destructors, then the process is repeated.
/// If, after at least {PTHREAD_DESTRUCTOR_ITERATIONS} iterations of destructor
/// calls for outstanding non-NULL values, there are still some non-NULL values
/// with associated destructors, implementations may stop calling destructors,
/// or they may continue calling destructors until no non-NULL values with
/// associated destructors exist, even though this might result in an infinite loop.
fn fetch_tls_dtor(
&mut self,
key: Option<TlsKey>,
) -> Option<(ty::Instance<'tcx>, Scalar<Tag>, TlsKey)> {
2017-07-31 06:30:44 -05:00
use std::collections::Bound::*;
2018-05-26 10:07:34 -05:00
let thread_local = &mut self.keys;
2017-07-31 06:30:44 -05:00
let start = match key {
Some(key) => Excluded(key),
None => Unbounded,
};
for (&key, &mut TlsEntry { ref mut data, dtor }) in
2018-05-26 10:07:34 -05:00
thread_local.range_mut((start, Unbounded))
{
2019-07-05 03:08:57 -05:00
if let Some(data_scalar) = *data {
2017-07-31 06:30:44 -05:00
if let Some(dtor) = dtor {
2019-07-05 03:08:57 -05:00
let ret = Some((dtor, data_scalar, key));
*data = None;
2018-08-07 08:22:11 -05:00
return ret;
2017-07-31 06:30:44 -05:00
}
}
}
2018-08-07 08:22:11 -05:00
None
2017-07-31 06:30:44 -05:00
}
}
2017-08-01 04:11:57 -05:00
2019-06-13 01:52:04 -05:00
impl<'mir, 'tcx> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
2019-06-08 15:14:47 -05:00
fn run_tls_dtors(&mut self) -> InterpResult<'tcx> {
let this = self.eval_context_mut();
2019-07-05 03:08:57 -05:00
let mut dtor = this.machine.tls.fetch_tls_dtor(None);
2017-08-01 04:11:57 -05:00
// FIXME: replace loop by some structure that works with stepping
while let Some((instance, ptr, key)) = dtor {
trace!("Running TLS dtor {:?} on {:?}", instance, ptr);
2019-07-05 03:08:57 -05:00
assert!(!this.is_null(ptr).unwrap(), "Data can't be NULL when dtor is called!");
2017-08-01 04:11:57 -05:00
// TODO: Potentially, this has to support all the other possible instances?
// See eval_fn_call in interpret/terminator/mod.rs
let mir = this.load_mir(instance.def)?;
let ret_place = MPlaceTy::dangling(this.layout_of(this.tcx.mk_unit())?, this).into();
this.push_stack_frame(
2017-08-01 04:11:57 -05:00
instance,
mir.span,
mir,
2018-10-09 15:03:14 -05:00
Some(ret_place),
2018-08-24 10:44:04 -05:00
StackPopCleanup::None { cleanup: true },
2017-08-01 04:11:57 -05:00
)?;
2019-06-10 06:01:55 -05:00
let arg_local = this.frame().body.args_iter().next().ok_or_else(
2019-04-03 03:48:11 -05:00
|| InterpError::AbiViolation("TLS dtor does not take enough arguments.".to_owned()),
)?;
let dest = this.eval_place(&mir::Place::Base(mir::PlaceBase::Local(arg_local)))?;
this.write_scalar(ptr, dest)?;
2017-08-01 04:11:57 -05:00
// step until out of stackframes
this.run()?;
2017-08-01 04:11:57 -05:00
2019-07-05 03:08:57 -05:00
dtor = match this.machine.tls.fetch_tls_dtor(Some(key)) {
2017-08-01 04:11:57 -05:00
dtor @ Some(_) => dtor,
2019-07-05 03:08:57 -05:00
None => this.machine.tls.fetch_tls_dtor(None),
2017-08-01 04:11:57 -05:00
};
}
2018-07-16 04:42:46 -05:00
// FIXME: On a windows target, call `unsafe extern "system" fn on_tls_callback`.
2017-08-01 04:11:57 -05:00
Ok(())
}
}