Skip to content

Commit ca4fa6f

Browse files
borsbors
committed
Auto merge of #55393 - oli-obk:immediate_immediately, r=RalfJung
Rename `Value` to `Immediate` for miri r? @RalfJung
2 parents ac70882 + 400f997 commit ca4fa6f

File tree

14 files changed

+196
-189
lines changed

14 files changed

+196
-189
lines changed

Diff for: ‎src/librustc_mir/const_eval.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,7 @@ use syntax::ast::Mutability;
3232
use syntax::source_map::{Span, DUMMY_SP};
3333

3434
use interpret::{self,
35-
PlaceTy, MemPlace, OpTy, Operand, Value, Scalar, ConstValue, Pointer,
35+
PlaceTy, MemPlace, OpTy, Operand, Immediate, Scalar, ConstValue, Pointer,
3636
EvalResult, EvalError, EvalErrorKind, GlobalId, EvalContext, StackPopCleanup,
3737
Allocation, AllocId, MemoryKind,
3838
snapshot, RefTracking,
@@ -115,7 +115,7 @@ pub fn op_to_const<'tcx>(
115115
_ => false,
116116
};
117117
let normalized_op = if normalize {
118-
ecx.try_read_value(op)?
118+
ecx.try_read_immediate(op)?
119119
} else {
120120
match op.op {
121121
Operand::Indirect(mplace) => Err(mplace),
@@ -137,9 +137,9 @@ pub fn op_to_const<'tcx>(
137137
let alloc = ecx.tcx.intern_const_alloc(alloc);
138138
ConstValue::ByRef(ptr.alloc_id, alloc, ptr.offset)
139139
},
140-
Ok(Value::Scalar(x)) =>
140+
Ok(Immediate::Scalar(x)) =>
141141
ConstValue::Scalar(x.not_undef()?),
142-
Ok(Value::ScalarPair(a, b)) =>
142+
Ok(Immediate::ScalarPair(a, b)) =>
143143
ConstValue::ScalarPair(a.not_undef()?, b.not_undef()?),
144144
};
145145
Ok(ty::Const::from_const_value(ecx.tcx.tcx, val, op.layout.ty))

Diff for: ‎src/librustc_mir/interpret/cast.rs

