Skip to content

Commit 38b7cdf

Browse files
oli-obkoli-obk
committed
Use target instead of machine for mir interpreter integer handling.
The naming of `machine` only makes sense from a mir interpreter internals perspective, but outside users talk about the `target` platform
1 parent 068161e commit 38b7cdf

File tree

51 files changed

+181
-181
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

51 files changed

+181
-181
lines changed

‎compiler/rustc_const_eval/src/const_eval/eval_queries.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -186,7 +186,7 @@ pub(super) fn op_to_const<'tcx>(
186186
0,
187187
),
188188
};
189-
let len = b.to_machine_usize(ecx).unwrap();
189+
let len = b.to_target_usize(ecx).unwrap();
190190
let start = start.try_into().unwrap();
191191
let len: usize = len.try_into().unwrap();
192192
ConstValue::Slice { data, start, end: start + len }

‎compiler/rustc_const_eval/src/const_eval/machine.rs

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -244,7 +244,7 @@ impl<'mir, 'tcx: 'mir> CompileTimeEvalContext<'mir, 'tcx> {
244244
assert_eq!(args.len(), 2);
245245

246246
let ptr = self.read_pointer(&args[0])?;
247-
let target_align = self.read_scalar(&args[1])?.to_machine_usize(self)?;
247+
let target_align = self.read_scalar(&args[1])?.to_target_usize(self)?;
248248

