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

primval -> scalar rename

Browse source
This commit is contained in:
Oliver Schneider 2018-05-22 19:30:16 +02:00
parent 1550fd212b
commit f82256e473
12 changed files with 79 additions and 79 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/librustc/mir/interpret/value.rs
View file

@ -37,12 +37,12 @@ impl<'tcx> ConstValue<'tcx> {
}
#[inline]
pub fn from_primval(val: Scalar) -> Self {
pub fn from_scalar(val: Scalar) -> Self {
ConstValue::Scalar(val)
}
#[inline]
pub fn to_primval(&self) -> Option<Scalar> {
pub fn to_scalar(&self) -> Option<Scalar> {
match *self {
ConstValue::ByRef(..) => None,
ConstValue::ScalarPair(..) => None,
@ -52,12 +52,12 @@ impl<'tcx> ConstValue<'tcx> {
#[inline]
pub fn to_bits(&self, size: Size) -> Option<u128> {
self.to_primval()?.to_bits(size).ok()
self.to_scalar()?.to_bits(size).ok()
}
#[inline]
pub fn to_ptr(&self) -> Option<Pointer> {
self.to_primval()?.to_ptr().ok()
self.to_scalar()?.to_ptr().ok()
}
}

12
src/librustc/ty/sty.rs
View file

@ -1830,12 +1830,12 @@ impl<'tcx> Const<'tcx> {
}
#[inline]
pub fn from_primval(
pub fn from_scalar(
tcx: TyCtxt<'_, '_, 'tcx>,
val: Scalar,
ty: Ty<'tcx>,
) -> &'tcx Self {
Self::from_const_value(tcx, ConstValue::from_primval(val), ty)
Self::from_const_value(tcx, ConstValue::from_scalar(val), ty)
}
#[inline]
@ -1847,12 +1847,12 @@ impl<'tcx> Const<'tcx> {
let defined = ty.scalar_size(tcx).unwrap_or_else(|| {
panic!("non-scalar type in from_bits: {:?}", ty)
}).bits() as u8;
Self::from_primval(tcx, Scalar::Bits { bits, defined }, ty)
Self::from_scalar(tcx, Scalar::Bits { bits, defined }, ty)
}
#[inline]
pub fn zero_sized(tcx: TyCtxt<'_, '_, 'tcx>, ty: Ty<'tcx>) -> &'tcx Self {
Self::from_primval(tcx, Scalar::undef(), ty)
Self::from_scalar(tcx, Scalar::undef(), ty)
}
#[inline]
@ -1894,9 +1894,9 @@ impl<'tcx> Const<'tcx> {
}
#[inline]
pub fn to_primval(&self) -> Option<Scalar> {
pub fn to_scalar(&self) -> Option<Scalar> {
match self.val {
ConstVal::Value(val) => val.to_primval(),
ConstVal::Value(val) => val.to_scalar(),
_ => None,
}
}

8
src/librustc_codegen_llvm/mir/constant.rs
View file

@ -28,7 +28,7 @@ use syntax::ast::Mutability;
use super::super::callee;
use super::FunctionCx;
pub fn primval_to_llvm(cx: &CodegenCx,
pub fn scalar_to_llvm(cx: &CodegenCx,
cv: Scalar,
layout: &layout::Scalar,
llty: Type) -> ValueRef {
@ -96,7 +96,7 @@ pub fn const_alloc_to_llvm(cx: &CodegenCx, alloc: &Allocation) -> ValueRef {
layout.endian,
&alloc.bytes[offset..(offset + pointer_size)],
).expect("const_alloc_to_llvm: could not read relocation pointer") as u64;
llvals.push(primval_to_llvm(
llvals.push(scalar_to_llvm(
cx,
Pointer { alloc_id, offset: Size::from_bytes(ptr_offset) }.into(),
&layout::Scalar {
@ -199,13 +199,13 @@ impl<'a, 'tcx> FunctionCx<'a, 'tcx> {
c,
constant.ty,
)?;
if let Some(prim) = field.to_primval() {
if let Some(prim) = field.to_scalar() {
let layout = bx.cx.layout_of(field_ty);
let scalar = match layout.abi {
layout::Abi::Scalar(ref x) => x,
_ => bug!("from_const: invalid ByVal layout: {:#?}", layout)
};
Ok(primval_to_llvm(
Ok(scalar_to_llvm(
bx.cx, prim, scalar,
layout.immediate_llvm_type(bx.cx),
))

8
src/librustc_codegen_llvm/mir/operand.rs
View file

@ -28,7 +28,7 @@ use std::fmt;
use std::ptr;
use super::{FunctionCx, LocalRef};
use super::constant::{primval_to_llvm, const_alloc_to_llvm};
use super::constant::{scalar_to_llvm, const_alloc_to_llvm};
use super::place::PlaceRef;
/// The representation of a Rust value. The enum variant is in fact
@ -110,7 +110,7 @@ impl<'a, 'tcx> OperandRef<'tcx> {
layout::Abi::Scalar(ref x) => x,
_ => bug!("from_const: invalid ByVal layout: {:#?}", layout)
};
let llval = primval_to_llvm(
let llval = scalar_to_llvm(
bx.cx,
x,
scalar,
@ -123,13 +123,13 @@ impl<'a, 'tcx> OperandRef<'tcx> {
layout::Abi::ScalarPair(ref a, ref b) => (a, b),
_ => bug!("from_const: invalid ScalarPair layout: {:#?}", layout)
};
let a_llval = primval_to_llvm(
let a_llval = scalar_to_llvm(
bx.cx,
a,
a_scalar,
layout.scalar_pair_element_llvm_type(bx.cx, 0),
);
let b_llval = primval_to_llvm(
let b_llval = scalar_to_llvm(
bx.cx,
b,
b_scalar,

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

@ -8,7 +8,7 @@ use rustc::mir::interpret::{Scalar, EvalResult, Pointer, PointerArithmetic};
use rustc_apfloat::Float;
impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
pub(super) fn cast_primval(
pub(super) fn cast_scalar(
&self,
val: Scalar,
src_ty: Ty<'tcx>,

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

@ -323,7 +323,7 @@ impl<'mir, 'tcx> super::Machine<'mir, 'tcx> for CompileTimeEvaluator {
bits: elem_align as u128,
defined: dest_layout.size.bits() as u8,
};
ecx.write_primval(dest, align_val, dest_layout.ty)?;
ecx.write_scalar(dest, align_val, dest_layout.ty)?;
}
"size_of" => {
@ -333,7 +333,7 @@ impl<'mir, 'tcx> super::Machine<'mir, 'tcx> for CompileTimeEvaluator {
bits: size,
defined: dest_layout.size.bits() as u8,
};
ecx.write_primval(dest, size_val, dest_layout.ty)?;
ecx.write_scalar(dest, size_val, dest_layout.ty)?;
}
"type_id" => {
@ -343,7 +343,7 @@ impl<'mir, 'tcx> super::Machine<'mir, 'tcx> for CompileTimeEvaluator {
bits: type_id,
defined: dest_layout.size.bits() as u8,
};
ecx.write_primval(dest, id_val, dest_layout.ty)?;
ecx.write_scalar(dest, id_val, dest_layout.ty)?;
}
name => return Err(ConstEvalError::NeedsRfc(format!("calling intrinsic `{}`", name)).into()),
@ -488,7 +488,7 @@ pub fn const_variant_index<'a, 'tcx>(
},
Value::ByRef(ptr, align) => (ptr, align),
};
let place = Place::from_primval_ptr(ptr, align);
let place = Place::from_scalar_ptr(ptr, align);
ecx.read_discriminant_as_variant_index(place, ty)
}

68
src/librustc_mir/interpret/eval_context.rs
View file

@ -546,9 +546,9 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
}
UnaryOp(un_op, ref operand) => {
let val = self.eval_operand_to_primval(operand)?;
let val = self.eval_operand_to_scalar(operand)?;
let val = self.unary_op(un_op, val, dest_ty)?;
self.write_primval(
self.write_scalar(
dest,
val,
dest_ty,
@ -610,7 +610,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
let ty = self.place_ty(place);
let (_, len) = src.elem_ty_and_len(ty, self.tcx.tcx);
let defined = self.memory.pointer_size().bits() as u8;
self.write_primval(
self.write_scalar(
dest,
Scalar::Bits {
bits: len as u128,
@ -652,7 +652,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
assert!(!layout.is_unsized(),
"SizeOf nullary MIR operator called for unsized type");
let defined = self.memory.pointer_size().bits() as u8;
self.write_primval(
self.write_scalar(
dest,
Scalar::Bits {
bits: layout.size.bytes() as u128,
@ -709,7 +709,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
.scalar_size(self.tcx.tcx)
.expect("can only cast variants to ints")
.bits() as u8;
return self.write_primval(
return self.write_scalar(
dest,
Scalar::Bits {
bits: discr_val,
@ -722,8 +722,8 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
layout::Variants::NicheFilling { .. } => {},
}
let src_val = self.value_to_primval(src)?;
let dest_val = self.cast_primval(src_val, src.ty, dest_ty)?;
let src_val = self.value_to_scalar(src)?;
let dest_val = self.cast_scalar(src_val, src.ty, dest_ty)?;
let valty = ValTy {
value: Value::Scalar(dest_val),
ty: dest_ty,
@ -799,7 +799,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
let place = self.eval_place(place)?;
let discr_val = self.read_discriminant_value(place, ty)?;
let defined = ty.scalar_size(self.tcx.tcx).expect("discriminant must be scalar").bits() as u8;
self.write_primval(dest, Scalar::Bits {
self.write_scalar(dest, Scalar::Bits {
bits: discr_val,
defined,
}, dest_ty)?;
@ -820,12 +820,12 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
}
}
pub(super) fn eval_operand_to_primval(
pub(super) fn eval_operand_to_scalar(
&mut self,
op: &mir::Operand<'tcx>,
) -> EvalResult<'tcx, Scalar> {
let valty = self.eval_operand(op)?;
self.value_to_primval(valty)
self.value_to_scalar(valty)
}
pub(crate) fn operands_to_args(
@ -923,7 +923,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
let (discr_place, discr) = self.place_field(place, mir::Field::new(0), layout)?;
trace!("discr place: {:?}, {:?}", discr_place, discr);
let raw_discr = self.value_to_primval(ValTy {
let raw_discr = self.value_to_scalar(ValTy {
value: self.read_place(discr_place)?,
ty: discr.ty
})?;
@ -1014,7 +1014,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
let discr_val = (discr_val << amt) >> amt;
let (discr_dest, tag) = self.place_field(dest, mir::Field::new(0), layout)?;
self.write_primval(discr_dest, Scalar::Bits {
self.write_scalar(discr_dest, Scalar::Bits {
bits: discr_val,
defined: size as u8,
}, tag.ty)?;
@ -1030,7 +1030,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
self.place_field(dest, mir::Field::new(0), layout)?;
let niche_value = ((variant_index - niche_variants.start()) as u128)
.wrapping_add(niche_start);
self.write_primval(niche_dest, Scalar::Bits {
self.write_scalar(niche_dest, Scalar::Bits {
bits: niche_value,
defined: niche.size.bits() as u8,
}, niche.ty)?;
@ -1116,20 +1116,20 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
}
}
pub fn value_to_primval(
pub fn value_to_scalar(
&self,
ValTy { value, ty } : ValTy<'tcx>,
) -> EvalResult<'tcx, Scalar> {
match self.follow_by_ref_value(value, ty)? {
Value::ByRef { .. } => bug!("follow_by_ref_value can't result in `ByRef`"),
Value::Scalar(primval) => {
Value::Scalar(scalar) => {
// TODO: Do we really want insta-UB here?
self.ensure_valid_value(primval, ty)?;
Ok(primval)
self.ensure_valid_value(scalar, ty)?;
Ok(scalar)
}
Value::ScalarPair(..) => bug!("value_to_primval can't work with fat pointers"),
Value::ScalarPair(..) => bug!("value_to_scalar can't work with fat pointers"),
}
}
@ -1141,7 +1141,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
self.write_value(valty, dest)
}
pub fn write_primval(
pub fn write_scalar(
&mut self,
dest: Place,
val: Scalar,
@ -1240,18 +1240,18 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
Value::ByRef(ptr, align) => {
self.memory.copy(ptr, align.min(layout.align), dest, dest_align.min(layout.align), layout.size, false)
}
Value::Scalar(primval) => {
Value::Scalar(scalar) => {
let signed = match layout.abi {
layout::Abi::Scalar(ref scal) => match scal.value {
layout::Primitive::Int(_, signed) => signed,
_ => false,
},
_ => match primval {
_ => match scalar {
Scalar::Bits { defined: 0, .. } => false,
_ => bug!("write_value_to_ptr: invalid ByVal layout: {:#?}", layout),
}
};
self.memory.write_primval(dest, dest_align, primval, layout.size, signed)
self.memory.write_scalar(dest, dest_align, scalar, layout.size, signed)
}
Value::ScalarPair(a_val, b_val) => {
trace!("write_value_to_ptr valpair: {:#?}", layout);
@ -1264,13 +1264,13 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
let b_offset = a_size.abi_align(b.align(&self));
let b_ptr = dest.ptr_offset(b_offset, &self)?.into();
// TODO: What about signedess?
self.memory.write_primval(a_ptr, dest_align, a_val, a_size, false)?;
self.memory.write_primval(b_ptr, dest_align, b_val, b_size, false)
self.memory.write_scalar(a_ptr, dest_align, a_val, a_size, false)?;
self.memory.write_scalar(b_ptr, dest_align, b_val, b_size, false)
}
}
}
pub fn ty_to_primval_kind(&self, ty: Ty<'tcx>) -> EvalResult<'tcx, ScalarKind> {
pub fn ty_to_scalar_kind(&self, ty: Ty<'tcx>) -> EvalResult<'tcx, ScalarKind> {
use syntax::ast::FloatTy;
let kind = match ty.sty {
@ -1382,7 +1382,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
.to_bits(ptr_size)?;
Ok(p.to_value_with_len(len as u64, self.tcx.tcx))
},
_ => bug!("unsized primval ptr read from {:?}", pointee_ty),
_ => bug!("unsized scalar ptr read from {:?}", pointee_ty),
}
}
}
@ -1395,10 +1395,10 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
) -> EvalResult<'tcx> {
match ty.sty {
ty::TyBool => {
self.memory.read_primval(ptr, ptr_align, Size::from_bytes(1))?.to_bool()?;
self.memory.read_scalar(ptr, ptr_align, Size::from_bytes(1))?.to_bool()?;
}
ty::TyChar => {
let c = self.memory.read_primval(ptr, ptr_align, Size::from_bytes(4))?.to_bits(Size::from_bytes(4))? as u32;
let c = self.memory.read_scalar(ptr, ptr_align, Size::from_bytes(4))?.to_bits(Size::from_bytes(4))? as u32;
match ::std::char::from_u32(c) {
Some(..) => (),
None => return err!(InvalidChar(c as u128)),
@ -1421,7 +1421,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
if let layout::Abi::Scalar(ref scalar) = self.layout_of(ty)?.abi {
let size = scalar.value.size(self);
self.memory.read_primval(ptr, ptr_align, size)?;
self.memory.read_scalar(ptr, ptr_align, size)?;
}
}
@ -1455,8 +1455,8 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
match layout.abi {
layout::Abi::Scalar(..) => {
let primval = self.memory.read_primval(ptr, ptr_align, layout.size)?;
Ok(Some(Value::Scalar(primval)))
let scalar = self.memory.read_scalar(ptr, ptr_align, layout.size)?;
Ok(Some(Value::Scalar(scalar)))
}
layout::Abi::ScalarPair(ref a, ref b) => {
let (a, b) = (&a.value, &b.value);
@ -1464,8 +1464,8 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
let a_ptr = ptr;
let b_offset = a_size.abi_align(b.align(self));
let b_ptr = ptr.offset(b_offset, self)?.into();
let a_val = self.memory.read_primval(a_ptr, ptr_align, a_size)?;
let b_val = self.memory.read_primval(b_ptr, ptr_align, b_size)?;
let a_val = self.memory.read_scalar(a_ptr, ptr_align, a_size)?;
let b_val = self.memory.read_scalar(b_ptr, ptr_align, b_size)?;
Ok(Some(Value::ScalarPair(a_val, b_val)))
}
_ => Ok(None),
@ -1584,7 +1584,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
}
let (src_f_value, src_field) = match src {
Value::ByRef(ptr, align) => {
let src_place = Place::from_primval_ptr(ptr, align);
let src_place = Place::from_scalar_ptr(ptr, align);
let (src_f_place, src_field) =
self.place_field(src_place, mir::Field::new(i), src_layout)?;
(self.read_place(src_f_place)?, src_field)

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

@ -707,7 +707,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> {
Ok(())
}
pub fn read_primval(&self, ptr: Pointer, ptr_align: Align, size: Size) -> EvalResult<'tcx, Scalar> {
pub fn read_scalar(&self, ptr: Pointer, ptr_align: Align, size: Size) -> EvalResult<'tcx, Scalar> {
self.check_relocation_edges(ptr, size)?; // Make sure we don't read part of a pointer as a pointer
let endianness = self.endianness();
let bytes = self.get_bytes_unchecked(ptr, size, ptr_align.min(self.int_align(size)))?;
@ -738,10 +738,10 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> {
}
pub fn read_ptr_sized(&self, ptr: Pointer, ptr_align: Align) -> EvalResult<'tcx, Scalar> {
self.read_primval(ptr, ptr_align, self.pointer_size())
self.read_scalar(ptr, ptr_align, self.pointer_size())
}
pub fn write_primval(&mut self, ptr: Scalar, ptr_align: Align, val: Scalar, size: Size, signed: bool) -> EvalResult<'tcx> {
pub fn write_scalar(&mut self, ptr: Scalar, ptr_align: Align, val: Scalar, size: Size, signed: bool) -> EvalResult<'tcx> {
let endianness = self.endianness();
let bytes = match val {
@ -787,7 +787,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> {
pub fn write_ptr_sized_unsigned(&mut self, ptr: Pointer, ptr_align: Align, val: Scalar) -> EvalResult<'tcx> {
let ptr_size = self.pointer_size();
self.write_primval(ptr.into(), ptr_align, val, ptr_size, false)
self.write_scalar(ptr.into(), ptr_align, val, ptr_size, false)
}
fn int_align(&self, size: Size) -> Align {

10
src/librustc_mir/interpret/operator.rs
View file

@ -16,8 +16,8 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
left: ValTy<'tcx>,
right: ValTy<'tcx>,
) -> EvalResult<'tcx, (Scalar, bool)> {
let left_val = self.value_to_primval(left)?;
let right_val = self.value_to_primval(right)?;
let left_val = self.value_to_scalar(left)?;
let right_val = self.value_to_scalar(right)?;
self.binary_op(op, left_val, left.ty, right_val, right.ty)
}
@ -51,7 +51,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
dest_ty: Ty<'tcx>,
) -> EvalResult<'tcx, bool> {
let (val, overflowed) = self.binop_with_overflow(op, left, right)?;
self.write_primval(dest, val, dest_ty)?;
self.write_scalar(dest, val, dest_ty)?;
Ok(overflowed)
}
}
@ -68,8 +68,8 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
) -> EvalResult<'tcx, (Scalar, bool)> {
use rustc::mir::BinOp::*;
let left_kind = self.ty_to_primval_kind(left_ty)?;
let right_kind = self.ty_to_primval_kind(right_ty)?;
let left_kind = self.ty_to_scalar_kind(left_ty)?;
let right_kind = self.ty_to_scalar_kind(right_ty)?;
trace!("Running binary op {:?}: {:?} ({:?}), {:?} ({:?})", bin_op, left, left_kind, right, right_kind);
// I: Handle operations that support pointers

10
src/librustc_mir/interpret/place.rs
View file

@ -35,10 +35,10 @@ pub enum PlaceExtra {
impl<'tcx> Place {
/// Produces a Place that will error if attempted to be read from
pub fn undef() -> Self {
Self::from_primval_ptr(Scalar::undef().into(), Align::from_bytes(1, 1).unwrap())
Self::from_scalar_ptr(Scalar::undef().into(), Align::from_bytes(1, 1).unwrap())
}
pub fn from_primval_ptr(ptr: Scalar, align: Align) -> Self {
pub fn from_scalar_ptr(ptr: Scalar, align: Align) -> Self {
Place::Ptr {
ptr,
align,
@ -47,7 +47,7 @@ impl<'tcx> Place {
}
pub fn from_ptr(ptr: Pointer, align: Align) -> Self {
Self::from_primval_ptr(ptr.into(), align)
Self::from_scalar_ptr(ptr.into(), align)
}
pub fn to_ptr_align_extra(self) -> (Scalar, Align, PlaceExtra) {
@ -310,7 +310,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
extra: PlaceExtra::Length(len),
}
}
_ => Place::from_primval_ptr(self.into_ptr(val)?, layout.align),
_ => Place::from_scalar_ptr(self.into_ptr(val)?, layout.align),
})
}
@ -388,7 +388,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
let value = self.frame().get_local(local)?;
let ty = self.tcx.types.usize;
let n = self
.value_to_primval(ValTy { value, ty })?
.value_to_scalar(ValTy { value, ty })?
.to_bits(self.tcx.data_layout.pointer_size)?;
self.place_index(base, base_ty, n as u64)
}

10
src/librustc_mir/interpret/terminator/mod.rs
View file

@ -38,7 +38,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
..
} => {
let discr_val = self.eval_operand(discr)?;
let discr_prim = self.value_to_primval(discr_val)?;
let discr_prim = self.value_to_scalar(discr_val)?;
// Branch to the `otherwise` case by default, if no match is found.
let mut target_block = targets[targets.len() - 1];
@ -67,7 +67,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
let func = self.eval_operand(func)?;
let (fn_def, sig) = match func.ty.sty {
ty::TyFnPtr(sig) => {
let fn_ptr = self.value_to_primval(func)?.to_ptr()?;
let fn_ptr = self.value_to_scalar(func)?.to_ptr()?;
let instance = self.memory.get_fn(fn_ptr)?;
let instance_ty = instance.ty(*self.tcx);
match instance_ty.sty {
@ -144,17 +144,17 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
target,
..
} => {
let cond_val = self.eval_operand_to_primval(cond)?.to_bool()?;
let cond_val = self.eval_operand_to_scalar(cond)?.to_bool()?;
if expected == cond_val {
self.goto_block(target);
} else {
use rustc::mir::interpret::EvalErrorKind::*;
return match *msg {
BoundsCheck { ref len, ref index } => {
let len = self.eval_operand_to_primval(len)
let len = self.eval_operand_to_scalar(len)
.expect("can't eval len")
.to_bits(self.memory().pointer_size())? as u64;
let index = self.eval_operand_to_primval(index)
let index = self.eval_operand_to_scalar(index)
.expect("can't eval index")
.to_bits(self.memory().pointer_size())? as u64;
err!(BoundsCheck { len, index })

6
src/librustc_mir/transform/const_prop.rs
View file

@ -305,7 +305,7 @@ impl<'b, 'a, 'tcx:'b> ConstPropagator<'b, 'a, 'tcx> {
let val = self.eval_operand(arg)?;
let prim = self.use_ecx(span, |this| {
this.ecx.value_to_primval(ValTy { value: val.0, ty: val.1 })
this.ecx.value_to_scalar(ValTy { value: val.0, ty: val.1 })
})?;
let val = self.use_ecx(span, |this| this.ecx.unary_op(op, prim, val.1))?;
Some((Value::Scalar(val), place_ty, span))
@ -326,7 +326,7 @@ impl<'b, 'a, 'tcx:'b> ConstPropagator<'b, 'a, 'tcx> {
}
let r = self.use_ecx(span, |this| {
this.ecx.value_to_primval(ValTy { value: right.0, ty: right.1 })
this.ecx.value_to_scalar(ValTy { value: right.0, ty: right.1 })
})?;
if op == BinOp::Shr || op == BinOp::Shl {
let left_ty = left.ty(self.mir, self.tcx);
@ -353,7 +353,7 @@ impl<'b, 'a, 'tcx:'b> ConstPropagator<'b, 'a, 'tcx> {
}
let left = self.eval_operand(left)?;
let l = self.use_ecx(span, |this| {
this.ecx.value_to_primval(ValTy { value: left.0, ty: left.1 })
this.ecx.value_to_scalar(ValTy { value: left.0, ty: left.1 })
})?;
trace!("const evaluating {:?} for {:?} and {:?}", op, left, right);
let (val, overflow) = self.use_ecx(span, |this| {