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

move some more helpers to rustc

Browse Source
This commit is contained in:
Ralf Jung 2018-08-26 20:42:26 +02:00
parent 752accf4e4
commit 904923fa7a
6 changed files with 31 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/fn_call.rs
View File

@ -305,7 +305,7 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for EvalContext<'a, '
};
self.write_scalar(
Scalar::from_i32(result),
Scalar::from_int(result, Size::from_bits(32)),
dest,
)?;
}
@ -346,7 +346,7 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for EvalContext<'a, '
let name = self.memory.read_c_str(name_ptr)?;
match self.machine.env_vars.get(name) {
Some(&var) => Scalar::Ptr(var),
None => Scalar::null(self.memory.pointer_size()),
None => Scalar::ptr_null(*self.tcx),
}
};
self.write_scalar(result, dest)?;
@ -446,7 +446,7 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for EvalContext<'a, '
// Some things needed for sys::thread initialization to go through
"signal" | "sigaction" | "sigaltstack" => {
self.write_scalar(Scalar::null(dest.layout.size), dest)?;
self.write_scalar(Scalar::from_int(0, dest.layout.size), dest)?;
}
"sysconf" => {
@ -729,6 +729,6 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for EvalContext<'a, '
}
fn write_null(&mut self, dest: PlaceTy<'tcx>) -> EvalResult<'tcx> {
self.write_scalar(Scalar::null(dest.layout.size), dest)
self.write_scalar(Scalar::from_int(0, dest.layout.size), dest)
}
}

45
src/helpers.rs
View File

