Skip to content

Commit 551df45

Browse files
oli-obkoli-obk
committed
Address behaviour changing review comments
1 parent c53aa29 commit 551df45

File tree

5 files changed

+58
-56
lines changed

5 files changed

+58
-56
lines changed

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

Lines changed: 0 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -218,15 +218,6 @@ impl ScalarMaybeUndef {
218218
Value::ScalarPair(self.into(), Scalar::Ptr(vtable).into())
219219
}
220220

221-
pub fn ptr_signed_offset<C: HasDataLayout>(self, i: i64, cx: C) -> EvalResult<'tcx, Self> {
222-
match self {
223-
ScalarMaybeUndef::Scalar(scalar) => {
224-
scalar.ptr_signed_offset(i, cx).map(ScalarMaybeUndef::Scalar)
225-
},
226-
ScalarMaybeUndef::Undef => Ok(ScalarMaybeUndef::Undef)
227-
}
228-
}
229-
230221
pub fn ptr_offset<C: HasDataLayout>(self, i: Size, cx: C) -> EvalResult<'tcx, Self> {
231222
match self {
232223
ScalarMaybeUndef::Scalar(scalar) => {
@@ -235,15 +226,6 @@ impl ScalarMaybeUndef {
235226
ScalarMaybeUndef::Undef => Ok(ScalarMaybeUndef::Undef)
236227
}
237228
}
238-
239-
pub fn ptr_wrapping_signed_offset<C: HasDataLayout>(self, i: i64, cx: C) -> Self {
240-
match self {
241-
ScalarMaybeUndef::Scalar(scalar) => {
242-
ScalarMaybeUndef::Scalar(scalar.ptr_wrapping_signed_offset(i, cx))
243-
},
244-
ScalarMaybeUndef::Undef => ScalarMaybeUndef::Undef
245-
}
246-
}
247229
}
248230

249231
impl<'tcx> Scalar {

‎src/librustc_mir/interpret/const_eval.rs

Lines changed: 17 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ use rustc::hir;
55
use rustc::mir::interpret::{ConstEvalErr, ScalarMaybeUndef};
66
use rustc::mir;
77
use rustc::ty::{self, TyCtxt, Ty, Instance};
8-
use rustc::ty::layout::{self, LayoutOf, Primitive, TyLayout};
8+
use rustc::ty::layout::{self, LayoutOf, Primitive, TyLayout, Size};
99
use rustc::ty::subst::Subst;
1010
use rustc_data_structures::indexed_vec::IndexVec;
1111

