use more specialized Scalar::from_ constructors where appropriate
This commit is contained in:
parent
2acf32d9ad
commit
1a0e69d34f
5 changed files with 13 additions and 13 deletions
|
@ -208,7 +208,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
|
|||
|
||||
Char => {
|
||||
// `u8` to `char` cast
|
||||
Ok(Scalar::from_uint(u8::try_from(v).unwrap(), Size::from_bytes(4)))
|
||||
Ok(Scalar::from_u32(u8::try_from(v).unwrap().into()))
|
||||
}
|
||||
|
||||
// Casts to bool are not permitted by rustc, no need to handle them here.
|
||||
|
|
|
@ -2,6 +2,8 @@
|
|||
//! looking at their MIR. Intrinsics/functions supported here are shared by CTFE
|
||||
//! and miri.
|
||||
|
||||
use std::convert::TryFrom;
|
||||
|
||||
use rustc::mir::{
|
||||
self,
|
||||
interpret::{ConstValue, GlobalId, InterpResult, Scalar},
|
||||
|
@ -220,7 +222,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
|
|||
sym::discriminant_value => {
|
||||
let place = self.deref_operand(args[0])?;
|
||||
let discr_val = self.read_discriminant(place.into())?.0;
|
||||
self.write_scalar(Scalar::from_uint(discr_val, dest.layout.size), dest)?;
|
||||
self.write_scalar(Scalar::from_u64(u64::try_from(discr_val).unwrap()), dest)?;
|
||||
}
|
||||
sym::unchecked_shl
|
||||
| sym::unchecked_shr
|
||||
|
@ -275,7 +277,6 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
|
|||
}
|
||||
|
||||
sym::ptr_offset_from => {
|
||||
let isize_layout = self.layout_of(self.tcx.types.isize)?;
|
||||
let a = self.read_immediate(args[0])?.to_scalar()?;
|
||||
let b = self.read_immediate(args[1])?.to_scalar()?;
|
||||
|
||||
|
@ -292,7 +293,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
|
|||
let a = a.to_machine_usize(self)?;
|
||||
let b = b.to_machine_usize(self)?;
|
||||
if a == b && a != 0 {
|
||||
self.write_scalar(Scalar::from_int(0, isize_layout.size), dest)?;
|
||||
self.write_scalar(Scalar::from_machine_isize(0, self), dest)?;
|
||||
true
|
||||
} else {
|
||||
false
|
||||
|
@ -312,6 +313,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
|
|||
);
|
||||
}
|
||||
let usize_layout = self.layout_of(self.tcx.types.usize)?;
|
||||
let isize_layout = self.layout_of(self.tcx.types.isize)?;
|
||||
let a_offset = ImmTy::from_uint(a.offset.bytes(), usize_layout);
|
||||
let b_offset = ImmTy::from_uint(b.offset.bytes(), usize_layout);
|
||||
let (val, _overflowed, _ty) =
|
||||
|
|
|
@ -56,7 +56,7 @@ impl<'tcx, Tag> Immediate<Tag> {
|
|||
pub fn new_slice(val: Scalar<Tag>, len: u64, cx: &impl HasDataLayout) -> Self {
|
||||
Immediate::ScalarPair(
|
||||
val.into(),
|
||||
Scalar::from_uint(len, cx.data_layout().pointer_size).into(),
|
||||
Scalar::from_machine_usize(len, cx).into(),
|
||||
)
|
||||
}
|
||||
|
||||
|
|
|
@ -180,7 +180,7 @@ impl<'tcx, Tag> MPlaceTy<'tcx, Tag> {
|
|||
#[inline]
|
||||
pub fn dangling(layout: TyLayout<'tcx>, cx: &impl HasDataLayout) -> Self {
|
||||
let align = layout.align.abi;
|
||||
let ptr = Scalar::from_uint(align.bytes(), cx.pointer_size());
|
||||
let ptr = Scalar::from_machine_usize(align.bytes(), cx);
|
||||
// `Poison` this to make sure that the pointer value `ptr` is never observable by the program.
|
||||
MPlaceTy { mplace: MemPlace { ptr, align, meta: MemPlaceMeta::Poison }, layout }
|
||||
}
|
||||
|
@ -504,7 +504,7 @@ where
|
|||
// implement this.
|
||||
ty::Array(inner, _) => (MemPlaceMeta::None, self.tcx.mk_array(inner, inner_len)),
|
||||
ty::Slice(..) => {
|
||||
let len = Scalar::from_uint(inner_len, self.pointer_size());
|
||||
let len = Scalar::from_machine_usize(inner_len, self);
|
||||
(MemPlaceMeta::Meta(len), base.layout.ty)
|
||||
}
|
||||
_ => bug!("cannot subslice non-array type: `{:?}`", base.layout.ty),
|
||||
|
@ -1044,7 +1044,7 @@ where
|
|||
kind: MemoryKind<M::MemoryKind>,
|
||||
) -> MPlaceTy<'tcx, M::PointerTag> {
|
||||
let ptr = self.memory.allocate_bytes(str.as_bytes(), kind);
|
||||
let meta = Scalar::from_uint(u128::try_from(str.len()).unwrap(), self.pointer_size());
|
||||
let meta = Scalar::from_machine_usize(u64::try_from(str.len()).unwrap(), self);
|
||||
let mplace = MemPlace {
|
||||
ptr: ptr.into(),
|
||||
align: Align::from_bytes(1).unwrap(),
|
||||
|
|
|
@ -3,7 +3,7 @@
|
|||
//! The main entry point is the `step` method.
|
||||
|
||||
use rustc::mir;
|
||||
use rustc::mir::interpret::{InterpResult, PointerArithmetic, Scalar};
|
||||
use rustc::mir::interpret::{InterpResult, Scalar};
|
||||
use rustc::ty::layout::LayoutOf;
|
||||
|
||||
use super::{InterpCx, Machine};
|
||||
|
@ -229,8 +229,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
|
|||
let src = self.eval_place(place)?;
|
||||
let mplace = self.force_allocation(src)?;
|
||||
let len = mplace.len(self)?;
|
||||
let size = self.pointer_size();
|
||||
self.write_scalar(Scalar::from_uint(len, size), dest)?;
|
||||
self.write_scalar(Scalar::from_machine_usize(len, self), dest)?;
|
||||
}
|
||||
|
||||
AddressOf(_, ref place) | Ref(_, _, ref place) => {
|
||||
|
@ -254,8 +253,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
|
|||
!layout.is_unsized(),
|
||||
"SizeOf nullary MIR operator called for unsized type"
|
||||
);
|
||||
let size = self.pointer_size();
|
||||
self.write_scalar(Scalar::from_uint(layout.size.bytes(), size), dest)?;
|
||||
self.write_scalar(Scalar::from_machine_usize(layout.size.bytes(), self), dest)?;
|
||||
}
|
||||
|
||||
Cast(kind, ref operand, _) => {
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue