bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

More work for multiple int sizes.

Browse source
This commit is contained in:
Scott Olson 2016-03-13 01:14:20 -06:00
parent 397dbd909a
commit c1edb9f978
2 changed files with 122 additions and 65 deletions
Download patch file Download diff file Expand all files Collapse all files

122
src/interpreter.rs
View file

@ -36,16 +36,6 @@ impl fmt::Display for EvalError {
}
}
// #[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.
@ -87,6 +77,15 @@ struct Interpreter<'a, 'tcx: 'a> {
stack: Vec<Frame<'a, 'tcx>>,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PrimVal {
Bool(bool),
I8(i8),
I16(i16),
I32(i32),
I64(i64),
}
impl<'a, 'tcx: 'a> Interpreter<'a, 'tcx> {
fn new(tcx: &'a TyCtxt<'tcx>, mir_map: &'a MirMap<'tcx>) -> Self {
Interpreter {
@ -109,7 +108,7 @@ impl<'a, 'tcx: 'a> Interpreter<'a, 'tcx> {
for (arg_decl, arg_operand) in mir.arg_decls.iter().zip(args) {
let repr = self.ty_to_repr(arg_decl.ty);
let dest = self.memory.allocate(repr.size());
let src = try!(self.operand_to_ptr(arg_operand));
let (src, _) = try!(self.eval_operand(arg_operand));
try!(self.memory.copy(src, dest, repr.size()));
locals.push(dest);
}
@ -161,22 +160,22 @@ impl<'a, 'tcx: 'a> Interpreter<'a, 'tcx> {
Goto { target } => current_block = target,
If { ref cond, targets: (then_target, else_target) } => {
let cond_ptr = try!(self.operand_to_ptr(cond));
let (cond_ptr, _) = try!(self.eval_operand(cond));
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));
let (discr_ptr, discr_repr) = try!(self.eval_lvalue(discr));
let discr_val = try!(self.memory.read_i64(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));
let val = try!(self.memory.read_i64(ptr));
if discr_val == val {
current_block = targets[index];
break;
@ -241,32 +240,35 @@ impl<'a, 'tcx: 'a> Interpreter<'a, 'tcx> {
right_operand: &mir::Operand<'tcx>, dest: Pointer) -> EvalResult<()>
{
// 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));
let (left, left_repr) = try!(self.eval_operand(left_operand));
let (right, right_repr) = try!(self.eval_operand(right_operand));
let left_val = try!(self.memory.read_primval(left, &left_repr));
let right_val = try!(self.memory.read_primval(right, &right_repr));
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,
use self::PrimVal::*;
let result_val = match (bin_op, left_val, right_val) {
(Add, I64(l), I64(r)) => I64(l + r),
(Sub, I64(l), I64(r)) => I64(l - r),
(Mul, I64(l), I64(r)) => I64(l * r),
(Div, I64(l), I64(r)) => I64(l / r),
(Rem, I64(l), I64(r)) => I64(l % r),
(BitXor, I64(l), I64(r)) => I64(l ^ r),
(BitAnd, I64(l), I64(r)) => I64(l & r),
(BitOr, I64(l), I64(r)) => I64(l | r),
(Shl, I64(l), I64(r)) => I64(l << r),
(Shr, I64(l), I64(r)) => I64(l >> r),
(Eq, I64(l), I64(r)) => Bool(l == r),
(Lt, I64(l), I64(r)) => Bool(l < r),
(Le, I64(l), I64(r)) => Bool(l <= r),
(Ne, I64(l), I64(r)) => Bool(l != r),
(Ge, I64(l), I64(r)) => Bool(l >= r),
(Gt, I64(l), I64(r)) => Bool(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),
};
self.memory.write_int(dest, n)
self.memory.write_primval(dest, result_val)
}
fn assign_to_product(&mut self, dest: Pointer, dest_repr: &Repr,
@ -274,7 +276,7 @@ impl<'a, 'tcx: 'a> Interpreter<'a, 'tcx> {
match *dest_repr {
Repr::Product { ref fields, .. } => {
for (field, operand) in fields.iter().zip(operands) {
let src = try!(self.operand_to_ptr(operand));
let (src, _) = try!(self.eval_operand(operand));
try!(self.memory.copy(src, dest.offset(field.offset), field.repr.size()));
}
}
@ -286,14 +288,12 @@ impl<'a, 'tcx: 'a> Interpreter<'a, 'tcx> {
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);
let (dest, dest_repr) = try!(self.eval_lvalue(lvalue));
use rustc::mir::repr::Rvalue::*;
match *rvalue {
Use(ref operand) => {
let src = try!(self.operand_to_ptr(operand));
let (src, _) = try!(self.eval_operand(operand));
self.memory.copy(src, dest, dest_repr.size())
}
@ -301,15 +301,19 @@ impl<'a, 'tcx: 'a> Interpreter<'a, 'tcx> {
self.eval_binary_op(bin_op, left, right, dest),
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));
let (src, src_repr) = try!(self.eval_operand(operand));
let src_val = try!(self.memory.read_primval(src, &src_repr));
use rustc::mir::repr::UnOp::*;
let n = match un_op {
Not => !m,
Neg => -m,
use self::PrimVal::*;
let result_val = match (un_op, src_val) {
(Not, Bool(b)) => Bool(!b),
(Not, I64(n)) => I64(!n),
(Neg, I64(n)) => I64(-n),
_ => unimplemented!(),
};
self.memory.write_int(dest, n)
self.memory.write_primval(dest, result_val)
}
Aggregate(ref kind, ref operands) => {
@ -346,22 +350,25 @@ impl<'a, 'tcx: 'a> Interpreter<'a, 'tcx> {
}
}
fn operand_to_ptr(&mut self, op: &mir::Operand<'tcx>) -> EvalResult<Pointer> {
fn eval_operand(&mut self, op: &mir::Operand<'tcx>) -> EvalResult<(Pointer, Repr)> {
use rustc::mir::repr::Operand::*;
match *op {
Consume(ref lvalue) => self.lvalue_to_ptr(lvalue),
Consume(ref lvalue) => self.eval_lvalue(lvalue),
Constant(ref constant) => {
Constant(mir::Constant { ref literal, ty, .. }) => {
use rustc::mir::repr::Literal::*;
match constant.literal {
Value { ref value } => self.const_to_ptr(value),
match *literal {
Value { ref value } => Ok((
try!(self.const_to_ptr(value)),
self.ty_to_repr(ty),
)),
ref l => panic!("can't handle item literal: {:?}", l),
}
}
}
}
fn lvalue_to_ptr(&self, lvalue: &mir::Lvalue<'tcx>) -> EvalResult<Pointer> {
fn eval_lvalue(&self, lvalue: &mir::Lvalue<'tcx>) -> EvalResult<(Pointer, Repr)> {
let frame = self.current_frame();
use rustc::mir::repr::Lvalue::*;
@ -374,7 +381,8 @@ impl<'a, 'tcx: 'a> Interpreter<'a, 'tcx> {
ref l => panic!("can't handle lvalue: {:?}", l),
};
Ok(ptr)
let ty = self.current_frame().mir.lvalue_ty(self.tcx, lvalue).to_ty(self.tcx);
Ok((ptr, self.ty_to_repr(ty)))
// mir::Lvalue::Projection(ref proj) => {
// let base_ptr = self.lvalue_to_ptr(&proj.base);
@ -419,7 +427,7 @@ impl<'a, 'tcx: 'a> Interpreter<'a, 'tcx> {
Int(n) => {
// TODO(tsion): Check int constant type.
let ptr = self.memory.allocate(8);
try!(self.memory.write_int(ptr, n));
try!(self.memory.write_i64(ptr, n));
Ok(ptr)
}
Uint(_u) => unimplemented!(),

63
src/memory.rs
View file

@ -2,7 +2,7 @@ use byteorder::{self, ByteOrder};
use std::collections::HashMap;
use std::ptr;
use interpreter::{EvalError, EvalResult};
use interpreter::{EvalError, EvalResult, PrimVal};
pub struct Memory {
next_id: u64,
@ -119,14 +119,25 @@ impl Memory {
Ok(())
}
pub fn read_int(&self, ptr: Pointer) -> EvalResult<i64> {
self.get_bytes(ptr, 8).map(byteorder::NativeEndian::read_i64)
pub fn read_primval(&self, ptr: Pointer, repr: &Repr) -> EvalResult<PrimVal> {
match *repr {
Repr::Bool => self.read_bool(ptr).map(PrimVal::Bool),
Repr::Int(IntRepr::I8) => self.read_i8(ptr).map(PrimVal::I8),
Repr::Int(IntRepr::I16) => self.read_i16(ptr).map(PrimVal::I16),
Repr::Int(IntRepr::I32) => self.read_i32(ptr).map(PrimVal::I32),
Repr::Int(IntRepr::I64) => self.read_i64(ptr).map(PrimVal::I64),
_ => panic!("primitive read of non-primitive: {:?}", repr),
}
}
pub fn write_int(&mut self, ptr: Pointer, n: i64) -> EvalResult<()> {
let bytes = try!(self.get_bytes_mut(ptr, 8));
byteorder::NativeEndian::write_i64(bytes, n);
Ok(())
pub fn write_primval(&mut self, ptr: Pointer, val: PrimVal) -> EvalResult<()> {
match val {
PrimVal::Bool(b) => self.write_bool(ptr, b),
PrimVal::I8(n) => self.write_i8(ptr, n),
PrimVal::I16(n) => self.write_i16(ptr, n),
PrimVal::I32(n) => self.write_i32(ptr, n),
PrimVal::I64(n) => self.write_i64(ptr, n),
}
}
pub fn read_bool(&self, ptr: Pointer) -> EvalResult<bool> {
@ -143,6 +154,44 @@ impl Memory {
bytes[0] = b as u8;
Ok(())
}
pub fn read_i8(&self, ptr: Pointer) -> EvalResult<i8> {
self.get_bytes(ptr, 1).map(|b| b[0] as i8)
}
pub fn write_i8(&mut self, ptr: Pointer, n: i8) -> EvalResult<()> {
self.get_bytes_mut(ptr, 1).map(|b| b[0] = n as u8)
}
pub fn read_i16(&self, ptr: Pointer) -> EvalResult<i16> {
self.get_bytes(ptr, 2).map(byteorder::NativeEndian::read_i16)
}
pub fn write_i16(&mut self, ptr: Pointer, n: i16) -> EvalResult<()> {
let bytes = try!(self.get_bytes_mut(ptr, 2));
byteorder::NativeEndian::write_i16(bytes, n);
Ok(())
}
pub fn read_i32(&self, ptr: Pointer) -> EvalResult<i32> {
self.get_bytes(ptr, 4).map(byteorder::NativeEndian::read_i32)
}
pub fn write_i32(&mut self, ptr: Pointer, n: i32) -> EvalResult<()> {
let bytes = try!(self.get_bytes_mut(ptr, 4));
byteorder::NativeEndian::write_i32(bytes, n);
Ok(())
}
pub fn read_i64(&self, ptr: Pointer) -> EvalResult<i64> {
self.get_bytes(ptr, 8).map(byteorder::NativeEndian::read_i64)
}
pub fn write_i64(&mut self, ptr: Pointer, n: i64) -> EvalResult<()> {
let bytes = try!(self.get_bytes_mut(ptr, 8));
byteorder::NativeEndian::write_i64(bytes, n);
Ok(())
}
}
impl Allocation {