2016-03-04 23:17:31 -06:00
|
|
|
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;
|
2016-02-28 01:07:03 -06:00
|
|
|
use std::error::Error;
|
|
|
|
use std::fmt;
|
2015-11-12 15:50:58 -06:00
|
|
|
|
2016-03-11 21:27:54 -06:00
|
|
|
use memory::{FieldRepr, Memory, Pointer, Repr};
|
2016-03-05 00:23:37 -06:00
|
|
|
|
2016-03-05 00:48:23 -06:00
|
|
|
const TRACE_EXECUTION: bool = true;
|
2016-02-27 19:20:25 -06:00
|
|
|
|
2016-02-28 01:07:03 -06:00
|
|
|
#[derive(Clone, Debug)]
|
2016-03-04 23:17:31 -06:00
|
|
|
pub enum EvalError {
|
2016-03-05 00:23:37 -06:00
|
|
|
DanglingPointerDeref,
|
2016-03-07 04:44:03 -06:00
|
|
|
InvalidBool,
|
2016-03-05 00:23:37 -06:00
|
|
|
PointerOutOfBounds,
|
2016-03-04 23:17:31 -06:00
|
|
|
}
|
2016-02-28 01:07:03 -06:00
|
|
|
|
|
|
|
pub type EvalResult<T> = Result<T, EvalError>;
|
|
|
|
|
|
|
|
impl Error for EvalError {
|
|
|
|
fn description(&self) -> &str {
|
2016-03-05 00:23:37 -06:00
|
|
|
match *self {
|
|
|
|
EvalError::DanglingPointerDeref => "dangling pointer was dereferenced",
|
2016-03-07 04:44:03 -06:00
|
|
|
EvalError::InvalidBool => "invalid boolean value read",
|
2016-03-05 00:23:37 -06:00
|
|
|
EvalError::PointerOutOfBounds => "pointer offset outside bounds of allocation",
|
|
|
|
}
|
2016-02-28 01:07:03 -06:00
|
|
|
}
|
|
|
|
|
2016-03-05 00:23:37 -06:00
|
|
|
fn cause(&self) -> Option<&Error> { None }
|
2016-02-28 01:07:03 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
impl fmt::Display for EvalError {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
|
|
write!(f, "{}", self.description())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-02-27 19:20:25 -06:00
|
|
|
// #[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),
|
|
|
|
// }
|
2015-11-21 01:07:32 -06:00
|
|
|
|
2016-03-06 04:23:24 -06:00
|
|
|
/// A stack frame.
|
2016-03-07 07:10:52 -06:00
|
|
|
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>,
|
2016-03-07 07:10:52 -06:00
|
|
|
|
2016-03-06 04:23:24 -06:00
|
|
|
/// A pointer for writing the return value of the current call, if it's not a diverging call.
|
|
|
|
return_ptr: Option<Pointer>,
|
2016-02-27 19:20:25 -06:00
|
|
|
|
2016-03-06 04:23:24 -06:00
|
|
|
/// 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>,
|
2016-02-27 19:20:25 -06:00
|
|
|
|
2016-03-06 04:23:24 -06:00
|
|
|
/// The offset of the first variable in `self.locals`.
|
|
|
|
var_offset: usize,
|
2016-02-27 19:20:25 -06:00
|
|
|
|
2016-03-06 04:23:24 -06:00
|
|
|
/// The offset of the first temporary in `self.locals`.
|
|
|
|
temp_offset: usize,
|
|
|
|
}
|
2016-02-27 19:20:25 -06:00
|
|
|
|
2016-03-07 07:10:52 -06:00
|
|
|
impl<'a, 'tcx: 'a> Frame<'a, 'tcx> {
|
2016-03-06 04:23:24 -06:00
|
|
|
fn arg_ptr(&self, i: u32) -> Pointer {
|
2016-03-07 07:10:52 -06:00
|
|
|
self.locals[i as usize]
|
2016-03-06 04:23:24 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
fn var_ptr(&self, i: u32) -> Pointer {
|
2016-03-07 07:10:52 -06:00
|
|
|
self.locals[self.var_offset + i as usize]
|
2016-03-06 04:23:24 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
fn temp_ptr(&self, i: u32) -> Pointer {
|
2016-03-07 07:10:52 -06:00
|
|
|
self.locals[self.temp_offset + i as usize]
|
2016-03-06 04:23:24 -06:00
|
|
|
}
|
|
|
|
}
|
2015-11-19 07:07:47 -06:00
|
|
|
|
|
|
|
struct Interpreter<'a, 'tcx: 'a> {
|
2016-03-04 23:17:31 -06:00
|
|
|
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,
|
2016-03-07 07:10:52 -06:00
|
|
|
stack: Vec<Frame<'a, 'tcx>>,
|
2015-11-16 15:22:27 -06:00
|
|
|
}
|
|
|
|
|
2016-03-07 07:10:52 -06:00
|
|
|
impl<'a, 'tcx: 'a> Interpreter<'a, 'tcx> {
|
2016-03-04 23:17:31 -06:00
|
|
|
fn new(tcx: &'a TyCtxt<'tcx>, mir_map: &'a MirMap<'tcx>) -> Self {
|
2015-11-12 15:50:58 -06:00
|
|
|
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(),
|
2016-03-06 04:23:24 -06:00
|
|
|
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>],
|
2016-03-07 07:10:52 -06:00
|
|
|
return_ptr: Option<Pointer>) -> EvalResult<()> {
|
2016-03-06 04:23:24 -06:00
|
|
|
let num_args = mir.arg_decls.len();
|
|
|
|
let num_vars = mir.var_decls.len();
|
2016-03-07 07:10:52 -06:00
|
|
|
let num_temps = mir.temp_decls.len();
|
2016-03-06 04:23:24 -06:00
|
|
|
assert_eq!(args.len(), num_args);
|
|
|
|
|
2016-03-07 07:10:52 -06:00
|
|
|
let mut locals = Vec::with_capacity(num_args + num_vars + num_temps);
|
2016-03-06 04:23:24 -06:00
|
|
|
|
2016-03-07 07:10:52 -06:00
|
|
|
for (arg_decl, arg_operand) in mir.arg_decls.iter().zip(args) {
|
2016-03-11 21:27:54 -06:00
|
|
|
let repr = self.ty_to_repr(arg_decl.ty);
|
2016-03-07 07:19:43 -06:00
|
|
|
let dest = self.memory.allocate(repr.size());
|
2016-03-07 07:10:52 -06:00
|
|
|
let src = try!(self.operand_to_ptr(arg_operand));
|
|
|
|
try!(self.memory.copy(src, dest, repr.size()));
|
|
|
|
locals.push(dest);
|
2015-11-12 15:50:58 -06:00
|
|
|
}
|
2016-03-06 04:23:24 -06:00
|
|
|
|
2016-03-07 07:10:52 -06:00
|
|
|
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| {
|
2016-03-11 21:27:54 -06:00
|
|
|
let repr = self.ty_to_repr(ty).size();
|
|
|
|
self.memory.allocate(repr)
|
2016-03-07 07:19:43 -06:00
|
|
|
}));
|
2016-03-07 07:10:52 -06:00
|
|
|
|
|
|
|
self.stack.push(Frame {
|
|
|
|
mir: mir,
|
2016-03-06 04:23:24 -06:00
|
|
|
return_ptr: return_ptr,
|
|
|
|
locals: locals,
|
|
|
|
var_offset: num_args,
|
|
|
|
temp_offset: num_args + num_vars,
|
|
|
|
});
|
|
|
|
|
|
|
|
Ok(())
|
2015-11-12 15:50:58 -06:00
|
|
|
}
|
|
|
|
|
2016-03-06 04:23:24 -06:00
|
|
|
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>],
|
2016-03-07 07:10:52 -06:00
|
|
|
return_ptr: Option<Pointer>) -> EvalResult<()> {
|
2016-03-06 04:23:24 -06:00
|
|
|
try!(self.push_stack_frame(mir, args, return_ptr));
|
2016-03-07 04:50:44 -06:00
|
|
|
let mut current_block = mir::START_BLOCK;
|
2015-11-19 03:23:50 -06:00
|
|
|
|
|
|
|
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);
|
2015-11-14 01:19:07 -06:00
|
|
|
|
2015-11-19 03:23:50 -06:00
|
|
|
for stmt in &block_data.statements {
|
2015-11-20 15:32:39 -06:00
|
|
|
if TRACE_EXECUTION { println!("{:?}", stmt); }
|
2016-03-07 03:32:02 -06:00
|
|
|
let mir::StatementKind::Assign(ref lvalue, ref rvalue) = stmt.kind;
|
2016-03-07 07:10:52 -06:00
|
|
|
try!(self.eval_assignment(lvalue, rvalue));
|
2015-11-19 03:23:50 -06:00
|
|
|
}
|
|
|
|
|
2016-01-06 21:05:08 -06:00
|
|
|
if TRACE_EXECUTION { println!("{:?}", block_data.terminator()); }
|
2015-11-20 15:32:39 -06:00
|
|
|
|
2016-03-07 03:32:02 -06:00
|
|
|
use rustc::mir::repr::Terminator::*;
|
2016-01-06 21:05:08 -06:00
|
|
|
match *block_data.terminator() {
|
2016-03-07 03:32:02 -06:00
|
|
|
Return => break,
|
2016-03-07 04:48:12 -06:00
|
|
|
|
2016-03-07 04:50:44 -06:00
|
|
|
Goto { target } => current_block = target,
|
2015-11-19 03:23:50 -06:00
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2016-03-07 03:32:02 -06:00
|
|
|
// Call { ref func, ref args, ref destination, .. } => {
|
2016-03-07 10:14:47 -06:00
|
|
|
// use rustc::middle::cstore::CrateStore;
|
2016-02-27 19:20:25 -06:00
|
|
|
// 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;
|
2016-02-27 19:20:25 -06:00
|
|
|
// }
|
|
|
|
// } else {
|
|
|
|
// panic!("tried to call a non-function value: {:?}", func_val);
|
|
|
|
// }
|
|
|
|
// }
|
|
|
|
|
2016-03-07 03:32:02 -06:00
|
|
|
// Switch { ref discr, ref targets, .. } => {
|
2016-02-27 19:20:25 -06:00
|
|
|
// 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];
|
2016-02-27 19:20:25 -06:00
|
|
|
// } else {
|
|
|
|
// panic!("Switch on non-Adt value: {:?}", discr_val);
|
|
|
|
// }
|
|
|
|
// }
|
2015-11-21 01:31:09 -06:00
|
|
|
|
2016-03-07 03:32:02 -06:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2016-03-07 03:32:02 -06:00
|
|
|
Resume => unimplemented!(),
|
2016-02-27 19:20:25 -06:00
|
|
|
_ => unimplemented!(),
|
2015-11-12 15:50:58 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-06 04:23:24 -06:00
|
|
|
self.pop_stack_frame();
|
2016-02-28 01:07:03 -06:00
|
|
|
Ok(())
|
2015-11-14 01:19:07 -06:00
|
|
|
}
|
|
|
|
|
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-02-28 01:07:03 -06:00
|
|
|
};
|
2016-03-07 07:48:38 -06:00
|
|
|
self.memory.write_int(dest, n)
|
2015-11-12 15:50:58 -06:00
|
|
|
}
|
|
|
|
|
2016-03-07 07:10:52 -06:00
|
|
|
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);
|
2016-03-11 21:27:54 -06:00
|
|
|
let dest_repr = self.ty_to_repr(dest_ty);
|
2015-11-20 15:54:02 -06:00
|
|
|
|
2016-03-07 03:32:02 -06:00
|
|
|
use rustc::mir::repr::Rvalue::*;
|
2015-11-12 16:13:35 -06:00
|
|
|
match *rvalue {
|
2016-03-07 03:32:02 -06:00
|
|
|
Use(ref operand) => {
|
2016-03-04 23:17:31 -06:00
|
|
|
let src = try!(self.operand_to_ptr(operand));
|
2016-03-07 07:10:52 -06:00
|
|
|
self.memory.copy(src, dest, dest_repr.size())
|
2016-02-27 19:20:25 -06:00
|
|
|
}
|
2015-11-20 15:54:02 -06:00
|
|
|
|
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:10:52 -06:00
|
|
|
|
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)
|
|
|
|
}
|
2016-03-04 23:17:31 -06:00
|
|
|
|
2016-03-11 21:27:54 -06:00
|
|
|
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 }
|
|
|
|
|
2016-03-07 07:10:52 -06:00
|
|
|
match dest_repr {
|
2016-03-04 23:17:31 -06:00
|
|
|
Repr::Aggregate { ref fields, .. } => {
|
|
|
|
for (field, operand) in fields.iter().zip(operands) {
|
|
|
|
let src = try!(self.operand_to_ptr(operand));
|
2016-03-07 07:10:52 -06:00
|
|
|
try!(self.memory.copy(src, dest.offset(field.offset),
|
|
|
|
field.repr.size()));
|
2016-03-04 23:17:31 -06:00
|
|
|
}
|
2016-03-07 07:10:52 -06:00
|
|
|
Ok(())
|
2016-03-04 23:17:31 -06:00
|
|
|
}
|
|
|
|
|
2016-03-07 07:10:52 -06:00
|
|
|
_ => unimplemented!(),
|
2016-03-04 23:17:31 -06:00
|
|
|
}
|
2015-11-12 15:50:58 -06:00
|
|
|
}
|
2015-11-12 17:24:43 -06:00
|
|
|
|
2016-03-07 03:32:02 -06:00
|
|
|
// Ref(_region, _kind, ref lvalue) => {
|
2016-02-27 19:20:25 -06:00
|
|
|
// Value::Pointer(self.lvalue_to_ptr(lvalue))
|
|
|
|
// }
|
2015-12-28 22:24:05 -06:00
|
|
|
|
2015-12-18 22:22:34 -06:00
|
|
|
ref r => panic!("can't handle rvalue: {:?}", r),
|
2015-11-12 15:50:58 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-07 07:10:52 -06:00
|
|
|
fn operand_to_ptr(&mut self, op: &mir::Operand<'tcx>) -> EvalResult<Pointer> {
|
2016-03-07 03:32:02 -06:00
|
|
|
use rustc::mir::repr::Operand::*;
|
2015-11-12 15:50:58 -06:00
|
|
|
match *op {
|
2016-03-07 03:32:02 -06:00
|
|
|
Consume(ref lvalue) => self.lvalue_to_ptr(lvalue),
|
2015-11-14 01:19:07 -06:00
|
|
|
|
2016-03-07 03:32:02 -06:00
|
|
|
Constant(ref constant) => {
|
|
|
|
use rustc::mir::repr::Literal::*;
|
2015-11-12 15:50:58 -06:00
|
|
|
match constant.literal {
|
2016-03-07 03:32:02 -06:00
|
|
|
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 15:50:58 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
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> {
|
2016-03-07 03:32:02 -06:00
|
|
|
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!(),
|
2016-03-07 03:32:02 -06:00
|
|
|
Int(n) => {
|
2016-03-07 07:19:43 -06:00
|
|
|
let ptr = self.memory.allocate(Repr::Int.size());
|
2016-03-07 07:10:52 -06:00
|
|
|
try!(self.memory.write_int(ptr, n));
|
2016-03-05 00:45:54 -06:00
|
|
|
Ok(ptr)
|
|
|
|
}
|
2016-03-07 03:32:02 -06:00
|
|
|
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());
|
2016-03-07 07:10:52 -06:00
|
|
|
try!(self.memory.write_bool(ptr, b));
|
2016-03-07 04:44:03 -06:00
|
|
|
Ok(ptr)
|
|
|
|
},
|
2016-03-07 03:32:02 -06:00
|
|
|
Struct(_node_id) => unimplemented!(),
|
|
|
|
Tuple(_node_id) => unimplemented!(),
|
|
|
|
Function(_def_id) => unimplemented!(),
|
|
|
|
Array(_, _) => unimplemented!(),
|
|
|
|
Repeat(_, _) => unimplemented!(),
|
2015-11-12 17:44:29 -06:00
|
|
|
}
|
|
|
|
}
|
2016-03-07 07:10:52 -06:00
|
|
|
|
2016-03-11 21:27:54 -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),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-03-07 07:10:52 -06:00
|
|
|
fn current_frame(&self) -> &Frame<'a, 'tcx> {
|
|
|
|
self.stack.last().expect("no call frames exist")
|
|
|
|
}
|
2015-11-12 15:50:58 -06:00
|
|
|
}
|
|
|
|
|
2016-03-04 23:17:31 -06:00
|
|
|
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 {
|
2015-11-12 15:50:58 -06:00
|
|
|
for attr in tcx.map.attrs(id) {
|
2016-03-07 10:14:47 -06:00
|
|
|
use syntax::attr::AttrMetaMethods;
|
2015-11-12 15:50:58 -06:00
|
|
|
if attr.check_name("miri_run") {
|
2015-11-12 17:11:41 -06:00
|
|
|
let item = tcx.map.expect_item(id);
|
|
|
|
|
2015-11-12 15:50:58 -06:00
|
|
|
println!("Interpreting: {}", item.name);
|
2015-11-20 20:49:25 -06:00
|
|
|
|
2016-03-04 23:17:31 -06:00
|
|
|
let mut miri = Interpreter::new(tcx, mir_map);
|
2016-02-27 19:20:25 -06:00
|
|
|
let return_ptr = match mir.return_ty {
|
2016-03-11 21:27:54 -06:00
|
|
|
ty::FnConverging(ty) => {
|
|
|
|
let repr = miri.ty_to_repr(ty).size();
|
|
|
|
Some(miri.memory.allocate(repr))
|
|
|
|
}
|
2016-03-04 23:17:31 -06:00
|
|
|
ty::FnDiverging => None,
|
2016-02-27 19:20:25 -06:00
|
|
|
};
|
2016-03-07 07:10:52 -06:00
|
|
|
miri.call(mir, &[], return_ptr).unwrap();
|
2015-11-12 17:11:41 -06:00
|
|
|
|
2016-03-04 23:17:31 -06:00
|
|
|
if let Some(ret) = return_ptr {
|
2016-03-04 23:44:49 -06:00
|
|
|
println!("Returned: {:?}\n", miri.memory.get(ret.alloc_id).unwrap());
|
2015-11-12 17:11:41 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|