Auto merge of rust-lang#55393 - oli-obk:immediate_immediately, r=RalfJung

Rename `Value` to `Immediate` for miri

r? @RalfJung

Author: bors

src/librustc_mir/const_eval.rs

@@ -32,7 +32,7 @@ use syntax::ast::Mutability;
 use syntax::source_map::{Span, DUMMY_SP};
 
 use interpret::{self,
-    PlaceTy, MemPlace, OpTy, Operand, Value, Scalar, ConstValue, Pointer,
+    PlaceTy, MemPlace, OpTy, Operand, Immediate, Scalar, ConstValue, Pointer,
     EvalResult, EvalError, EvalErrorKind, GlobalId, EvalContext, StackPopCleanup,
     Allocation, AllocId, MemoryKind,
     snapshot, RefTracking,
@@ -115,7 +115,7 @@ pub fn op_to_const<'tcx>(
             _ => false,
         };
     let normalized_op = if normalize {
-        ecx.try_read_value(op)?
+        ecx.try_read_immediate(op)?
     } else {
         match op.op {
             Operand::Indirect(mplace) => Err(mplace),
@@ -137,9 +137,9 @@ pub fn op_to_const<'tcx>(
             let alloc = ecx.tcx.intern_const_alloc(alloc);
             ConstValue::ByRef(ptr.alloc_id, alloc, ptr.offset)
         },
-        Ok(Value::Scalar(x)) =>
+        Ok(Immediate::Scalar(x)) =>
             ConstValue::Scalar(x.not_undef()?),
-        Ok(Value::ScalarPair(a, b)) =>
+        Ok(Immediate::ScalarPair(a, b)) =>
             ConstValue::ScalarPair(a.not_undef()?, b.not_undef()?),
     };
     Ok(ty::Const::from_const_value(ecx.tcx.tcx, val, op.layout.ty))

src/librustc_mir/interpret/cast.rs

