user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Use rustc traits instead of our own

Browse source
This commit is contained in:
Oliver Schneider 2017-07-23 15:00:22 +02:00
parent 4d38f8dffb
commit 9c07f424da
3 changed files with 19 additions and 21 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/librustc_mir/interpret/cast.rs
View file

@ -4,7 +4,7 @@ use syntax::ast::{FloatTy, IntTy, UintTy};
use error::{EvalResult, EvalError};
use eval_context::EvalContext;
use value::PrimVal;
use memory::{MemoryPointer, HasDataLayout};
use memory::{MemoryPointer, PointerArithmetic};
impl<'a, 'tcx> EvalContext<'a, 'tcx> {
pub(super) fn cast_primval(

30
src/librustc_mir/interpret/memory.rs
View file

@ -68,30 +68,30 @@ pub struct MemoryPointer {
pub offset: u64,
}
impl MemoryPointer {
impl<'tcx> MemoryPointer {
pub fn new(alloc_id: AllocId, offset: u64) -> Self {
MemoryPointer { alloc_id, offset }
}
pub(crate) fn wrapping_signed_offset<'a, L: HasDataLayout<'a>>(self, i: i64, l: L) -> Self {
pub(crate) fn wrapping_signed_offset<L: PointerArithmetic>(self, i: i64, l: L) -> Self {
MemoryPointer::new(self.alloc_id, l.wrapping_signed_offset(self.offset, i))
}
pub(crate) fn overflowing_signed_offset<'a, L: HasDataLayout<'a>>(self, i: i128, l: L) -> (Self, bool) {
pub(crate) fn overflowing_signed_offset<L: PointerArithmetic>(self, i: i128, l: L) -> (Self, bool) {
let (res, over) = l.overflowing_signed_offset(self.offset, i);
(MemoryPointer::new(self.alloc_id, res), over)
}
pub(crate) fn signed_offset<'a, 'tcx, L: HasDataLayout<'a>>(self, i: i64, l: L) -> EvalResult<'tcx, Self> {
pub(crate) fn signed_offset<L: PointerArithmetic>(self, i: i64, l: L) -> EvalResult<'tcx, Self> {
Ok(MemoryPointer::new(self.alloc_id, l.signed_offset(self.offset, i)?))
}
pub(crate) fn overflowing_offset<'a, L: HasDataLayout<'a>>(self, i: u64, l: L) -> (Self, bool) {
pub(crate) fn overflowing_offset<L: PointerArithmetic>(self, i: u64, l: L) -> (Self, bool) {
let (res, over) = l.overflowing_offset(self.offset, i);
(MemoryPointer::new(self.alloc_id, res), over)
}
pub(crate) fn offset<'a, 'tcx, L: HasDataLayout<'a>>(self, i: u64, l: L) -> EvalResult<'tcx, Self> {
pub(crate) fn offset<L: PointerArithmetic>(self, i: u64, l: L) -> EvalResult<'tcx, Self> {
Ok(MemoryPointer::new(self.alloc_id, l.offset(self.offset, i)?))
}
}
@ -1183,9 +1183,7 @@ impl<'a, 'tcx> HasMemory<'a, 'tcx> for EvalContext<'a, 'tcx> {
// Pointer arithmetic
////////////////////////////////////////////////////////////////////////////////
pub(crate) trait HasDataLayout<'a> : Copy {
fn data_layout(self) -> &'a TargetDataLayout;
pub trait PointerArithmetic : layout::HasDataLayout {
// These are not supposed to be overriden.
//// Trunace the given value to the pointer size; also return whether there was an overflow
@ -1236,17 +1234,17 @@ pub(crate) trait HasDataLayout<'a> : Copy {
}
}
impl<'a> HasDataLayout<'a> for &'a TargetDataLayout {
impl<T: layout::HasDataLayout> PointerArithmetic for T {}
impl<'a, 'tcx> layout::HasDataLayout for &'a Memory<'a, 'tcx> {
#[inline]
fn data_layout(self) -> &'a TargetDataLayout {
self
fn data_layout(&self) -> &TargetDataLayout {
self.layout
}
}
impl<'a, 'b, 'tcx, T> HasDataLayout<'a> for &'b T
where T: HasMemory<'a, 'tcx> {
impl<'a, 'tcx> layout::HasDataLayout for &'a EvalContext<'a, 'tcx> {
#[inline]
fn data_layout(self) -> &'a TargetDataLayout {
fn data_layout(&self) -> &TargetDataLayout {
self.memory().layout
}
}

8
src/librustc_mir/interpret/value.rs
View file

@ -2,7 +2,7 @@
#![allow(float_cmp)]
use error::{EvalError, EvalResult};
use memory::{Memory, MemoryPointer, HasMemory, HasDataLayout};
use memory::{Memory, MemoryPointer, HasMemory, PointerArithmetic};
pub(super) fn bytes_to_f32(bytes: u128) -> f32 {
f32::from_bits(bytes as u32)
@ -59,7 +59,7 @@ impl<'tcx> Pointer {
self.primval
}
pub(crate) fn signed_offset<'a, L: HasDataLayout<'a>>(self, i: i64, layout: L) -> EvalResult<'tcx, Self> {
pub(crate) fn signed_offset<L: PointerArithmetic>(self, i: i64, layout: L) -> EvalResult<'tcx, Self> {
match self.primval {
PrimVal::Bytes(b) => {
assert_eq!(b as u64 as u128, b);
@ -70,7 +70,7 @@ impl<'tcx> Pointer {
}
}
pub(crate) fn offset<'a, L: HasDataLayout<'a>>(self, i: u64, layout: L) -> EvalResult<'tcx, Self> {
pub(crate) fn offset<L: PointerArithmetic>(self, i: u64, layout: L) -> EvalResult<'tcx, Self> {
match self.primval {
PrimVal::Bytes(b) => {
assert_eq!(b as u64 as u128, b);
@ -81,7 +81,7 @@ impl<'tcx> Pointer {
}
}
pub(crate) fn wrapping_signed_offset<'a, L: HasDataLayout<'a>>(self, i: i64, layout: L) -> EvalResult<'tcx, Self> {
pub(crate) fn wrapping_signed_offset<L: PointerArithmetic>(self, i: i64, layout: L) -> EvalResult<'tcx, Self> {
match self.primval {
PrimVal::Bytes(b) => {
assert_eq!(b as u64 as u128, b);