rust/src/interpreter.rs

490 lines
18 KiB
Rust
Raw Normal View History

use rustc::middle::const_eval;
use rustc::middle::ty::{self, TyCtxt};
2016-02-18 19:06:22 -06:00
use rustc::mir::mir_map::MirMap;
2016-03-07 10:14:47 -06:00
use rustc::mir::repr as mir;
use std::error::Error;
use std::fmt;
use memory::{FieldRepr, Memory, Pointer, Repr};
2016-03-05 00:48:23 -06:00
const TRACE_EXECUTION: bool = true;
#[derive(Clone, Debug)]
pub enum EvalError {
DanglingPointerDeref,
2016-03-07 04:44:03 -06:00
InvalidBool,
PointerOutOfBounds,
}
pub type EvalResult<T> = Result<T, EvalError>;
impl Error for EvalError {
fn description(&self) -> &str {
match *self {
EvalError::DanglingPointerDeref => "dangling pointer was dereferenced",
2016-03-07 04:44:03 -06:00
EvalError::InvalidBool => "invalid boolean value read",
EvalError::PointerOutOfBounds => "pointer offset outside bounds of allocation",
}
}
fn cause(&self) -> Option<&Error> { None }
}
impl fmt::Display for EvalError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
// #[derive(Clone, Debug, PartialEq)]
// enum Value {
// Uninit,
// Bool(bool),
// Int(i64), // FIXME(tsion): Should be bit-width aware.
// Pointer(Pointer),
// Adt { variant: usize, data_ptr: Pointer },
// Func(def_id::DefId),
// }
/// A stack frame.
struct Frame<'a, 'tcx: 'a> {
/// The MIR for the fucntion called on this frame.
2016-03-07 10:14:47 -06:00
mir: &'a mir::Mir<'tcx>,
/// A pointer for writing the return value of the current call, if it's not a diverging call.
return_ptr: Option<Pointer>,
/// The list of locals for the current function, stored in order as
/// `[arguments..., variables..., temporaries...]`. The variables begin at `self.var_offset`
/// and the temporaries at `self.temp_offset`.
locals: Vec<Pointer>,
/// The offset of the first variable in `self.locals`.
var_offset: usize,
/// The offset of the first temporary in `self.locals`.
temp_offset: usize,
}
impl<'a, 'tcx: 'a> Frame<'a, 'tcx> {
fn arg_ptr(&self, i: u32) -> Pointer {
self.locals[i as usize]
}
fn var_ptr(&self, i: u32) -> Pointer {
self.locals[self.var_offset + i as usize]
}
fn temp_ptr(&self, i: u32) -> Pointer {
self.locals[self.temp_offset + i as usize]
}
}
2015-11-19 07:07:47 -06:00
struct Interpreter<'a, 'tcx: 'a> {
tcx: &'a TyCtxt<'tcx>,
2015-11-19 07:07:47 -06:00
mir_map: &'a MirMap<'tcx>,
2016-03-07 10:14:47 -06:00
memory: Memory,
stack: Vec<Frame<'a, 'tcx>>,
}
impl<'a, 'tcx: 'a> Interpreter<'a, 'tcx> {
fn new(tcx: &'a TyCtxt<'tcx>, mir_map: &'a MirMap<'tcx>) -> Self {
Interpreter {
2015-11-19 07:07:47 -06:00
tcx: tcx,
mir_map: mir_map,
2016-03-07 10:14:47 -06:00
memory: Memory::new(),
stack: Vec::new(),
}
}
2016-03-07 10:14:47 -06:00
fn push_stack_frame(&mut self, mir: &'a mir::Mir<'tcx>, args: &[&mir::Operand<'tcx>],
return_ptr: Option<Pointer>) -> EvalResult<()> {
let num_args = mir.arg_decls.len();
let num_vars = mir.var_decls.len();
let num_temps = mir.temp_decls.len();
assert_eq!(args.len(), num_args);
let mut locals = Vec::with_capacity(num_args + num_vars + num_temps);
for (arg_decl, arg_operand) in mir.arg_decls.iter().zip(args) {
let repr = self.ty_to_repr(arg_decl.ty);
2016-03-07 07:19:43 -06:00
let dest = self.memory.allocate(repr.size());
let src = try!(self.operand_to_ptr(arg_operand));
try!(self.memory.copy(src, dest, repr.size()));
locals.push(dest);
}
let var_tys = mir.var_decls.iter().map(|v| v.ty);
let temp_tys = mir.temp_decls.iter().map(|t| t.ty);
2016-03-07 07:19:43 -06:00
locals.extend(var_tys.chain(temp_tys).map(|ty| {
let repr = self.ty_to_repr(ty).size();
self.memory.allocate(repr)
2016-03-07 07:19:43 -06:00
}));
self.stack.push(Frame {
mir: mir,
return_ptr: return_ptr,
locals: locals,
var_offset: num_args,
temp_offset: num_args + num_vars,
});
Ok(())
}
fn pop_stack_frame(&mut self) {
let _frame = self.stack.pop().expect("tried to pop a stack frame, but there were none");
// TODO(tsion): Deallocate local variables.
}
2016-03-07 10:14:47 -06:00
fn call(&mut self, mir: &'a mir::Mir<'tcx>, args: &[&mir::Operand<'tcx>],
return_ptr: Option<Pointer>) -> EvalResult<()> {
try!(self.push_stack_frame(mir, args, return_ptr));
2016-03-07 04:50:44 -06:00
let mut current_block = mir::START_BLOCK;
loop {
2016-03-07 04:50:44 -06:00
if TRACE_EXECUTION { println!("Entering block: {:?}", current_block); }
let block_data = mir.basic_block_data(current_block);
for stmt in &block_data.statements {
if TRACE_EXECUTION { println!("{:?}", stmt); }
let mir::StatementKind::Assign(ref lvalue, ref rvalue) = stmt.kind;
try!(self.eval_assignment(lvalue, rvalue));
}
2016-01-06 21:05:08 -06:00
if TRACE_EXECUTION { println!("{:?}", block_data.terminator()); }
use rustc::mir::repr::Terminator::*;
2016-01-06 21:05:08 -06:00
match *block_data.terminator() {
Return => break,
2016-03-07 04:48:12 -06:00
2016-03-07 04:50:44 -06:00
Goto { target } => current_block = target,
2016-03-07 04:48:12 -06:00
If { ref cond, targets: (then_target, else_target) } => {
let cond_ptr = try!(self.operand_to_ptr(cond));
2016-03-07 08:22:18 -06:00
let cond_val = try!(self.memory.read_bool(cond_ptr));
current_block = if cond_val { then_target } else { else_target };
}
SwitchInt { ref discr, ref values, ref targets, .. } => {
// FIXME(tsion): Handle non-integer switch types.
let discr_ptr = try!(self.lvalue_to_ptr(discr));
let discr_val = try!(self.memory.read_int(discr_ptr));
// Branch to the `otherwise` case by default, if no match is found.
current_block = targets[targets.len() - 1];
for (index, val_const) in values.iter().enumerate() {
let ptr = try!(self.const_to_ptr(val_const));
let val = try!(self.memory.read_int(ptr));
if discr_val == val {
current_block = targets[index];
break;
}
}
2016-03-07 04:48:12 -06:00
}
// Call { ref func, ref args, ref destination, .. } => {
2016-03-07 10:14:47 -06:00
// use rustc::middle::cstore::CrateStore;
// let ptr = destination.as_ref().map(|&(ref lv, _)| self.lvalue_to_ptr(lv));
// let func_val = self.operand_to_ptr(func);
// if let Value::Func(def_id) = func_val {
// let mir_data;
// let mir = match self.tcx.map.as_local_node_id(def_id) {
// Some(node_id) => self.mir_map.map.get(&node_id).unwrap(),
// None => {
// let cstore = &self.tcx.sess.cstore;
// mir_data = cstore.maybe_get_item_mir(self.tcx, def_id).unwrap();
// &mir_data
// }
// };
// let arg_vals: Vec<Value> =
// args.iter().map(|arg| self.operand_to_ptr(arg)).collect();
// self.call(mir, &arg_vals, ptr);
// if let Some((_, target)) = *destination {
2016-03-07 04:50:44 -06:00
// current_block = target;
// }
// } else {
// panic!("tried to call a non-function value: {:?}", func_val);
// }
// }
// Switch { ref discr, ref targets, .. } => {
// let discr_val = self.read_lvalue(discr);
// if let Value::Adt { variant, .. } = discr_val {
2016-03-07 04:50:44 -06:00
// current_block = targets[variant];
// } else {
// panic!("Switch on non-Adt value: {:?}", discr_val);
// }
// }
Drop { target, .. } => {
2016-02-18 19:06:22 -06:00
// TODO: Handle destructors and dynamic drop.
2016-03-07 04:50:44 -06:00
current_block = target;
2016-02-18 19:06:22 -06:00
}
Resume => unimplemented!(),
_ => unimplemented!(),
}
}
self.pop_stack_frame();
Ok(())
}
2016-03-07 07:50:49 -06:00
fn eval_binary_op(&mut self, bin_op: mir::BinOp, left_operand: &mir::Operand<'tcx>,
right_operand: &mir::Operand<'tcx>, dest: Pointer) -> EvalResult<()>
{
2016-03-07 07:48:38 -06:00
// FIXME(tsion): Check for non-integer binary operations.
let left = try!(self.operand_to_ptr(left_operand));
let right = try!(self.operand_to_ptr(right_operand));
let l = try!(self.memory.read_int(left));
let r = try!(self.memory.read_int(right));
use rustc::mir::repr::BinOp::*;
let n = match bin_op {
Add => l + r,
Sub => l - r,
Mul => l * r,
Div => l / r,
Rem => l % r,
BitXor => l ^ r,
BitAnd => l & r,
BitOr => l | r,
Shl => l << r,
Shr => l >> r,
_ => unimplemented!(),
// Eq => Value::Bool(l == r),
// Lt => Value::Bool(l < r),
// Le => Value::Bool(l <= r),
// Ne => Value::Bool(l != r),
// Ge => Value::Bool(l >= r),
// Gt => Value::Bool(l > r),
};
2016-03-07 07:48:38 -06:00
self.memory.write_int(dest, n)
}
fn eval_assignment(&mut self, lvalue: &mir::Lvalue<'tcx>, rvalue: &mir::Rvalue<'tcx>)
-> EvalResult<()>
{
let dest = try!(self.lvalue_to_ptr(lvalue));
let dest_ty = self.current_frame().mir.lvalue_ty(self.tcx, lvalue).to_ty(self.tcx);
let dest_repr = self.ty_to_repr(dest_ty);
use rustc::mir::repr::Rvalue::*;
match *rvalue {
Use(ref operand) => {
let src = try!(self.operand_to_ptr(operand));
self.memory.copy(src, dest, dest_repr.size())
}
2016-03-07 07:48:38 -06:00
BinaryOp(bin_op, ref left, ref right) =>
self.eval_binary_op(bin_op, left, right, dest),
2016-03-07 07:57:08 -06:00
UnaryOp(un_op, ref operand) => {
// FIXME(tsion): Check for non-integer operations.
let ptr = try!(self.operand_to_ptr(operand));
let m = try!(self.memory.read_int(ptr));
use rustc::mir::repr::UnOp::*;
let n = match un_op {
Not => !m,
Neg => -m,
};
self.memory.write_int(dest, n)
}
Aggregate(ref _kind, ref operands) => {
// TODO(tsion): Handle different `kind` variants.
// let max_fields = adt_def.variants
// .iter()
// .map(|v| v.fields.len())
// .max()
// .unwrap_or(0);
// let ptr = self.allocate_aggregate(max_fields);
// for (i, operand) in operands.iter().enumerate() {
// let val = self.operand_to_ptr(operand);
// self.write_pointer(ptr.offset(i), val);
// }
// Value::Adt { variant: variant, data_ptr: ptr }
match dest_repr {
Repr::Aggregate { ref fields, .. } => {
for (field, operand) in fields.iter().zip(operands) {
let src = try!(self.operand_to_ptr(operand));
try!(self.memory.copy(src, dest.offset(field.offset),
field.repr.size()));
}
Ok(())
}
_ => unimplemented!(),
}
}
// Ref(_region, _kind, ref lvalue) => {
// Value::Pointer(self.lvalue_to_ptr(lvalue))
// }
2015-12-28 22:24:05 -06:00
ref r => panic!("can't handle rvalue: {:?}", r),
}
}
fn operand_to_ptr(&mut self, op: &mir::Operand<'tcx>) -> EvalResult<Pointer> {
use rustc::mir::repr::Operand::*;
match *op {
Consume(ref lvalue) => self.lvalue_to_ptr(lvalue),
Constant(ref constant) => {
use rustc::mir::repr::Literal::*;
match constant.literal {
Value { ref value } => self.const_to_ptr(value),
2016-03-12 20:23:48 -06:00
ref l => panic!("can't handle item literal: {:?}", l),
}
}
}
}
2015-11-12 17:44:29 -06:00
2016-03-07 07:48:38 -06:00
fn lvalue_to_ptr(&self, lvalue: &mir::Lvalue<'tcx>) -> EvalResult<Pointer> {
let frame = self.current_frame();
use rustc::mir::repr::Lvalue::*;
let ptr = match *lvalue {
ReturnPointer =>
frame.return_ptr.expect("ReturnPointer used in a function with no return value"),
Arg(i) => frame.arg_ptr(i),
Var(i) => frame.var_ptr(i),
Temp(i) => frame.temp_ptr(i),
ref l => panic!("can't handle lvalue: {:?}", l),
};
Ok(ptr)
// mir::Lvalue::Projection(ref proj) => {
// let base_ptr = self.lvalue_to_ptr(&proj.base);
// match proj.elem {
// mir::ProjectionElem::Field(field, _) => {
// base_ptr.offset(field.index())
// }
// mir::ProjectionElem::Downcast(_, variant) => {
// let adt_val = self.read_pointer(base_ptr);
// if let Value::Adt { variant: actual_variant, data_ptr } = adt_val {
// debug_assert_eq!(variant, actual_variant);
// data_ptr
// } else {
// panic!("Downcast attempted on non-ADT: {:?}", adt_val)
// }
// }
// mir::ProjectionElem::Deref => {
// let ptr_val = self.read_pointer(base_ptr);
// if let Value::Pointer(ptr) = ptr_val {
// ptr
// } else {
// panic!("Deref attempted on non-pointer: {:?}", ptr_val)
// }
// }
// mir::ProjectionElem::Index(ref _operand) => unimplemented!(),
// mir::ProjectionElem::ConstantIndex { .. } => unimplemented!(),
// }
// }
// _ => unimplemented!(),
// }
}
2016-03-05 00:45:54 -06:00
fn const_to_ptr(&mut self, const_val: &const_eval::ConstVal) -> EvalResult<Pointer> {
use rustc::middle::const_eval::ConstVal::*;
2015-11-12 17:44:29 -06:00
match *const_val {
2016-03-07 04:44:03 -06:00
Float(_f) => unimplemented!(),
Int(n) => {
2016-03-07 07:19:43 -06:00
let ptr = self.memory.allocate(Repr::Int.size());
try!(self.memory.write_int(ptr, n));
2016-03-05 00:45:54 -06:00
Ok(ptr)
}
Uint(_u) => unimplemented!(),
Str(ref _s) => unimplemented!(),
ByteStr(ref _bs) => unimplemented!(),
2016-03-07 04:44:03 -06:00
Bool(b) => {
2016-03-07 07:19:43 -06:00
let ptr = self.memory.allocate(Repr::Bool.size());
try!(self.memory.write_bool(ptr, b));
2016-03-07 04:44:03 -06:00
Ok(ptr)
},
Struct(_node_id) => unimplemented!(),
Tuple(_node_id) => unimplemented!(),
Function(_def_id) => unimplemented!(),
Array(_, _) => unimplemented!(),
Repeat(_, _) => unimplemented!(),
2015-11-12 17:44:29 -06:00
}
}
fn make_aggregate_repr<I>(&self, iter: I) -> Repr where I: IntoIterator<Item = ty::Ty<'tcx>> {
let mut size = 0;
let fields = iter.into_iter().map(|ty| {
let repr = self.ty_to_repr(ty);
let old_size = size;
size += repr.size();
FieldRepr { offset: old_size, repr: repr }
}).collect();
Repr::Aggregate { size: size, fields: fields }
}
// TODO(tsion): Cache these outputs.
fn ty_to_repr(&self, ty: ty::Ty<'tcx>) -> Repr {
match ty.sty {
ty::TyBool => Repr::Bool,
ty::TyInt(_) => Repr::Int,
ty::TyTuple(ref fields) => self.make_aggregate_repr(fields.iter().cloned()),
ty::TyEnum(adt_def, ref subst) | ty::TyStruct(adt_def, ref subst) => {
// TODO(tsion): Support multi-variant enums.
assert!(adt_def.variants.len() == 1);
let field_tys = adt_def.variants[0].fields.iter().map(|f| f.ty(self.tcx, subst));
self.make_aggregate_repr(field_tys)
}
ref t => panic!("can't convert type to repr: {:?}", t),
}
}
fn current_frame(&self) -> &Frame<'a, 'tcx> {
self.stack.last().expect("no call frames exist")
}
}
pub fn interpret_start_points<'tcx>(tcx: &TyCtxt<'tcx>, mir_map: &MirMap<'tcx>) {
2016-02-18 19:06:22 -06:00
for (&id, mir) in &mir_map.map {
for attr in tcx.map.attrs(id) {
2016-03-07 10:14:47 -06:00
use syntax::attr::AttrMetaMethods;
if attr.check_name("miri_run") {
2015-11-12 17:11:41 -06:00
let item = tcx.map.expect_item(id);
println!("Interpreting: {}", item.name);
let mut miri = Interpreter::new(tcx, mir_map);
let return_ptr = match mir.return_ty {
ty::FnConverging(ty) => {
let repr = miri.ty_to_repr(ty).size();
Some(miri.memory.allocate(repr))
}
ty::FnDiverging => None,
};
miri.call(mir, &[], return_ptr).unwrap();
2015-11-12 17:11:41 -06:00
if let Some(ret) = return_ptr {
println!("Returned: {:?}\n", miri.memory.get(ret.alloc_id).unwrap());
2015-11-12 17:11:41 -06:00
}
}
}
}
}