@@ -19,7 +19,7 @@ use rustc::mir::interpret::{
 use rustc::mir::CastKind;
 use rustc_apfloat::Float;
 
-use super::{EvalContext, Machine, PlaceTy, OpTy, Value};
+use super::{EvalContext, Machine, PlaceTy, OpTy, Immediate};
 
 impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
     fn type_is_fat_ptr(&self, ty: Ty<'tcx>) -> bool {
@@ -45,7 +45,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
 
             Misc => {
                 let src_layout = src.layout;
-                let src = self.read_value(src)?;
+                let src = self.read_immediate(src)?;
 
                 let src = if M::ENABLE_PTR_TRACKING_HOOKS && src_layout.ty.is_region_ptr() {
                     // The only `Misc` casts on references are those creating raw pointers.
@@ -61,14 +61,14 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
                 if self.type_is_fat_ptr(src_layout.ty) {
                     match (src, self.type_is_fat_ptr(dest.layout.ty)) {
                         // pointers to extern types
-                        (Value::Scalar(_),_) |
+                        (Immediate::Scalar(_),_) |
                         // slices and trait objects to other slices/trait objects
-                        (Value::ScalarPair(..), true) => {
-                            // No change to value
-                            self.write_value(src, dest)?;
+                        (Immediate::ScalarPair(..), true) => {
+                            // No change to immediate
+                            self.write_immediate(src, dest)?;
                         }
                         // slices and trait objects to thin pointers (dropping the metadata)
-                        (Value::ScalarPair(data, _), false) => {
+                        (Immediate::ScalarPair(data, _), false) => {
                             self.write_scalar(data, dest)?;
                         }
                     }
@@ -118,11 +118,11 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
             }
 
             UnsafeFnPointer => {
-                let src = self.read_value(src)?;
+                let src = self.read_immediate(src)?;
                 match dest.layout.ty.sty {
                     ty::FnPtr(_) => {
                         // No change to value
-                        self.write_value(*src, dest)?;
+                        self.write_immediate(*src, dest)?;
                     }
                     ref other => bug!("fn to unsafe fn cast on {:?}", other),
                 }
@@ -144,8 +144,8 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
                             ty::ClosureKind::FnOnce,
                         );
                         let fn_ptr = self.memory.create_fn_alloc(instance).with_default_tag();
-                        let val = Value::Scalar(Scalar::Ptr(fn_ptr.into()).into());
-                        self.write_value(val, dest)?;
+                        let val = Immediate::Scalar(Scalar::Ptr(fn_ptr.into()).into());
+                        self.write_immediate(val, dest)?;
                     }
                     ref other => bug!("closure fn pointer on {:?}", other),
                 }
@@ -326,24 +326,28 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
 
         match (&src_pointee_ty.sty, &dest_pointee_ty.sty) {
             (&ty::Array(_, length), &ty::Slice(_)) => {
-                let ptr = self.read_value(src)?.to_scalar_ptr()?;
+                let ptr = self.read_immediate(src)?.to_scalar_ptr()?;
                 // u64 cast is from usize to u64, which is always good
-                let val = Value::new_slice(ptr, length.unwrap_usize(self.tcx.tcx), self.tcx.tcx);
-                self.write_value(val, dest)
+                let val = Immediate::new_slice(
+                    ptr,
+                    length.unwrap_usize(self.tcx.tcx),
+                    self.tcx.tcx,
+                );
+                self.write_immediate(val, dest)
             }
             (&ty::Dynamic(..), &ty::Dynamic(..)) => {
                 // For now, upcasts are limited to changes in marker
                 // traits, and hence never actually require an actual
                 // change to the vtable.
-                let val = self.read_value(src)?;
-                self.write_value(*val, dest)
+                let val = self.read_immediate(src)?;
+                self.write_immediate(*val, dest)
             }
             (_, &ty::Dynamic(ref data, _)) => {
                 // Initial cast from sized to dyn trait
                 let vtable = self.get_vtable(src_pointee_ty, data.principal())?;
-                let ptr = self.read_value(src)?.to_scalar_ptr()?;
-                let val = Value::new_dyn_trait(ptr, vtable);
-                self.write_value(val, dest)
+                let ptr = self.read_immediate(src)?.to_scalar_ptr()?;
+                let val = Immediate::new_dyn_trait(ptr, vtable);
+                self.write_immediate(val, dest)
             }
 
             _ => bug!("invalid unsizing {:?} -> {:?}", src.layout.ty, dest.layout.ty),

src/librustc_mir/interpret/eval_context.rs

@@ -32,7 +32,7 @@ use rustc::mir::interpret::{
 use rustc_data_structures::fx::FxHashMap;
 
 use super::{
-    Value, Operand, MemPlace, MPlaceTy, Place, PlaceTy, ScalarMaybeUndef,
+    Immediate, Operand, MemPlace, MPlaceTy, Place, PlaceTy, ScalarMaybeUndef,
     Memory, Machine
 };
 
@@ -333,9 +333,9 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tc
         self.layout_of(local_ty)
     }
 
-    pub fn str_to_value(&mut self, s: &str) -> EvalResult<'tcx, Value<M::PointerTag>> {
+    pub fn str_to_immediate(&mut self, s: &str) -> EvalResult<'tcx, Immediate<M::PointerTag>> {
         let ptr = self.memory.allocate_static_bytes(s.as_bytes()).with_default_tag();
-        Ok(Value::new_slice(Scalar::Ptr(ptr), s.len() as u64, self.tcx.tcx))
+        Ok(Immediate::new_slice(Scalar::Ptr(ptr), s.len() as u64, self.tcx.tcx))
     }
 
     /// Return the actual dynamic size and alignment of the place at the given type.
@@ -457,11 +457,11 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tc
 
         // don't allocate at all for trivial constants
         if mir.local_decls.len() > 1 {
-            // We put some marker value into the locals that we later want to initialize.
+            // We put some marker immediate into the locals that we later want to initialize.
             // This can be anything except for LocalValue::Dead -- because *that* is the
             // value we use for things that we know are initially dead.
             let dummy =
-                LocalValue::Live(Operand::Immediate(Value::Scalar(ScalarMaybeUndef::Undef)));
+                LocalValue::Live(Operand::Immediate(Immediate::Scalar(ScalarMaybeUndef::Undef)));
             let mut locals = IndexVec::from_elem(dummy, &mir.local_decls);
             // Return place is handled specially by the `eval_place` functions, and the
             // entry in `locals` should never be used. Make it dead, to be sure.
@@ -652,13 +652,13 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tc
                             ptr => write!(msg, " by integral ref: {:?}", ptr).unwrap(),
                         }
                     }
-                    Ok(Operand::Immediate(Value::Scalar(val))) => {
+                    Ok(Operand::Immediate(Immediate::Scalar(val))) => {
                         write!(msg, " {:?}", val).unwrap();
                         if let ScalarMaybeUndef::Scalar(Scalar::Ptr(ptr)) = val {
                             allocs.push(ptr.alloc_id);
                         }
                     }
-                    Ok(Operand::Immediate(Value::ScalarPair(val1, val2))) => {
+                    Ok(Operand::Immediate(Immediate::ScalarPair(val1, val2))) => {
                         write!(msg, " ({:?}, {:?})", val1, val2).unwrap();
                         if let ScalarMaybeUndef::Scalar(Scalar::Ptr(ptr)) = val1 {
                             allocs.push(ptr.alloc_id);

src/librustc_mir/interpret/intrinsics.rs

@@ -115,8 +115,8 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
             | "add_with_overflow"
             | "sub_with_overflow"
             | "mul_with_overflow" => {
-                let lhs = self.read_value(args[0])?;
-                let rhs = self.read_value(args[1])?;
+                let lhs = self.read_immediate(args[0])?;
+                let rhs = self.read_immediate(args[1])?;
                 let (bin_op, ignore_overflow) = match intrinsic_name {
                     "overflowing_add" => (BinOp::Add, true),
                     "overflowing_sub" => (BinOp::Sub, true),
@@ -133,8 +133,8 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
                 }
             }
             "unchecked_shl" | "unchecked_shr" => {
-                let l = self.read_value(args[0])?;
-                let r = self.read_value(args[1])?;
+                let l = self.read_immediate(args[0])?;
+                let r = self.read_immediate(args[1])?;
                 let bin_op = match intrinsic_name {
                     "unchecked_shl" => BinOp::Shl,
                     "unchecked_shr" => BinOp::Shr,
@@ -172,8 +172,8 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
         // Some fn calls are actually BinOp intrinsics
         if let Some((op, oflo)) = self.tcx.is_binop_lang_item(def_id) {
             let dest = dest.expect("128 lowerings can't diverge");
-            let l = self.read_value(args[0])?;
-            let r = self.read_value(args[1])?;
+            let l = self.read_immediate(args[0])?;
+            let r = self.read_immediate(args[1])?;
             if oflo {
                 self.binop_with_overflow(op, l, r, dest)?;
             } else {
@@ -183,7 +183,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
         } else if Some(def_id) == self.tcx.lang_items().panic_fn() {
             assert!(args.len() == 1);
             // &(&'static str, &'static str, u32, u32)
-            let ptr = self.read_value(args[0])?;
+            let ptr = self.read_immediate(args[0])?;
             let place = self.ref_to_mplace(ptr)?;
             let (msg, file, line, col) = (
                 self.mplace_field(place, 0)?,
@@ -192,9 +192,9 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
                 self.mplace_field(place, 3)?,
             );
 
-            let msg_place = self.ref_to_mplace(self.read_value(msg.into())?)?;
+            let msg_place = self.ref_to_mplace(self.read_immediate(msg.into())?)?;
             let msg = Symbol::intern(self.read_str(msg_place)?);
-            let file_place = self.ref_to_mplace(self.read_value(file.into())?)?;
+            let file_place = self.ref_to_mplace(self.read_immediate(file.into())?)?;
             let file = Symbol::intern(self.read_str(file_place)?);
             let line = self.read_scalar(line.into())?.to_u32()?;
             let col = self.read_scalar(col.into())?.to_u32()?;
@@ -203,17 +203,17 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
             assert!(args.len() == 2);
             // &'static str, &(&'static str, u32, u32)
             let msg = args[0];
-            let ptr = self.read_value(args[1])?;
+            let ptr = self.read_immediate(args[1])?;
             let place = self.ref_to_mplace(ptr)?;
             let (file, line, col) = (
                 self.mplace_field(place, 0)?,
                 self.mplace_field(place, 1)?,
                 self.mplace_field(place, 2)?,
             );
 
-            let msg_place = self.ref_to_mplace(self.read_value(msg.into())?)?;
+            let msg_place = self.ref_to_mplace(self.read_immediate(msg.into())?)?;
             let msg = Symbol::intern(self.read_str(msg_place)?);
-            let file_place = self.ref_to_mplace(self.read_value(file.into())?)?;
+            let file_place = self.ref_to_mplace(self.read_immediate(file.into())?)?;
             let file = Symbol::intern(self.read_str(file_place)?);
             let line = self.read_scalar(line.into())?.to_u32()?;
             let col = self.read_scalar(col.into())?.to_u32()?;

src/librustc_mir/interpret/mod.rs

@@ -36,6 +36,6 @@ pub use self::memory::{Memory, MemoryKind};
 
 pub use self::machine::{Machine, AllocMap, MayLeak};
 
-pub use self::operand::{ScalarMaybeUndef, Value, ValTy, Operand, OpTy};
+pub use self::operand::{ScalarMaybeUndef, Immediate, ImmTy, Operand, OpTy};
 
 pub use self::validity::RefTracking;