Skip to content

Commit c53aa29

Browse files
oli-obkoli-obk
committed
Address stylistic review comments and rebase fallout
1 parent 32eb10f commit c53aa29

File tree

9 files changed

+44
-83
lines changed

9 files changed

+44
-83
lines changed

‎src/librustc/mir/interpret/value.rs

Lines changed: 6 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -28,8 +28,11 @@ impl<'tcx> ConstValue<'tcx> {
2828
pub fn from_byval_value(val: Value) -> EvalResult<'static, Self> {
2929
Ok(match val {
3030
Value::ByRef(..) => bug!(),
31-
Value::ScalarPair(a, b) => ConstValue::ScalarPair(a.read()?, b.read()?),
32-
Value::Scalar(val) => ConstValue::Scalar(val.read()?),
31+
Value::ScalarPair(a, b) => ConstValue::ScalarPair(
32+
a.unwrap_or_err()?,
33+
b.unwrap_or_err()?,
34+
),
35+
Value::Scalar(val) => ConstValue::Scalar(val.unwrap_or_err()?),
3336
})
3437
}
3538

@@ -197,7 +200,7 @@ impl From<Scalar> for ScalarMaybeUndef {
197200
}
198201

199202
impl ScalarMaybeUndef {
200-
pub fn read(self) -> EvalResult<'static, Scalar> {
203+
pub fn unwrap_or_err(self) -> EvalResult<'static, Scalar> {
201204
match self {
202205
ScalarMaybeUndef::Scalar(scalar) => Ok(scalar),
203206
ScalarMaybeUndef::Undef => err!(ReadUndefBytes),

‎src/librustc_mir/interpret/const_eval.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -88,8 +88,8 @@ pub fn value_to_const_value<'tcx>(
8888
}
8989
let val = (|| {
9090
match val {
91-
Value::Scalar(val) => Ok(ConstValue::Scalar(val.read()?)),
92-
Value::ScalarPair(a, b) => Ok(ConstValue::ScalarPair(a.read()?, b.read()?)),
91+
Value::Scalar(val) => Ok(ConstValue::Scalar(val.unwrap_or_err()?)),
92+
Value::ScalarPair(a, b) => Ok(ConstValue::ScalarPair(a.unwrap_or_err()?, b.unwrap_or_err()?)),
9393
Value::ByRef(ptr, align) => {
9494
let ptr = ptr.to_ptr().unwrap();
9595
let alloc = ecx.memory.get(ptr.alloc_id)?;
@@ -441,7 +441,7 @@ pub fn const_val_field<'a, 'tcx>(
441441
let place = ecx.allocate_place_for_value(value, layout, variant)?;
442442
let (place, layout) = ecx.place_field(place, field, layout)?;
443443
let (ptr, align) = place.to_ptr_align();
444-
let mut new_value = Value::ByRef(ptr.read()?, align);
444+
let mut new_value = Value::ByRef(ptr.unwrap_or_err()?, align);
445445
new_value = ecx.try_read_by_ref(new_value, layout.ty)?;
446446
use rustc_data_structures::indexed_vec::Idx;
447447
match (value, new_value) {
@@ -485,7 +485,7 @@ pub fn const_variant_index<'a, 'tcx>(
485485
},
486486
Value::ByRef(ptr, align) => (ptr, align),
487487
};
488-
let place = Place::from_scalar_ptr(ptr, align);
488+
let place = Place::from_scalar_ptr(ptr.into(), align);
489489
ecx.read_discriminant_as_variant_index(place, layout)
490490
}
491491

‎src/librustc_mir/interpret/eval_context.rs

Lines changed: 22 additions & 64 deletions
Original file line numberDiff line numberDiff line change
@@ -616,7 +616,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
616616
if let Place::Ptr { ptr, .. } = frame.return_place {
617617
// FIXME: to_ptr()? might be too extreme here, static zsts might reach this under certain conditions
618618
self.memory.mark_static_initialized(
619-
ptr.read()?.to_ptr()?.alloc_id,
619+
ptr.unwrap_or_err()?.to_ptr()?.alloc_id,
620620
mutable,
621621
)?
622622
} else {
@@ -744,7 +744,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
744744
let (dest, dest_align) = self.force_allocation(dest)?.to_ptr_align();
745745

746746
if length > 0 {
747-
let dest = dest.read()?;
747+
let dest = dest.unwrap_or_err()?;
748748
//write the first value
749749
self.write_value_to_ptr(value, dest, dest_align, elem_ty)?;
750750

@@ -1082,7 +1082,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
10821082
},
10831083
};
10841084
Ok(Place::Ptr {
1085-
ptr,
1085+
ptr: ptr.into(),
10861086
align,
10871087
extra: variant.map_or(PlaceExtra::None, PlaceExtra::DowncastVariant),
10881088
})
@@ -1120,7 +1120,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
11201120

11211121
/// ensures this Value is not a ByRef
11221122
pub fn follow_by_ref_value(
1123-
&mut self,
1123+
&self,
11241124
value: Value,
11251125
ty: Ty<'tcx>,
11261126
) -> EvalResult<'tcx, Value> {
@@ -1133,13 +1133,13 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
11331133
}
11341134

11351135
pub fn value_to_scalar(
1136-
&mut self,
1136+
&self,
11371137
ValTy { value, ty } : ValTy<'tcx>,
11381138
) -> EvalResult<'tcx, Scalar> {
11391139
match self.follow_by_ref_value(value, ty)? {
11401140
Value::ByRef { .. } => bug!("follow_by_ref_value can't result in `ByRef`"),
11411141

1142-
Value::Scalar(scalar) => Ok(scalar),
1142+
Value::Scalar(scalar) => scalar.unwrap_or_err(),
11431143

11441144
Value::ScalarPair(..) => bug!("value_to_scalar can't work with fat pointers"),
11451145
}
@@ -1179,7 +1179,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
11791179
match dest {
11801180
Place::Ptr { ptr, align, extra } => {
11811181
assert_eq!(extra, PlaceExtra::None);
1182-
self.write_value_to_ptr(src_val, ptr.read()?, align, dest_ty)
1182+
self.write_value_to_ptr(src_val, ptr.unwrap_or_err()?, align, dest_ty)
11831183
}
11841184

11851185
Place::Local { frame, local } => {
@@ -1288,37 +1288,6 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
12881288
}
12891289
}
12901290

1291-
pub(crate) fn read_ptr(
1292-
&self,
1293-
ptr: Pointer,
1294-
ptr_align: Align,
1295-
pointee_ty: Ty<'tcx>,
1296-
) -> EvalResult<'tcx, Value> {
1297-
let ptr_size = self.memory.pointer_size();
1298-
let p: ScalarMaybeUndef = self.memory.read_ptr_sized(ptr, ptr_align)?;
1299-
if self.type_is_sized(pointee_ty) {
1300-
Ok(Value::Scalar(p))
1301-
} else {
1302-
trace!("reading fat pointer extra of type {}", pointee_ty);
1303-
let extra = ptr.offset(ptr_size, self)?;
1304-
match self.tcx.struct_tail(pointee_ty).sty {
1305-
ty::TyDynamic(..) => Ok(Value::ScalarPair(
1306-
p,
1307-
self.memory.read_ptr_sized(extra, ptr_align)?,
1308-
)),
1309-
ty::TySlice(..) | ty::TyStr => {
1310-
let len = self
1311-
.memory
1312-
.read_ptr_sized(extra, ptr_align)?
1313-
.read()?
1314-
.to_bits(ptr_size)?;
1315-
Ok(p.to_value_with_len(len as u64, self.tcx.tcx))
1316-
},
1317-
_ => bug!("unsized scalar ptr read from {:?}", pointee_ty),
1318-
}
1319-
}
1320-
}
1321-
13221291
fn validate_scalar(
13231292
&self,
13241293
value: Scalar,
@@ -1330,8 +1299,11 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
13301299
trace!("validate scalar: {:#?}, {:#?}, {:#?}, {}", value, size, scalar, ty);
13311300
let (lo, hi) = scalar.valid_range.clone().into_inner();
13321301

1333-
let (bits, defined) = match value {
1334-
Scalar::Bits { bits, defined } => (bits, defined),
1302+
let bits = match value {
1303+
Scalar::Bits { bits, size: value_size } => {
1304+
assert_eq!(value_size as u64, size.bytes());
1305+
bits
1306+
},
13351307
Scalar::Ptr(_) => {
13361308
let ptr_size = self.memory.pointer_size();
13371309
let ptr_max = u128::max_value() >> (128 - ptr_size.bits());
@@ -1374,30 +1346,16 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
13741346
}
13751347

13761348
use std::ops::RangeInclusive;
1377-
let in_range = |bound: RangeInclusive<u128>| {
1378-
defined as u64 >= size.bits() && bound.contains(&bits)
1379-
};
1349+
let in_range = |bound: RangeInclusive<u128>| bound.contains(&bits);
13801350
if lo > hi {
13811351
if in_range(0..=hi) || in_range(lo..=u128::max_value()) {
13821352
Ok(())
1383-
} else if defined as u64 >= size.bits() {
1384-
validation_failure!(
1385-
bits,
1386-
path,
1387-
format!("something in the range {:?} or {:?}", ..=hi, lo..)
1388-
)
13891353
} else {
13901354
validation_failure!("undefined bytes", path)
13911355
}
13921356
} else {
13931357
if in_range(scalar.valid_range.clone()) {
13941358
Ok(())
1395-
} else if defined as u64 >= size.bits() {
1396-
validation_failure!(
1397-
bits,
1398-
path,
1399-
format!("something in the range {:?}", scalar.valid_range)
1400-
)
14011359
} else {
14021360
validation_failure!("undefined bytes", path)
14031361
}
@@ -1455,7 +1413,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
14551413
// expectation.
14561414
layout::Abi::Scalar(ref scalar) => {
14571415
let size = scalar.value.size(self);
1458-
let value = self.memory.read_scalar(ptr, ptr_align, size)?;
1416+
let value = self.memory.read_scalar(ptr, ptr_align, size)?.unwrap_or_err()?;
14591417
self.validate_scalar(value, size, scalar, &path, layout.ty)?;
14601418
if scalar.value == Primitive::Pointer {
14611419
// ignore integer pointers, we can't reason about the final hardware
@@ -1538,7 +1496,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
15381496
}
15391497
}
15401498

1541-
pub fn try_read_by_ref(&mut self, mut val: Value, ty: Ty<'tcx>) -> EvalResult<'tcx, Value> {
1499+
pub fn try_read_by_ref(&self, mut val: Value, ty: Ty<'tcx>) -> EvalResult<'tcx, Value> {
15421500
// Convert to ByVal or ScalarPair if possible
15431501
if let Value::ByRef(ptr, align) = val {
15441502
if let Some(read_val) = self.try_read_value(ptr, align, ty)? {
@@ -1548,7 +1506,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
15481506
Ok(val)
15491507
}
15501508

1551-
pub fn try_read_value(&mut self, ptr: Scalar, ptr_align: Align, ty: Ty<'tcx>) -> EvalResult<'tcx, Option<Value>> {
1509+
pub fn try_read_value(&self, ptr: Scalar, ptr_align: Align, ty: Ty<'tcx>) -> EvalResult<'tcx, Option<Value>> {
15521510
let mut layout = self.layout_of(ty)?;
15531511
self.memory.check_align(ptr, ptr_align)?;
15541512

@@ -1563,9 +1521,9 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
15631521
layout::Variants::Tagged { .. } => {
15641522
let variant_index = self.read_discriminant_as_variant_index(
15651523
Place::from_ptr(ptr, ptr_align),
1566-
layout.ty,
1524+
layout,
15671525
)?;
1568-
layout = layout.for_variant(&self, variant_index);
1526+
layout = layout.for_variant(self, variant_index);
15691527
trace!("variant layout: {:#?}", layout);
15701528
},
15711529
layout::Variants::Single { .. } => {},
@@ -1578,10 +1536,10 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
15781536
}
15791537
layout::Abi::ScalarPair(ref a, ref b) => {
15801538
let (a, b) = (&a.value, &b.value);
1581-
let (a_size, b_size) = (a.size(&self), b.size(&self));
1539+
let (a_size, b_size) = (a.size(self), b.size(self));
15821540
let a_ptr = ptr;
1583-
let b_offset = a_size.abi_align(b.align(&self));
1584-
let b_ptr = ptr.offset(b_offset, &self)?.into();
1541+
let b_offset = a_size.abi_align(b.align(self));
1542+
let b_ptr = ptr.offset(b_offset, self)?.into();
15851543
let a_val = self.memory.read_scalar(a_ptr, ptr_align, a_size)?;
15861544
let b_val = self.memory.read_scalar(b_ptr, ptr_align, b_size)?;
15871545
Ok(Some(Value::ScalarPair(a_val, b_val)))
@@ -1929,7 +1887,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
19291887
ScalarMaybeUndef::Undef,
19301888
ScalarMaybeUndef::Undef,
19311889
),
1932-
_ => Value::ByRef(self.alloc_ptr(ty)?.into(), layout.align),
1890+
_ => Value::ByRef(self.alloc_ptr(layout)?.into(), layout.align),
19331891
})
19341892
}
19351893
}

‎src/librustc_mir/interpret/memory.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1011,11 +1011,11 @@ pub trait HasMemory<'a, 'mir, 'tcx: 'a + 'mir, M: Machine<'mir, 'tcx>> {
10111011
let vtable = mem.read_ptr_sized(
10121012
ref_ptr.ptr_offset(mem.pointer_size(), &mem.tcx.data_layout)?.to_ptr()?,
10131013
align
1014-
)?.read()?.to_ptr()?;
1014+
)?.unwrap_or_err()?.to_ptr()?;
10151015
Ok((ptr, vtable))
10161016
}
10171017

1018-
Value::ScalarPair(ptr, vtable) => Ok((ptr, vtable.read()?.to_ptr()?)),
1018+
Value::ScalarPair(ptr, vtable) => Ok((ptr, vtable.unwrap_or_err()?.to_ptr()?)),
10191019
_ => bug!("expected ptr and vtable, got {:?}", value),
10201020
}
10211021
}
@@ -1031,11 +1031,11 @@ pub trait HasMemory<'a, 'mir, 'tcx: 'a + 'mir, M: Machine<'mir, 'tcx>> {
10311031
let len = mem.read_ptr_sized(
10321032
ref_ptr.ptr_offset(mem.pointer_size(), &mem.tcx.data_layout)?.to_ptr()?,
10331033
align
1034-
)?.read()?.to_bits(mem.pointer_size())? as u64;
1034+
)?.unwrap_or_err()?.to_bits(mem.pointer_size())? as u64;
10351035
Ok((ptr, len))
10361036
}
10371037
Value::ScalarPair(ptr, val) => {
1038-
let len = val.read()?.to_bits(self.memory().pointer_size())?;
1038+
let len = val.unwrap_or_err()?.to_bits(self.memory().pointer_size())?;
10391039
Ok((ptr, len as u64))
10401040
}
10411041
Value::Scalar(_) => bug!("expected ptr and length, got {:?}", value),

‎src/librustc_mir/interpret/place.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -197,7 +197,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
197197
match place {
198198
Place::Ptr { ptr, align, extra } => {
199199
assert_eq!(extra, PlaceExtra::None);
200-
Ok(Value::ByRef(ptr.read()?, align))
200+
Ok(Value::ByRef(ptr.unwrap_or_err()?, align))
201201
}
202202
Place::Local { frame, local } => self.stack[frame].locals[local].access(),
203203
}

‎src/librustc_mir/interpret/terminator/drop.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -52,7 +52,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
5252
let instance = match ty.sty {
5353
ty::TyDynamic(..) => {
5454
if let Value::ScalarPair(_, vtable) = arg {
55-
self.read_drop_type_from_vtable(vtable.read()?.to_ptr()?)?
55+
self.read_drop_type_from_vtable(vtable.unwrap_or_err()?.to_ptr()?)?
5656
} else {
5757
bug!("expected fat ptr, got {:?}", arg);
5858
}

‎src/librustc_mir/interpret/terminator/mod.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -392,7 +392,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
392392
let fn_ptr = self.memory.read_ptr_sized(
393393
vtable.offset(ptr_size * (idx as u64 + 3), &self)?,
394394
ptr_align
395-
)?.read()?.to_ptr()?;
395+
)?.unwrap_or_err()?.to_ptr()?;
396396
let instance = self.memory.get_fn(fn_ptr)?;
397397
let mut args = args.to_vec();
398398
let ty = self.layout_of(args[0].ty)?.field(&self, 0)?.ty;

‎src/librustc_mir/interpret/traits.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -72,7 +72,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
7272
) -> EvalResult<'tcx, ty::Instance<'tcx>> {
7373
// we don't care about the pointee type, we just want a pointer
7474
let pointer_align = self.tcx.data_layout.pointer_align;
75-
let drop_fn = self.memory.read_ptr_sized(vtable, pointer_align)?.read()?.to_ptr()?;
75+
let drop_fn = self.memory.read_ptr_sized(vtable, pointer_align)?.unwrap_or_err()?.to_ptr()?;
7676
self.memory.get_fn(drop_fn)
7777
}
7878

@@ -82,11 +82,11 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
8282
) -> EvalResult<'tcx, (Size, Align)> {
8383
let pointer_size = self.memory.pointer_size();
8484
let pointer_align = self.tcx.data_layout.pointer_align;
85-
let size = self.memory.read_ptr_sized(vtable.offset(pointer_size, self)?, pointer_align)?.read()?.to_bits(pointer_size)? as u64;
85+
let size = self.memory.read_ptr_sized(vtable.offset(pointer_size, self)?, pointer_align)?.unwrap_or_err()?.to_bits(pointer_size)? as u64;
8686
let align = self.memory.read_ptr_sized(
8787
vtable.offset(pointer_size * 2, self)?,
8888
pointer_align
89-
)?.read()?.to_bits(pointer_size)? as u64;
89+
)?.unwrap_or_err()?.to_bits(pointer_size)? as u64;
9090
Ok((Size::from_bytes(size), Align::from_bytes(align, align).unwrap()))
9191
}
9292
}

‎src/librustc_mir/transform/const_prop.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -369,7 +369,7 @@ impl<'b, 'a, 'tcx:'b> ConstPropagator<'b, 'a, 'tcx> {
369369
Value::Scalar(Scalar::Bits {
370370
bits: n as u128,
371371
size: self.tcx.data_layout.pointer_size.bytes() as u8,
372-
}),
372+
}.into()),
373373
self.tcx.layout_of(self.param_env.and(self.tcx.types.usize)).ok()?,
374374
span,
375375
)))
@@ -391,7 +391,7 @@ impl<'b, 'a, 'tcx:'b> ConstPropagator<'b, 'a, 'tcx> {
391391
this.ecx.value_to_scalar(ValTy { value: val.0, ty: val.1.ty })
392392
})?;
393393
let val = self.use_ecx(source_info, |this| this.ecx.unary_op(op, prim, val.1))?;
394-
Some((Value::Scalar(val), place_layout, span))
394+
Some((Value::Scalar(val.into()), place_layout, span))
395395
}
396396
Rvalue::CheckedBinaryOp(op, ref left, ref right) |
397397
Rvalue::BinaryOp(op, ref left, ref right) => {

0 commit comments

Comments
 (0)