@ -1,17 +1,5 @@
use rustc::ty::layout::Size;
use super::{Scalar, ScalarMaybeUndef, EvalResult};
pub trait ScalarExt {
fn null(size: Size) -> Self;
fn from_i32(i: i32) -> Self;
fn from_uint(i: impl Into<u128>, ptr_size: Size) -> Self;
fn from_int(i: impl Into<i128>, ptr_size: Size) -> Self;
fn from_f32(f: f32) -> Self;
fn from_f64(f: f64) -> Self;
fn is_null(self) -> bool;
}
pub trait FalibleScalarExt {
/// HACK: this function just extracts all bits if `defined != 0`
/// Mainly used for args of C-functions and we should totally correctly fetch the size
@ -19,39 +7,6 @@ pub trait FalibleScalarExt {
fn to_bytes(self) -> EvalResult<'static, u128>;
}
impl ScalarExt for Scalar {
fn null(size: Size) -> Self {
Scalar::Bits { bits: 0, size: size.bytes() as u8 }
}
fn from_i32(i: i32) -> Self {
Scalar::Bits { bits: i as u32 as u128, size: 4 }
}
fn from_uint(i: impl Into<u128>, size: Size) -> Self {
Scalar::Bits { bits: i.into(), size: size.bytes() as u8 }
}
fn from_int(i: impl Into<i128>, size: Size) -> Self {
Scalar::Bits { bits: i.into() as u128, size: size.bytes() as u8 }
}
fn from_f32(f: f32) -> Self {
Scalar::Bits { bits: f.to_bits() as u128, size: 4 }
}
fn from_f64(f: f64) -> Self {
Scalar::Bits { bits: f.to_bits() as u128, size: 8 }
}
fn is_null(self) -> bool {
match self {
Scalar::Bits { bits, .. } => bits == 0,
Scalar::Ptr(_) => false
}
}
}
impl FalibleScalarExt for Scalar {
fn to_bytes(self) -> EvalResult<'static, u128> {
match self {

58
src/intrinsic.rs
View File

@ -2,12 +2,12 @@ use rustc::mir;
use rustc::ty::layout::{self, LayoutOf, Size};
use rustc::ty;
use rustc::mir::interpret::{EvalResult, Scalar, ScalarMaybeUndef};
use rustc::mir::interpret::{EvalResult, Scalar, ScalarMaybeUndef, PointerArithmetic};
use rustc_mir::interpret::{
PlaceTy, EvalContext, OpTy, Value
};
use super::{ScalarExt, FalibleScalarExt, OperatorEvalContextExt};
use super::{FalibleScalarExt, OperatorEvalContextExt};
pub trait EvalContextExt<'tcx> {
fn call_intrinsic(
@ -204,8 +204,7 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super:
"sinf32" | "fabsf32" | "cosf32" | "sqrtf32" | "expf32" | "exp2f32" | "logf32" |
"log10f32" | "log2f32" | "floorf32" | "ceilf32" | "truncf32" => {
let f = self.read_scalar(args[0])?.to_bytes()?;
let f = f32::from_bits(f as u32);
let f = self.read_scalar(args[0])?.to_f32()?;
let f = match intrinsic_name {
"sinf32" => f.sin(),
"fabsf32" => f.abs(),
@ -226,8 +225,7 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super:
"sinf64" | "fabsf64" | "cosf64" | "sqrtf64" | "expf64" | "exp2f64" | "logf64" |
"log10f64" | "log2f64" | "floorf64" | "ceilf64" | "truncf64" => {
let f = self.read_scalar(args[0])?.to_bytes()?;
let f = f64::from_bits(f as u64);
let f = self.read_scalar(args[0])?.to_f64()?;
let f = match intrinsic_name {
"sinf64" => f.sin(),
"fabsf64" => f.abs(),
@ -282,12 +280,12 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super:
if !dest.layout.is_zst() { // notzhing to do for ZST
match dest.layout.abi {
layout::Abi::Scalar(ref s) => {
let x = Scalar::null(s.value.size(&self));
let x = Scalar::from_int(0, s.value.size(&self));
self.write_value(Value::Scalar(x.into()), dest)?;
}
layout::Abi::ScalarPair(ref s1, ref s2) => {
let x = Scalar::null(s1.value.size(&self));
let y = Scalar::null(s2.value.size(&self));
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)?;
}
_ => {
@ -304,7 +302,7 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super:
let ty = substs.type_at(0);
let layout = self.layout_of(ty)?;
let align = layout.align.pref();
let ptr_size = self.memory.pointer_size();
let ptr_size = self.pointer_size();
let align_val = Scalar::from_uint(align as u128, ptr_size);
self.write_scalar(align_val, dest)?;
}
@ -365,10 +363,8 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super:
}
"powf32" => {
let f = self.read_scalar(args[0])?.to_bits(Size::from_bits(32))?;
let f = f32::from_bits(f as u32);
let f2 = self.read_scalar(args[1])?.to_bits(Size::from_bits(32))?;
let f2 = f32::from_bits(f2 as u32);
let f = self.read_scalar(args[0])?.to_f32()?;
let f2 = self.read_scalar(args[1])?.to_f32()?;
self.write_scalar(
Scalar::from_f32(f.powf(f2)),
dest,
@ -376,10 +372,8 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super:
}
"powf64" => {
let f = self.read_scalar(args[0])?.to_bits(Size::from_bits(64))?;
let f = f64::from_bits(f as u64);
let f2 = self.read_scalar(args[1])?.to_bits(Size::from_bits(64))?;
let f2 = f64::from_bits(f2 as u64);
let f = self.read_scalar(args[0])?.to_f64()?;
let f2 = self.read_scalar(args[1])?.to_f64()?;
self.write_scalar(
Scalar::from_f64(f.powf(f2)),
dest,
@ -387,12 +381,9 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super:
}
"fmaf32" => {
let a = self.read_scalar(args[0])?.to_bits(Size::from_bits(32))?;
let a = f32::from_bits(a as u32);
let b = self.read_scalar(args[1])?.to_bits(Size::from_bits(32))?;
let b = f32::from_bits(b as u32);
let c = self.read_scalar(args[2])?.to_bits(Size::from_bits(32))?;
let c = f32::from_bits(c as u32);
let a = self.read_scalar(args[0])?.to_f32()?;
let b = self.read_scalar(args[1])?.to_f32()?;
let c = self.read_scalar(args[2])?.to_f32()?;
self.write_scalar(
Scalar::from_f32(a * b + c),
dest,
@ -400,12 +391,9 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super:
}
"fmaf64" => {
let a = self.read_scalar(args[0])?.to_bits(Size::from_bits(64))?;
let a = f64::from_bits(a as u64);
let b = self.read_scalar(args[1])?.to_bits(Size::from_bits(64))?;
let b = f64::from_bits(b as u64);
let c = self.read_scalar(args[2])?.to_bits(Size::from_bits(64))?;
let c = f64::from_bits(c as u64);
let a = self.read_scalar(args[0])?.to_f64()?;
let b = self.read_scalar(args[1])?.to_f64()?;
let c = self.read_scalar(args[2])?.to_f64()?;
self.write_scalar(
Scalar::from_f64(a * b + c),
dest,
@ -413,8 +401,7 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super:
}
"powif32" => {
let f = self.read_scalar(args[0])?.to_bits(Size::from_bits(32))?;
let f = f32::from_bits(f as u32);
let f = self.read_scalar(args[0])?.to_f32()?;
let i = self.read_scalar(args[1])?.to_i32()?;
self.write_scalar(
Scalar::from_f32(f.powi(i)),
@ -423,8 +410,7 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super:
}
"powif64" => {
let f = self.read_scalar(args[0])?.to_bits(Size::from_bits(64))?;
let f = f64::from_bits(f as u64);
let f = self.read_scalar(args[0])?.to_f64()?;
let i = self.read_scalar(args[1])?.to_i32()?;
self.write_scalar(
Scalar::from_f64(f.powi(i)),
@ -435,7 +421,7 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super:
"size_of_val" => {
let mplace = self.ref_to_mplace(self.read_value(args[0])?)?;
let (size, _) = self.size_and_align_of_mplace(mplace)?;
let ptr_size = self.memory.pointer_size();
let ptr_size = self.pointer_size();
self.write_scalar(
Scalar::from_uint(size.bytes() as u128, ptr_size),
dest,
@ -446,7 +432,7 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super:
"align_of_val" => {
let mplace = self.ref_to_mplace(self.read_value(args[0])?)?;
let (_, align) = self.size_and_align_of_mplace(mplace)?;
let ptr_size = self.memory.pointer_size();
let ptr_size = self.pointer_size();
self.write_scalar(
Scalar::from_uint(align.abi(), ptr_size),
dest,

2
src/lib.rs
View File

@ -46,7 +46,7 @@ use tls::EvalContextExt as TlsEvalContextExt;
use memory::MemoryKind as MiriMemoryKind;
use locks::LockInfo;
use range_map::RangeMap;
use helpers::{ScalarExt, FalibleScalarExt};
use helpers::FalibleScalarExt;
pub fn create_ecx<'a, 'mir: 'a, 'tcx: 'mir>(
tcx: TyCtxt<'a, 'tcx, 'tcx>,

8
src/tls.rs
View File

@ -1,6 +1,6 @@
use rustc::{ty, mir};
use super::{TlsKey, TlsEntry, EvalResult, EvalErrorKind, Scalar, ScalarExt, Memory, Evaluator,
use super::{TlsKey, TlsEntry, EvalResult, EvalErrorKind, Scalar, Memory, Evaluator,
Place, StackPopCleanup, EvalContext};
pub trait MemoryExt<'tcx> {
@ -22,11 +22,10 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> MemoryExt<'tcx> for Memory<'a, 'mir, 'tcx, Evalu
fn create_tls_key(&mut self, dtor: Option<ty::Instance<'tcx>>) -> TlsKey {
let new_key = self.data.next_thread_local;
self.data.next_thread_local += 1;
let ptr_size = self.pointer_size();
self.data.thread_local.insert(
new_key,
TlsEntry {
data: Scalar::null(ptr_size).into(),
data: Scalar::ptr_null(*self.tcx).into(),
dtor,
},
);
@ -89,7 +88,6 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> MemoryExt<'tcx> for Memory<'a, 'mir, 'tcx, Evalu
) -> Option<(ty::Instance<'tcx>, Scalar, TlsKey)> {
use std::collections::Bound::*;
let ptr_size = self.pointer_size();
let thread_local = &mut self.data.thread_local;
let start = match key {
Some(key) => Excluded(key),
@ -101,7 +99,7 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> MemoryExt<'tcx> for Memory<'a, 'mir, 'tcx, Evalu
if !data.is_null() {
if let Some(dtor) = dtor {
let ret = Some((dtor, *data, key));
*data = Scalar::null(ptr_size);
*data = Scalar::ptr_null(*self.tcx);
return ret;
}
}

4
tests/run-pass/char.rs
View File

@ -3,7 +3,5 @@ fn main() {
assert_eq!(c, 'x');
assert!('a' < 'z');
assert!('1' < '9');
assert_eq!(std::char::from_u32('x' as u32).unwrap(), 'x');
// FIXME:
// assert_eq!(std::char::from_u32('x' as u32), Some('x'));
assert_eq!(std::char::from_u32('x' as u32), Some('x'));
}