miri/lib.rs

   1 #![feature(
   2     i128_type,
   3     rustc_private,
   4 )]
   5
   6 // From rustc.
   7 #[macro_use]
   8 extern crate log;
   9 extern crate log_settings;
  10 #[macro_use]
  11 extern crate rustc;
  12 extern crate rustc_const_math;
  13 extern crate rustc_data_structures;
  14 extern crate syntax;
  15
  16 use rustc::ty::{self, TyCtxt};
  17 use rustc::ty::layout::Layout;
  18 use rustc::hir::def_id::DefId;
  19 use rustc::mir;
  20
  21 use syntax::codemap::Span;
  22
  23 use std::collections::{
  24     HashMap,
  25     BTreeMap,
  26 };
  27
  28 extern crate rustc_miri;
  29 pub use rustc_miri::interpret::*;
  30
  31 mod fn_call;
  32 mod operator;
  33 mod intrinsic;
  34 mod helpers;
  35 mod memory;
  36 mod tls;
  37
  38 use fn_call::EvalContextExt as MissingFnsEvalContextExt;
  39 use operator::EvalContextExt as OperatorEvalContextExt;
  40 use intrinsic::EvalContextExt as IntrinsicEvalContextExt;
  41 use tls::MemoryExt as TlsMemoryExt;
  42
  43 pub fn eval_main<'a, 'tcx: 'a>(
  44     tcx: TyCtxt<'a, 'tcx, 'tcx>,
  45     main_id: DefId,
  46     start_wrapper: Option<DefId>,
  47     limits: ResourceLimits,
  48 ) {
  49     fn run_main<'a, 'tcx: 'a>(
  50         ecx: &mut rustc_miri::interpret::EvalContext<'a, 'tcx, Evaluator>,
  51         main_id: DefId,
  52         start_wrapper: Option<DefId>,
  53     ) -> EvalResult<'tcx> {
  54         let main_instance = ty::Instance::mono(ecx.tcx, main_id);
  55         let main_mir = ecx.load_mir(main_instance.def)?;
  56         let mut cleanup_ptr = None; // Pointer to be deallocated when we are done
  57
  58         if !main_mir.return_ty.is_nil() || main_mir.arg_count != 0 {
  59             return Err(EvalError::Unimplemented("miri does not support main functions without `fn()` type signatures".to_owned()));
  60         }
  61
  62         if let Some(start_id) = start_wrapper {
  63             let start_instance = ty::Instance::mono(ecx.tcx, start_id);
  64             let start_mir = ecx.load_mir(start_instance.def)?;
  65
  66             if start_mir.arg_count != 3 {
  67                 return Err(EvalError::AbiViolation(format!("'start' lang item should have three arguments, but has {}", start_mir.arg_count)));
  68             }
  69
  70             // Return value
  71             let size = ecx.tcx.data_layout.pointer_size.bytes();
  72             let align = ecx.tcx.data_layout.pointer_align.abi();
  73             let ret_ptr = ecx.memory_mut().allocate(size, align, Kind::Stack)?;
  74             cleanup_ptr = Some(ret_ptr);
  75
  76             // Push our stack frame
  77             ecx.push_stack_frame(
  78                 start_instance,
  79                 start_mir.span,
  80                 start_mir,
  81                 Lvalue::from_ptr(ret_ptr),
  82                 StackPopCleanup::None,
  83             )?;
  84
  85             let mut args = ecx.frame().mir.args_iter();
  86
  87             // First argument: pointer to main()
  88             let main_ptr = ecx.memory_mut().create_fn_alloc(main_instance);
  89             let dest = ecx.eval_lvalue(&mir::Lvalue::Local(args.next().unwrap()))?;
  90             let main_ty = main_instance.def.def_ty(ecx.tcx);
  91             let main_ptr_ty = ecx.tcx.mk_fn_ptr(main_ty.fn_sig(ecx.tcx));
  92             ecx.write_value(Value::ByVal(PrimVal::Ptr(main_ptr)), dest, main_ptr_ty)?;
  93
  94             // Second argument (argc): 0
  95             let dest = ecx.eval_lvalue(&mir::Lvalue::Local(args.next().unwrap()))?;
  96             let ty = ecx.tcx.types.isize;
  97             ecx.write_null(dest, ty)?;
  98
  99             // Third argument (argv): 0
 100             let dest = ecx.eval_lvalue(&mir::Lvalue::Local(args.next().unwrap()))?;
 101             let ty = ecx.tcx.mk_imm_ptr(ecx.tcx.mk_imm_ptr(ecx.tcx.types.u8));
 102             ecx.write_null(dest, ty)?;
 103         } else {
 104             ecx.push_stack_frame(
 105                 main_instance,
 106                 main_mir.span,
 107                 main_mir,
 108                 Lvalue::undef(),
 109                 StackPopCleanup::None,
 110             )?;
 111         }
 112
 113         while ecx.step()? {}
 114         ecx.finish()?;
 115         if let Some(cleanup_ptr) = cleanup_ptr {
 116             ecx.memory_mut().deallocate(cleanup_ptr, None, Kind::Stack)?;
 117         }
 118         Ok(())
 119     }
 120
 121     let mut ecx = EvalContext::new(tcx, limits, Default::default(), Default::default());
 122     match run_main(&mut ecx, main_id, start_wrapper) {
 123         Ok(()) => {
 124             let leaks = ecx.memory().leak_report();
 125             if leaks != 0 {
 126                 tcx.sess.err("the evaluated program leaked memory");
 127             }
 128         }
 129         Err(e) => {
 130             ecx.report(&e);
 131         }
 132     }
 133 }
 134
 135 struct Evaluator;
 136 #[derive(Default)]
 137 struct EvaluatorData {
 138     /// Environment variables set by `setenv`
 139     /// Miri does not expose env vars from the host to the emulated program
 140     pub(crate) env_vars: HashMap<Vec<u8>, MemoryPointer>,
 141 }
 142
 143 pub type TlsKey = usize;
 144
 145 #[derive(Copy, Clone, Debug)]
 146 pub struct TlsEntry<'tcx> {
 147     data: Pointer, // Will eventually become a map from thread IDs to `Pointer`s, if we ever support more than one thread.
 148     dtor: Option<ty::Instance<'tcx>>,
 149 }
 150
 151 #[derive(Default)]
 152 struct MemoryData<'tcx> {
 153     /// The Key to use for the next thread-local allocation.
 154     next_thread_local: TlsKey,
 155
 156     /// pthreads-style thread-local storage.
 157     thread_local: BTreeMap<TlsKey, TlsEntry<'tcx>>,
 158 }
 159
 160 trait EvalContextExt<'tcx> {
 161     fn finish(&mut self) -> EvalResult<'tcx>;
 162 }
 163
 164 impl<'a, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'tcx, Evaluator> {
 165     fn finish(&mut self) -> EvalResult<'tcx> {
 166         let mut dtor = self.memory.fetch_tls_dtor(None)?;
 167         // FIXME: replace loop by some structure that works with stepping
 168         while let Some((instance, ptr, key)) = dtor {
 169             trace!("Running TLS dtor {:?} on {:?}", instance, ptr);
 170             // TODO: Potentially, this has to support all the other possible instances?
 171             // See eval_fn_call in interpret/terminator/mod.rs
 172             let mir = self.load_mir(instance.def)?;
 173             self.push_stack_frame(
 174                 instance,
 175                 mir.span,
 176                 mir,
 177                 Lvalue::undef(),
 178                 StackPopCleanup::None,
 179             )?;
 180             let arg_local = self.frame().mir.args_iter().next().ok_or(EvalError::AbiViolation("TLS dtor does not take enough arguments.".to_owned()))?;
 181             let dest = self.eval_lvalue(&mir::Lvalue::Local(arg_local))?;
 182             let ty = self.tcx.mk_mut_ptr(self.tcx.types.u8);
 183             self.write_ptr(dest, ptr, ty)?;
 184
 185             // step until out of stackframes
 186             while self.step()? {}
 187
 188             dtor = match self.memory.fetch_tls_dtor(Some(key))? {
 189                 dtor @ Some(_) => dtor,
 190                 None => self.memory.fetch_tls_dtor(None)?,
 191             };
 192         }
 193         Ok(())
 194     }
 195 }
 196
 197 impl<'tcx> Machine<'tcx> for Evaluator {
 198     type Data = EvaluatorData;
 199     type MemoryData = MemoryData<'tcx>;
 200     type MemoryKinds = memory::Kind;
 201
 202     /// Returns Ok() when the function was handled, fail otherwise
 203     fn eval_fn_call<'a>(
 204         ecx: &mut EvalContext<'a, 'tcx, Self>,
 205         instance: ty::Instance<'tcx>,
 206         destination: Option<(Lvalue<'tcx>, mir::BasicBlock)>,
 207         arg_operands: &[mir::Operand<'tcx>],
 208         span: Span,
 209         sig: ty::FnSig<'tcx>,
 210     ) -> EvalResult<'tcx, bool> {
 211         ecx.eval_fn_call(instance, destination, arg_operands, span, sig)
 212     }
 213
 214     fn call_intrinsic<'a>(
 215         ecx: &mut rustc_miri::interpret::EvalContext<'a, 'tcx, Self>,
 216         instance: ty::Instance<'tcx>,
 217         args: &[mir::Operand<'tcx>],
 218         dest: Lvalue<'tcx>,
 219         dest_ty: ty::Ty<'tcx>,
 220         dest_layout: &'tcx Layout,
 221         target: mir::BasicBlock,
 222     ) -> EvalResult<'tcx> {
 223         ecx.call_intrinsic(instance, args, dest, dest_ty, dest_layout, target)
 224     }
 225
 226     fn ptr_op<'a>(
 227         ecx: &rustc_miri::interpret::EvalContext<'a, 'tcx, Self>,
 228         bin_op: mir::BinOp,
 229         left: PrimVal,
 230         left_ty: ty::Ty<'tcx>,
 231         right: PrimVal,
 232         right_ty: ty::Ty<'tcx>,
 233     ) -> EvalResult<'tcx, Option<(PrimVal, bool)>> {
 234         ecx.ptr_op(bin_op, left, left_ty, right, right_ty)
 235     }
 236
 237     fn mark_static_initialized(m: memory::Kind) -> EvalResult<'tcx> {
 238         use memory::Kind::*;
 239         match m {
 240             // FIXME: This could be allowed, but not for env vars set during miri execution
 241             Env => Err(EvalError::Unimplemented("statics can't refer to env vars".to_owned())),
 242             _ => Ok(()),
 243         }
 244     }
 245
 246     fn box_alloc<'a>(
 247         ecx: &mut EvalContext<'a, 'tcx, Self>,
 248         ty: ty::Ty<'tcx>,
 249     ) -> EvalResult<'tcx, PrimVal> {
 250         // FIXME: call the `exchange_malloc` lang item if available
 251         let size = ecx.type_size(ty)?.expect("box only works with sized types");
 252         let align = ecx.type_align(ty)?;
 253         if size == 0 {
 254             Ok(PrimVal::Bytes(align.into()))
 255         } else {
 256             ecx.memory
 257                 .allocate(size, align, Kind::Machine(memory::Kind::Rust))
 258                 .map(PrimVal::Ptr)
 259         }
 260     }
 261 }