Renamed "undef" stuff to "uninit"
1. InvalidUndefBytes -> InvalidUninitBytes 2. ScalarMaybeUndef -> ScalarMaybeUninit 3. UndefMask -> InitMask Related issue #71193
This commit is contained in:
Hanif Bin Ariffin
parent
63d0377994
commit
b2a8b39cd0
20 changed files with 138 additions and 138 deletions
|
|
@ -10,7 +10,7 @@ use rustc_data_structures::sorted_map::SortedMap;
|
|||
use rustc_target::abi::{Align, HasDataLayout, Size};
|
||||
|
||||
use super::{
|
||||
read_target_uint, write_target_uint, AllocId, InterpResult, Pointer, Scalar, ScalarMaybeUndef,
|
||||
read_target_uint, write_target_uint, AllocId, InterpResult, Pointer, Scalar, ScalarMaybeUninit,
|
||||
};
|
||||
|
||||
#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
|
||||
|
|
@ -25,7 +25,7 @@ pub struct Allocation<Tag = (), Extra = ()> {
|
|||
/// at the given offset.
|
||||
relocations: Relocations<Tag>,
|
||||
/// Denotes which part of this allocation is initialized.
|
||||
undef_mask: UndefMask,
|
||||
init_mask: InitMask,
|
||||
/// The size of the allocation. Currently, must always equal `bytes.len()`.
|
||||
pub size: Size,
|
||||
/// The alignment of the allocation to detect unaligned reads.
|
||||
|
|
@ -92,7 +92,7 @@ impl<Tag> Allocation<Tag> {
|
|||
Self {
|
||||
bytes,
|
||||
relocations: Relocations::new(),
|
||||
undef_mask: UndefMask::new(size, true),
|
||||
init_mask: InitMask::new(size, true),
|
||||
size,
|
||||
align,
|
||||
mutability: Mutability::Not,
|
||||
|
|
@ -108,7 +108,7 @@ impl<Tag> Allocation<Tag> {
|
|||
Allocation {
|
||||
bytes: vec![0; size.bytes_usize()],
|
||||
relocations: Relocations::new(),
|
||||
undef_mask: UndefMask::new(size, false),
|
||||
init_mask: InitMask::new(size, false),
|
||||
size,
|
||||
align,
|
||||
mutability: Mutability::Mut,
|
||||
|
|
@ -138,7 +138,7 @@ impl Allocation<(), ()> {
|
|||
})
|
||||
.collect(),
|
||||
),
|
||||
undef_mask: self.undef_mask,
|
||||
init_mask: self.init_mask,
|
||||
align: self.align,
|
||||
mutability: self.mutability,
|
||||
extra,
|
||||
|
|
@ -160,9 +160,9 @@ impl<Tag, Extra> Allocation<Tag, Extra> {
|
|||
&self.bytes[range]
|
||||
}
|
||||
|
||||
/// Returns the undef mask.
|
||||
pub fn undef_mask(&self) -> &UndefMask {
|
||||
&self.undef_mask
|
||||
/// Returns the mask indicating which bytes are initialized.
|
||||
pub fn init_mask(&self) -> &InitMask {
|
||||
&self.init_mask
|
||||
}
|
||||
|
||||
/// Returns the relocation list.
|
||||
|
|
@ -358,15 +358,15 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra<Tag>> Allocation<Tag, Extra> {
|
|||
cx: &impl HasDataLayout,
|
||||
ptr: Pointer<Tag>,
|
||||
size: Size,
|
||||
) -> InterpResult<'tcx, ScalarMaybeUndef<Tag>> {
|
||||
) -> InterpResult<'tcx, ScalarMaybeUninit<Tag>> {
|
||||
// `get_bytes_unchecked` tests relocation edges.
|
||||
let bytes = self.get_bytes_with_undef_and_ptr(cx, ptr, size)?;
|
||||
// Undef check happens *after* we established that the alignment is correct.
|
||||
// Uninit check happens *after* we established that the alignment is correct.
|
||||
// We must not return `Ok()` for unaligned pointers!
|
||||
if self.is_defined(ptr, size).is_err() {
|
||||
// This inflates undefined bytes to the entire scalar, even if only a few
|
||||
// bytes are undefined.
|
||||
return Ok(ScalarMaybeUndef::Undef);
|
||||
// This inflates uninitialized bytes to the entire scalar, even if only a few
|
||||
// bytes are uninitialized.
|
||||
return Ok(ScalarMaybeUninit::Uninit);
|
||||
}
|
||||
// Now we do the actual reading.
|
||||
let bits = read_target_uint(cx.data_layout().endian, bytes).unwrap();
|
||||
|
|
@ -377,11 +377,11 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra<Tag>> Allocation<Tag, Extra> {
|
|||
} else {
|
||||
if let Some(&(tag, alloc_id)) = self.relocations.get(&ptr.offset) {
|
||||
let ptr = Pointer::new_with_tag(alloc_id, Size::from_bytes(bits), tag);
|
||||
return Ok(ScalarMaybeUndef::Scalar(ptr.into()));
|
||||
return Ok(ScalarMaybeUninit::Scalar(ptr.into()));
|
||||
}
|
||||
}
|
||||
// We don't. Just return the bits.
|
||||
Ok(ScalarMaybeUndef::Scalar(Scalar::from_uint(bits, size)))
|
||||
Ok(ScalarMaybeUninit::Scalar(Scalar::from_uint(bits, size)))
|
||||
}
|
||||
|
||||
/// Reads a pointer-sized scalar.
|
||||
|
|
@ -392,7 +392,7 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra<Tag>> Allocation<Tag, Extra> {
|
|||
&self,
|
||||
cx: &impl HasDataLayout,
|
||||
ptr: Pointer<Tag>,
|
||||
) -> InterpResult<'tcx, ScalarMaybeUndef<Tag>> {
|
||||
) -> InterpResult<'tcx, ScalarMaybeUninit<Tag>> {
|
||||
self.read_scalar(cx, ptr, cx.data_layout().pointer_size)
|
||||
}
|
||||
|
||||
|
|
@ -409,12 +409,12 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra<Tag>> Allocation<Tag, Extra> {
|
|||
&mut self,
|
||||
cx: &impl HasDataLayout,
|
||||
ptr: Pointer<Tag>,
|
||||
val: ScalarMaybeUndef<Tag>,
|
||||
val: ScalarMaybeUninit<Tag>,
|
||||
type_size: Size,
|
||||
) -> InterpResult<'tcx> {
|
||||
let val = match val {
|
||||
ScalarMaybeUndef::Scalar(scalar) => scalar,
|
||||
ScalarMaybeUndef::Undef => {
|
||||
ScalarMaybeUninit::Scalar(scalar) => scalar,
|
||||
ScalarMaybeUninit::Uninit => {
|
||||
self.mark_definedness(ptr, type_size, false);
|
||||
return Ok(());
|
||||
}
|
||||
|
|
@ -445,7 +445,7 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra<Tag>> Allocation<Tag, Extra> {
|
|||
&mut self,
|
||||
cx: &impl HasDataLayout,
|
||||
ptr: Pointer<Tag>,
|
||||
val: ScalarMaybeUndef<Tag>,
|
||||
val: ScalarMaybeUninit<Tag>,
|
||||
) -> InterpResult<'tcx> {
|
||||
let ptr_size = cx.data_layout().pointer_size;
|
||||
self.write_scalar(cx, ptr, val, ptr_size)
|
||||
|
|
@ -514,10 +514,10 @@ impl<'tcx, Tag: Copy, Extra> Allocation<Tag, Extra> {
|
|||
// Mark parts of the outermost relocations as undefined if they partially fall outside the
|
||||
// given range.
|
||||
if first < start {
|
||||
self.undef_mask.set_range(first, start, false);
|
||||
self.init_mask.set_range(first, start, false);
|
||||
}
|
||||
if last > end {
|
||||
self.undef_mask.set_range(end, last, false);
|
||||
self.init_mask.set_range(end, last, false);
|
||||
}
|
||||
|
||||
// Forget all the relocations.
|
||||
|
|
@ -548,21 +548,21 @@ impl<'tcx, Tag: Copy, Extra> Allocation<Tag, Extra> {
|
|||
/// Returns `Ok(())` if it's defined. Otherwise returns the index of the byte
|
||||
/// at which the first undefined access begins.
|
||||
fn is_defined(&self, ptr: Pointer<Tag>, size: Size) -> Result<(), Size> {
|
||||
self.undef_mask.is_range_defined(ptr.offset, ptr.offset + size) // `Size` addition
|
||||
self.init_mask.is_range_initialized(ptr.offset, ptr.offset + size) // `Size` addition
|
||||
}
|
||||
|
||||
/// Checks that a range of bytes is defined. If not, returns the `ReadUndefBytes`
|
||||
/// error which will report the first byte which is undefined.
|
||||
fn check_defined(&self, ptr: Pointer<Tag>, size: Size) -> InterpResult<'tcx> {
|
||||
self.is_defined(ptr, size)
|
||||
.or_else(|idx| throw_ub!(InvalidUndefBytes(Some(Pointer::new(ptr.alloc_id, idx)))))
|
||||
.or_else(|idx| throw_ub!(InvalidUninitBytes(Some(Pointer::new(ptr.alloc_id, idx)))))
|
||||
}
|
||||
|
||||
pub fn mark_definedness(&mut self, ptr: Pointer<Tag>, size: Size, new_state: bool) {
|
||||
if size.bytes() == 0 {
|
||||
return;
|
||||
}
|
||||
self.undef_mask.set_range(ptr.offset, ptr.offset + size, new_state);
|
||||
self.init_mask.set_range(ptr.offset, ptr.offset + size, new_state);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -601,13 +601,13 @@ impl<Tag, Extra> Allocation<Tag, Extra> {
|
|||
// where each element toggles the state.
|
||||
|
||||
let mut ranges = smallvec::SmallVec::<[u64; 1]>::new();
|
||||
let initial = self.undef_mask.get(src.offset);
|
||||
let initial = self.init_mask.get(src.offset);
|
||||
let mut cur_len = 1;
|
||||
let mut cur = initial;
|
||||
|
||||
for i in 1..size.bytes() {
|
||||
// FIXME: optimize to bitshift the current undef block's bits and read the top bit.
|
||||
if self.undef_mask.get(src.offset + Size::from_bytes(i)) == cur {
|
||||
if self.init_mask.get(src.offset + Size::from_bytes(i)) == cur {
|
||||
cur_len += 1;
|
||||
} else {
|
||||
ranges.push(cur_len);
|
||||
|
|
@ -632,7 +632,7 @@ impl<Tag, Extra> Allocation<Tag, Extra> {
|
|||
// An optimization where we can just overwrite an entire range of definedness bits if
|
||||
// they are going to be uniformly `1` or `0`.
|
||||
if defined.ranges.len() <= 1 {
|
||||
self.undef_mask.set_range_inbounds(
|
||||
self.init_mask.set_range_inbounds(
|
||||
dest.offset,
|
||||
dest.offset + size * repeat, // `Size` operations
|
||||
defined.initial,
|
||||
|
|
@ -647,7 +647,7 @@ impl<Tag, Extra> Allocation<Tag, Extra> {
|
|||
for range in &defined.ranges {
|
||||
let old_j = j;
|
||||
j += range;
|
||||
self.undef_mask.set_range_inbounds(
|
||||
self.init_mask.set_range_inbounds(
|
||||
Size::from_bytes(old_j),
|
||||
Size::from_bytes(j),
|
||||
cur,
|
||||
|
|
@ -739,29 +739,29 @@ impl<Tag: Copy, Extra> Allocation<Tag, Extra> {
|
|||
type Block = u64;
|
||||
|
||||
/// A bitmask where each bit refers to the byte with the same index. If the bit is `true`, the byte
|
||||
/// is defined. If it is `false` the byte is undefined.
|
||||
/// is initialized. If it is `false` the byte is uninitialized.
|
||||
#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
|
||||
#[derive(HashStable)]
|
||||
pub struct UndefMask {
|
||||
pub struct InitMask {
|
||||
blocks: Vec<Block>,
|
||||
len: Size,
|
||||
}
|
||||
|
||||
impl UndefMask {
|
||||
impl InitMask {
|
||||
pub const BLOCK_SIZE: u64 = 64;
|
||||
|
||||
pub fn new(size: Size, state: bool) -> Self {
|
||||
let mut m = UndefMask { blocks: vec![], len: Size::ZERO };
|
||||
let mut m = InitMask { blocks: vec![], len: Size::ZERO };
|
||||
m.grow(size, state);
|
||||
m
|
||||
}
|
||||
|
||||
/// Checks whether the range `start..end` (end-exclusive) is entirely defined.
|
||||
/// Checks whether the range `start..end` (end-exclusive) is entirely initialized.
|
||||
///
|
||||
/// Returns `Ok(())` if it's defined. Otherwise returns the index of the byte
|
||||
/// at which the first undefined access begins.
|
||||
/// Returns `Ok(())` if it's initialized. Otherwise returns the index of the byte
|
||||
/// at which the first uninitialized access begins.
|
||||
#[inline]
|
||||
pub fn is_range_defined(&self, start: Size, end: Size) -> Result<(), Size> {
|
||||
pub fn is_range_initialized(&self, start: Size, end: Size) -> Result<(), Size> {
|
||||
if end > self.len {
|
||||
return Err(self.len);
|
||||
}
|
||||
|
|
@ -870,7 +870,7 @@ impl UndefMask {
|
|||
#[inline]
|
||||
fn bit_index(bits: Size) -> (usize, usize) {
|
||||
let bits = bits.bytes();
|
||||
let a = bits / UndefMask::BLOCK_SIZE;
|
||||
let b = bits % UndefMask::BLOCK_SIZE;
|
||||
let a = bits / InitMask::BLOCK_SIZE;
|
||||
let b = bits % InitMask::BLOCK_SIZE;
|
||||
(usize::try_from(a).unwrap(), usize::try_from(b).unwrap())
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
use super::{AllocId, Pointer, RawConst, ScalarMaybeUndef};
|
||||
use super::{AllocId, Pointer, RawConst, ScalarMaybeUninit};
|
||||
|
||||
use crate::mir::interpret::ConstValue;
|
||||
use crate::ty::layout::LayoutError;
|
||||
|
|
@ -378,13 +378,13 @@ pub enum UndefinedBehaviorInfo<'tcx> {
|
|||
/// Using a non-character `u32` as character.
|
||||
InvalidChar(u32),
|
||||
/// An enum discriminant was set to a value which was outside the range of valid values.
|
||||
InvalidDiscriminant(ScalarMaybeUndef),
|
||||
InvalidDiscriminant(ScalarMaybeUninit),
|
||||
/// Using a pointer-not-to-a-function as function pointer.
|
||||
InvalidFunctionPointer(Pointer),
|
||||
/// Using a string that is not valid UTF-8,
|
||||
InvalidStr(std::str::Utf8Error),
|
||||
/// Using uninitialized data where it is not allowed.
|
||||
InvalidUndefBytes(Option<Pointer>),
|
||||
InvalidUninitBytes(Option<Pointer>),
|
||||
/// Working with a local that is not currently live.
|
||||
DeadLocal,
|
||||
/// Data size is not equal to target size.
|
||||
|
|
@ -455,12 +455,12 @@ impl fmt::Display for UndefinedBehaviorInfo<'_> {
|
|||
write!(f, "using {} as function pointer but it does not point to a function", p)
|
||||
}
|
||||
InvalidStr(err) => write!(f, "this string is not valid UTF-8: {}", err),
|
||||
InvalidUndefBytes(Some(p)) => write!(
|
||||
InvalidUninitBytes(Some(p)) => write!(
|
||||
f,
|
||||
"reading uninitialized memory at {}, but this operation requires initialized memory",
|
||||
p
|
||||
),
|
||||
InvalidUndefBytes(None) => write!(
|
||||
InvalidUninitBytes(None) => write!(
|
||||
f,
|
||||
"using uninitialized data, but this operation requires initialized memory"
|
||||
),
|
||||
|
|
|
|||
|
|
@ -122,9 +122,9 @@ pub use self::error::{
|
|||
ResourceExhaustionInfo, UndefinedBehaviorInfo, UnsupportedOpInfo,
|
||||
};
|
||||
|
||||
pub use self::value::{get_slice_bytes, ConstValue, RawConst, Scalar, ScalarMaybeUndef};
|
||||
pub use self::value::{get_slice_bytes, ConstValue, RawConst, Scalar, ScalarMaybeUninit};
|
||||
|
||||
pub use self::allocation::{Allocation, AllocationExtra, Relocations, UndefMask};
|
||||
pub use self::allocation::{Allocation, AllocationExtra, InitMask, Relocations};
|
||||
|
||||
pub use self::pointer::{Pointer, PointerArithmetic};
|
||||
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ pub struct RawConst<'tcx> {
|
|||
pub enum ConstValue<'tcx> {
|
||||
/// Used only for types with `layout::abi::Scalar` ABI and ZSTs.
|
||||
///
|
||||
/// Not using the enum `Value` to encode that this must not be `Undef`.
|
||||
/// Not using the enum `Value` to encode that this must not be `Uninit`.
|
||||
Scalar(Scalar),
|
||||
|
||||
/// Used only for `&[u8]` and `&str`
|
||||
|
|
@ -542,62 +542,62 @@ impl<Tag> From<Pointer<Tag>> for Scalar<Tag> {
|
|||
}
|
||||
|
||||
#[derive(Clone, Copy, Eq, PartialEq, RustcEncodable, RustcDecodable, HashStable, Hash)]
|
||||
pub enum ScalarMaybeUndef<Tag = ()> {
|
||||
pub enum ScalarMaybeUninit<Tag = ()> {
|
||||
Scalar(Scalar<Tag>),
|
||||
Undef,
|
||||
Uninit,
|
||||
}
|
||||
|
||||
impl<Tag> From<Scalar<Tag>> for ScalarMaybeUndef<Tag> {
|
||||
impl<Tag> From<Scalar<Tag>> for ScalarMaybeUninit<Tag> {
|
||||
#[inline(always)]
|
||||
fn from(s: Scalar<Tag>) -> Self {
|
||||
ScalarMaybeUndef::Scalar(s)
|
||||
ScalarMaybeUninit::Scalar(s)
|
||||
}
|
||||
}
|
||||
|
||||
impl<Tag> From<Pointer<Tag>> for ScalarMaybeUndef<Tag> {
|
||||
impl<Tag> From<Pointer<Tag>> for ScalarMaybeUninit<Tag> {
|
||||
#[inline(always)]
|
||||
fn from(s: Pointer<Tag>) -> Self {
|
||||
ScalarMaybeUndef::Scalar(s.into())
|
||||
ScalarMaybeUninit::Scalar(s.into())
|
||||
}
|
||||
}
|
||||
|
||||
// We want the `Debug` output to be readable as it is used by `derive(Debug)` for
|
||||
// all the Miri types.
|
||||
impl<Tag: fmt::Debug> fmt::Debug for ScalarMaybeUndef<Tag> {
|
||||
impl<Tag: fmt::Debug> fmt::Debug for ScalarMaybeUninit<Tag> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
ScalarMaybeUndef::Undef => write!(f, "<uninitialized>"),
|
||||
ScalarMaybeUndef::Scalar(s) => write!(f, "{:?}", s),
|
||||
ScalarMaybeUninit::Uninit => write!(f, "<uninitialized>"),
|
||||
ScalarMaybeUninit::Scalar(s) => write!(f, "{:?}", s),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<Tag: fmt::Debug> fmt::Display for ScalarMaybeUndef<Tag> {
|
||||
impl<Tag: fmt::Debug> fmt::Display for ScalarMaybeUninit<Tag> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
ScalarMaybeUndef::Undef => write!(f, "uninitialized bytes"),
|
||||
ScalarMaybeUndef::Scalar(s) => write!(f, "{}", s),
|
||||
ScalarMaybeUninit::Uninit => write!(f, "uninitialized bytes"),
|
||||
ScalarMaybeUninit::Scalar(s) => write!(f, "{}", s),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'tcx, Tag> ScalarMaybeUndef<Tag> {
|
||||
impl<'tcx, Tag> ScalarMaybeUninit<Tag> {
|
||||
/// Erase the tag from the scalar, if any.
|
||||
///
|
||||
/// Used by error reporting code to avoid having the error type depend on `Tag`.
|
||||
#[inline]
|
||||
pub fn erase_tag(self) -> ScalarMaybeUndef {
|
||||
pub fn erase_tag(self) -> ScalarMaybeUninit {
|
||||
match self {
|
||||
ScalarMaybeUndef::Scalar(s) => ScalarMaybeUndef::Scalar(s.erase_tag()),
|
||||
ScalarMaybeUndef::Undef => ScalarMaybeUndef::Undef,
|
||||
ScalarMaybeUninit::Scalar(s) => ScalarMaybeUninit::Scalar(s.erase_tag()),
|
||||
ScalarMaybeUninit::Uninit => ScalarMaybeUninit::Uninit,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn not_undef(self) -> InterpResult<'static, Scalar<Tag>> {
|
||||
match self {
|
||||
ScalarMaybeUndef::Scalar(scalar) => Ok(scalar),
|
||||
ScalarMaybeUndef::Undef => throw_ub!(InvalidUndefBytes(None)),
|
||||
ScalarMaybeUninit::Scalar(scalar) => Ok(scalar),
|
||||
ScalarMaybeUninit::Uninit => throw_ub!(InvalidUninitBytes(None)),
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@ use crate::interpret::eval_nullary_intrinsic;
|
|||
use crate::interpret::{
|
||||
intern_const_alloc_recursive, Allocation, ConstValue, GlobalId, Immediate, InternKind,
|
||||
InterpCx, InterpResult, MPlaceTy, MemoryKind, OpTy, RawConst, RefTracking, Scalar,
|
||||
ScalarMaybeUndef, StackPopCleanup,
|
||||
ScalarMaybeUninit, StackPopCleanup,
|
||||
};
|
||||
use rustc_hir::def::DefKind;
|
||||
use rustc_middle::mir;
|
||||
|
|
@ -100,9 +100,9 @@ pub(super) fn op_to_const<'tcx>(
|
|||
) -> ConstValue<'tcx> {
|
||||
// We do not have value optimizations for everything.
|
||||
// Only scalars and slices, since they are very common.
|
||||
// Note that further down we turn scalars of undefined bits back to `ByRef`. These can result
|
||||
// Note that further down we turn scalars of uninitialized bits back to `ByRef`. These can result
|
||||
// from scalar unions that are initialized with one of their zero sized variants. We could
|
||||
// instead allow `ConstValue::Scalar` to store `ScalarMaybeUndef`, but that would affect all
|
||||
// instead allow `ConstValue::Scalar` to store `ScalarMaybeUninit`, but that would affect all
|
||||
// the usual cases of extracting e.g. a `usize`, without there being a real use case for the
|
||||
// `Undef` situation.
|
||||
let try_as_immediate = match op.layout.abi {
|
||||
|
|
@ -149,8 +149,8 @@ pub(super) fn op_to_const<'tcx>(
|
|||
// see comment on `let try_as_immediate` above
|
||||
Err(imm) => match *imm {
|
||||
Immediate::Scalar(x) => match x {
|
||||
ScalarMaybeUndef::Scalar(s) => ConstValue::Scalar(s),
|
||||
ScalarMaybeUndef::Undef => to_const_value(op.assert_mem_place(ecx)),
|
||||
ScalarMaybeUninit::Scalar(s) => ConstValue::Scalar(s),
|
||||
ScalarMaybeUninit::Uninit => to_const_value(op.assert_mem_place(ecx)),
|
||||
},
|
||||
Immediate::ScalarPair(a, b) => {
|
||||
let (data, start) = match a.not_undef().unwrap() {
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ use rustc_target::abi::{Align, HasDataLayout, LayoutOf, Size, TargetDataLayout};
|
|||
|
||||
use super::{
|
||||
Immediate, MPlaceTy, Machine, MemPlace, MemPlaceMeta, Memory, OpTy, Operand, Place, PlaceTy,
|
||||
ScalarMaybeUndef, StackPopJump,
|
||||
ScalarMaybeUninit, StackPopJump,
|
||||
};
|
||||
use crate::util::storage::AlwaysLiveLocals;
|
||||
|
||||
|
|
@ -910,16 +910,16 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
|
|||
},
|
||||
LocalValue::Live(Operand::Immediate(Immediate::Scalar(val))) => {
|
||||
write!(msg, " {:?}", val).unwrap();
|
||||
if let ScalarMaybeUndef::Scalar(Scalar::Ptr(ptr)) = val {
|
||||
if let ScalarMaybeUninit::Scalar(Scalar::Ptr(ptr)) = val {
|
||||
allocs.push(ptr.alloc_id);
|
||||
}
|
||||
}
|
||||
LocalValue::Live(Operand::Immediate(Immediate::ScalarPair(val1, val2))) => {
|
||||
write!(msg, " ({:?}, {:?})", val1, val2).unwrap();
|
||||
if let ScalarMaybeUndef::Scalar(Scalar::Ptr(ptr)) = val1 {
|
||||
if let ScalarMaybeUninit::Scalar(Scalar::Ptr(ptr)) = val1 {
|
||||
allocs.push(ptr.alloc_id);
|
||||
}
|
||||
if let ScalarMaybeUndef::Scalar(Scalar::Ptr(ptr)) = val2 {
|
||||
if let ScalarMaybeUninit::Scalar(Scalar::Ptr(ptr)) = val2 {
|
||||
allocs.push(ptr.alloc_id);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ use rustc_target::abi::{VariantIdx, Variants};
|
|||
|
||||
use super::{
|
||||
from_known_layout, sign_extend, truncate, ConstValue, GlobalId, InterpCx, InterpResult,
|
||||
MPlaceTy, Machine, MemPlace, Place, PlaceTy, Pointer, Scalar, ScalarMaybeUndef,
|
||||
MPlaceTy, Machine, MemPlace, Place, PlaceTy, Pointer, Scalar, ScalarMaybeUninit,
|
||||
};
|
||||
|
||||
/// An `Immediate` represents a single immediate self-contained Rust value.
|
||||
|
|
@ -28,13 +28,13 @@ use super::{
|
|||
/// defined on `Immediate`, and do not have to work with a `Place`.
|
||||
#[derive(Copy, Clone, Debug, PartialEq, Eq, HashStable, Hash)]
|
||||
pub enum Immediate<Tag = ()> {
|
||||
Scalar(ScalarMaybeUndef<Tag>),
|
||||
ScalarPair(ScalarMaybeUndef<Tag>, ScalarMaybeUndef<Tag>),
|
||||
Scalar(ScalarMaybeUninit<Tag>),
|
||||
ScalarPair(ScalarMaybeUninit<Tag>, ScalarMaybeUninit<Tag>),
|
||||
}
|
||||
|
||||
impl<Tag> From<ScalarMaybeUndef<Tag>> for Immediate<Tag> {
|
||||
impl<Tag> From<ScalarMaybeUninit<Tag>> for Immediate<Tag> {
|
||||
#[inline(always)]
|
||||
fn from(val: ScalarMaybeUndef<Tag>) -> Self {
|
||||
fn from(val: ScalarMaybeUninit<Tag>) -> Self {
|
||||
Immediate::Scalar(val)
|
||||
}
|
||||
}
|
||||
|
|
@ -63,7 +63,7 @@ impl<'tcx, Tag> Immediate<Tag> {
|
|||
}
|
||||
|
||||
#[inline]
|
||||
pub fn to_scalar_or_undef(self) -> ScalarMaybeUndef<Tag> {
|
||||
pub fn to_scalar_or_undef(self) -> ScalarMaybeUninit<Tag> {
|
||||
match self {
|
||||
Immediate::Scalar(val) => val,
|
||||
Immediate::ScalarPair(..) => bug!("Got a wide pointer where a scalar was expected"),
|
||||
|
|
@ -97,14 +97,14 @@ impl<Tag: Copy> std::fmt::Display for ImmTy<'tcx, Tag> {
|
|||
/// Helper function for printing a scalar to a FmtPrinter
|
||||
fn p<'a, 'tcx, F: std::fmt::Write, Tag>(
|
||||
cx: FmtPrinter<'a, 'tcx, F>,
|
||||
s: ScalarMaybeUndef<Tag>,
|
||||
s: ScalarMaybeUninit<Tag>,
|
||||
ty: Ty<'tcx>,
|
||||
) -> Result<FmtPrinter<'a, 'tcx, F>, std::fmt::Error> {
|
||||
match s {
|
||||
ScalarMaybeUndef::Scalar(s) => {
|
||||
ScalarMaybeUninit::Scalar(s) => {
|
||||
cx.pretty_print_const_scalar(s.erase_tag(), ty, true)
|
||||
}
|
||||
ScalarMaybeUndef::Undef => cx.typed_value(
|
||||
ScalarMaybeUninit::Uninit => cx.typed_value(
|
||||
|mut this| {
|
||||
this.write_str("{undef ")?;
|
||||
Ok(this)
|
||||
|
|
@ -319,7 +319,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
|
|||
pub fn read_scalar(
|
||||
&self,
|
||||
op: OpTy<'tcx, M::PointerTag>,
|
||||
) -> InterpResult<'tcx, ScalarMaybeUndef<M::PointerTag>> {
|
||||
) -> InterpResult<'tcx, ScalarMaybeUninit<M::PointerTag>> {
|
||||
Ok(self.read_immediate(op)?.to_scalar_or_undef())
|
||||
}
|
||||
|
||||
|
|
@ -644,7 +644,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
|
|||
let variants_end = niche_variants.end().as_u32();
|
||||
let raw_discr = raw_discr
|
||||
.not_undef()
|
||||
.map_err(|_| err_ub!(InvalidDiscriminant(ScalarMaybeUndef::Undef)))?;
|
||||
.map_err(|_| err_ub!(InvalidDiscriminant(ScalarMaybeUninit::Uninit)))?;
|
||||
match raw_discr.to_bits_or_ptr(discr_val.layout.size, self) {
|
||||
Err(ptr) => {
|
||||
// The niche must be just 0 (which an inbounds pointer value never is)
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ use rustc_target::abi::{HasDataLayout, LayoutOf, Size, VariantIdx, Variants};
|
|||
use super::{
|
||||
mir_assign_valid_types, truncate, AllocId, AllocMap, Allocation, AllocationExtra, ImmTy,
|
||||
Immediate, InterpCx, InterpResult, LocalValue, Machine, MemoryKind, OpTy, Operand, Pointer,
|
||||
PointerArithmetic, RawConst, Scalar, ScalarMaybeUndef,
|
||||
PointerArithmetic, RawConst, Scalar, ScalarMaybeUninit,
|
||||
};
|
||||
|
||||
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, HashStable)]
|
||||
|
|
@ -645,7 +645,7 @@ where
|
|||
#[inline(always)]
|
||||
pub fn write_scalar(
|
||||
&mut self,
|
||||
val: impl Into<ScalarMaybeUndef<M::PointerTag>>,
|
||||
val: impl Into<ScalarMaybeUninit<M::PointerTag>>,
|
||||
dest: PlaceTy<'tcx, M::PointerTag>,
|
||||
) -> InterpResult<'tcx> {
|
||||
self.write_immediate(Immediate::Scalar(val.into()), dest)
|
||||
|
|
@ -697,19 +697,19 @@ where
|
|||
// This is a very common path, avoid some checks in release mode
|
||||
assert!(!dest.layout.is_unsized(), "Cannot write unsized data");
|
||||
match src {
|
||||
Immediate::Scalar(ScalarMaybeUndef::Scalar(Scalar::Ptr(_))) => assert_eq!(
|
||||
Immediate::Scalar(ScalarMaybeUninit::Scalar(Scalar::Ptr(_))) => assert_eq!(
|
||||
self.pointer_size(),
|
||||
dest.layout.size,
|
||||
"Size mismatch when writing pointer"
|
||||
),
|
||||
Immediate::Scalar(ScalarMaybeUndef::Scalar(Scalar::Raw { size, .. })) => {
|
||||
Immediate::Scalar(ScalarMaybeUninit::Scalar(Scalar::Raw { size, .. })) => {
|
||||
assert_eq!(
|
||||
Size::from_bytes(size),
|
||||
dest.layout.size,
|
||||
"Size mismatch when writing bits"
|
||||
)
|
||||
}
|
||||
Immediate::Scalar(ScalarMaybeUndef::Undef) => {} // undef can have any size
|
||||
Immediate::Scalar(ScalarMaybeUninit::Uninit) => {} // undef can have any size
|
||||
Immediate::ScalarPair(_, _) => {
|
||||
// FIXME: Can we check anything here?
|
||||
}
|
||||
|
|
|
|||
|
|
@ -365,7 +365,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
|
|||
let place = try_validation!(
|
||||
self.ecx.ref_to_mplace(value),
|
||||
self.path,
|
||||
err_ub!(InvalidUndefBytes(..)) => { "uninitialized {}", kind },
|
||||
err_ub!(InvalidUninitBytes(..)) => { "uninitialized {}", kind },
|
||||
);
|
||||
if place.layout.is_unsized() {
|
||||
self.check_wide_ptr_meta(place.meta, place.layout)?;
|
||||
|
|
@ -513,7 +513,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
|
|||
let place = try_validation!(
|
||||
self.ecx.ref_to_mplace(self.ecx.read_immediate(value)?),
|
||||
self.path,
|
||||
err_ub!(InvalidUndefBytes(..)) => { "uninitialized raw pointer" },
|
||||
err_ub!(InvalidUninitBytes(..)) => { "uninitialized raw pointer" },
|
||||
);
|
||||
if place.layout.is_unsized() {
|
||||
self.check_wide_ptr_meta(place.meta, place.layout)?;
|
||||
|
|
@ -592,7 +592,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
|
|||
let value = try_validation!(
|
||||
value.not_undef(),
|
||||
self.path,
|
||||
err_ub!(InvalidUndefBytes(..)) => { "{}", value }
|
||||
err_ub!(InvalidUninitBytes(..)) => { "{}", value }
|
||||
expected { "something {}", wrapping_range_format(valid_range, max_hi) },
|
||||
);
|
||||
let bits = match value.to_bits_or_ptr(op.layout.size, self.ecx) {
|
||||
|
|
@ -802,7 +802,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValueVisitor<'mir, 'tcx, M>
|
|||
// For some errors we might be able to provide extra information.
|
||||
// (This custom logic does not fit the `try_validation!` macro.)
|
||||
match err.kind {
|
||||
err_ub!(InvalidUndefBytes(Some(ptr))) => {
|
||||
err_ub!(InvalidUninitBytes(Some(ptr))) => {
|
||||
// Some byte was uninitialized, determine which
|
||||
// element that byte belongs to so we can
|
||||
// provide an index.
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ use crate::const_eval::error_to_const_error;
|
|||
use crate::interpret::{
|
||||
self, compile_time_machine, intern_const_alloc_recursive, AllocId, Allocation, Frame, ImmTy,
|
||||
Immediate, InternKind, InterpCx, LocalState, LocalValue, Memory, MemoryKind, OpTy,
|
||||
Operand as InterpOperand, PlaceTy, Pointer, ScalarMaybeUndef, StackPopCleanup,
|
||||
Operand as InterpOperand, PlaceTy, Pointer, ScalarMaybeUninit, StackPopCleanup,
|
||||
};
|
||||
use crate::transform::{MirPass, MirSource};
|
||||
|
||||
|
|
@ -633,7 +633,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
|
|||
|
||||
if let Some(Ok(imm)) = imm {
|
||||
match *imm {
|
||||
interpret::Immediate::Scalar(ScalarMaybeUndef::Scalar(scalar)) => {
|
||||
interpret::Immediate::Scalar(ScalarMaybeUninit::Scalar(scalar)) => {
|
||||
*rval = Rvalue::Use(self.operand_from_scalar(
|
||||
scalar,
|
||||
value.layout.ty,
|
||||
|
|
@ -641,8 +641,8 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
|
|||
));
|
||||
}
|
||||
Immediate::ScalarPair(
|
||||
ScalarMaybeUndef::Scalar(one),
|
||||
ScalarMaybeUndef::Scalar(two),
|
||||
ScalarMaybeUninit::Scalar(one),
|
||||
ScalarMaybeUninit::Scalar(two),
|
||||
) => {
|
||||
// Found a value represented as a pair. For now only do cont-prop if type of
|
||||
// Rvalue is also a pair with two scalars. The more general case is more
|
||||
|
|
@ -693,12 +693,12 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
|
|||
}
|
||||
|
||||
match *op {
|
||||
interpret::Operand::Immediate(Immediate::Scalar(ScalarMaybeUndef::Scalar(s))) => {
|
||||
interpret::Operand::Immediate(Immediate::Scalar(ScalarMaybeUninit::Scalar(s))) => {
|
||||
s.is_bits()
|
||||
}
|
||||
interpret::Operand::Immediate(Immediate::ScalarPair(
|
||||
ScalarMaybeUndef::Scalar(l),
|
||||
ScalarMaybeUndef::Scalar(r),
|
||||
ScalarMaybeUninit::Scalar(l),
|
||||
ScalarMaybeUninit::Scalar(r),
|
||||
)) => l.is_bits() && r.is_bits(),
|
||||
interpret::Operand::Indirect(_) if mir_opt_level >= 2 => {
|
||||
let mplace = op.assert_mem_place(&self.ecx);
|
||||
|
|
@ -889,7 +889,7 @@ impl<'mir, 'tcx> MutVisitor<'tcx> for ConstPropagator<'mir, 'tcx> {
|
|||
TerminatorKind::Assert { expected, ref msg, ref mut cond, .. } => {
|
||||
if let Some(value) = self.eval_operand(&cond, source_info) {
|
||||
trace!("assertion on {:?} should be {:?}", value, expected);
|
||||
let expected = ScalarMaybeUndef::from(Scalar::from_bool(*expected));
|
||||
let expected = ScalarMaybeUninit::from(Scalar::from_bool(*expected));
|
||||
let value_const = self.ecx.read_scalar(value).unwrap();
|
||||
if expected != value_const {
|
||||
// Poison all places this operand references so that further code
|
||||
|
|
@ -936,7 +936,7 @@ impl<'mir, 'tcx> MutVisitor<'tcx> for ConstPropagator<'mir, 'tcx> {
|
|||
);
|
||||
} else {
|
||||
if self.should_const_prop(value) {
|
||||
if let ScalarMaybeUndef::Scalar(scalar) = value_const {
|
||||
if let ScalarMaybeUninit::Scalar(scalar) = value_const {
|
||||
*cond = self.operand_from_scalar(
|
||||
scalar,
|
||||
self.tcx.types.bool,
|
||||
|
|
@ -950,7 +950,7 @@ impl<'mir, 'tcx> MutVisitor<'tcx> for ConstPropagator<'mir, 'tcx> {
|
|||
TerminatorKind::SwitchInt { ref mut discr, switch_ty, .. } => {
|
||||
if let Some(value) = self.eval_operand(&discr, source_info) {
|
||||
if self.should_const_prop(value) {
|
||||
if let ScalarMaybeUndef::Scalar(scalar) =
|
||||
if let ScalarMaybeUninit::Scalar(scalar) =
|
||||
self.ecx.read_scalar(value).unwrap()
|
||||
{
|
||||
*discr = self.operand_from_scalar(scalar, switch_ty, source_info.span);
|
||||
|
|
@ -1003,9 +1003,9 @@ impl<'mir, 'tcx> MutVisitor<'tcx> for ConstPropagator<'mir, 'tcx> {
|
|||
// and use it to do const-prop here and everywhere else
|
||||
// where it makes sense.
|
||||
if let interpret::Operand::Immediate(
|
||||
interpret::Immediate::Scalar(
|
||||
interpret::ScalarMaybeUndef::Scalar(scalar),
|
||||
),
|
||||
interpret::Immediate::Scalar(ScalarMaybeUninit::Scalar(
|
||||
scalar,
|
||||
)),
|
||||
) = *value
|
||||
{
|
||||
*opr = self.operand_from_scalar(
|
||||
|
|
|
|||
|
|
@ -774,7 +774,7 @@ fn write_allocation_bytes<Tag: Copy + Debug, Extra>(
|
|||
ascii.push('╼');
|
||||
i += ptr_size;
|
||||
}
|
||||
} else if alloc.undef_mask().is_range_defined(i, i + Size::from_bytes(1)).is_ok() {
|
||||
} else if alloc.init_mask().is_range_initialized(i, i + Size::from_bytes(1)).is_ok() {
|
||||
let j = i.bytes_usize();
|
||||
|
||||
// Checked definedness (and thus range) and relocations. This access also doesn't
|
||||
|
|
|
|||
|
|
@ -51,10 +51,10 @@
|
|||
// + literal: Const { ty: fn(&str) -> ! {std::rt::begin_panic::<&str>}, val: Value(Scalar(<ZST>)) }
|
||||
// ty::Const
|
||||
// + ty: &str
|
||||
// + val: Value(Slice { data: Allocation { bytes: [101, 120, 112, 108, 105, 99, 105, 116, 32, 112, 97, 110, 105, 99], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [16383], len: Size { raw: 14 } }, size: Size { raw: 14 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 14 })
|
||||
// + val: Value(Slice { data: Allocation { bytes: [101, 120, 112, 108, 105, 99, 105, 116, 32, 112, 97, 110, 105, 99], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [16383], len: Size { raw: 14 } }, size: Size { raw: 14 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 14 })
|
||||
// mir::Constant
|
||||
// + span: $SRC_DIR/libstd/macros.rs:LL:COL
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [101, 120, 112, 108, 105, 99, 105, 116, 32, 112, 97, 110, 105, 99], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [16383], len: Size { raw: 14 } }, size: Size { raw: 14 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 14 }) }
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [101, 120, 112, 108, 105, 99, 105, 116, 32, 112, 97, 110, 105, 99], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [16383], len: Size { raw: 14 } }, size: Size { raw: 14 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 14 }) }
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@
|
|||
- // + ty: fn() -> std::vec::Vec<u32> {std::vec::Vec::<u32>::new}
|
||||
- // + val: Value(Scalar(<ZST>))
|
||||
+ // + ty: alloc::raw_vec::RawVec<u32>
|
||||
+ // + val: Value(ByRef { alloc: Allocation { bytes: [4, 0, 0, 0, 0, 0, 0, 0], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [255], len: Size { raw: 8 } }, size: Size { raw: 8 }, align: Align { pow2: 2 }, mutability: Not, extra: () }, offset: Size { raw: 0 } })
|
||||
+ // + val: Value(ByRef { alloc: Allocation { bytes: [4, 0, 0, 0, 0, 0, 0, 0], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [255], len: Size { raw: 8 } }, size: Size { raw: 8 }, align: Align { pow2: 2 }, mutability: Not, extra: () }, offset: Size { raw: 0 } })
|
||||
// mir::Constant
|
||||
- // + span: $DIR/inline-into-box-place.rs:8:33: 8:41
|
||||
- // + user_ty: UserType(1)
|
||||
|
|
@ -38,7 +38,7 @@
|
|||
- bb2: {
|
||||
+ // + span: $SRC_DIR/liballoc/vec.rs:LL:COL
|
||||
+ // + user_ty: UserType(0)
|
||||
+ // + literal: Const { ty: alloc::raw_vec::RawVec<u32>, val: Value(ByRef { alloc: Allocation { bytes: [4, 0, 0, 0, 0, 0, 0, 0], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [255], len: Size { raw: 8 } }, size: Size { raw: 8 }, align: Align { pow2: 2 }, mutability: Not, extra: () }, offset: Size { raw: 0 } }) }
|
||||
+ // + literal: Const { ty: alloc::raw_vec::RawVec<u32>, val: Value(ByRef { alloc: Allocation { bytes: [4, 0, 0, 0, 0, 0, 0, 0], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [255], len: Size { raw: 8 } }, size: Size { raw: 8 }, align: Align { pow2: 2 }, mutability: Not, extra: () }, offset: Size { raw: 0 } }) }
|
||||
+ ((*_4).1: usize) = const 0usize; // scope 2 at $SRC_DIR/liballoc/vec.rs:LL:COL
|
||||
+ // ty::Const
|
||||
+ // + ty: usize
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@
|
|||
- // + ty: fn() -> std::vec::Vec<u32> {std::vec::Vec::<u32>::new}
|
||||
- // + val: Value(Scalar(<ZST>))
|
||||
+ // + ty: alloc::raw_vec::RawVec<u32>
|
||||
+ // + val: Value(ByRef { alloc: Allocation { bytes: [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [65535], len: Size { raw: 16 } }, size: Size { raw: 16 }, align: Align { pow2: 3 }, mutability: Not, extra: () }, offset: Size { raw: 0 } })
|
||||
+ // + val: Value(ByRef { alloc: Allocation { bytes: [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [65535], len: Size { raw: 16 } }, size: Size { raw: 16 }, align: Align { pow2: 3 }, mutability: Not, extra: () }, offset: Size { raw: 0 } })
|
||||
// mir::Constant
|
||||
- // + span: $DIR/inline-into-box-place.rs:8:33: 8:41
|
||||
- // + user_ty: UserType(1)
|
||||
|
|
@ -38,7 +38,7 @@
|
|||
- bb2: {
|
||||
+ // + span: $SRC_DIR/liballoc/vec.rs:LL:COL
|
||||
+ // + user_ty: UserType(0)
|
||||
+ // + literal: Const { ty: alloc::raw_vec::RawVec<u32>, val: Value(ByRef { alloc: Allocation { bytes: [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [65535], len: Size { raw: 16 } }, size: Size { raw: 16 }, align: Align { pow2: 3 }, mutability: Not, extra: () }, offset: Size { raw: 0 } }) }
|
||||
+ // + literal: Const { ty: alloc::raw_vec::RawVec<u32>, val: Value(ByRef { alloc: Allocation { bytes: [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [65535], len: Size { raw: 16 } }, size: Size { raw: 16 }, align: Align { pow2: 3 }, mutability: Not, extra: () }, offset: Size { raw: 0 } }) }
|
||||
+ ((*_4).1: usize) = const 0usize; // scope 2 at $SRC_DIR/liballoc/vec.rs:LL:COL
|
||||
+ // ty::Const
|
||||
+ // + ty: usize
|
||||
|
|
|
|||
|
|
@ -32,10 +32,10 @@ fn unwrap(_1: std::option::Option<T>) -> T {
|
|||
// + literal: Const { ty: fn(&str) -> ! {std::rt::begin_panic::<&str>}, val: Value(Scalar(<ZST>)) }
|
||||
// ty::Const
|
||||
// + ty: &str
|
||||
// + val: Value(Slice { data: Allocation { bytes: [101, 120, 112, 108, 105, 99, 105, 116, 32, 112, 97, 110, 105, 99], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [16383], len: Size { raw: 14 } }, size: Size { raw: 14 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 14 })
|
||||
// + val: Value(Slice { data: Allocation { bytes: [101, 120, 112, 108, 105, 99, 105, 116, 32, 112, 97, 110, 105, 99], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [16383], len: Size { raw: 14 } }, size: Size { raw: 14 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 14 })
|
||||
// mir::Constant
|
||||
// + span: $SRC_DIR/libstd/macros.rs:LL:COL
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [101, 120, 112, 108, 105, 99, 105, 116, 32, 112, 97, 110, 105, 99], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [16383], len: Size { raw: 14 } }, size: Size { raw: 14 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 14 }) }
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [101, 120, 112, 108, 105, 99, 105, 116, 32, 112, 97, 110, 105, 99], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [16383], len: Size { raw: 14 } }, size: Size { raw: 14 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 14 }) }
|
||||
}
|
||||
|
||||
bb3: {
|
||||
|
|
|
|||
|
|
@ -15,10 +15,10 @@ fn main() -> () {
|
|||
_4 = const ""; // scope 0 at $DIR/no-spurious-drop-after-call.rs:9:20: 9:22
|
||||
// ty::Const
|
||||
// + ty: &str
|
||||
// + val: Value(Slice { data: Allocation { bytes: [], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [], len: Size { raw: 0 } }, size: Size { raw: 0 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 0 })
|
||||
// + val: Value(Slice { data: Allocation { bytes: [], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [], len: Size { raw: 0 } }, size: Size { raw: 0 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 0 })
|
||||
// mir::Constant
|
||||
// + span: $DIR/no-spurious-drop-after-call.rs:9:20: 9:22
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [], len: Size { raw: 0 } }, size: Size { raw: 0 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 0 }) }
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [], len: Size { raw: 0 } }, size: Size { raw: 0 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 0 }) }
|
||||
_3 = &(*_4); // scope 0 at $DIR/no-spurious-drop-after-call.rs:9:20: 9:22
|
||||
_2 = const <str as std::string::ToString>::to_string(move _3) -> bb2; // scope 0 at $DIR/no-spurious-drop-after-call.rs:9:20: 9:34
|
||||
// ty::Const
|
||||
|
|
|
|||
|
|
@ -653,10 +653,10 @@ static XXX: &Foo = {
|
|||
_2 = Foo { tup: const "hi", data: move _3 }; // scope 0 at $DIR/storage_live_dead_in_statics.rs:5:29: 23:2
|
||||
// ty::Const
|
||||
// + ty: &str
|
||||
// + val: Value(Slice { data: Allocation { bytes: [104, 105], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [3], len: Size { raw: 2 } }, size: Size { raw: 2 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 2 })
|
||||
// + val: Value(Slice { data: Allocation { bytes: [104, 105], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [3], len: Size { raw: 2 } }, size: Size { raw: 2 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 2 })
|
||||
// mir::Constant
|
||||
// + span: $DIR/storage_live_dead_in_statics.rs:6:10: 6:14
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [104, 105], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [3], len: Size { raw: 2 } }, size: Size { raw: 2 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 2 }) }
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [104, 105], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [3], len: Size { raw: 2 } }, size: Size { raw: 2 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 2 }) }
|
||||
_1 = &_2; // scope 0 at $DIR/storage_live_dead_in_statics.rs:5:28: 23:2
|
||||
_0 = &(*_1); // scope 0 at $DIR/storage_live_dead_in_statics.rs:5:28: 23:2
|
||||
StorageDead(_5); // scope 0 at $DIR/storage_live_dead_in_statics.rs:23:1: 23:2
|
||||
|
|
|
|||
|
|
@ -21,10 +21,10 @@ fn main() -> () {
|
|||
_5 = const "C"; // scope 0 at $DIR/uninhabited_enum_branching.rs:23:21: 23:24
|
||||
// ty::Const
|
||||
// + ty: &str
|
||||
// + val: Value(Slice { data: Allocation { bytes: [67], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 })
|
||||
// + val: Value(Slice { data: Allocation { bytes: [67], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 })
|
||||
// mir::Constant
|
||||
// + span: $DIR/uninhabited_enum_branching.rs:23:21: 23:24
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [67], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 }) }
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [67], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 }) }
|
||||
_1 = &(*_5); // scope 0 at $DIR/uninhabited_enum_branching.rs:23:21: 23:24
|
||||
StorageDead(_5); // scope 0 at $DIR/uninhabited_enum_branching.rs:23:23: 23:24
|
||||
StorageDead(_2); // scope 0 at $DIR/uninhabited_enum_branching.rs:24:6: 24:7
|
||||
|
|
@ -41,10 +41,10 @@ fn main() -> () {
|
|||
_9 = const "E"; // scope 0 at $DIR/uninhabited_enum_branching.rs:28:21: 28:24
|
||||
// ty::Const
|
||||
// + ty: &str
|
||||
// + val: Value(Slice { data: Allocation { bytes: [69], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 })
|
||||
// + val: Value(Slice { data: Allocation { bytes: [69], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 })
|
||||
// mir::Constant
|
||||
// + span: $DIR/uninhabited_enum_branching.rs:28:21: 28:24
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [69], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 }) }
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [69], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 }) }
|
||||
_6 = &(*_9); // scope 0 at $DIR/uninhabited_enum_branching.rs:28:21: 28:24
|
||||
StorageDead(_9); // scope 0 at $DIR/uninhabited_enum_branching.rs:28:23: 28:24
|
||||
goto -> bb3; // scope 0 at $DIR/uninhabited_enum_branching.rs:26:5: 29:6
|
||||
|
|
@ -54,10 +54,10 @@ fn main() -> () {
|
|||
_6 = const "D"; // scope 0 at $DIR/uninhabited_enum_branching.rs:27:21: 27:24
|
||||
// ty::Const
|
||||
// + ty: &str
|
||||
// + val: Value(Slice { data: Allocation { bytes: [68], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 })
|
||||
// + val: Value(Slice { data: Allocation { bytes: [68], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 })
|
||||
// mir::Constant
|
||||
// + span: $DIR/uninhabited_enum_branching.rs:27:21: 27:24
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [68], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 }) }
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [68], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 }) }
|
||||
goto -> bb3; // scope 0 at $DIR/uninhabited_enum_branching.rs:26:5: 29:6
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -27,10 +27,10 @@
|
|||
_5 = const "C"; // scope 0 at $DIR/uninhabited_enum_branching.rs:23:21: 23:24
|
||||
// ty::Const
|
||||
// + ty: &str
|
||||
// + val: Value(Slice { data: Allocation { bytes: [67], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 })
|
||||
// + val: Value(Slice { data: Allocation { bytes: [67], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 })
|
||||
// mir::Constant
|
||||
// + span: $DIR/uninhabited_enum_branching.rs:23:21: 23:24
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [67], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 }) }
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [67], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 }) }
|
||||
_1 = &(*_5); // scope 0 at $DIR/uninhabited_enum_branching.rs:23:21: 23:24
|
||||
StorageDead(_5); // scope 0 at $DIR/uninhabited_enum_branching.rs:23:23: 23:24
|
||||
goto -> bb4; // scope 0 at $DIR/uninhabited_enum_branching.rs:20:5: 24:6
|
||||
|
|
@ -40,10 +40,10 @@
|
|||
_1 = const "A(Empty)"; // scope 0 at $DIR/uninhabited_enum_branching.rs:21:24: 21:34
|
||||
// ty::Const
|
||||
// + ty: &str
|
||||
// + val: Value(Slice { data: Allocation { bytes: [65, 40, 69, 109, 112, 116, 121, 41], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [255], len: Size { raw: 8 } }, size: Size { raw: 8 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 8 })
|
||||
// + val: Value(Slice { data: Allocation { bytes: [65, 40, 69, 109, 112, 116, 121, 41], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [255], len: Size { raw: 8 } }, size: Size { raw: 8 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 8 })
|
||||
// mir::Constant
|
||||
// + span: $DIR/uninhabited_enum_branching.rs:21:24: 21:34
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [65, 40, 69, 109, 112, 116, 121, 41], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [255], len: Size { raw: 8 } }, size: Size { raw: 8 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 8 }) }
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [65, 40, 69, 109, 112, 116, 121, 41], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [255], len: Size { raw: 8 } }, size: Size { raw: 8 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 8 }) }
|
||||
goto -> bb4; // scope 0 at $DIR/uninhabited_enum_branching.rs:20:5: 24:6
|
||||
}
|
||||
|
||||
|
|
@ -52,10 +52,10 @@
|
|||
_4 = const "B(Empty)"; // scope 0 at $DIR/uninhabited_enum_branching.rs:22:24: 22:34
|
||||
// ty::Const
|
||||
// + ty: &str
|
||||
// + val: Value(Slice { data: Allocation { bytes: [66, 40, 69, 109, 112, 116, 121, 41], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [255], len: Size { raw: 8 } }, size: Size { raw: 8 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 8 })
|
||||
// + val: Value(Slice { data: Allocation { bytes: [66, 40, 69, 109, 112, 116, 121, 41], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [255], len: Size { raw: 8 } }, size: Size { raw: 8 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 8 })
|
||||
// mir::Constant
|
||||
// + span: $DIR/uninhabited_enum_branching.rs:22:24: 22:34
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [66, 40, 69, 109, 112, 116, 121, 41], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [255], len: Size { raw: 8 } }, size: Size { raw: 8 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 8 }) }
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [66, 40, 69, 109, 112, 116, 121, 41], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [255], len: Size { raw: 8 } }, size: Size { raw: 8 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 8 }) }
|
||||
_1 = &(*_4); // scope 0 at $DIR/uninhabited_enum_branching.rs:22:24: 22:34
|
||||
StorageDead(_4); // scope 0 at $DIR/uninhabited_enum_branching.rs:22:33: 22:34
|
||||
goto -> bb4; // scope 0 at $DIR/uninhabited_enum_branching.rs:20:5: 24:6
|
||||
|
|
@ -76,10 +76,10 @@
|
|||
_9 = const "E"; // scope 0 at $DIR/uninhabited_enum_branching.rs:28:21: 28:24
|
||||
// ty::Const
|
||||
// + ty: &str
|
||||
// + val: Value(Slice { data: Allocation { bytes: [69], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 })
|
||||
// + val: Value(Slice { data: Allocation { bytes: [69], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 })
|
||||
// mir::Constant
|
||||
// + span: $DIR/uninhabited_enum_branching.rs:28:21: 28:24
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [69], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 }) }
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [69], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 }) }
|
||||
_6 = &(*_9); // scope 0 at $DIR/uninhabited_enum_branching.rs:28:21: 28:24
|
||||
StorageDead(_9); // scope 0 at $DIR/uninhabited_enum_branching.rs:28:23: 28:24
|
||||
goto -> bb7; // scope 0 at $DIR/uninhabited_enum_branching.rs:26:5: 29:6
|
||||
|
|
@ -89,10 +89,10 @@
|
|||
_6 = const "D"; // scope 0 at $DIR/uninhabited_enum_branching.rs:27:21: 27:24
|
||||
// ty::Const
|
||||
// + ty: &str
|
||||
// + val: Value(Slice { data: Allocation { bytes: [68], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 })
|
||||
// + val: Value(Slice { data: Allocation { bytes: [68], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 })
|
||||
// mir::Constant
|
||||
// + span: $DIR/uninhabited_enum_branching.rs:27:21: 27:24
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [68], relocations: Relocations(SortedMap { data: [] }), undef_mask: UndefMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 }) }
|
||||
// + literal: Const { ty: &str, val: Value(Slice { data: Allocation { bytes: [68], relocations: Relocations(SortedMap { data: [] }), init_mask: InitMask { blocks: [1], len: Size { raw: 1 } }, size: Size { raw: 1 }, align: Align { pow2: 0 }, mutability: Not, extra: () }, start: 0, end: 1 }) }
|
||||
goto -> bb7; // scope 0 at $DIR/uninhabited_enum_branching.rs:26:5: 29:6
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -7,11 +7,11 @@
|
|||
extern crate rustc_middle;
|
||||
extern crate rustc_target;
|
||||
|
||||
use rustc_middle::mir::interpret::UndefMask;
|
||||
use rustc_middle::mir::interpret::InitMask;
|
||||
use rustc_target::abi::Size;
|
||||
|
||||
fn main() {
|
||||
let mut mask = UndefMask::new(Size::from_bytes(500), false);
|
||||
let mut mask = InitMask::new(Size::from_bytes(500), false);
|
||||
assert!(!mask.get(Size::from_bytes(499)));
|
||||
mask.set(Size::from_bytes(499), true);
|
||||
assert!(mask.get(Size::from_bytes(499)));
|
||||
Loading…
Add table
Add a link
Reference in a new issue