From 904923fa7a4635636b0bc5c33e9901773e7f6747 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sun, 26 Aug 2018 20:42:26 +0200 Subject: [PATCH] move some more helpers to rustc --- src/fn_call.rs | 8 +++--- src/helpers.rs | 45 -------------------------------- src/intrinsic.rs | 58 ++++++++++++++++-------------------------- src/lib.rs | 2 +- src/tls.rs | 8 +++--- tests/run-pass/char.rs | 4 +-- 6 files changed, 31 insertions(+), 94 deletions(-) diff --git a/src/fn_call.rs b/src/fn_call.rs index a9791e2b7ca..0e768fcccf9 100644 --- a/src/fn_call.rs +++ b/src/fn_call.rs @@ -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) } } diff --git a/src/helpers.rs b/src/helpers.rs index 24285fa4a6e..27b2109d18a 100644 --- a/src/helpers.rs +++ b/src/helpers.rs @@ -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, ptr_size: Size) -> Self; - fn from_int(i: impl Into, 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, size: Size) -> Self { - Scalar::Bits { bits: i.into(), size: size.bytes() as u8 } - } - - fn from_int(i: impl Into, 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 { diff --git a/src/intrinsic.rs b/src/intrinsic.rs index 6847d8e546f..695943d57b0 100644 --- a/src/intrinsic.rs +++ b/src/intrinsic.rs @@ -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, diff --git a/src/lib.rs b/src/lib.rs index 42dac6a28d8..0ce510a6598 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -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>, diff --git a/src/tls.rs b/src/tls.rs index 6cec39483c4..bd0318a62ed 100644 --- a/src/tls.rs +++ b/src/tls.rs @@ -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>) -> 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; } } diff --git a/tests/run-pass/char.rs b/tests/run-pass/char.rs index 505c09b0ad8..5524f0ae7ab 100644 --- a/tests/run-pass/char.rs +++ b/tests/run-pass/char.rs @@ -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')); }