Implement basic support for concurrency (Linux only).

Author: Vytautas Astrauskas

src/diagnostics.rs

@@ -43,7 +43,7 @@ pub enum NonHaltingDiagnostic {
 
 /// Emit a custom diagnostic without going through the miri-engine machinery
 pub fn report_error<'tcx, 'mir>(
-    ecx: &InterpCx<'mir, 'tcx, Evaluator<'tcx>>,
+    ecx: &InterpCx<'mir, 'tcx, Evaluator<'mir, 'tcx>>,
     mut e: InterpErrorInfo<'tcx>,
 ) -> Option<i64> {
     use InterpError::*;
@@ -108,7 +108,7 @@ pub fn report_error<'tcx, 'mir>(
 /// Report an error or note (depending on the `error` argument) at the current frame's current statement.
 /// Also emits a full stacktrace of the interpreter stack.
 fn report_msg<'tcx, 'mir>(
-    ecx: &InterpCx<'mir, 'tcx, Evaluator<'tcx>>,
+    ecx: &InterpCx<'mir, 'tcx, Evaluator<'mir, 'tcx>>,
     title: &str,
     span_msg: String,
     helps: &[String],
@@ -164,7 +164,7 @@ pub fn register_diagnostic(e: NonHaltingDiagnostic) {
     DIAGNOSTICS.with(|diagnostics| diagnostics.borrow_mut().push(e));
 }
 
-impl<'mir, 'tcx> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
+impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
 pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
     /// Emit all diagnostics that were registed with `register_diagnostics`
     fn process_diagnostics(&self) {

src/eval.rs

@@ -59,7 +59,7 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
     tcx: TyCtxt<'tcx>,
     main_id: DefId,
     config: MiriConfig,
-) -> InterpResult<'tcx, (InterpCx<'mir, 'tcx, Evaluator<'tcx>>, MPlaceTy<'tcx, Tag>)> {
+) -> InterpResult<'tcx, (InterpCx<'mir, 'tcx, Evaluator<'mir, 'tcx>>, MPlaceTy<'tcx, Tag>)> {
     let mut ecx = InterpCx::new(
         tcx.at(rustc_span::source_map::DUMMY_SP),
         ty::ParamEnv::reveal_all(),
@@ -198,7 +198,8 @@ pub fn eval_main<'tcx>(tcx: TyCtxt<'tcx>, main_id: DefId, config: MiriConfig) ->
     // Perform the main execution.
     let res: InterpResult<'_, i64> = (|| {
         // Main loop.
-        while ecx.step()? {
+        while ecx.schedule()? {
+            assert!(ecx.step()?);
             ecx.process_diagnostics();
         }
         // Read the return code pointer *before* we run TLS destructors, to assert

src/helpers.rs

@@ -12,7 +12,7 @@ use rand::RngCore;
 
 use crate::*;
 
-impl<'mir, 'tcx> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
+impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
 
 /// Gets an instance for a path.
 fn try_resolve_did<'mir, 'tcx>(tcx: TyCtxt<'tcx>, path: &[&str]) -> Option<DefId> {
@@ -264,7 +264,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             unsafe_cell_action: F,
         }
 
-        impl<'ecx, 'mir, 'tcx, F> ValueVisitor<'mir, 'tcx, Evaluator<'tcx>>
+        impl<'ecx, 'mir, 'tcx: 'mir, F> ValueVisitor<'mir, 'tcx, Evaluator<'mir, 'tcx>>
             for UnsafeCellVisitor<'ecx, 'mir, 'tcx, F>
         where
             F: FnMut(MPlaceTy<'tcx, Tag>) -> InterpResult<'tcx>,

src/intptrcast.rs

@@ -41,7 +41,7 @@ impl Default for GlobalState {
 impl<'mir, 'tcx> GlobalState {
     pub fn int_to_ptr(
         int: u64,
-        memory: &Memory<'mir, 'tcx, Evaluator<'tcx>>,
+        memory: &Memory<'mir, 'tcx, Evaluator<'mir, 'tcx>>,
     ) -> InterpResult<'tcx, Pointer<Tag>> {
         let global_state = memory.extra.intptrcast.borrow();
         let pos = global_state.int_to_ptr_map.binary_search_by_key(&int, |(addr, _)| *addr);
@@ -73,7 +73,7 @@ impl<'mir, 'tcx> GlobalState {
 
     pub fn ptr_to_int(
         ptr: Pointer<Tag>,
-        memory: &Memory<'mir, 'tcx, Evaluator<'tcx>>,
+        memory: &Memory<'mir, 'tcx, Evaluator<'mir, 'tcx>>,
     ) -> InterpResult<'tcx, u64> {
         let mut global_state = memory.extra.intptrcast.borrow_mut();
         let global_state = &mut *global_state;

src/lib.rs

@@ -12,6 +12,7 @@ extern crate rustc_ast;
 #[macro_use] extern crate rustc_middle;
 extern crate rustc_data_structures;
 extern crate rustc_hir;
+extern crate rustc_index;
 extern crate rustc_mir;
 extern crate rustc_span;
 extern crate rustc_target;
@@ -26,6 +27,7 @@ mod operator;
 mod range_map;
 mod shims;
 mod stacked_borrows;
+mod threads;
 
 // Make all those symbols available in the same place as our own.
 pub use rustc_mir::interpret::*;
@@ -59,6 +61,7 @@ pub use crate::range_map::RangeMap;
 pub use crate::stacked_borrows::{
     EvalContextExt as StackedBorEvalContextExt, Item, Permission, PtrId, Stack, Stacks, Tag,
 };
+pub use crate::threads::EvalContextExt as ThreadsEvalContextExt;
 
 /// Insert rustc arguments at the beginning of the argument list that Miri wants to be
 /// set per default, for maximal validation power.

src/machine.rs

@@ -18,6 +18,8 @@ use rustc_span::symbol::{sym, Symbol};
 
 use crate::*;
 
+pub use crate::threads::{ThreadId, ThreadSet, ThreadLocalStorage};
+
 // Some global facts about the emulated machine.
 pub const PAGE_SIZE: u64 = 4 * 1024; // FIXME: adjust to target architecture
 pub const STACK_ADDR: u64 = 32 * PAGE_SIZE; // not really about the "stack", but where we start assigning integer addresses to allocations
@@ -74,6 +76,7 @@ pub struct AllocExtra {
 pub struct MemoryExtra {
     pub stacked_borrows: Option<stacked_borrows::MemoryExtra>,
     pub intptrcast: intptrcast::MemoryExtra,
+    pub tls: ThreadLocalStorage,
 
     /// Mapping extern static names to their canonical allocation.
     extern_statics: FxHashMap<Symbol, AllocId>,
@@ -100,6 +103,7 @@ impl MemoryExtra {
             extern_statics: FxHashMap::default(),
             rng: RefCell::new(rng),
             tracked_alloc_id,
+            tls: Default::default(),
         }
     }
 
@@ -147,7 +151,7 @@ impl MemoryExtra {
 }
 
 /// The machine itself.
-pub struct Evaluator<'tcx> {
+pub struct Evaluator<'mir, 'tcx> {
     /// Environment variables set by `setenv`.
     /// Miri does not expose env vars from the host to the emulated program.
     pub(crate) env_vars: EnvVars<'tcx>,
@@ -182,9 +186,11 @@ pub struct Evaluator<'tcx> {
 
     /// The "time anchor" for this machine's monotone clock (for `Instant` simulation).
     pub(crate) time_anchor: Instant,
+
+    pub(crate) threads: ThreadSet<'mir, 'tcx>,
 }
 
-impl<'tcx> Evaluator<'tcx> {
+impl<'mir, 'tcx> Evaluator<'mir, 'tcx> {
     pub(crate) fn new(communicate: bool, validate: bool) -> Self {
         Evaluator {
             // `env_vars` could be initialized properly here if `Memory` were available before
@@ -201,12 +207,13 @@ impl<'tcx> Evaluator<'tcx> {
             dir_handler: Default::default(),
             panic_payload: None,
             time_anchor: Instant::now(),
+            threads: Default::default(),
         }
     }
 }
 
 /// A rustc InterpCx for Miri.
-pub type MiriEvalContext<'mir, 'tcx> = InterpCx<'mir, 'tcx, Evaluator<'tcx>>;
+pub type MiriEvalContext<'mir, 'tcx> = InterpCx<'mir, 'tcx, Evaluator<'mir, 'tcx>>;
 
 /// A little trait that's useful to be inherited by extension traits.
 pub trait MiriEvalContextExt<'mir, 'tcx> {
@@ -225,7 +232,7 @@ impl<'mir, 'tcx> MiriEvalContextExt<'mir, 'tcx> for MiriEvalContext<'mir, 'tcx>
 }
 
 /// Machine hook implementations.
-impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'tcx> {
+impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'mir, 'tcx> {
     type MemoryKind = MiriMemoryKind;
 
     type FrameExtra = FrameData<'tcx>;
@@ -241,6 +248,19 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'tcx> {
 
     const CHECK_ALIGN: bool = true;
 
+    #[inline(always)]
+    fn stack<'a>(
+        ecx: &'a InterpCx<'mir, 'tcx, Self>
+    ) -> &'a [Frame<'mir, 'tcx, Self::PointerTag, Self::FrameExtra>] {
+        ecx.active_thread_stack()
+    }
+
+    fn stack_mut<'a>(
+        ecx: &'a mut InterpCx<'mir, 'tcx, Self>
+    ) -> &'a mut Vec<Frame<'mir, 'tcx, Self::PointerTag, Self::FrameExtra>> {
+        ecx.active_thread_stack_mut()
+    }
+
     #[inline(always)]
     fn enforce_validity(ecx: &InterpCx<'mir, 'tcx, Self>) -> bool {
         ecx.machine.validate
@@ -333,29 +353,39 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'tcx> {
 
     fn canonical_alloc_id(mem: &Memory<'mir, 'tcx, Self>, id: AllocId) -> AllocId {
         let tcx = mem.tcx;
-        // Figure out if this is an extern static, and if yes, which one.
-        let def_id = match tcx.alloc_map.lock().get(id) {
-            Some(GlobalAlloc::Static(def_id)) if tcx.is_foreign_item(def_id) => def_id,
+        let alloc = tcx.alloc_map.lock().get(id);
+        match alloc {
+            Some(GlobalAlloc::Static(def_id)) if tcx.is_foreign_item(def_id) => {
+                // Figure out if this is an extern static, and if yes, which one.
+                let attrs = tcx.get_attrs(def_id);
+                let link_name = match attr::first_attr_value_str_by_name(&attrs, sym::link_name) {
+                    Some(name) => name,
+                    None => tcx.item_name(def_id),
+                };
+                // Check if we know this one.
+                if let Some(canonical_id) = mem.extra.extern_statics.get(&link_name) {
+                    trace!("canonical_alloc_id: {:?} ({}) -> {:?}", id, link_name, canonical_id);
+                    *canonical_id
+                } else {
+                    // Return original id; `Memory::get_static_alloc` will throw an error.
+                    id
+                }
+            },
+            Some(GlobalAlloc::Static(def_id)) if tcx.has_attr(def_id, sym::thread_local) => {
+                // We have a thread local, so we need to get a unique allocation id for it.
+                mem.extra.tls.get_or_register_allocation(*tcx, id)
+            },
             _ => {
                 // No need to canonicalize anything.
-                return id;
+                id
             }
-        };
-        let attrs = tcx.get_attrs(def_id);
-        let link_name = match attr::first_attr_value_str_by_name(&attrs, sym::link_name) {
-            Some(name) => name,
-            None => tcx.item_name(def_id),
-        };
-        // Check if we know this one.
-        if let Some(canonical_id) = mem.extra.extern_statics.get(&link_name) {
-            trace!("canonical_alloc_id: {:?} ({}) -> {:?}", id, link_name, canonical_id);
-            *canonical_id
-        } else {
-            // Return original id; `Memory::get_static_alloc` will throw an error.
-            id
         }
     }
 
+    fn resolve_thread_local_allocation_id(extra: &Self::MemoryExtra, id: AllocId) -> AllocId {
+        extra.tls.resolve_allocation(id)
+    }
+
     fn init_allocation_extra<'b>(
         memory_extra: &MemoryExtra,
         id: AllocId,

src/shims/dlsym.rs

@@ -20,7 +20,7 @@ impl Dlsym {
     }
 }
 
-impl<'mir, 'tcx> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
+impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
 pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
     fn call_dlsym(
         &mut self,

src/shims/env.rs

@@ -35,7 +35,7 @@ pub struct EnvVars<'tcx> {
 
 impl<'tcx> EnvVars<'tcx> {
     pub(crate) fn init<'mir>(
-        ecx: &mut InterpCx<'mir, 'tcx, Evaluator<'tcx>>,
+        ecx: &mut InterpCx<'mir, 'tcx, Evaluator<'mir, 'tcx>>,
         mut excluded_env_vars: Vec<String>,
     ) -> InterpResult<'tcx> {
         let target_os = ecx.tcx.sess.target.target.target_os.as_str();
@@ -61,7 +61,7 @@ impl<'tcx> EnvVars<'tcx> {
     }
 
     pub(crate) fn cleanup<'mir>(
-        ecx: &mut InterpCx<'mir, 'tcx, Evaluator<'tcx>>,
+        ecx: &mut InterpCx<'mir, 'tcx, Evaluator<'mir, 'tcx>>,
     ) -> InterpResult<'tcx> {
         // Deallocate individual env vars.
         for (_name, ptr) in ecx.machine.env_vars.map.drain() {
@@ -78,7 +78,7 @@ impl<'tcx> EnvVars<'tcx> {
 fn alloc_env_var_as_c_str<'mir, 'tcx>(
     name: &OsStr,
     value: &OsStr,
-    ecx: &mut InterpCx<'mir, 'tcx, Evaluator<'tcx>>,
+    ecx: &mut InterpCx<'mir, 'tcx, Evaluator<'mir, 'tcx>>,
 ) -> InterpResult<'tcx, Pointer<Tag>> {
     let mut name_osstring = name.to_os_string();
     name_osstring.push("=");
@@ -89,15 +89,15 @@ fn alloc_env_var_as_c_str<'mir, 'tcx>(
 fn alloc_env_var_as_wide_str<'mir, 'tcx>(
     name: &OsStr,
     value: &OsStr,
-    ecx: &mut InterpCx<'mir, 'tcx, Evaluator<'tcx>>,
+    ecx: &mut InterpCx<'mir, 'tcx, Evaluator<'mir, 'tcx>>,
 ) -> InterpResult<'tcx, Pointer<Tag>> {
     let mut name_osstring = name.to_os_string();
     name_osstring.push("=");
     name_osstring.push(value);
     Ok(ecx.alloc_os_str_as_wide_str(name_osstring.as_os_str(), MiriMemoryKind::Env.into()))
 }
 
-impl<'mir, 'tcx> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
+impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
 pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
     fn getenv(&mut self, name_op: OpTy<'tcx, Tag>) -> InterpResult<'tcx, Scalar<Tag>> {
         let this = self.eval_context_mut();

src/shims/foreign_items.rs

@@ -12,7 +12,7 @@ use rustc_ast::attr;
 
 use crate::*;
 
-impl<'mir, 'tcx> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
+impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
 pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
     /// Returns the minimum alignment for the target architecture for allocations of the given size.
     fn min_align(&self, size: u64, kind: MiriMemoryKind) -> Align {