+23-19
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ use rustc::mir::interpret::{
1919
use rustc::mir::CastKind;
2020
use rustc_apfloat::Float;
2121

22-
use super::{EvalContext, Machine, PlaceTy, OpTy, Value};
22+
use super::{EvalContext, Machine, PlaceTy, OpTy, Immediate};
2323

2424
impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
2525
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>
4545

4646
Misc => {
4747
let src_layout = src.layout;
48-
let src = self.read_value(src)?;
48+
let src = self.read_immediate(src)?;
4949

5050
let src = if M::ENABLE_PTR_TRACKING_HOOKS && src_layout.ty.is_region_ptr() {
5151
// 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>
6161
if self.type_is_fat_ptr(src_layout.ty) {
6262
match (src, self.type_is_fat_ptr(dest.layout.ty)) {
6363
// pointers to extern types
64-
(Value::Scalar(_),_) |
64+
(Immediate::Scalar(_),_) |
6565
// slices and trait objects to other slices/trait objects
66-
(Value::ScalarPair(..), true) => {
67-
// No change to value
68-
self.write_value(src, dest)?;
66+
(Immediate::ScalarPair(..), true) => {
67+
// No change to immediate
68+
self.write_immediate(src, dest)?;
6969
}
7070
// slices and trait objects to thin pointers (dropping the metadata)
71-
(Value::ScalarPair(data, _), false) => {
71+
(Immediate::ScalarPair(data, _), false) => {
7272
self.write_scalar(data, dest)?;
7373
}
7474
}
@@ -118,11 +118,11 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
118118
}
119119

120120
UnsafeFnPointer => {
121-
let src = self.read_value(src)?;
121+
let src = self.read_immediate(src)?;
122122
match dest.layout.ty.sty {
123123
ty::FnPtr(_) => {
124124
// No change to value
125-
self.write_value(*src, dest)?;
125+
self.write_immediate(*src, dest)?;
126126
}
127127
ref other => bug!("fn to unsafe fn cast on {:?}", other),
128128
}
@@ -144,8 +144,8 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
144144
ty::ClosureKind::FnOnce,
145145
);
146146
let fn_ptr = self.memory.create_fn_alloc(instance).with_default_tag();
147-
let val = Value::Scalar(Scalar::Ptr(fn_ptr.into()).into());
148-
self.write_value(val, dest)?;
147+
let val = Immediate::Scalar(Scalar::Ptr(fn_ptr.into()).into());
148+
self.write_immediate(val, dest)?;
149149
}
150150
ref other => bug!("closure fn pointer on {:?}", other),
151151
}
@@ -326,24 +326,28 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
326326

327327
match (&src_pointee_ty.sty, &dest_pointee_ty.sty) {
328328
(&ty::Array(_, length), &ty::Slice(_)) => {
329-
let ptr = self.read_value(src)?.to_scalar_ptr()?;
329+
let ptr = self.read_immediate(src)?.to_scalar_ptr()?;
330330
// u64 cast is from usize to u64, which is always good
331-
let val = Value::new_slice(ptr, length.unwrap_usize(self.tcx.tcx), self.tcx.tcx);
332-
self.write_value(val, dest)
331+
let val = Immediate::new_slice(
332+
ptr,
333+
length.unwrap_usize(self.tcx.tcx),
334+
self.tcx.tcx,
335+
);
336+
self.write_immediate(val, dest)
333337
}
334338
(&ty::Dynamic(..), &ty::Dynamic(..)) => {
335339
// For now, upcasts are limited to changes in marker
336340
// traits, and hence never actually require an actual
337341
// change to the vtable.
338-
let val = self.read_value(src)?;
339-
self.write_value(*val, dest)
342+
let val = self.read_immediate(src)?;
343+
self.write_immediate(*val, dest)
340344
}
341345
(_, &ty::Dynamic(ref data, _)) => {
342346
// Initial cast from sized to dyn trait
343347
let vtable = self.get_vtable(src_pointee_ty, data.principal())?;
344-
let ptr = self.read_value(src)?.to_scalar_ptr()?;
345-
let val = Value::new_dyn_trait(ptr, vtable);
346-
self.write_value(val, dest)
348+
let ptr = self.read_immediate(src)?.to_scalar_ptr()?;
349+
let val = Immediate::new_dyn_trait(ptr, vtable);
350+
self.write_immediate(val, dest)
347351
}
348352

349353
_ => bug!("invalid unsizing {:?} -> {:?}", src.layout.ty, dest.layout.ty),

Diff for: ‎src/librustc_mir/interpret/eval_context.rs

+7-7
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,7 @@ use rustc::mir::interpret::{
3232
use rustc_data_structures::fx::FxHashMap;
3333

3434
use super::{
35-
Value, Operand, MemPlace, MPlaceTy, Place, PlaceTy, ScalarMaybeUndef,
35+
Immediate, Operand, MemPlace, MPlaceTy, Place, PlaceTy, ScalarMaybeUndef,
3636
Memory, Machine
3737
};
3838

@@ -333,9 +333,9 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tc
333333
self.layout_of(local_ty)
334334
}
335335

336-
pub fn str_to_value(&mut self, s: &str) -> EvalResult<'tcx, Value<M::PointerTag>> {
336+
pub fn str_to_immediate(&mut self, s: &str) -> EvalResult<'tcx, Immediate<M::PointerTag>> {
337337
let ptr = self.memory.allocate_static_bytes(s.as_bytes()).with_default_tag();
338-
Ok(Value::new_slice(Scalar::Ptr(ptr), s.len() as u64, self.tcx.tcx))
338+
Ok(Immediate::new_slice(Scalar::Ptr(ptr), s.len() as u64, self.tcx.tcx))
339339
}
340340

341341
/// 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
457457

458458
// don't allocate at all for trivial constants
459459
if mir.local_decls.len() > 1 {
460-
// We put some marker value into the locals that we later want to initialize.
460+
// We put some marker immediate into the locals that we later want to initialize.
461461
// This can be anything except for LocalValue::Dead -- because *that* is the
462462
// value we use for things that we know are initially dead.
463463
let dummy =
464-
LocalValue::Live(Operand::Immediate(Value::Scalar(ScalarMaybeUndef::Undef)));
464+
LocalValue::Live(Operand::Immediate(Immediate::Scalar(ScalarMaybeUndef::Undef)));
465465
let mut locals = IndexVec::from_elem(dummy, &mir.local_decls);
466466
// Return place is handled specially by the `eval_place` functions, and the
467467
// 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
652652
ptr => write!(msg, " by integral ref: {:?}", ptr).unwrap(),
653653
}
654654
}
655-
Ok(Operand::Immediate(Value::Scalar(val))) => {
655+
Ok(Operand::Immediate(Immediate::Scalar(val))) => {
656656
write!(msg, " {:?}", val).unwrap();
657657
if let ScalarMaybeUndef::Scalar(Scalar::Ptr(ptr)) = val {
658658
allocs.push(ptr.alloc_id);
659659
}
660660
}
661-
Ok(Operand::Immediate(Value::ScalarPair(val1, val2))) => {
661+
Ok(Operand::Immediate(Immediate::ScalarPair(val1, val2))) => {
662662
write!(msg, " ({:?}, {:?})", val1, val2).unwrap();
663663
if let ScalarMaybeUndef::Scalar(Scalar::Ptr(ptr)) = val1 {
664664
allocs.push(ptr.alloc_id);

Diff for: ‎src/librustc_mir/interpret/intrinsics.rs

+12-12
Original file line numberDiff line numberDiff line change
@@ -115,8 +115,8 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
115115
| "add_with_overflow"
116116
| "sub_with_overflow"
117117
| "mul_with_overflow" => {
118-
let lhs = self.read_value(args[0])?;
119-
let rhs = self.read_value(args[1])?;
118+
let lhs = self.read_immediate(args[0])?;
119+
let rhs = self.read_immediate(args[1])?;
120120
let (bin_op, ignore_overflow) = match intrinsic_name {
121121
"overflowing_add" => (BinOp::Add, true),
122122
"overflowing_sub" => (BinOp::Sub, true),
@@ -133,8 +133,8 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
133133
}
134134
}
135135
"unchecked_shl" | "unchecked_shr" => {
136-
let l = self.read_value(args[0])?;
137-
let r = self.read_value(args[1])?;
136+
let l = self.read_immediate(args[0])?;
137+
let r = self.read_immediate(args[1])?;
138138
let bin_op = match intrinsic_name {
139139
"unchecked_shl" => BinOp::Shl,
140140
"unchecked_shr" => BinOp::Shr,
@@ -172,8 +172,8 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
172172
// Some fn calls are actually BinOp intrinsics
173173
if let Some((op, oflo)) = self.tcx.is_binop_lang_item(def_id) {
174174
let dest = dest.expect("128 lowerings can't diverge");
175-
let l = self.read_value(args[0])?;
176-
let r = self.read_value(args[1])?;
175+
let l = self.read_immediate(args[0])?;
176+
let r = self.read_immediate(args[1])?;
177177
if oflo {
178178
self.binop_with_overflow(op, l, r, dest)?;
179179
} else {
@@ -183,7 +183,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
183183
} else if Some(def_id) == self.tcx.lang_items().panic_fn() {
184184
assert!(args.len() == 1);
185185
// &(&'static str, &'static str, u32, u32)
186-
let ptr = self.read_value(args[0])?;
186+
let ptr = self.read_immediate(args[0])?;
187187
let place = self.ref_to_mplace(ptr)?;
188188
let (msg, file, line, col) = (
189189
self.mplace_field(place, 0)?,
@@ -192,9 +192,9 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
192192
self.mplace_field(place, 3)?,
193193
);
194194

195-
let msg_place = self.ref_to_mplace(self.read_value(msg.into())?)?;
195+
let msg_place = self.ref_to_mplace(self.read_immediate(msg.into())?)?;
196196
let msg = Symbol::intern(self.read_str(msg_place)?);
197-
let file_place = self.ref_to_mplace(self.read_value(file.into())?)?;
197+
let file_place = self.ref_to_mplace(self.read_immediate(file.into())?)?;
198198
let file = Symbol::intern(self.read_str(file_place)?);
199199
let line = self.read_scalar(line.into())?.to_u32()?;
200200
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>
203203
assert!(args.len() == 2);
204204
// &'static str, &(&'static str, u32, u32)
205205
let msg = args[0];
206-
let ptr = self.read_value(args[1])?;
206+
let ptr = self.read_immediate(args[1])?;
207207
let place = self.ref_to_mplace(ptr)?;
208208
let (file, line, col) = (
209209
self.mplace_field(place, 0)?,
210210
self.mplace_field(place, 1)?,
211211
self.mplace_field(place, 2)?,
212212
);
213213

214-
let msg_place = self.ref_to_mplace(self.read_value(msg.into())?)?;
214+
let msg_place = self.ref_to_mplace(self.read_immediate(msg.into())?)?;
215215
let msg = Symbol::intern(self.read_str(msg_place)?);
216-
let file_place = self.ref_to_mplace(self.read_value(file.into())?)?;
216+
let file_place = self.ref_to_mplace(self.read_immediate(file.into())?)?;
217217
let file = Symbol::intern(self.read_str(file_place)?);
218218
let line = self.read_scalar(line.into())?.to_u32()?;
219219
let col = self.read_scalar(col.into())?.to_u32()?;

Diff for: ‎src/librustc_mir/interpret/mod.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -36,6 +36,6 @@ pub use self::memory::{Memory, MemoryKind};
3636

3737
pub use self::machine::{Machine, AllocMap, MayLeak};
3838

39-
pub use self::operand::{ScalarMaybeUndef, Value, ValTy, Operand, OpTy};
39+
pub use self::operand::{ScalarMaybeUndef, Immediate, ImmTy, Operand, OpTy};
4040

4141
pub use self::validity::RefTracking;

0 commit comments

Comments
 (0)