@@ -76,9 +76,8 @@ pub fn eval_promoted<'a, 'mir, 'tcx>(
7676
pub fn value_to_const_value<'tcx>(
7777
ecx: &EvalContext<'_, '_, 'tcx, CompileTimeEvaluator>,
7878
val: Value,
79-
ty: Ty<'tcx>,
79+
layout: TyLayout<'tcx>,
8080
) -> &'tcx ty::Const<'tcx> {
81-
let layout = ecx.layout_of(ty).unwrap();
8281
match (val, &layout.abi) {
8382
(Value::Scalar(ScalarMaybeUndef::Scalar(Scalar::Bits { size: 0, ..})), _) if layout.is_zst() => {},
8483
(Value::ByRef(..), _) |
@@ -103,19 +102,19 @@ pub fn value_to_const_value<'tcx>(
103102
}
104103
})();
105104
match val {
106-
Ok(val) => ty::Const::from_const_value(ecx.tcx.tcx, val, ty),
107-
Err(err) => {
108-
let (frames, span) = ecx.generate_stacktrace(None);
109-
let err = ConstEvalErr {
110-
span,
111-
error: err,
112-
stacktrace: frames,
113-
};
114-
err.report_as_error(
115-
ecx.tcx,
116-
"failed to convert Value to ConstValue, this is a bug",
117-
);
118-
span_bug!(span, "miri error occured when converting Value to ConstValue")
105+
Ok(val) => ty::Const::from_const_value(ecx.tcx.tcx, val, layout.ty),
106+
Err(error) => {
107+
let (stacktrace, span) = ecx.generate_stacktrace(None);
108+
let err = ConstEvalErr { span, error, stacktrace };
109+
if let Some(mut err) = err.struct_error(ecx.tcx, "failed to convert Value to ConstValue") {
110+
err.delay_as_bug();
111+
} else {
112+
span_bug!(span, "failed to convert Value to ConstValue")
113+
}
114+
let alloc = Allocation::undef(layout.size, layout.align);
115+
let alloc = ecx.tcx.intern_const_alloc(alloc);
116+
let val = ConstValue::ByRef(alloc, Size::ZERO);
117+
ty::Const::from_const_value(ecx.tcx.tcx, val, layout.ty)
119118
}
120119
}
121120
}
@@ -455,7 +454,7 @@ pub fn const_val_field<'a, 'tcx>(
455454
),
456455
_ => {},
457456
}
458-
Ok(value_to_const_value(&ecx, new_value, layout.ty))
457+
Ok(value_to_const_value(&ecx, new_value, layout))
459458
})();
460459
result.map_err(|err| {
461460
let (trace, span) = ecx.generate_stacktrace(None);
@@ -556,7 +555,7 @@ pub fn const_eval_provider<'a, 'tcx>(
556555
if tcx.is_static(def_id).is_none() && cid.promoted.is_none() {
557556
val = ecx.try_read_by_ref(val, layout.ty)?;
558557
}
559-
Ok(value_to_const_value(&ecx, val, layout.ty))
558+
Ok(value_to_const_value(&ecx, val, layout))
560559
}).map_err(|err| {
561560
let (trace, span) = ecx.generate_stacktrace(None);
562561
let err = ConstEvalErr {

‎src/librustc_mir/interpret/eval_context.rs

Lines changed: 27 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -1261,7 +1261,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
12611261
},
12621262
_ => false,
12631263
};
1264-
self.memory.write_scalar(dest, dest_align, scalar, layout.size, signed)
1264+
self.memory.write_scalar(dest, dest_align, scalar, layout.size, layout.align, signed)
12651265
}
12661266
Value::ScalarPair(a_val, b_val) => {
12671267
trace!("write_value_to_ptr valpair: {:#?}", layout);
@@ -1270,12 +1270,13 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
12701270
_ => bug!("write_value_to_ptr: invalid ScalarPair layout: {:#?}", layout)
12711271
};
12721272
let (a_size, b_size) = (a.size(&self), b.size(&self));
1273+
let (a_align, b_align) = (a.align(&self), b.align(&self));
12731274
let a_ptr = dest;
1274-
let b_offset = a_size.abi_align(b.align(&self));
1275+
let b_offset = a_size.abi_align(b_align);
12751276
let b_ptr = dest.ptr_offset(b_offset, &self)?.into();
12761277
// TODO: What about signedess?
1277-
self.memory.write_scalar(a_ptr, dest_align, a_val, a_size, false)?;
1278-
self.memory.write_scalar(b_ptr, dest_align, b_val, b_size, false)
1278+
self.memory.write_scalar(a_ptr, dest_align, a_val, a_size, a_align, false)?;
1279+
self.memory.write_scalar(b_ptr, dest_align, b_val, b_size, b_align, false)
12791280
}
12801281
}
12811282
}
@@ -1290,7 +1291,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
12901291

