Work with MIR-libstd

README.md

@@ -54,6 +54,29 @@ Then, inside your own project, use `cargo +nightly miri` to run your project, if
 a bin project, or run `cargo +nightly miri test` to run all tests in your project
 through miri.
 
+## Running miri with full libstd
+
+Per default libstd does not contain the MIR of non-polymorphic functions.  When
+miri hits a call to such a function, execution terminates.  To fix this, it is
+possible to compile libstd with full MIR:
+
+```sh
+rustup component add rust-src
+chmod +x -R ~/.rustup/toolchains/*/lib/rustlib/src/rust/src/jemalloc/include/jemalloc/
+cargo install xargo
+cd xargo/
+RUSTFLAGS='-Zalways-encode-mir' xargo build
+```
+
+Now you can run miri against the libstd compiled by xargo:
+
+```sh
+cargo run --bin miri -- --sysroot ~/.xargo/HOST tests/run-pass/vecs.rs
+```
+
+Notice that you will have to re-run the last step of the preparations above when
+your toolchain changes (e.g., when you update the nightly).
+
 ## Contributing and getting help
 
 Check out the issues on this GitHub repository for some ideas. There's lots that

src/bin/miri.rs

@@ -84,7 +84,7 @@ fn after_analysis<'a, 'tcx>(state: &mut CompileState<'a, 'tcx>) {
                     if i.attrs.iter().any(|attr| attr.name().map_or(false, |n| n == "test")) {
                         let did = self.1.hir.body_owner_def_id(body_id);
                         println!("running test: {}", self.1.hir.def_path(did).to_string(self.1));
-                        miri::eval_main(self.1, did, self.0);
+                        miri::eval_main(self.1, did, None, self.0);
                         self.2.session.abort_if_errors();
                     }
                 }
@@ -95,7 +95,9 @@ fn after_analysis<'a, 'tcx>(state: &mut CompileState<'a, 'tcx>) {
         state.hir_crate.unwrap().visit_all_item_likes(&mut Visitor(limits, tcx, state));
     } else if let Some((entry_node_id, _)) = *state.session.entry_fn.borrow() {
         let entry_def_id = tcx.hir.local_def_id(entry_node_id);
-        miri::eval_main(tcx, entry_def_id, limits);
+        let start_wrapper = tcx.lang_items.start_fn().and_then(|start_fn|
+                                if tcx.is_mir_available(start_fn) { Some(start_fn) } else { None });
+        miri::eval_main(tcx, entry_def_id, start_wrapper, limits);
 
         state.session.abort_if_errors();
     } else {

src/error.rs

@@ -38,6 +38,9 @@ pub enum EvalError<'tcx> {
     },
     ExecutionTimeLimitReached,
     StackFrameLimitReached,
