squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

Rollup merge of #94681 - RalfJung:miri-cast, r=oli-obk

Browse source 
CTFE engine: expose misc_cast to Miri

We need that to implement `simd_cast`/`simd_as` in Miri.

While at it, also change other code outside `cast.rs` to use `misc_cast` instead of lower-level methods.

r? `@oli-obk`
This commit is contained in:
Matthias Krüger 2022-03-07 06:44:04 +01:00 committed by GitHub
parent 02539e1612 d29d2307b9
commit f7eb3830df
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 13 additions and 8 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
compiler/rustc_const_eval/src/interpret/cast.rs
View file

@ -97,7 +97,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
Ok(()) Ok(())
} }
fn misc_cast( pub fn misc_cast(
&self, &self,
src: &ImmTy<'tcx, M::PointerTag>, src: &ImmTy<'tcx, M::PointerTag>,
cast_ty: Ty<'tcx>, cast_ty: Ty<'tcx>,
@ -139,7 +139,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
if let Some(discr) = src.layout.ty.discriminant_for_variant(*self.tcx, index) { if let Some(discr) = src.layout.ty.discriminant_for_variant(*self.tcx, index) {
assert!(src.layout.is_zst()); assert!(src.layout.is_zst());
let discr_layout = self.layout_of(discr.ty)?; let discr_layout = self.layout_of(discr.ty)?;
return Ok(self.cast_from_scalar(discr.val, discr_layout, cast_ty).into()); return Ok(self.cast_from_int_like(discr.val, discr_layout, cast_ty).into());
} }
} }
Variants::Multiple { .. } => {} Variants::Multiple { .. } => {}
@ -169,17 +169,17 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
} }
} }
// # The remaining source values are scalar. // # The remaining source values are scalar and "int-like".
// For all remaining casts, we either // For all remaining casts, we either
// (a) cast a raw ptr to usize, or // (a) cast a raw ptr to usize, or
// (b) cast from an integer-like (including bool, char, enums). // (b) cast from an integer-like (including bool, char, enums).
// In both cases we want the bits. // In both cases we want the bits.
let bits = src.to_scalar()?.to_bits(src.layout.size)?; let bits = src.to_scalar()?.to_bits(src.layout.size)?;
Ok(self.cast_from_scalar(bits, src.layout, cast_ty).into()) Ok(self.cast_from_int_like(bits, src.layout, cast_ty).into())
} }
pub(super) fn cast_from_scalar( fn cast_from_int_like(
&self, &self,
v: u128, // raw bits (there is no ScalarTy so we separate data+layout) v: u128, // raw bits (there is no ScalarTy so we separate data+layout)
src_layout: TyAndLayout<'tcx>, src_layout: TyAndLayout<'tcx>,

11
compiler/rustc_const_eval/src/interpret/operand.rs
View file

@ -681,18 +681,22 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
let tag_val = self.read_immediate(&self.operand_field(op, tag_field)?)?; let tag_val = self.read_immediate(&self.operand_field(op, tag_field)?)?;
assert_eq!(tag_layout.size, tag_val.layout.size); assert_eq!(tag_layout.size, tag_val.layout.size);
assert_eq!(tag_layout.abi.is_signed(), tag_val.layout.abi.is_signed()); assert_eq!(tag_layout.abi.is_signed(), tag_val.layout.abi.is_signed());
let tag_val = tag_val.to_scalar()?; trace!("tag value: {}", tag_val);
trace!("tag value: {:?}", tag_val);
// Figure out which discriminant and variant this corresponds to. // Figure out which discriminant and variant this corresponds to.
Ok(match *tag_encoding { Ok(match *tag_encoding {
TagEncoding::Direct => { TagEncoding::Direct => {
// Generate a specific error if `tag_val` is not an integer.
// (`tag_bits` itself is only used for error messages below.)
let tag_bits = tag_val let tag_bits = tag_val
.to_scalar()?
.try_to_int() .try_to_int()
.map_err(|dbg_val| err_ub!(InvalidTag(dbg_val)))? .map_err(|dbg_val| err_ub!(InvalidTag(dbg_val)))?
.assert_bits(tag_layout.size); .assert_bits(tag_layout.size);
// Cast bits from tag layout to discriminant layout. // Cast bits from tag layout to discriminant layout.
let discr_val = self.cast_from_scalar(tag_bits, tag_layout, discr_layout.ty); // After the checks we did above, this cannot fail.
let discr_val =
self.misc_cast(&tag_val, discr_layout.ty).unwrap().to_scalar().unwrap();
let discr_bits = discr_val.assert_bits(discr_layout.size); let discr_bits = discr_val.assert_bits(discr_layout.size);
// Convert discriminant to variant index, and catch invalid discriminants. // Convert discriminant to variant index, and catch invalid discriminants.
let index = match *op.layout.ty.kind() { let index = match *op.layout.ty.kind() {
@ -712,6 +716,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
(discr_val, index.0) (discr_val, index.0)
} }
TagEncoding::Niche { dataful_variant, ref niche_variants, niche_start } => { TagEncoding::Niche { dataful_variant, ref niche_variants, niche_start } => {
let tag_val = tag_val.to_scalar()?;
// Compute the variant this niche value/"tag" corresponds to. With niche layout, // Compute the variant this niche value/"tag" corresponds to. With niche layout,
// discriminant (encoded in niche/tag) and variant index are the same. // discriminant (encoded in niche/tag) and variant index are the same.
let variants_start = niche_variants.start().as_u32(); let variants_start = niche_variants.start().as_u32();