From f82256e473aad86bd44eb9010178f378ae6470c6 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Tue, 22 May 2018 19:30:16 +0200 Subject: [PATCH] primval -> scalar rename --- src/librustc/mir/interpret/value.rs | 8 +-- src/librustc/ty/sty.rs | 12 ++-- src/librustc_codegen_llvm/mir/constant.rs | 8 +-- src/librustc_codegen_llvm/mir/operand.rs | 8 +-- src/librustc_mir/interpret/cast.rs | 2 +- src/librustc_mir/interpret/const_eval.rs | 8 +-- src/librustc_mir/interpret/eval_context.rs | 68 ++++++++++---------- src/librustc_mir/interpret/memory.rs | 8 +-- src/librustc_mir/interpret/operator.rs | 10 +-- src/librustc_mir/interpret/place.rs | 10 +-- src/librustc_mir/interpret/terminator/mod.rs | 10 +-- src/librustc_mir/transform/const_prop.rs | 6 +- 12 files changed, 79 insertions(+), 79 deletions(-) diff --git a/src/librustc/mir/interpret/value.rs b/src/librustc/mir/interpret/value.rs index 4a174d3fa959..2bda474a0a60 100644 --- a/src/librustc/mir/interpret/value.rs +++ b/src/librustc/mir/interpret/value.rs @@ -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 { + pub fn to_scalar(&self) -> Option { 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 { - self.to_primval()?.to_bits(size).ok() + self.to_scalar()?.to_bits(size).ok() } #[inline] pub fn to_ptr(&self) -> Option { - self.to_primval()?.to_ptr().ok() + self.to_scalar()?.to_ptr().ok() } } diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs index 4accc1b10f83..edec1fe280d3 100644 --- a/src/librustc/ty/sty.rs +++ b/src/librustc/ty/sty.rs @@ -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 { + pub fn to_scalar(&self) -> Option { match self.val { - ConstVal::Value(val) => val.to_primval(), + ConstVal::Value(val) => val.to_scalar(), _ => None, } } diff --git a/src/librustc_codegen_llvm/mir/constant.rs b/src/librustc_codegen_llvm/mir/constant.rs index fc3733f13985..ef0bc3ed3306 100644 --- a/src/librustc_codegen_llvm/mir/constant.rs +++ b/src/librustc_codegen_llvm/mir/constant.rs @@ -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), )) diff --git a/src/librustc_codegen_llvm/mir/operand.rs b/src/librustc_codegen_llvm/mir/operand.rs index 606b07d8095c..98383e882c4e 100644 --- a/src/librustc_codegen_llvm/mir/operand.rs +++ b/src/librustc_codegen_llvm/mir/operand.rs @@ -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, diff --git a/src/librustc_mir/interpret/cast.rs b/src/librustc_mir/interpret/cast.rs index 4efd89d3816d..fb80f80cd27d 100644 --- a/src/librustc_mir/interpret/cast.rs +++ b/src/librustc_mir/interpret/cast.rs @@ -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>, diff --git a/src/librustc_mir/interpret/const_eval.rs b/src/librustc_mir/interpret/const_eval.rs index 14de0e14cd41..b1f290d7b614 100644 --- a/src/librustc_mir/interpret/const_eval.rs +++ b/src/librustc_mir/interpret/const_eval.rs @@ -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) } diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs index 5e03e759af98..963e5b5ec623 100644 --- a/src/librustc_mir/interpret/eval_context.rs +++ b/src/librustc_mir/interpret/eval_context.rs @@ -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) diff --git a/src/librustc_mir/interpret/memory.rs b/src/librustc_mir/interpret/memory.rs index e0a12e5e9a40..42e93593028d 100644 --- a/src/librustc_mir/interpret/memory.rs +++ b/src/librustc_mir/interpret/memory.rs @@ -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 { diff --git a/src/librustc_mir/interpret/operator.rs b/src/librustc_mir/interpret/operator.rs index fff8da78dc14..13c576b4883e 100644 --- a/src/librustc_mir/interpret/operator.rs +++ b/src/librustc_mir/interpret/operator.rs @@ -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 diff --git a/src/librustc_mir/interpret/place.rs b/src/librustc_mir/interpret/place.rs index 1f4925a0ab2a..c1bcffe7e9aa 100644 --- a/src/librustc_mir/interpret/place.rs +++ b/src/librustc_mir/interpret/place.rs @@ -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) } diff --git a/src/librustc_mir/interpret/terminator/mod.rs b/src/librustc_mir/interpret/terminator/mod.rs index 8493a0849df4..2cc355b04e31 100644 --- a/src/librustc_mir/interpret/terminator/mod.rs +++ b/src/librustc_mir/interpret/terminator/mod.rs @@ -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 }) diff --git a/src/librustc_mir/transform/const_prop.rs b/src/librustc_mir/transform/const_prop.rs index d9d9104c9392..0083c22dc177 100644 --- a/src/librustc_mir/transform/const_prop.rs +++ b/src/librustc_mir/transform/const_prop.rs @@ -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| {