249249
if !target_align.is_power_of_two() {
250250
throw_ub_format!("`align_offset` called with non-power-of-two align: {}", target_align);
@@ -276,7 +276,7 @@ impl<'mir, 'tcx: 'mir> CompileTimeEvalContext<'mir, 'tcx> {
276276
Ok(ControlFlow::Break(()))
277277
} else {
278278
// Not alignable in const, return `usize::MAX`.
279-
let usize_max = Scalar::from_machine_usize(self.machine_usize_max(), self);
279+
let usize_max = Scalar::from_target_usize(self.target_usize_max(), self);
280280
self.write_scalar(usize_max, dest)?;
281281
self.return_to_block(ret)?;
282282
Ok(ControlFlow::Break(()))
@@ -470,8 +470,8 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
470470
ecx.write_scalar(Scalar::from_u8(cmp), dest)?;
471471
}
472472
sym::const_allocate => {
473-
let size = ecx.read_scalar(&args[0])?.to_machine_usize(ecx)?;
474-
let align = ecx.read_scalar(&args[1])?.to_machine_usize(ecx)?;
473+
let size = ecx.read_scalar(&args[0])?.to_target_usize(ecx)?;
474+
let align = ecx.read_scalar(&args[1])?.to_target_usize(ecx)?;
475475

476476
let align = match Align::from_bytes(align) {
477477
Ok(a) => a,
@@ -487,8 +487,8 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
487487
}
488488
sym::const_deallocate => {
489489
let ptr = ecx.read_pointer(&args[0])?;
490-
let size = ecx.read_scalar(&args[1])?.to_machine_usize(ecx)?;
491-
let align = ecx.read_scalar(&args[2])?.to_machine_usize(ecx)?;
490+
let size = ecx.read_scalar(&args[1])?.to_target_usize(ecx)?;
491+
let align = ecx.read_scalar(&args[2])?.to_target_usize(ecx)?;
492492

493493
let size = Size::from_bytes(size);
494494
let align = match Align::from_bytes(align) {

‎compiler/rustc_const_eval/src/const_eval/mod.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -155,7 +155,7 @@ pub(crate) fn deref_mir_constant<'tcx>(
155155
// In case of unsized types, figure out the real type behind.
156156
MemPlaceMeta::Meta(scalar) => match mplace.layout.ty.kind() {
157157
ty::Str => bug!("there's no sized equivalent of a `str`"),
158-
ty::Slice(elem_ty) => tcx.mk_array(*elem_ty, scalar.to_machine_usize(&tcx).unwrap()),
158+
ty::Slice(elem_ty) => tcx.mk_array(*elem_ty, scalar.to_target_usize(&tcx).unwrap()),
159159
_ => bug!(
160160
"type {} should not have metadata, but had {:?}",
161161
mplace.layout.ty,

‎compiler/rustc_const_eval/src/const_eval/valtrees.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -239,7 +239,7 @@ fn create_pointee_place<'tcx>(
239239
MPlaceTy::from_aligned_ptr_with_meta(
240240
ptr.into(),
241241
layout,
242-
MemPlaceMeta::Meta(Scalar::from_machine_usize(num_elems as u64, &tcx)),
242+
MemPlaceMeta::Meta(Scalar::from_target_usize(num_elems as u64, &tcx)),
243243
)
244244
} else {
245245
create_mplace_from_layout(ecx, ty)
@@ -355,7 +355,7 @@ fn valtree_into_mplace<'tcx>(
355355
let imm = match inner_ty.kind() {
356356
ty::Slice(_) | ty::Str => {
357357
let len = valtree.unwrap_branch().len();
358-
let len_scalar = Scalar::from_machine_usize(len as u64, &tcx);
358+
let len_scalar = Scalar::from_target_usize(len as u64, &tcx);
359359

360360
Immediate::ScalarPair(
361361
Scalar::from_maybe_pointer((*pointee_place).ptr, &tcx),
@@ -426,7 +426,7 @@ fn valtree_into_mplace<'tcx>(
426426
place
427427
.offset_with_meta(
428428
offset,
429-
MemPlaceMeta::Meta(Scalar::from_machine_usize(
429+
MemPlaceMeta::Meta(Scalar::from_target_usize(
430430
num_elems as u64,
431431
&tcx,
432432
)),

‎compiler/rustc_const_eval/src/interpret/cast.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -231,7 +231,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
231231
// First cast to usize.
232232
let scalar = src.to_scalar();
233233
let addr = self.cast_from_int_like(scalar, src.layout, self.tcx.types.usize)?;
234-
let addr = addr.to_machine_usize(self)?;
234+
let addr = addr.to_target_usize(self)?;
235235

236236
// Then turn address into pointer.
237237
let ptr = M::ptr_from_addr_cast(&self, addr)?;

‎compiler/rustc_const_eval/src/interpret/eval_context.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -639,7 +639,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
639639
}
640640

641641
ty::Slice(_) | ty::Str => {
642-
let len = metadata.unwrap_meta().to_machine_usize(self)?;
642+
let len = metadata.unwrap_meta().to_target_usize(self)?;
643643
let elem = layout.field(self, 0);
644644

645645
// Make sure the slice is not too big.

‎compiler/rustc_const_eval/src/interpret/intrinsics.rs

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -71,15 +71,15 @@ pub(crate) fn eval_nullary_intrinsic<'tcx>(
7171
sym::pref_align_of => {
7272
// Correctly handles non-monomorphic calls, so there is no need for ensure_monomorphic_enough.
7373
let layout = tcx.layout_of(param_env.and(tp_ty)).map_err(|e| err_inval!(Layout(e)))?;
74-
ConstValue::from_machine_usize(layout.align.pref.bytes(), &tcx)
74+
ConstValue::from_target_usize(layout.align.pref.bytes(), &tcx)
7575
}
7676
sym::type_id => {
7777
ensure_monomorphic_enough(tcx, tp_ty)?;
7878
ConstValue::from_u64(tcx.type_id_hash(tp_ty))
7979
}
8080
sym::variant_count => match tp_ty.kind() {
8181
// Correctly handles non-monomorphic calls, so there is no need for ensure_monomorphic_enough.
82-
ty::Adt(adt, _) => ConstValue::from_machine_usize(adt.variants().len() as u64, &tcx),
82+
ty::Adt(adt, _) => ConstValue::from_target_usize(adt.variants().len() as u64, &tcx),
8383
ty::Alias(..) | ty::Param(_) | ty::Placeholder(_) | ty::Infer(_) => {
8484
throw_inval!(TooGeneric)
8585
}
@@ -104,7 +104,7 @@ pub(crate) fn eval_nullary_intrinsic<'tcx>(
104104
| ty::GeneratorWitnessMIR(_, _)
105105
| ty::Never
106106
| ty::Tuple(_)
107-
| ty::Error(_) => ConstValue::from_machine_usize(0u64, &tcx),
107+
| ty::Error(_) => ConstValue::from_target_usize(0u64, &tcx),
108108
},
109109
other => bug!("`{}` is not a zero arg intrinsic", other),
110110
})
@@ -156,7 +156,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
156156
_ => bug!(),
157157
};
158158

159-
self.write_scalar(Scalar::from_machine_usize(result, self), dest)?;
159+
self.write_scalar(Scalar::from_target_usize(result, self), dest)?;
160160
}
161161

162162
sym::pref_align_of
@@ -302,15 +302,15 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
302302
}
303303
sym::offset => {
304304
let ptr = self.read_pointer(&args[0])?;
305-
let offset_count = self.read_machine_isize(&args[1])?;
305+
let offset_count = self.read_target_isize(&args[1])?;
306306
let pointee_ty = substs.type_at(0);
307307

308308
let offset_ptr = self.ptr_offset_inbounds(ptr, pointee_ty, offset_count)?;
309309
self.write_pointer(offset_ptr, dest)?;
310310
}
311311
sym::arith_offset => {
312312
let ptr = self.read_pointer(&args[0])?;
313-
let offset_count = self.read_machine_isize(&args[1])?;
313+
let offset_count = self.read_target_isize(&args[1])?;
314314
let pointee_ty = substs.type_at(0);
315315

316316
let pointee_size = i64::try_from(self.layout_of(pointee_ty)?.size.bytes()).unwrap();
@@ -376,7 +376,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
376376
// The signed form of the intrinsic allows this. If we interpret the
377377
// difference as isize, we'll get the proper signed difference. If that
378378
// seems *positive*, they were more than isize::MAX apart.
379-
let dist = val.to_machine_isize(self)?;
379+
let dist = val.to_target_isize(self)?;
380380
if dist >= 0 {
381381
throw_ub_format!(
382382
"`{}` called when first pointer is too far before second",
@@ -386,7 +386,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
386386
dist
387387
} else {
388388
// b >= a
389-
let dist = val.to_machine_isize(self)?;
389+
let dist = val.to_target_isize(self)?;
390390
// If converting to isize produced a *negative* result, we had an overflow
391391
// because they were more than isize::MAX apart.
392392
if dist < 0 {
@@ -411,10 +411,10 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
411411

412412
// Perform division by size to compute return value.
413413
let ret_layout = if intrinsic_name == sym::ptr_offset_from_unsigned {
414-
assert!(0 <= dist && dist <= self.machine_isize_max());
414+
assert!(0 <= dist && dist <= self.target_isize_max());
415415
usize_layout
416416
} else {
417-
assert!(self.machine_isize_min() <= dist && dist <= self.machine_isize_max());
417+
assert!(self.target_isize_min() <= dist && dist <= self.target_isize_max());
418418
isize_layout
419419
};
420420
let pointee_layout = self.layout_of(substs.type_at(0))?;
@@ -525,12 +525,12 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
525525
sym::vtable_size => {
526526
let ptr = self.read_pointer(&args[0])?;
527527
let (size, _align) = self.get_vtable_size_and_align(ptr)?;
528-
self.write_scalar(Scalar::from_machine_usize(size.bytes(), self), dest)?;
528+
self.write_scalar(Scalar::from_target_usize(size.bytes(), self), dest)?;
529529
}
530530
sym::vtable_align => {
531531
let ptr = self.read_pointer(&args[0])?;
532532
let (_size, align) = self.get_vtable_size_and_align(ptr)?;
533-
self.write_scalar(Scalar::from_machine_usize(align.bytes(), self), dest)?;
533+
self.write_scalar(Scalar::from_target_usize(align.bytes(), self), dest)?;
534534
}
535535

536536
_ => return Ok(false),
@@ -669,10 +669,10 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
669669
count: &OpTy<'tcx, <M as Machine<'mir, 'tcx>>::Provenance>,
670670
nonoverlapping: bool,
671671
) -> InterpResult<'tcx> {
672-
let count = self.read_machine_usize(&count)?;
672+
let count = self.read_target_usize(&count)?;
673673
let layout = self.layout_of(src.layout.ty.builtin_deref(true).unwrap().ty)?;
674674
let (size, align) = (layout.size, layout.align.abi);
675-
// `checked_mul` enforces a too small bound (the correct one would probably be machine_isize_max),
675+
// `checked_mul` enforces a too small bound (the correct one would probably be target_isize_max),
676676
// but no actual allocation can be big enough for the difference to be noticeable.
677677
let size = size.checked_mul(count, self).ok_or_else(|| {
678678
err_ub_format!(
@@ -697,9 +697,9 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
697697

698698
let dst = self.read_pointer(&dst)?;
699699
let byte = self.read_scalar(&byte)?.to_u8()?;
700-
let count = self.read_machine_usize(&count)?;
700+
let count = self.read_target_usize(&count)?;
701701

702-
// `checked_mul` enforces a too small bound (the correct one would probably be machine_isize_max),
702+
// `checked_mul` enforces a too small bound (the correct one would probably be target_isize_max),
703703
// but no actual allocation can be big enough for the difference to be noticeable.
704704
let len = layout
705705
.size

‎compiler/rustc_const_eval/src/interpret/memory.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -425,7 +425,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
425425
throw_ub!(PointerOutOfBounds {
426426
alloc_id,
427427
alloc_size,
428-
ptr_offset: self.machine_usize_to_isize(offset.bytes()),
428+
ptr_offset: self.target_usize_to_isize(offset.bytes()),
429429
ptr_size: size,
430430
msg,
431431
})

‎compiler/rustc_const_eval/src/interpret/operand.rs

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -52,7 +52,7 @@ impl<Prov: Provenance> Immediate<Prov> {
5252
}
5353

5454
pub fn new_slice(val: Scalar<Prov>, len: u64, cx: &impl HasDataLayout) -> Self {
55-
Immediate::ScalarPair(val, Scalar::from_machine_usize(len, cx))
55+
Immediate::ScalarPair(val, Scalar::from_target_usize(len, cx))
5656
}
5757

5858
pub fn new_dyn_trait(
@@ -414,12 +414,12 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
414414
self.read_scalar(op)?.to_pointer(self)
415415
}
416416
/// Read a pointer-sized unsigned integer from a place.
417-
pub fn read_machine_usize(&self, op: &OpTy<'tcx, M::Provenance>) -> InterpResult<'tcx, u64> {
418-
self.read_scalar(op)?.to_machine_usize(self)
417+
pub fn read_target_usize(&self, op: &OpTy<'tcx, M::Provenance>) -> InterpResult<'tcx, u64> {
418+
self.read_scalar(op)?.to_target_usize(self)
419419
}
420420
/// Read a pointer-sized signed integer from a place.
421-
pub fn read_machine_isize(&self, op: &OpTy<'tcx, M::Provenance>) -> InterpResult<'tcx, i64> {
422-
self.read_scalar(op)?.to_machine_isize(self)
421+
pub fn read_target_isize(&self, op: &OpTy<'tcx, M::Provenance>) -> InterpResult<'tcx, i64> {
422+
self.read_scalar(op)?.to_target_isize(self)
423423
}
424424

425425
/// Turn the wide MPlace into a string (must already be dereferenced!)

‎compiler/rustc_const_eval/src/interpret/place.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -229,7 +229,7 @@ impl<'tcx, Prov: Provenance> MPlaceTy<'tcx, Prov> {
229229
if self.layout.is_unsized() {
230230
// We need to consult `meta` metadata
231231
match self.layout.ty.kind() {
232-
ty::Slice(..) | ty::Str => self.mplace.meta.unwrap_meta().to_machine_usize(cx),
232+
ty::Slice(..) | ty::Str => self.mplace.meta.unwrap_meta().to_target_usize(cx),
233233
_ => bug!("len not supported on unsized type {:?}", self.layout.ty),
234234
}
235235
} else {
@@ -756,7 +756,7 @@ where
756756
mutbl: Mutability,
757757
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::Provenance>> {
758758
let ptr = self.allocate_bytes_ptr(str.as_bytes(), Align::ONE, kind, mutbl)?;
759-
let meta = Scalar::from_machine_usize(u64::try_from(str.len()).unwrap(), self);
759+
let meta = Scalar::from_target_usize(u64::try_from(str.len()).unwrap(), self);
760760
let mplace = MemPlace { ptr: ptr.into(), meta: MemPlaceMeta::Meta(meta) };
761761

762762
let ty = self.tcx.mk_ref(

0 commit comments

Comments
 (0)