12911292
fn validate_scalar(
12921293
&self,
1293-
value: Scalar,
1294+
value: ScalarMaybeUndef,
12941295
size: Size,
12951296
scalar: &layout::Scalar,
12961297
path: &str,
@@ -1299,6 +1300,11 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
12991300
trace!("validate scalar: {:#?}, {:#?}, {:#?}, {}", value, size, scalar, ty);
13001301
let (lo, hi) = scalar.valid_range.clone().into_inner();
13011302

1303+
let value = match value {
1304+
ScalarMaybeUndef::Scalar(scalar) => scalar,
1305+
ScalarMaybeUndef::Undef => return validation_failure!("undefined bytes", path),
1306+
};
1307+
13021308
let bits = match value {
13031309
Scalar::Bits { bits, size: value_size } => {
13041310
assert_eq!(value_size as u64, size.bytes());
@@ -1351,13 +1357,21 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
13511357
if in_range(0..=hi) || in_range(lo..=u128::max_value()) {
13521358
Ok(())
13531359
} else {
1354-
validation_failure!("undefined bytes", path)
1360+
validation_failure!(
1361+
bits,
1362+
path,
1363+
format!("something in the range {:?} or {:?}", ..=hi, lo..)
1364+
)
13551365
}
13561366
} else {
13571367
if in_range(scalar.valid_range.clone()) {
13581368
Ok(())
13591369
} else {
1360-
validation_failure!("undefined bytes", path)
1370+
validation_failure!(
1371+
bits,
1372+
path,
1373+
format!("something in the range {:?}", scalar.valid_range)
1374+
)
13611375
}
13621376
}
13631377
}
@@ -1387,10 +1401,10 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
13871401
mir::Field::new(0),
13881402
layout,
13891403
)?;
1390-
let tag_value = self.value_to_scalar(ValTy {
1391-
value: tag_value,
1392-
ty: tag_layout.ty,
1393-
})?;
1404+
let tag_value = match self.follow_by_ref_value(tag_value, tag_layout.ty)? {
1405+
Value::Scalar(val) => val,
1406+
_ => bug!("tag must be scalar"),
1407+
};
13941408
let path = format!("{}.TAG", path);
13951409
self.validate_scalar(tag_value, size, tag, &path, tag_layout.ty)?;
13961410
let variant_index = self.read_discriminant_as_variant_index(
@@ -1413,11 +1427,11 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
14131427
// expectation.
14141428
layout::Abi::Scalar(ref scalar) => {
14151429
let size = scalar.value.size(self);
1416-
let value = self.memory.read_scalar(ptr, ptr_align, size)?.unwrap_or_err()?;
1430+
let value = self.memory.read_scalar(ptr, ptr_align, size)?;
14171431
self.validate_scalar(value, size, scalar, &path, layout.ty)?;
14181432
if scalar.value == Primitive::Pointer {
14191433
// ignore integer pointers, we can't reason about the final hardware
1420-
if let Scalar::Ptr(ptr) = value {
1434+
if let Scalar::Ptr(ptr) = value.unwrap_or_err()? {
14211435
let alloc_kind = self.tcx.alloc_map.lock().get(ptr.alloc_id);
14221436
if let Some(AllocType::Static(did)) = alloc_kind {
14231437
// statics from other crates are already checked

‎src/librustc_mir/interpret/memory.rs

Lines changed: 11 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -789,7 +789,15 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> {
789789
self.read_scalar(ptr, ptr_align, self.pointer_size())
790790
}
791791

792-
pub fn write_scalar(&mut self, ptr: Scalar, ptr_align: Align, val: ScalarMaybeUndef, type_size: Size, signed: bool) -> EvalResult<'tcx> {
792+
pub fn write_scalar(
793+
&mut self,
794+
ptr: Scalar,
795+
ptr_align: Align,
796+
val: ScalarMaybeUndef,
797+
type_size: Size,
798+
type_align: Align,
799+
signed: bool,
800+
) -> EvalResult<'tcx> {
793801
let endianness = self.endianness();
794802

795803
let val = match val {
@@ -818,8 +826,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> {
818826
let ptr = ptr.to_ptr()?;
819827

820828
{
821-
let align = self.int_align(type_size);
822-
let dst = self.get_bytes_mut(ptr, type_size, ptr_align.min(align))?;
829+
let dst = self.get_bytes_mut(ptr, type_size, ptr_align.min(type_align))?;
823830
if signed {
824831
write_target_int(endianness, dst, bytes as i128).unwrap();
825832
} else {
@@ -843,7 +850,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> {
843850

844851
pub fn write_ptr_sized_unsigned(&mut self, ptr: Pointer, ptr_align: Align, val: ScalarMaybeUndef) -> EvalResult<'tcx> {
845852
let ptr_size = self.pointer_size();
846-
self.write_scalar(ptr.into(), ptr_align, val, ptr_size, false)
853+
self.write_scalar(ptr.into(), ptr_align, val, ptr_size, ptr_align, false)
847854
}
848855

849856
fn int_align(&self, size: Size) -> Align {

‎src/librustc_mir/interpret/place.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -62,13 +62,13 @@ impl<'tcx> Place {
6262
let (ptr, align, _extra) = self.to_ptr_align_extra();
6363
(ptr, align)
6464
}
65-
/*
65+
6666
pub fn to_ptr(self) -> EvalResult<'tcx, Pointer> {
6767
// At this point, we forget about the alignment information -- the place has been turned into a reference,
6868
// and no matter where it came from, it now must be aligned.
69-
self.to_ptr_align().0.to_ptr()
69+
self.to_ptr_align().0.unwrap_or_err()?.to_ptr()
7070
}
71-
*/
71+
7272
pub(super) fn elem_ty_and_len(
7373
self,
7474
ty: Ty<'tcx>,

0 commit comments

Comments
 (0)