mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #510 from solson/rustup

Browse Source 
rustup: value -> immediate, by-value HasLayout, edition 2018
This commit is contained in:
Oliver S̶c̶h̶n̶e̶i̶d̶e̶r Scherer 2018-11-05 17:02:38 +01:00 committed by GitHub
commit 0e9e0f2d82
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 78 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.toml
View File

@ -9,6 +9,7 @@ repository = "https://github.com/solson/miri"
version = "0.1.0"
build = "build.rs"
default-run = "miri"
edition = "2018"
[lib]
test = true # we have unit tests

2
rust-version
View File

@ -1 +1 @@
nightly-2018-11-04
nightly-2018-11-05

2
src/bin/miri-rustc-tests.rs
View File

@ -1,4 +1,4 @@
#![feature(rustc_private)]
#![feature(rustc_private, extern_crate_item_prelude)]
extern crate miri;
extern crate getopts;
extern crate rustc;

2
src/bin/miri.rs
View File

@ -1,4 +1,4 @@
#![feature(rustc_private)]
#![feature(rustc_private, extern_crate_item_prelude)]
extern crate getopts;
extern crate miri;

50
src/fn_call.rs
View File

@ -120,7 +120,7 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for super::MiriEvalCo
match &link_name[..] {
"malloc" => {
let size = self.read_scalar(args[0])?.to_usize(&self)?;
let size = self.read_scalar(args[0])?.to_usize(self)?;
if size == 0 {
self.write_null(dest)?;
} else {
@ -132,7 +132,7 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for super::MiriEvalCo
"free" => {
let ptr = self.read_scalar(args[0])?.not_undef()?.erase_tag(); // raw ptr operation, no tag
if !ptr.is_null_ptr(&self) {
if !ptr.is_null_ptr(self) {
self.memory_mut().deallocate(
ptr.to_ptr()?.with_default_tag(),
None,
@ -142,8 +142,8 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for super::MiriEvalCo
}
"__rust_alloc" => {
let size = self.read_scalar(args[0])?.to_usize(&self)?;
let align = self.read_scalar(args[1])?.to_usize(&self)?;
let size = self.read_scalar(args[0])?.to_usize(self)?;
let align = self.read_scalar(args[1])?.to_usize(self)?;
if size == 0 {
return err!(HeapAllocZeroBytes);
}
@ -160,8 +160,8 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for super::MiriEvalCo
self.write_scalar(Scalar::Ptr(ptr), dest)?;
}
"__rust_alloc_zeroed" => {
let size = self.read_scalar(args[0])?.to_usize(&self)?;
let align = self.read_scalar(args[1])?.to_usize(&self)?;
let size = self.read_scalar(args[0])?.to_usize(self)?;
let align = self.read_scalar(args[1])?.to_usize(self)?;
if size == 0 {
return err!(HeapAllocZeroBytes);
}
@ -180,8 +180,8 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for super::MiriEvalCo
}
"__rust_dealloc" => {
let ptr = self.read_scalar(args[0])?.to_ptr()?.erase_tag(); // raw ptr operation, no tag
let old_size = self.read_scalar(args[1])?.to_usize(&self)?;
let align = self.read_scalar(args[2])?.to_usize(&self)?;
let old_size = self.read_scalar(args[1])?.to_usize(self)?;
let align = self.read_scalar(args[2])?.to_usize(self)?;
if old_size == 0 {
return err!(HeapAllocZeroBytes);
}
@ -196,9 +196,9 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for super::MiriEvalCo
}
"__rust_realloc" => {
let ptr = self.read_scalar(args[0])?.to_ptr()?.erase_tag(); // raw ptr operation, no tag
let old_size = self.read_scalar(args[1])?.to_usize(&self)?;
let align = self.read_scalar(args[2])?.to_usize(&self)?;
let new_size = self.read_scalar(args[3])?.to_usize(&self)?;
let old_size = self.read_scalar(args[1])?.to_usize(self)?;
let align = self.read_scalar(args[2])?.to_usize(self)?;
let new_size = self.read_scalar(args[3])?.to_usize(self)?;
if old_size == 0 || new_size == 0 {
return err!(HeapAllocZeroBytes);
}
@ -222,7 +222,7 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for super::MiriEvalCo
//
// libc::syscall(NR_GETRANDOM, buf.as_mut_ptr(), buf.len(), GRND_NONBLOCK)
// is called if a `HashMap` is created the regular way.
match self.read_scalar(args[0])?.to_usize(&self)? {
match self.read_scalar(args[0])?.to_usize(self)? {
318 | 511 => {
return err!(Unimplemented(
"miri does not support random number generators".to_owned(),
@ -260,7 +260,7 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for super::MiriEvalCo
// Now we make a function call. TODO: Consider making this re-usable? EvalContext::step does sth. similar for the TLS dtors,
// and of course eval_main.
let mir = self.load_mir(f_instance.def)?;
let ret_place = MPlaceTy::dangling(self.layout_of(self.tcx.mk_unit())?, &self).into();
let ret_place = MPlaceTy::dangling(self.layout_of(self.tcx.mk_unit())?, self).into();
self.push_stack_frame(
f_instance,
mir.span,
@ -294,7 +294,7 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for super::MiriEvalCo
"memcmp" => {
let left = self.read_scalar(args[0])?.not_undef()?.erase_tag(); // raw ptr operation
let right = self.read_scalar(args[1])?.not_undef()?.erase_tag(); // raw ptr operation
let n = Size::from_bytes(self.read_scalar(args[2])?.to_usize(&self)?);
let n = Size::from_bytes(self.read_scalar(args[2])?.to_usize(self)?);
let result = {
let left_bytes = self.memory().read_bytes(left.with_default_tag(), n)?;
@ -318,11 +318,11 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for super::MiriEvalCo
let ptr = self.read_scalar(args[0])?.not_undef()?.erase_tag(); // raw ptr operation
let ptr = ptr.with_default_tag();
let val = self.read_scalar(args[1])?.to_bytes()? as u8;
let num = self.read_scalar(args[2])?.to_usize(&self)?;
let num = self.read_scalar(args[2])?.to_usize(self)?;
if let Some(idx) = self.memory().read_bytes(ptr, Size::from_bytes(num))?
.iter().rev().position(|&c| c == val)
{
let new_ptr = ptr.ptr_offset(Size::from_bytes(num - idx as u64 - 1), &self)?;
let new_ptr = ptr.ptr_offset(Size::from_bytes(num - idx as u64 - 1), self)?;
self.write_scalar(new_ptr, dest)?;
} else {
self.write_null(dest)?;
@ -333,12 +333,12 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for super::MiriEvalCo
let ptr = self.read_scalar(args[0])?.not_undef()?.erase_tag(); // raw ptr operation
let ptr = ptr.with_default_tag();
let val = self.read_scalar(args[1])?.to_bytes()? as u8;
let num = self.read_scalar(args[2])?.to_usize(&self)?;
let num = self.read_scalar(args[2])?.to_usize(self)?;
if let Some(idx) = self.memory().read_bytes(ptr, Size::from_bytes(num))?.iter().position(
|&c| c == val,
)
{
let new_ptr = ptr.ptr_offset(Size::from_bytes(idx as u64), &self)?;
let new_ptr = ptr.ptr_offset(Size::from_bytes(idx as u64), self)?;
self.write_scalar(new_ptr, dest)?;
} else {
self.write_null(dest)?;
@ -351,7 +351,7 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for super::MiriEvalCo
let name = self.memory().read_c_str(name_ptr.with_default_tag())?;
match self.machine.env_vars.get(name) {
Some(&var) => Scalar::Ptr(var),
None => Scalar::ptr_null(*self.tcx),
None => Scalar::ptr_null(&*self.tcx),
}
};
self.write_scalar(result, dest)?;
@ -361,7 +361,7 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for super::MiriEvalCo
let mut success = None;
{
let name_ptr = self.read_scalar(args[0])?.not_undef()?.erase_tag(); // raw ptr operation
if !name_ptr.is_null_ptr(&self) {
if !name_ptr.is_null_ptr(self) {
let name = self.memory().read_c_str(name_ptr.to_ptr()?
.with_default_tag())?.to_owned();
if !name.is_empty() && !name.contains(&b'=') {
@ -385,7 +385,7 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for super::MiriEvalCo
let name_ptr = self.read_scalar(args[0])?.not_undef()?.erase_tag(); // raw ptr operation
let value_ptr = self.read_scalar(args[1])?.to_ptr()?.erase_tag(); // raw ptr operation
let value = self.memory().read_c_str(value_ptr.with_default_tag())?;
if !name_ptr.is_null_ptr(&self) {
if !name_ptr.is_null_ptr(self) {
let name = self.memory().read_c_str(name_ptr.to_ptr()?.with_default_tag())?;
if !name.is_empty() && !name.contains(&b'=') {
new = Some((name.to_owned(), value.to_owned()));
@ -400,7 +400,7 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for super::MiriEvalCo
MiriMemoryKind::Env.into(),
)?.with_default_tag();
self.memory_mut().write_bytes(value_copy.into(), &value)?;
let trailing_zero_ptr = value_copy.offset(Size::from_bytes(value.len() as u64), &self)?.into();
let trailing_zero_ptr = value_copy.offset(Size::from_bytes(value.len() as u64), self)?.into();
self.memory_mut().write_bytes(trailing_zero_ptr, &[0])?;
if let Some(var) = self.machine.env_vars.insert(
name.to_owned(),
@ -510,7 +510,7 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for super::MiriEvalCo
let key_layout = self.layout_of(key_type)?;
// Create key and write it into the memory where key_ptr wants it
let key = self.machine.tls.create_tls_key(dtor, *self.tcx) as u128;
let key = self.machine.tls.create_tls_key(dtor, &*self.tcx) as u128;
if key_layout.size.bits() < 128 && key >= (1u128 << key_layout.size.bits() as u128) {
return err!(OutOfTls);
}
@ -555,7 +555,7 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for super::MiriEvalCo
}
"pthread_attr_getstack" => {
// second argument is where we are supposed to write the stack size
let ptr = self.ref_to_mplace(self.read_value(args[1])?)?;
let ptr = self.ref_to_mplace(self.read_immediate(args[1])?)?;
let stackaddr = Scalar::from_int(0x80000, args[1].layout.size); // just any address
self.write_scalar(stackaddr, ptr.into())?;
// return 0
@ -613,7 +613,7 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for super::MiriEvalCo
// This just creates a key; Windows does not natively support TLS dtors.
// Create key and return it
let key = self.machine.tls.create_tls_key(None, *self.tcx) as u128;
let key = self.machine.tls.create_tls_key(None, &*self.tcx) as u128;
// Figure out how large a TLS key actually is. This is c::DWORD.
if dest.layout.size.bits() < 128 && key >= (1u128 << dest.layout.size.bits() as u128) {

78
src/intrinsic.rs
View File

@ -5,7 +5,7 @@ use rustc::ty;
use rustc::mir::interpret::{EvalResult, PointerArithmetic};
use crate::{
PlaceTy, OpTy, Value, Scalar, ScalarMaybeUndef, Borrow,
PlaceTy, OpTy, Immediate, Scalar, ScalarMaybeUndef, Borrow,
ScalarExt, OperatorEvalContextExt
};
@ -38,13 +38,13 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
let intrinsic_name = &self.tcx.item_name(instance.def_id()).as_str()[..];
match intrinsic_name {
"arith_offset" => {
let offset = self.read_scalar(args[1])?.to_isize(&self)?;
let offset = self.read_scalar(args[1])?.to_isize(self)?;
let ptr = self.read_scalar(args[0])?.not_undef()?;
let pointee_ty = substs.type_at(0);
let pointee_size = self.layout_of(pointee_ty)?.size.bytes() as i64;
let offset = offset.overflowing_mul(pointee_size).0;
let result_ptr = ptr.ptr_wrapping_signed_offset(offset, &self);
let result_ptr = ptr.ptr_wrapping_signed_offset(offset, self);
self.write_scalar(result_ptr, dest)?;
}
@ -59,7 +59,7 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
"atomic_load_relaxed" |
"atomic_load_acq" |
"volatile_load" => {
let ptr = self.ref_to_mplace(self.read_value(args[0])?)?;
let ptr = self.ref_to_mplace(self.read_immediate(args[0])?)?;
let val = self.read_scalar(ptr.into())?; // make sure it fits into a scalar; otherwise it cannot be atomic
self.write_scalar(val, dest)?;
}
@ -68,7 +68,7 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
"atomic_store_relaxed" |
"atomic_store_rel" |
"volatile_store" => {
let ptr = self.ref_to_mplace(self.read_value(args[0])?)?;
let ptr = self.ref_to_mplace(self.read_immediate(args[0])?)?;
let val = self.read_scalar(args[1])?; // make sure it fits into a scalar; otherwise it cannot be atomic
self.write_scalar(val, ptr.into())?;
}
@ -78,7 +78,7 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
}
_ if intrinsic_name.starts_with("atomic_xchg") => {
let ptr = self.ref_to_mplace(self.read_value(args[0])?)?;
let ptr = self.ref_to_mplace(self.read_immediate(args[0])?)?;
let new = self.read_scalar(args[1])?;
let old = self.read_scalar(ptr.into())?;
self.write_scalar(old, dest)?; // old value is returned
@ -86,14 +86,14 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
}
_ if intrinsic_name.starts_with("atomic_cxchg") => {
let ptr = self.ref_to_mplace(self.read_value(args[0])?)?;
let expect_old = self.read_value(args[1])?; // read as value for the sake of `binary_op_val()`
let ptr = self.ref_to_mplace(self.read_immediate(args[0])?)?;
let expect_old = self.read_immediate(args[1])?; // read as value for the sake of `binary_op_val()`
let new = self.read_scalar(args[2])?;
let old = self.read_value(ptr.into())?; // read as value for the sake of `binary_op_val()`
let old = self.read_immediate(ptr.into())?; // read as value for the sake of `binary_op_val()`
// binary_op_val will bail if either of them is not a scalar
let (eq, _) = self.binary_op_val(mir::BinOp::Eq, old, expect_old)?;
let res = Value::ScalarPair(old.to_scalar_or_undef(), eq.into());
self.write_value(res, dest)?; // old value is returned
let res = Immediate::ScalarPair(old.to_scalar_or_undef(), eq.into());
self.write_immediate(res, dest)?; // old value is returned
// update ptr depending on comparison
if eq.to_bool()? {
self.write_scalar(new, ptr.into())?;
@ -125,13 +125,13 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
"atomic_xsub_rel" |
"atomic_xsub_acqrel" |
"atomic_xsub_relaxed" => {
let ptr = self.ref_to_mplace(self.read_value(args[0])?)?;
let ptr = self.ref_to_mplace(self.read_immediate(args[0])?)?;
if !ptr.layout.ty.is_integral() {
return err!(Unimplemented(format!("Atomic arithmetic operations only work on integer types")));
}
let rhs = self.read_value(args[1])?;
let old = self.read_value(ptr.into())?;
self.write_value(*old, dest)?; // old value is returned
let rhs = self.read_immediate(args[1])?;
let old = self.read_immediate(ptr.into())?;
self.write_immediate(*old, dest)?; // old value is returned
let op = match intrinsic_name.split('_').nth(1).unwrap() {
"or" => mir::BinOp::BitOr,
"xor" => mir::BinOp::BitXor,
@ -151,7 +151,7 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
let elem_ty = substs.type_at(0);
let elem_layout = self.layout_of(elem_ty)?;
let elem_size = elem_layout.size.bytes();
let count = self.read_scalar(args[2])?.to_usize(&self)?;
let count = self.read_scalar(args[2])?.to_usize(self)?;
let elem_align = elem_layout.align;
// erase tags: this is a raw ptr operation
let src = self.read_scalar(args[0])?.not_undef()?.erase_tag();
@ -167,7 +167,7 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
}
"discriminant_value" => {
let place = self.ref_to_mplace(self.read_value(args[0])?)?;
let place = self.ref_to_mplace(self.read_immediate(args[0])?)?;
let discr_val = self.read_discriminant(place.into())?.0;
self.write_scalar(Scalar::from_uint(discr_val, dest.layout.size), dest)?;
}
@ -215,8 +215,8 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
}
"fadd_fast" | "fsub_fast" | "fmul_fast" | "fdiv_fast" | "frem_fast" => {
let a = self.read_value(args[0])?;
let b = self.read_value(args[1])?;
let a = self.read_immediate(args[0])?;
let b = self.read_immediate(args[1])?;
let op = match intrinsic_name {
"fadd_fast" => mir::BinOp::Add,
"fsub_fast" => mir::BinOp::Sub,
@ -231,8 +231,8 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
"exact_div" => {
// Performs an exact division, resulting in undefined behavior where
// `x % y != 0` or `y == 0` or `x == T::min_value() && y == -1`
let a = self.read_value(args[0])?;
let b = self.read_value(args[1])?;
let a = self.read_immediate(args[0])?;
let b = self.read_immediate(args[1])?;
// check x % y != 0
if self.binary_op_val(mir::BinOp::Rem, a, b)?.0.to_bytes()? != 0 {
return err!(ValidationFailure(format!("exact_div: {:?} cannot be divided by {:?}", a, b)));
@ -251,13 +251,13 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
if !dest.layout.is_zst() { // nothing to do for ZST
match dest.layout.abi {
layout::Abi::Scalar(ref s) => {
let x = Scalar::from_int(0, s.value.size(&self));
self.write_value(Value::Scalar(x.into()), dest)?;
let x = Scalar::from_int(0, s.value.size(self));
self.write_immediate(Immediate::Scalar(x.into()), dest)?;
}
layout::Abi::ScalarPair(ref s1, ref s2) => {
let x = Scalar::from_int(0, s1.value.size(&self));
let y = Scalar::from_int(0, s2.value.size(&self));
self.write_value(Value::ScalarPair(x.into(), y.into()), dest)?;
let x = Scalar::from_int(0, s1.value.size(self));
let y = Scalar::from_int(0, s2.value.size(self));
self.write_immediate(Immediate::ScalarPair(x.into(), y.into()), dest)?;
}
_ => {
// Do it in memory
@ -279,12 +279,12 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
}
"move_val_init" => {
let ptr = self.ref_to_mplace(self.read_value(args[0])?)?;
let ptr = self.ref_to_mplace(self.read_immediate(args[0])?)?;
self.copy_op(args[1], ptr.into())?;
}
"offset" => {
let offset = self.read_scalar(args[1])?.to_isize(&self)?;
let offset = self.read_scalar(args[1])?.to_isize(self)?;
let ptr = self.read_scalar(args[0])?.not_undef()?;
let result_ptr = self.pointer_offset_inbounds(ptr, substs.type_at(0), offset)?;
self.write_scalar(result_ptr, dest)?;
@ -347,7 +347,7 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
}
"size_of_val" => {
let mplace = self.ref_to_mplace(self.read_value(args[0])?)?;
let mplace = self.ref_to_mplace(self.read_immediate(args[0])?)?;
let (size, _) = self.size_and_align_of_mplace(mplace)?
.expect("size_of_val called on extern type");
let ptr_size = self.pointer_size();
@ -359,7 +359,7 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
"min_align_of_val" |
"align_of_val" => {
let mplace = self.ref_to_mplace(self.read_value(args[0])?)?;
let mplace = self.ref_to_mplace(self.read_immediate(args[0])?)?;
let (_, align) = self.size_and_align_of_mplace(mplace)?
.expect("size_of_val called on extern type");
let ptr_size = self.pointer_size();
@ -372,13 +372,13 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
"type_name" => {
let ty = substs.type_at(0);
let ty_name = ty.to_string();
let value = self.str_to_value(&ty_name)?;
self.write_value(value, dest)?;
let value = self.str_to_immediate(&ty_name)?;
self.write_immediate(value, dest)?;
}
"unchecked_div" => {
let l = self.read_value(args[0])?;
let r = self.read_value(args[1])?;
let l = self.read_immediate(args[0])?;
let r = self.read_immediate(args[1])?;
let rval = r.to_scalar()?.to_bytes()?;
if rval == 0 {
return err!(Intrinsic(format!("Division by 0 in unchecked_div")));
@ -392,8 +392,8 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
}
"unchecked_rem" => {
let l = self.read_value(args[0])?;
let r = self.read_value(args[1])?;
let l = self.read_immediate(args[0])?;
let r = self.read_immediate(args[1])?;
let rval = r.to_scalar()?.to_bytes()?;
if rval == 0 {
return err!(Intrinsic(format!("Division by 0 in unchecked_rem")));
@ -416,11 +416,11 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
match dest.layout.abi {
layout::Abi::Scalar(..) => {
let x = ScalarMaybeUndef::Undef;
self.write_value(Value::Scalar(x), dest)?;
self.write_immediate(Immediate::Scalar(x), dest)?;
}
layout::Abi::ScalarPair(..) => {
let x = ScalarMaybeUndef::Undef;
self.write_value(Value::ScalarPair(x, x), dest)?;
self.write_immediate(Immediate::ScalarPair(x, x), dest)?;
}
_ => {
// Do it in memory
@ -437,7 +437,7 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
let ty_layout = self.layout_of(ty)?;
let val_byte = self.read_scalar(args[1])?.to_u8()?;
let ptr = self.read_scalar(args[0])?.not_undef()?.erase_tag().with_default_tag();
let count = self.read_scalar(args[2])?.to_usize(&self)?;
let count = self.read_scalar(args[2])?.to_usize(self)?;
self.memory().check_align(ptr, ty_layout.align)?;
self.memory_mut().write_repeat(ptr, val_byte, ty_layout.size * count)?;
}

4
src/lib.rs
View File

@ -1,4 +1,4 @@
#![feature(rustc_private)]
#![feature(rustc_private, extern_crate_item_prelude)]
#![cfg_attr(feature = "cargo-clippy", allow(cast_lossless))]
@ -253,7 +253,7 @@ impl Into<MemoryKind<MiriMemoryKind>> for MiriMemoryKind {
impl MayLeak for MiriMemoryKind {
#[inline(always)]
fn may_leak(self) -> bool {
use MiriMemoryKind::*;
use self::MiriMemoryKind::*;
match self {
Rust | C => false,
Env | MutStatic => true,

4
src/stacked_borrows.rs
View File

@ -539,12 +539,12 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
// above. First deref, which will call `tag_dereference`.
// (This is somewhat redundant because validation already did the same thing,
// but what can you do.)
let val = self.read_value(self.place_to_op(place)?)?;
let val = self.read_immediate(self.place_to_op(place)?)?;
let dest = self.ref_to_mplace(val)?;
// Now put a new ref into the old place, which will call `tag_reference`.
// FIXME: Honor `fn_entry`!
let val = self.create_ref(dest, Some(mutbl))?;
self.write_value(val, place)?;
self.write_immediate(val, place)?;
Ok(())
}
}

12
src/tls.rs
View File

@ -42,7 +42,7 @@ impl<'tcx> TlsData<'tcx> {
pub fn create_tls_key(
&mut self,
dtor: Option<ty::Instance<'tcx>>,
cx: impl HasDataLayout,
cx: &impl HasDataLayout,
) -> TlsKey {
let new_key = self.next_key;
self.next_key += 1;
@ -109,7 +109,7 @@ impl<'tcx> TlsData<'tcx> {
fn fetch_tls_dtor(
&mut self,
key: Option<TlsKey>,
cx: impl HasDataLayout,
cx: &impl HasDataLayout,
) -> Option<(ty::Instance<'tcx>, Scalar<Borrow>, TlsKey)> {
use std::collections::Bound::*;
@ -135,14 +135,14 @@ impl<'tcx> TlsData<'tcx> {
impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, 'tcx> {
fn run_tls_dtors(&mut self) -> EvalResult<'tcx> {
let mut dtor = self.machine.tls.fetch_tls_dtor(None, *self.tcx);
let mut dtor = self.machine.tls.fetch_tls_dtor(None, &*self.tcx);
// FIXME: replace loop by some structure that works with stepping
while let Some((instance, ptr, key)) = dtor {
trace!("Running TLS dtor {:?} on {:?}", instance, ptr);
// TODO: Potentially, this has to support all the other possible instances?
// See eval_fn_call in interpret/terminator/mod.rs
let mir = self.load_mir(instance.def)?;
let ret_place = MPlaceTy::dangling(self.layout_of(self.tcx.mk_unit())?, &self).into();
let ret_place = MPlaceTy::dangling(self.layout_of(self.tcx.mk_unit())?, self).into();
self.push_stack_frame(
instance,
mir.span,
@ -159,9 +159,9 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx> for super::MiriEvalContext<
// step until out of stackframes
self.run()?;
dtor = match self.machine.tls.fetch_tls_dtor(Some(key), *self.tcx) {
dtor = match self.machine.tls.fetch_tls_dtor(Some(key), &*self.tcx) {
dtor @ Some(_) => dtor,
None => self.machine.tls.fetch_tls_dtor(None, *self.tcx),
None => self.machine.tls.fetch_tls_dtor(None, &*self.tcx),
};
}
// FIXME: On a windows target, call `unsafe extern "system" fn on_tls_callback`.