From 0cc934b7de9958c10ba4e6b6e74fa9fc6dc798a0 Mon Sep 17 00:00:00 2001
From: David Renshaw <dwrenshaw@gmail.com>
Date: Sat, 2 Dec 2017 10:59:18 -0500
Subject: [PATCH] modify signature of write_value() to use ValTy, as in miri
---
src/eval_context.rs | 29 ++++++++++++++---------------
src/operator.rs | 4 ++--
src/terminator/drop.rs | 4 ++--
src/terminator/intrinsic.rs | 6 +++---
src/terminator/mod.rs | 25 +++++++++++++------------
5 files changed, 34 insertions(+), 34 deletions(-)
diff --git a/src/eval_context.rs b/src/eval_context.rs
index fdfc567..5d87730 100644
--- a/src/eval_context.rs
+++ b/src/eval_context.rs
@@ -494,7 +494,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
match *rvalue {
Use(ref operand) => {
let value = self.eval_operand(operand)?;
- self.write_value(value, dest, dest_ty)?;
+ self.write_value(ValTy { value, ty: dest_ty }, dest)?;
}
BinaryOp(bin_op, ref left, ref right) => {
@@ -539,7 +539,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
if !self.type_layout(value_ty)?.is_zst() {
let field_index = active_field_index.unwrap_or(i);
let (field_dest, _) = self.lvalue_field(dest, mir::Field::new(field_index), layout)?;
- self.write_value(value, field_dest, value_ty)?;
+ self.write_value(ValTy { value, ty: value_ty }, field_dest)?;
}
}
}
@@ -582,7 +582,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
bug!("attempted to take a reference to an enum downcast lvalue"),
};
- self.write_value(val, dest, dest_ty)?;
+ self.write_value(ValTy { value: val, ty: dest_ty }, dest)?;
}
NullaryOp(mir::NullOp::Box, ty) => {
@@ -626,10 +626,10 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
match (src, self.type_is_fat_ptr(dest_ty)) {
(Value::ByRef(_), _) |
(Value::ByValPair(..), true) => {
- self.write_value(src, dest, dest_ty)?;
+ self.write_value(ValTy { value: src, ty: dest_ty }, dest)?;
},
(Value::ByValPair(data, _), false) => {
- self.write_value(Value::ByVal(data), dest, dest_ty)?;
+ self.write_value(ValTy { value: Value::ByVal(data), ty: dest_ty }, dest)?;
},
(Value::ByVal(_), _) => bug!("expected fat ptr"),
}
@@ -646,7 +646,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
Err(err)
}
});
- self.write_value(Value::ByVal(dest_val?), dest, dest_ty)?;
+ self.write_value(ValTy { value: Value::ByVal(dest_val?), ty: dest_ty}, dest)?;
}
}
@@ -654,7 +654,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
ty::TyFnDef(def_id, substs) => {
let instance = self.resolve(def_id, substs)?;
let fn_ptr = self.memory.create_fn_alloc(instance);
- self.write_value(Value::ByVal(PrimVal::Ptr(fn_ptr)), dest, dest_ty)?;
+ self.write_value(ValTy { value: Value::ByVal(PrimVal::Ptr(fn_ptr)), ty: dest_ty }, dest)?;
},
ref other => bug!("reify fn pointer on {:?}", other),
},
@@ -662,7 +662,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
UnsafeFnPointer => match dest_ty.sty {
ty::TyFnPtr(_) => {
let src = self.eval_operand(operand)?;
- self.write_value(src, dest, dest_ty)?;
+ self.write_value(ValTy { value: src, ty: dest_ty }, dest)?;
},
ref other => bug!("fn to unsafe fn cast on {:?}", other),
},
@@ -671,7 +671,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
ty::TyClosure(def_id, substs) => {
let instance = resolve_closure(self.tcx, def_id, substs, ty::ClosureKind::FnOnce);
let fn_ptr = self.memory.create_fn_alloc(instance);
- self.write_value(Value::ByVal(PrimVal::Ptr(fn_ptr)), dest, dest_ty)?;
+ self.write_value(ValTy { value: Value::ByVal(PrimVal::Ptr(fn_ptr)), ty: dest_ty}, dest)?;
},
ref other => bug!("reify fn pointer on {:?}", other),
},
@@ -977,14 +977,13 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
val: PrimVal,
dest_ty: Ty<'tcx>,
) -> EvalResult<'tcx> {
- self.write_value(Value::ByVal(val), dest, dest_ty)
+ self.write_value(ValTy { value: Value::ByVal(val), ty: dest_ty }, dest)
}
pub(super) fn write_value(
&mut self,
- src_val: Value,
+ ValTy { value: src_val, ty: dest_ty } : ValTy<'tcx>,
dest: Lvalue<'tcx>,
- dest_ty: Ty<'tcx>,
) -> EvalResult<'tcx> {
match dest {
Lvalue::Global(cid) => {
@@ -1357,13 +1356,13 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
(&ty::TyArray(_, length), &ty::TySlice(_)) => {
let ptr = src.read_ptr(&self.memory)?;
let len = PrimVal::from_u128(length.val.to_const_int().unwrap().to_u64().unwrap() as u128);
- self.write_value(Value::ByValPair(ptr, len), dest, dest_ty)
+ self.write_value(ValTy { value: Value::ByValPair(ptr, len), ty: dest_ty }, dest)
}
(&ty::TyDynamic(..), &ty::TyDynamic(..)) => {
// For now, upcasts are limited to changes in marker
// traits, and hence never actually require an actual
// change to the vtable.
- self.write_value(src, dest, dest_ty)
+ self.write_value(ValTy { value: src, ty: dest_ty }, dest)
},
(_, &ty::TyDynamic(ref data, _)) => {
let trait_ref = data.principal().unwrap().with_self_ty(self.tcx, src_pointee_ty);
@@ -1371,7 +1370,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
let vtable = self.get_vtable(src_pointee_ty, trait_ref)?;
let ptr = src.read_ptr(&self.memory)?;
let extra = PrimVal::Ptr(vtable);
- self.write_value(Value::ByValPair(ptr, extra), dest, dest_ty)
+ self.write_value(ValTy { value: Value::ByValPair(ptr, extra), ty: dest_ty}, dest)
},
_ => bug!("invalid unsizing {:?} -> {:?}", src_ty, dest_ty),
diff --git a/src/operator.rs b/src/operator.rs
index 57989fb..771e875 100644
--- a/src/operator.rs
+++ b/src/operator.rs
@@ -5,7 +5,7 @@ use syntax::ast::FloatTy;
use std::cmp::Ordering;
use error::{EvalError, EvalResult};
-use eval_context::EvalContext;
+use eval_context::{EvalContext, ValTy};
use lvalue::Lvalue;
use memory::{Pointer, PointerOffset, SByte};
use value::{
@@ -45,7 +45,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
) -> EvalResult<'tcx> {
let (val, overflowed) = self.binop_with_overflow(op, left, right)?;
let val = Value::ByValPair(val, PrimVal::from_bool(overflowed));
- self.write_value(val, dest, dest_ty)
+ self.write_value(ValTy { value: val, ty: dest_ty}, dest)
}
/// Applies the binary operation `op` to the arguments and writes the result to the
diff --git a/src/terminator/drop.rs b/src/terminator/drop.rs
index 3cf20bb..835020a 100644
--- a/src/terminator/drop.rs
+++ b/src/terminator/drop.rs
@@ -3,7 +3,7 @@ use rustc::ty::{self, Ty};
use syntax::codemap::Span;
use error::EvalResult;
-use eval_context::{EvalContext, StackPopCleanup};
+use eval_context::{EvalContext, StackPopCleanup, ValTy};
use lvalue::{Lvalue, LvalueExtra};
use value::PrimVal;
use value::Value;
@@ -64,6 +64,6 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
let arg_local = arg_locals.next().unwrap();
let dest = self.eval_lvalue(&mir::Place::Local(arg_local))?;
let arg_ty = self.tcx.mk_mut_ptr(ty);
- self.write_value(arg, dest, arg_ty)
+ self.write_value(ValTy { value: arg, ty: arg_ty }, dest)
}
}
diff --git a/src/terminator/intrinsic.rs b/src/terminator/intrinsic.rs
index 8fc92b9..2a575e1 100644
--- a/src/terminator/intrinsic.rs
+++ b/src/terminator/intrinsic.rs
@@ -5,7 +5,7 @@ use rustc::ty::subst::Substs;
use rustc::ty::{self, Ty};
use error::{EvalError, EvalResult};
-use eval_context::EvalContext;
+use eval_context::{EvalContext, ValTy};
use lvalue::{Lvalue, LvalueExtra};
use memory::{Pointer, PointerOffset};
use value::{PrimVal, PrimValKind, Value};
@@ -67,7 +67,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
"volatile_load" => {
let ty = instance.substs.type_at(0);
let ptr = arg_vals[0].read_ptr(&self.memory)?.to_ptr()?;
- self.write_value(Value::ByRef(ptr), dest, ty)?;
+ self.write_value(ValTy { value: Value::ByRef(ptr), ty }, dest)?;
}
"atomic_store" |
@@ -418,7 +418,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
let ty = instance.substs.type_at(0);
let ty_name = ty.to_string();
let s = self.str_to_value(&ty_name)?;
- self.write_value(s, dest, dest_ty)?;
+ self.write_value(ValTy { value: s, ty: dest_ty }, dest)?;
}
"type_id" => {
let ty = instance.substs.type_at(0);
diff --git a/src/terminator/mod.rs b/src/terminator/mod.rs
index f62d12c..b99366a 100644
--- a/src/terminator/mod.rs
+++ b/src/terminator/mod.rs
@@ -328,7 +328,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
for arg in arg_operands {
let arg_val = self.eval_operand(arg)?;
let arg_ty = self.operand_ty(arg);
- args.push((arg_val, arg_ty));
+ args.push(ValTy { value: arg_val, ty: arg_ty});
}
if self.eval_fn_call_inner(
instance,
@@ -343,9 +343,9 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
match sig.abi {
// closure as closure once
Abi::RustCall => {
- for (arg_local, (arg_val, arg_ty)) in arg_locals.zip(args) {
+ for (arg_local, arg_valty) in arg_locals.zip(args) {
let dest = self.eval_lvalue(&mir::Place::Local(arg_local))?;
- self.write_value(arg_val, dest, arg_ty)?;
+ self.write_value(arg_valty, dest)?;
}
},
// non capture closure as fn ptr
@@ -355,9 +355,10 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
trace!("arg_locals: {:?}", self.frame().mir.args_iter().collect::<Vec<_>>());
trace!("arg_operands: {:?}", arg_operands);
let local = arg_locals.nth(1).unwrap();
- for (i, (arg_val, arg_ty)) in args.into_iter().enumerate() {
- let dest = self.eval_lvalue(&mir::Place::Local(local).field(mir::Field::new(i), arg_ty))?;
- self.write_value(arg_val, dest, arg_ty)?;
+ for (i, arg_valty) in args.into_iter().enumerate() {
+ let dest = self.eval_lvalue(&mir::Place::Local(local).field(mir::Field::new(i),
+ arg_valty.ty))?;
+ self.write_value(arg_valty, dest)?;
}
},
_ => bug!("bad ABI for ClosureOnceShim: {:?}", sig.abi),
@@ -400,9 +401,9 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
trace!("arg_operands: {:?}", arg_operands);
match sig.abi {
Abi::Rust => {
- for (arg_local, ValTy { value: arg_val, ty: arg_ty }) in arg_locals.zip(args) {
+ for (arg_local, valty) in arg_locals.zip(args) {
let dest = self.eval_lvalue(&mir::Place::Local(arg_local))?;
- self.write_value(arg_val, dest, arg_ty)?;
+ self.write_value(valty, dest)?;
}
}
Abi::RustCall => {
@@ -411,7 +412,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
{ // write first argument
let first_local = arg_locals.next().unwrap();
let dest = self.eval_lvalue(&mir::Place::Local(first_local))?;
- self.write_value(args[0].value, dest, args[0].ty)?;
+ self.write_value(ValTy { value: args[0].value, ty: args[0].ty }, dest)?;
}
// unpack and write all other args
@@ -432,7 +433,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
dest,
field.ty
);
- self.write_value(arg, dest, field.ty)?;
+ self.write_value(ValTy { value: arg, ty: field.ty }, dest)?;
}
}
Value::ByVal(PrimVal::Undef) => {}
@@ -442,7 +443,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
arg_locals.next().unwrap(),
))?;
let field_ty = layout.field(&self, 0)?.ty;
- self.write_value(other, dest, field_ty)?;
+ self.write_value(ValTy { value: other, ty: field_ty }, dest)?;
}
}
} else {
@@ -451,7 +452,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
let dest = self.eval_lvalue(
&mir::Place::Local(arg_locals.next().unwrap()),
)?;
- self.write_value(args[1].value, dest, args[1].ty)?;
+ self.write_value(ValTy {value: args[1].value, ty: args[1].ty }, dest)?;
}
} else {
bug!(
--
GitLab