+    OutOfTls,
+    TlsOutOfBounds,
+    AbiViolation(String),
     AlignmentCheckFailed {
         required: u64,
         has: u64,
@@ -101,6 +104,11 @@ impl<'tcx> Error for EvalError<'tcx> {
                 "reached the configured maximum execution time",
             EvalError::StackFrameLimitReached =>
                 "reached the configured maximum number of stack frames",
+            EvalError::OutOfTls =>
+                "reached the maximum number of representable TLS keys",
+            EvalError::TlsOutOfBounds =>
+                "accessed an invalid (unallocated) TLS key",
+            EvalError::AbiViolation(ref msg) => msg,
             EvalError::AlignmentCheckFailed{..} =>
                 "tried to execute a misaligned read or write",
             EvalError::CalledClosureAsFunction =>

src/eval_context.rs

@@ -126,6 +126,7 @@ impl Default for ResourceLimits {
 
 impl<'a, 'tcx> EvalContext<'a, 'tcx> {
     pub fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>, limits: ResourceLimits) -> Self {
+        // Register array drop glue code
         let source_info = mir::SourceInfo {
             span: DUMMY_SP,
             scope: mir::ARGUMENT_VISIBILITY_SCOPE
@@ -852,7 +853,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                             let fn_ptr = self.memory.create_fn_alloc(instance);
                             self.write_value(Value::ByVal(PrimVal::Ptr(fn_ptr)), dest, dest_ty)?;
                         },
-                        ref other => bug!("reify fn pointer on {:?}", other),
+                        ref other => bug!("closure fn pointer on {:?}", other),
                     },
                 }
             }
@@ -1557,6 +1558,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
     }
 
     pub(super) fn dump_local(&self, lvalue: Lvalue<'tcx>) {
+        // Debug output
         if let Lvalue::Local { frame, local, field } = lvalue {
             let mut allocs = Vec::new();
             let mut msg = format!("{:?}", local);
@@ -1676,62 +1678,113 @@ impl<'tcx> Frame<'tcx> {
 
 pub fn eval_main<'a, 'tcx: 'a>(
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
-    def_id: DefId,
+    main_id: DefId,
+    start_wrapper: Option<DefId>,
     limits: ResourceLimits,
 ) {
-    let mut ecx = EvalContext::new(tcx, limits);
-    let instance = ty::Instance::mono(tcx, def_id);
-    let mir = ecx.load_mir(instance.def).expect("main function's MIR not found");
-
-    if !mir.return_ty.is_nil() || mir.arg_count != 0 {
-        let msg = "miri does not support main functions without `fn()` type signatures";
-        tcx.sess.err(&EvalError::Unimplemented(String::from(msg)).to_string());
-        return;
-    }
-
-    ecx.push_stack_frame(
-        instance,
-        DUMMY_SP,
-        mir,
-        Lvalue::from_ptr(Pointer::zst_ptr()),
-        StackPopCleanup::None,
-    ).expect("could not allocate first stack frame");
-
-    loop {
-        match ecx.step() {
-            Ok(true) => {}
-            Ok(false) => {
-                let leaks = ecx.memory.leak_report();
-                if leaks != 0 {
-                    tcx.sess.err("the evaluated program leaked memory");
-                }
-                return;
+    fn run_main<'a, 'tcx: 'a>(
+        ecx: &mut EvalContext<'a, 'tcx>,
+        main_id: DefId,
+        start_wrapper: Option<DefId>,
+    ) -> EvalResult<'tcx> {
+        let main_instance = ty::Instance::mono(ecx.tcx, main_id);
+        let main_mir = ecx.load_mir(main_instance.def)?;
+        let mut cleanup_ptr = None; // Pointer to be deallocated when we are done
+
+        if !main_mir.return_ty.is_nil() || main_mir.arg_count != 0 {
+            return Err(EvalError::Unimplemented("miri does not support main functions without `fn()` type signatures".to_owned()));
+        }
+
+        if let Some(start_id) = start_wrapper {
+            let start_instance = ty::Instance::mono(ecx.tcx, start_id);
+            let start_mir = ecx.load_mir(start_instance.def)?;
+
+            if start_mir.arg_count != 3 {
+                return Err(EvalError::AbiViolation(format!("'start' lang item should have three arguments, but has {}", start_mir.arg_count)));
             }
-            Err(e) => {
-                report(tcx, &ecx, e);
-                return;
+
+            // Return value
+            let ret_ptr = ecx.memory.allocate(ecx.tcx.data_layout.pointer_size.bytes(), ecx.tcx.data_layout.pointer_align.abi())?;
+            cleanup_ptr = Some(ret_ptr);
+
+            // Push our stack frame
+            ecx.push_stack_frame(
+                start_instance,
+                start_mir.span,
+                start_mir,
+                Lvalue::from_ptr(ret_ptr),
+                StackPopCleanup::None,
+            )?;
+
+            let mut args = ecx.frame().mir.args_iter();
+
+            // First argument: pointer to main()
+            let main_ptr = ecx.memory.create_fn_alloc(main_instance);
+            let dest = ecx.eval_lvalue(&mir::Lvalue::Local(args.next().unwrap()))?;
+            let main_ty = main_instance.def.def_ty(ecx.tcx);
+            let main_ptr_ty = ecx.tcx.mk_fn_ptr(main_ty.fn_sig());
+            ecx.write_value(Value::ByVal(PrimVal::Ptr(main_ptr)), dest, main_ptr_ty)?;
+
+            // Second argument (argc): 0
+            let dest = ecx.eval_lvalue(&mir::Lvalue::Local(args.next().unwrap()))?;
+            let ty = ecx.tcx.types.isize;
+            ecx.write_value(Value::ByVal(PrimVal::Bytes(0)), dest, ty)?;
+
+            // Third argument (argv): 0
+            let dest = ecx.eval_lvalue(&mir::Lvalue::Local(args.next().unwrap()))?;
+            let ty = ecx.tcx.mk_imm_ptr(ecx.tcx.mk_imm_ptr(ecx.tcx.types.u8));
+            ecx.write_value(Value::ByVal(PrimVal::Bytes(0)), dest, ty)?;
+        } else {
+            ecx.push_stack_frame(
+                main_instance,
+                main_mir.span,
+                main_mir,
+                Lvalue::from_ptr(Pointer::zst_ptr()),
+                StackPopCleanup::None,
+            )?;
+        }
+
+        while ecx.step()? {}
+        if let Some(cleanup_ptr) = cleanup_ptr {
+            ecx.memory.deallocate(cleanup_ptr)?;
+        }
+        return Ok(());
+    }
+
+    let mut ecx = EvalContext::new(tcx, limits);
+    match run_main(&mut ecx, main_id, start_wrapper) {
+        Ok(()) => {
+            let leaks = ecx.memory.leak_report();
+            if leaks != 0 {
+                tcx.sess.err("the evaluated program leaked memory");
             }
         }
+        Err(e) => {
+            report(tcx, &ecx, e);
+        }
     }
 }
 
 fn report(tcx: TyCtxt, ecx: &EvalContext, e: EvalError) {
-    let frame = ecx.stack().last().expect("stackframe was empty");
-    let block = &frame.mir.basic_blocks()[frame.block];
-    let span = if frame.stmt < block.statements.len() {
-        block.statements[frame.stmt].source_info.span
-    } else {
-        block.terminator().source_info.span
-    };
-    let mut err = tcx.sess.struct_span_err(span, &e.to_string());
-    for &Frame { instance, span, .. } in ecx.stack().iter().rev() {
-        if tcx.def_key(instance.def_id()).disambiguated_data.data == DefPathData::ClosureExpr {
-            err.span_note(span, "inside call to closure");
-            continue;
+    if let Some(frame) = ecx.stack().last() {
+        let block = &frame.mir.basic_blocks()[frame.block];
+        let span = if frame.stmt < block.statements.len() {
+            block.statements[frame.stmt].source_info.span
+        } else {
+            block.terminator().source_info.span
+        };
+        let mut err = tcx.sess.struct_span_err(span, &e.to_string());
+        for &Frame { instance, span, .. } in ecx.stack().iter().rev() {
+            if tcx.def_key(instance.def_id()).disambiguated_data.data == DefPathData::ClosureExpr {
+                err.span_note(span, "inside call to closure");
+                continue;
+            }
+            err.span_note(span, &format!("inside call to {}", instance));
         }
-        err.span_note(span, &format!("inside call to {}", instance));
+        err.emit();
+    } else {
+        tcx.sess.err(&e.to_string());
     }
-    err.emit();
 }
 
 // TODO(solson): Upstream these methods into rustc::ty::layout.

src/lvalue.rs

@@ -104,6 +104,15 @@ impl<'tcx> Global<'tcx> {
             initialized: false,
         }
     }
+
+    pub(super) fn initialized(ty: Ty<'tcx>, value: Value, mutable: bool) -> Self {
+        Global {
+            value,
+            mutable,
+            ty,
+            initialized: true,
+        }
+    }
 }
 
 impl<'a, 'tcx> EvalContext<'a, 'tcx> {

src/memory.rs

@@ -98,6 +98,18 @@ impl Pointer {
     pub fn never_ptr() -> Self {
         Pointer::new(NEVER_ALLOC_ID, 0)
     }
+
+    pub fn is_null_ptr(&self) -> bool {
+        return *self == Pointer::from_int(0)
+    }
+}
+
+pub type TlsKey = usize;
+
+#[derive(Copy, Clone, Debug)]
+pub struct TlsEntry<'tcx> {
+    data: Pointer, // will eventually become a map from thread IDs to pointers
+    dtor: Option<ty::Instance<'tcx>>,
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -149,6 +161,12 @@ pub struct Memory<'a, 'tcx> {
     /// A cache for basic byte allocations keyed by their contents. This is used to deduplicate
     /// allocations for string and bytestring literals.
     literal_alloc_cache: HashMap<Vec<u8>, AllocId>,
+
+    /// pthreads-style Thread-local storage.  We only have one thread, so this is just a map from TLS keys (indices into the vector) to the pointer stored there.
+    thread_local: HashMap<TlsKey, TlsEntry<'tcx>>,
+
+    /// The Key to use for the next thread-local allocation.
+    next_thread_local: TlsKey,
 }
 
 const ZST_ALLOC_ID: AllocId = AllocId(0);
@@ -167,6 +185,8 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
             packed: BTreeSet::new(),
             static_alloc: HashSet::new(),
             literal_alloc_cache: HashMap::new(),
+            thread_local: HashMap::new(),
+            next_thread_local: 0,
         }
     }
 
@@ -345,6 +365,59 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
     pub(crate) fn clear_packed(&mut self) {
         self.packed.clear();
     }
+
+    pub(crate) fn create_tls_key(&mut self, dtor: Option<ty::Instance<'tcx>>) -> TlsKey {
+        let new_key = self.next_thread_local;
+        self.next_thread_local += 1;
+        self.thread_local.insert(new_key, TlsEntry { data: Pointer::from_int(0), dtor });
+        trace!("New TLS key allocated: {} with dtor {:?}", new_key, dtor);
+        return new_key;
+    }
+
+    pub(crate) fn delete_tls_key(&mut self, key: TlsKey) -> EvalResult<'tcx> {
+        return match self.thread_local.remove(&key) {
+            Some(_) => {
+                trace!("TLS key {} removed", key);
+                Ok(())
+            },
+            None => Err(EvalError::TlsOutOfBounds)
+        }
+    }
+
+    pub(crate) fn load_tls(&mut self, key: TlsKey) -> EvalResult<'tcx, Pointer> {
+        return match self.thread_local.get(&key) {
+            Some(&TlsEntry { data, .. }) => {
+                trace!("TLS key {} loaded: {:?}", key, data);
+                Ok(data)
+            },
+            None => Err(EvalError::TlsOutOfBounds)
+        }
+    }
+
+    pub(crate) fn store_tls(&mut self, key: TlsKey, new_data: Pointer) -> EvalResult<'tcx> {
+        return match self.thread_local.get_mut(&key) {
+            Some(&mut TlsEntry { ref mut data, .. }) => {
+                trace!("TLS key {} stored: {:?}", key, new_data);
+                *data = new_data;
+                Ok(())
+            },
+            None => Err(EvalError::TlsOutOfBounds)
+        }
+    }
+
+    // Returns a dtor and its argument, if one is supposed to run
+    pub(crate) fn fetch_tls_dtor(&mut self) -> Option<(ty::Instance<'tcx>, Pointer)> {
+        for (_, &mut TlsEntry { ref mut data, dtor }) in self.thread_local.iter_mut() {
+            if !data.is_null_ptr() {
+                if let Some(dtor) = dtor {
+                    let old_data = *data;
+                    *data = Pointer::from_int(0);
+                    return Some((dtor, old_data));
+                }
+            }
+        }
+        return None;
+    }
 }
 
 // The derived `Ord` impl sorts first by the first field, then, if the fields are the same