def children(self):
(length, data_ptr) = \
rustpp.extract_length_and_ptr_from_std_btreeset(self.__val)
- leaf_node = GdbValue(data_ptr.get_wrapped_value().dereference())
- maybe_uninit_keys = leaf_node.get_child_at_index(3)
- manually_drop_keys = maybe_uninit_keys.get_child_at_index(1)
- keys = manually_drop_keys.get_child_at_index(0)
- gdb_ptr = keys.get_wrapped_value()
+ val = GdbValue(data_ptr.get_wrapped_value().dereference()).get_child_at_index(3)
+ gdb_ptr = val.get_wrapped_value()
for index in xrange(length):
yield (str(index), gdb_ptr[index])
def children(self):
(length, data_ptr) = \
rustpp.extract_length_and_ptr_from_std_btreemap(self.__val)
- leaf_node = GdbValue(data_ptr.get_wrapped_value().dereference())
- maybe_uninit_keys = leaf_node.get_child_at_index(3)
- manually_drop_keys = maybe_uninit_keys.get_child_at_index(1)
- keys = manually_drop_keys.get_child_at_index(0)
+ keys = GdbValue(data_ptr.get_wrapped_value().dereference()).get_child_at_index(3)
keys_ptr = keys.get_wrapped_value()
- maybe_uninit_vals = leaf_node.get_child_at_index(4)
- manually_drop_vals = maybe_uninit_vals.get_child_at_index(1)
- vals = manually_drop_vals.get_child_at_index(0)
+ vals = GdbValue(data_ptr.get_wrapped_value().dereference()).get_child_at_index(4)
vals_ptr = vals.get_wrapped_value()
for index in xrange(length):
yield (str(index), keys_ptr[index])
// This implies that even an empty internal node has at least one edge.
use core::marker::PhantomData;
-use core::mem::{self, MaybeUninit};
+use core::mem;
use core::ptr::{self, Unique, NonNull};
use core::slice;
/// This node's index into the parent node's `edges` array.
/// `*node.parent.edges[node.parent_idx]` should be the same thing as `node`.
/// This is only guaranteed to be initialized when `parent` is nonnull.
- parent_idx: MaybeUninit<u16>,
+ parent_idx: u16,
/// The number of keys and values this node stores.
///
/// The arrays storing the actual data of the node. Only the first `len` elements of each
/// array are initialized and valid.
- keys: MaybeUninit<[K; CAPACITY]>,
- vals: MaybeUninit<[V; CAPACITY]>,
+ keys: [K; CAPACITY],
+ vals: [V; CAPACITY],
}
impl<K, V> LeafNode<K, V> {
LeafNode {
// As a general policy, we leave fields uninitialized if they can be, as this should
// be both slightly faster and easier to track in Valgrind.
- keys: MaybeUninit::uninitialized(),
- vals: MaybeUninit::uninitialized(),
+ keys: mem::uninitialized(),
+ vals: mem::uninitialized(),
parent: ptr::null(),
- parent_idx: MaybeUninit::uninitialized(),
+ parent_idx: mem::uninitialized(),
len: 0
}
}
// ever take a pointer past the first key.
static EMPTY_ROOT_NODE: LeafNode<(), ()> = LeafNode {
parent: ptr::null(),
- parent_idx: MaybeUninit::uninitialized(),
+ parent_idx: 0,
len: 0,
- keys: MaybeUninit::uninitialized(),
- vals: MaybeUninit::uninitialized(),
+ keys: [(); CAPACITY],
+ vals: [(); CAPACITY],
};
/// The underlying representation of internal nodes. As with `LeafNode`s, these should be hidden
root: self.root,
_marker: PhantomData
},
- idx: unsafe { usize::from(*self.as_leaf().parent_idx.get_ref()) },
+ idx: self.as_leaf().parent_idx as usize,
_marker: PhantomData
})
} else {
// the node, which is allowed by LLVM.
unsafe {
slice::from_raw_parts(
- self.as_leaf().keys.as_ptr() as *const K,
+ self.as_leaf().keys.as_ptr(),
self.len()
)
}
debug_assert!(!self.is_shared_root());
unsafe {
slice::from_raw_parts(
- self.as_leaf().vals.as_ptr() as *const V,
+ self.as_leaf().vals.as_ptr(),
self.len()
)
}
} else {
unsafe {
slice::from_raw_parts_mut(
- self.as_leaf_mut().keys.get_mut() as *mut [K] as *mut K,
+ &mut self.as_leaf_mut().keys as *mut [K] as *mut K,
self.len()
)
}
debug_assert!(!self.is_shared_root());
unsafe {
slice::from_raw_parts_mut(
- self.as_leaf_mut().vals.get_mut() as *mut [V] as *mut V,
+ &mut self.as_leaf_mut().vals as *mut [V] as *mut V,
self.len()
)
}
let ptr = self.node.as_internal_mut() as *mut _;
let mut child = self.descend();
child.as_leaf_mut().parent = ptr;
- child.as_leaf_mut().parent_idx.set(idx);
+ child.as_leaf_mut().parent_idx = idx;
}
/// Unsafely asserts to the compiler some static information about whether the underlying
ptr::copy_nonoverlapping(
self.node.keys().as_ptr().add(self.idx + 1),
- new_node.keys.as_mut_ptr() as *mut K,
+ new_node.keys.as_mut_ptr(),
new_len
);
ptr::copy_nonoverlapping(
self.node.vals().as_ptr().add(self.idx + 1),
- new_node.vals.as_mut_ptr() as *mut V,
+ new_node.vals.as_mut_ptr(),
new_len
);
ptr::copy_nonoverlapping(
self.node.keys().as_ptr().add(self.idx + 1),
- new_node.data.keys.as_mut_ptr() as *mut K,
+ new_node.data.keys.as_mut_ptr(),
new_len
);
ptr::copy_nonoverlapping(
self.node.vals().as_ptr().add(self.idx + 1),
- new_node.data.vals.as_mut_ptr() as *mut V,
+ new_node.data.vals.as_mut_ptr(),
new_len
);
ptr::copy_nonoverlapping(
#![feature(rustc_const_unstable)]
#![feature(const_vec_new)]
#![feature(slice_partition_dedup)]
-#![feature(maybe_uninit)]
// Allow testing this library
// except according to those terms.
use fmt::{Formatter, Result, LowerExp, UpperExp, Display, Debug};
-use mem::MaybeUninit;
+use mem;
use num::flt2dec;
// Don't inline this so callers don't use the stack space this function
where T: flt2dec::DecodableFloat
{
unsafe {
- let mut buf = MaybeUninit::<[u8; 1024]>::uninitialized(); // enough for f32 and f64
- let mut parts = MaybeUninit::<[flt2dec::Part; 4]>::uninitialized();
+ let mut buf: [u8; 1024] = mem::uninitialized(); // enough for f32 and f64
+ let mut parts: [flt2dec::Part; 4] = mem::uninitialized();
let formatted = flt2dec::to_exact_fixed_str(flt2dec::strategy::grisu::format_exact,
*num, sign, precision,
- false, buf.get_mut(), parts.get_mut());
+ false, &mut buf, &mut parts);
fmt.pad_formatted_parts(&formatted)
}
}
{
unsafe {
// enough for f32 and f64
- let mut buf = MaybeUninit::<[u8; flt2dec::MAX_SIG_DIGITS]>::uninitialized();
- let mut parts = MaybeUninit::<[flt2dec::Part; 4]>::uninitialized();
+ let mut buf: [u8; flt2dec::MAX_SIG_DIGITS] = mem::uninitialized();
+ let mut parts: [flt2dec::Part; 4] = mem::uninitialized();
let formatted = flt2dec::to_shortest_str(flt2dec::strategy::grisu::format_shortest, *num,
- sign, precision, false, buf.get_mut(),
- parts.get_mut());
+ sign, precision, false, &mut buf, &mut parts);
fmt.pad_formatted_parts(&formatted)
}
}
where T: flt2dec::DecodableFloat
{
unsafe {
- let mut buf = MaybeUninit::<[u8; 1024]>::uninitialized(); // enough for f32 and f64
- let mut parts = MaybeUninit::<[flt2dec::Part; 6]>::uninitialized();
+ let mut buf: [u8; 1024] = mem::uninitialized(); // enough for f32 and f64
+ let mut parts: [flt2dec::Part; 6] = mem::uninitialized();
let formatted = flt2dec::to_exact_exp_str(flt2dec::strategy::grisu::format_exact,
*num, sign, precision,
- upper, buf.get_mut(), parts.get_mut());
+ upper, &mut buf, &mut parts);
fmt.pad_formatted_parts(&formatted)
}
}
{
unsafe {
// enough for f32 and f64
- let mut buf = MaybeUninit::<[u8; flt2dec::MAX_SIG_DIGITS]>::uninitialized();
- let mut parts = MaybeUninit::<[flt2dec::Part; 6]>::uninitialized();
+ let mut buf: [u8; flt2dec::MAX_SIG_DIGITS] = mem::uninitialized();
+ let mut parts: [flt2dec::Part; 6] = mem::uninitialized();
let formatted = flt2dec::to_shortest_exp_str(flt2dec::strategy::grisu::format_shortest,
*num, sign, (0, 0), upper,
- buf.get_mut(), parts.get_mut());
+ &mut buf, &mut parts);
fmt.pad_formatted_parts(&formatted)
}
}
#[allow(unused_macros)]
macro_rules! vector_impl { ($([$f:ident, $($args:tt)*]),*) => { $($f!($($args)*);)* } }
#[path = "../stdsimd/coresimd/mod.rs"]
-// replacing uses of mem::{uninitialized,zeroed} with MaybeUninit needs to be in the stdsimd repo
-#[allow(deprecated)]
#[allow(missing_docs, missing_debug_implementations, dead_code, unused_imports)]
#[unstable(feature = "stdsimd", issue = "48556")]
#[cfg(not(stage0))] // allow changes to how stdsimd works in stage0
/// assert_eq!(0, x);
/// ```
#[inline]
-#[rustc_deprecated(since = "2.0.0", reason = "use `mem::MaybeUninit::zeroed` instead")]
#[stable(feature = "rust1", since = "1.0.0")]
pub unsafe fn zeroed<T>() -> T {
intrinsics::init()
/// [copy_no]: ../intrinsics/fn.copy_nonoverlapping.html
/// [`Drop`]: ../ops/trait.Drop.html
#[inline]
-#[rustc_deprecated(since = "2.0.0", reason = "use `mem::MaybeUninit::uninitialized` instead")]
#[stable(feature = "rust1", since = "1.0.0")]
pub unsafe fn uninitialized<T>() -> T {
intrinsics::uninit()
&mut self.value
}
}
-
-/// A newtype to construct uninitialized instances of `T`
-#[allow(missing_debug_implementations)]
-#[unstable(feature = "maybe_uninit", issue = "53491")]
-// NOTE after stabilizing `MaybeUninit` proceed to deprecate `mem::{uninitialized,zeroed}`
-pub union MaybeUninit<T> {
- uninit: (),
- value: ManuallyDrop<T>,
-}
-
-impl<T> MaybeUninit<T> {
- /// Create a new `MaybeUninit` in an uninitialized state.
- ///
- /// Note that dropping a `MaybeUninit` will never call `T`'s drop code.
- /// It is your responsibility to make sure `T` gets dropped if it got initialized.
- #[unstable(feature = "maybe_uninit", issue = "53491")]
- pub const fn uninitialized() -> MaybeUninit<T> {
- MaybeUninit { uninit: () }
- }
-
- /// Create a new `MaybeUninit` in an uninitialized state, with the memory being
- /// filled with `0` bytes. It depends on `T` whether that already makes for
- /// proper initialization. For example, `MaybeUninit<usize>::zeroed()` is initialized,
- /// but `MaybeUninit<&'static i32>::zeroed()` is not because references must not
- /// be null.
- ///
- /// Note that dropping a `MaybeUninit` will never call `T`'s drop code.
- /// It is your responsibility to make sure `T` gets dropped if it got initialized.
- #[unstable(feature = "maybe_uninit", issue = "53491")]
- pub fn zeroed() -> MaybeUninit<T> {
- let mut u = MaybeUninit::<T>::uninitialized();
- unsafe {
- u.as_mut_ptr().write_bytes(0u8, 1);
- }
- u
- }
-
- /// Set the value of the `MaybeUninit`. This overwrites any previous value without dropping it.
- #[unstable(feature = "maybe_uninit", issue = "53491")]
- pub fn set(&mut self, val: T) {
- unsafe {
- self.value = ManuallyDrop::new(val);
- }
- }
-
- /// Extract the value from the `MaybeUninit` container. This is a great way
- /// to ensure that the data will get dropped, because the resulting `T` is
- /// subject to the usual drop handling.
- ///
- /// # Unsafety
- ///
- /// It is up to the caller to guarantee that the the `MaybeUninit` really is in an initialized
- /// state, otherwise this will immediately cause undefined behavior.
- #[unstable(feature = "maybe_uninit", issue = "53491")]
- pub unsafe fn into_inner(self) -> T {
- ManuallyDrop::into_inner(self.value)
- }
-
- /// Get a reference to the contained value.
- ///
- /// # Unsafety
- ///
- /// It is up to the caller to guarantee that the the `MaybeUninit` really is in an initialized
- /// state, otherwise this will immediately cause undefined behavior.
- #[unstable(feature = "maybe_uninit", issue = "53491")]
- pub unsafe fn get_ref(&self) -> &T {
- &*self.value
- }
-
- /// Get a mutable reference to the contained value.
- ///
- /// # Unsafety
- ///
- /// It is up to the caller to guarantee that the the `MaybeUninit` really is in an initialized
- /// state, otherwise this will immediately cause undefined behavior.
- #[unstable(feature = "maybe_uninit", issue = "53491")]
- pub unsafe fn get_mut(&mut self) -> &mut T {
- &mut *self.value
- }
-
- /// Get a pointer to the contained value. Reading from this pointer will be undefined
- /// behavior unless the `MaybeUninit` is initialized.
- #[unstable(feature = "maybe_uninit", issue = "53491")]
- pub fn as_ptr(&self) -> *const T {
- unsafe { &*self.value as *const T }
- }
-
- /// Get a mutable pointer to the contained value. Reading from this pointer will be undefined
- /// behavior unless the `MaybeUninit` is initialized.
- #[unstable(feature = "maybe_uninit", issue = "53491")]
- pub fn as_mut_ptr(&mut self) -> *mut T {
- unsafe { &mut *self.value as *mut T }
- }
-}
use fmt;
use hash;
use marker::{PhantomData, Unsize};
-use mem::{self, MaybeUninit};
+use mem;
use nonzero::NonZero;
use cmp::Ordering::{self, Less, Equal, Greater};
#[stable(feature = "rust1", since = "1.0.0")]
pub unsafe fn swap<T>(x: *mut T, y: *mut T) {
// Give ourselves some scratch space to work with
- let mut tmp = MaybeUninit::<T>::uninitialized();
+ let mut tmp: T = mem::uninitialized();
// Perform the swap
- copy_nonoverlapping(x, tmp.as_mut_ptr(), 1);
+ copy_nonoverlapping(x, &mut tmp, 1);
copy(y, x, 1); // `x` and `y` may overlap
- copy_nonoverlapping(tmp.get_ref(), y, 1);
+ copy_nonoverlapping(&tmp, y, 1);
+
+ // y and t now point to the same thing, but we need to completely forget `tmp`
+ // because it's no longer relevant.
+ mem::forget(tmp);
}
/// Swaps `count * size_of::<T>()` bytes between the two regions of memory
while i + block_size <= len {
// Create some uninitialized memory as scratch space
// Declaring `t` here avoids aligning the stack when this loop is unused
- let mut t = mem::MaybeUninit::<Block>::uninitialized();
- let t = t.as_mut_ptr() as *mut u8;
+ let mut t: Block = mem::uninitialized();
+ let t = &mut t as *mut _ as *mut u8;
let x = x.add(i);
let y = y.add(i);
if i < len {
// Swap any remaining bytes
- let mut t = mem::MaybeUninit::<UnalignedBlock>::uninitialized();
+ let mut t: UnalignedBlock = mem::uninitialized();
let rem = len - i;
- let t = t.as_mut_ptr() as *mut u8;
+ let t = &mut t as *mut _ as *mut u8;
let x = x.add(i);
let y = y.add(i);
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub unsafe fn read<T>(src: *const T) -> T {
- let mut tmp = MaybeUninit::<T>::uninitialized();
- copy_nonoverlapping(src, tmp.as_mut_ptr(), 1);
- tmp.into_inner()
+ let mut tmp: T = mem::uninitialized();
+ copy_nonoverlapping(src, &mut tmp, 1);
+ tmp
}
/// Reads the value from `src` without moving it. This leaves the
#[inline]
#[stable(feature = "ptr_unaligned", since = "1.17.0")]
pub unsafe fn read_unaligned<T>(src: *const T) -> T {
- let mut tmp = MaybeUninit::<T>::uninitialized();
+ let mut tmp: T = mem::uninitialized();
copy_nonoverlapping(src as *const u8,
- tmp.as_mut_ptr() as *mut u8,
+ &mut tmp as *mut T as *mut u8,
mem::size_of::<T>());
- tmp.into_inner()
+ tmp
}
/// Overwrites a memory location with the given value without reading or
// except according to those terms.
use cmp;
-use mem::{self, MaybeUninit};
+use mem;
use ptr;
/// Rotation is much faster if it has access to a little bit of memory. This
}
impl<T> RawArray<T> {
+ fn new() -> Self {
+ unsafe { mem::uninitialized() }
+ }
+ fn ptr(&self) -> *mut T {
+ unsafe { &self.typed as *const T as *mut T }
+ }
fn cap() -> usize {
if mem::size_of::<T>() == 0 {
usize::max_value()
}
}
- let mut rawarray = MaybeUninit::<RawArray<T>>::uninitialized();
- let buf = &mut (*rawarray.as_mut_ptr()).typed as *mut [T; 2] as *mut T;
+ let rawarray = RawArray::new();
+ let buf = rawarray.ptr();
let dim = mid.sub(left).add(right);
if left <= right {
//! stable sorting implementation.
use cmp;
-use mem::{self, MaybeUninit};
+use mem;
use ptr;
/// When dropped, copies from `src` into `dest`.
let mut block_l = BLOCK;
let mut start_l = ptr::null_mut();
let mut end_l = ptr::null_mut();
- let mut offsets_l = MaybeUninit::<[u8; BLOCK]>::uninitialized();
+ let mut offsets_l: [u8; BLOCK] = unsafe { mem::uninitialized() };
// The current block on the right side (from `r.sub(block_r)` to `r`).
let mut r = unsafe { l.add(v.len()) };
let mut block_r = BLOCK;
let mut start_r = ptr::null_mut();
let mut end_r = ptr::null_mut();
- let mut offsets_r = MaybeUninit::<[u8; BLOCK]>::uninitialized();
+ let mut offsets_r: [u8; BLOCK] = unsafe { mem::uninitialized() };
// FIXME: When we get VLAs, try creating one array of length `min(v.len(), 2 * BLOCK)` rather
// than two fixed-size arrays of length `BLOCK`. VLAs might be more cache-efficient.
if start_l == end_l {
// Trace `block_l` elements from the left side.
- start_l = offsets_l.as_mut_ptr() as *mut u8;
- end_l = offsets_l.as_mut_ptr() as *mut u8;
+ start_l = offsets_l.as_mut_ptr();
+ end_l = offsets_l.as_mut_ptr();
let mut elem = l;
for i in 0..block_l {
if start_r == end_r {
// Trace `block_r` elements from the right side.
- start_r = offsets_r.as_mut_ptr() as *mut u8;
- end_r = offsets_r.as_mut_ptr() as *mut u8;
+ start_r = offsets_r.as_mut_ptr();
+ end_r = offsets_r.as_mut_ptr();
let mut elem = r;
for i in 0..block_r {
}
}
- if sized && fields.iter().any(|f| f.abi.is_uninhabited()) {
+ if sized && fields.iter().any(|f| f.abi == Abi::Uninhabited) {
abi = Abi::Uninhabited;
}
// See issue #49298 for more details on the need to leave space
// for non-ZST uninhabited data (mostly partial initialization).
let absent = |fields: &[TyLayout]| {
- let uninhabited = fields.iter().any(|f| f.abi.is_uninhabited());
+ let uninhabited = fields.iter().any(|f| f.abi == Abi::Uninhabited);
let is_zst = fields.iter().all(|f| f.is_zst());
uninhabited && is_zst
};
_ => Abi::Aggregate { sized: true },
};
- if st.iter().all(|v| v.abi.is_uninhabited()) {
+ if st.iter().all(|v| v.abi == Abi::Uninhabited) {
abi = Abi::Uninhabited;
}
let discr_type = def.repr.discr_type();
let bits = Integer::from_attr(tcx, discr_type).size().bits();
for (i, discr) in def.discriminants(tcx).enumerate() {
- if variants[i].iter().any(|f| f.abi.is_uninhabited()) {
+ if variants[i].iter().any(|f| f.abi == Abi::Uninhabited) {
continue;
}
let mut x = discr.val as i128;
}
}
- if layout_variants.iter().all(|v| v.abi.is_uninhabited()) {
+ if layout_variants.iter().all(|v| v.abi == Abi::Uninhabited) {
abi = Abi::Uninhabited;
}
}
None => {}
};
- if cx.layout_of(sig.output()).abi.is_uninhabited() {
+ if cx.layout_of(sig.output()).abi == ty::layout::Abi::Uninhabited {
flags = flags | DIFlags::FlagNoReturn;
}
use llvm;
use llvm::AttributePlace::Function;
use rustc::ty::{self, Ty};
-use rustc::ty::layout::LayoutOf;
+use rustc::ty::layout::{self, LayoutOf};
use rustc::session::config::Sanitizer;
use rustc_data_structures::small_c_str::SmallCStr;
use rustc_target::spec::PanicStrategy;
let fty = FnType::new(cx, sig, &[]);
let llfn = declare_raw_fn(cx, name, fty.llvm_cconv(), fty.llvm_type(cx));
- if cx.layout_of(sig.output()).abi.is_uninhabited() {
+ if cx.layout_of(sig.output()).abi == layout::Abi::Uninhabited {
llvm::Attribute::NoReturn.apply_llfn(Function, llfn);
}
_ => FnType::new(bx.cx, sig, &extra_args)
};
- // emit a panic instead of instantiating an uninhabited type
- if (intrinsic == Some("init") || intrinsic == Some("uninit")) &&
- fn_ty.ret.layout.abi.is_uninhabited()
- {
- let loc = bx.sess().source_map().lookup_char_pos(span.lo());
- let filename = Symbol::intern(&loc.file.name.to_string()).as_str();
- let filename = C_str_slice(bx.cx, filename);
- let line = C_u32(bx.cx, loc.line as u32);
- let col = C_u32(bx.cx, loc.col.to_usize() as u32 + 1);
- let align = tcx.data_layout.aggregate_align
- .max(tcx.data_layout.i32_align)
- .max(tcx.data_layout.pointer_align);
-
- let str = format!(
- "Attempted to instantiate uninhabited type {} using mem::{}",
- sig.output(),
- if intrinsic == Some("init") { "zeroed" } else { "uninitialized" }
- );
- let msg_str = Symbol::intern(&str).as_str();
- let msg_str = C_str_slice(bx.cx, msg_str);
- let msg_file_line_col = C_struct(bx.cx,
- &[msg_str, filename, line, col],
- false);
- let msg_file_line_col = consts::addr_of(bx.cx,
- msg_file_line_col,
- align,
- Some("panic_loc"));
-
- // Obtain the panic entry point.
- let def_id =
- common::langcall(bx.tcx(), Some(span), "", lang_items::PanicFnLangItem);
- let instance = ty::Instance::mono(bx.tcx(), def_id);
- let fn_ty = FnType::of_instance(bx.cx, &instance);
- let llfn = callee::get_fn(bx.cx, instance);
-
- // Codegen the actual panic invoke/call.
- do_call(
- self,
- bx,
- fn_ty,
- llfn,
- &[msg_file_line_col],
- destination.as_ref().map(|(_, bb)| (ReturnDest::Nothing, *bb)),
- cleanup,
- );
- return;
- }
-
// The arguments we'll be passing. Plus one to account for outptr, if used.
let arg_count = fn_ty.args.len() + fn_ty.ret.is_indirect() as usize;
let mut llargs = Vec::with_capacity(arg_count);
/// Obtain the actual discriminant of a value.
pub fn codegen_get_discr(self, bx: &Builder<'a, 'll, 'tcx>, cast_to: Ty<'tcx>) -> &'ll Value {
let cast_to = bx.cx.layout_of(cast_to).immediate_llvm_type(bx.cx);
- if self.layout.abi.is_uninhabited() {
+ if self.layout.abi == layout::Abi::Uninhabited {
return C_undef(cast_to);
}
match self.layout.variants {
/// Set the discriminant for a new value of the given case of the given
/// representation.
pub fn codegen_set_discr(&self, bx: &Builder<'a, 'll, 'tcx>, variant_index: usize) {
- if self.layout.for_variant(bx.cx, variant_index).abi.is_uninhabited() {
+ if self.layout.for_variant(bx.cx, variant_index).abi == layout::Abi::Uninhabited {
return;
}
match self.layout.variants {
mir::CastKind::Misc => {
assert!(cast.is_llvm_immediate());
let ll_t_out = cast.immediate_llvm_type(bx.cx);
- if operand.layout.abi.is_uninhabited() {
+ if operand.layout.abi == layout::Abi::Uninhabited {
return (bx, OperandRef {
val: OperandValue::Immediate(C_undef(ll_t_out)),
layout: cast,
rval: OpTy<'tcx>,
) -> EvalResult<'tcx, (u128, usize)> {
trace!("read_discriminant_value {:#?}", rval.layout);
- if rval.layout.abi.is_uninhabited() {
+ if rval.layout.abi == layout::Abi::Uninhabited {
return err!(Unreachable);
}
_ => false,
}
}
-
- /// Returns true if this is an uninhabited type
- pub fn is_uninhabited(&self) -> bool {
- match *self {
- Abi::Uninhabited => true,
- _ => false,
- }
- }
}
#[derive(PartialEq, Eq, Hash, Debug)]
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// compile-flags: -O
-#![crate_type="lib"]
-#![feature(maybe_uninit)]
-
-use std::mem::MaybeUninit;
-
-// Boxing a `MaybeUninit` value should not copy junk from the stack
-#[no_mangle]
-pub fn box_uninitialized() -> Box<MaybeUninit<usize>> {
- // CHECK-LABEL: @box_uninitialized
- // CHECK-NOT: store
- Box::new(MaybeUninit::uninitialized())
-}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// NOTE Instantiating an empty enum is UB. This test may break in the future.
-
// LLDB can't handle zero-sized values
// ignore-lldb
#![allow(unused_variables)]
#![feature(omit_gdb_pretty_printer_section)]
-#![feature(maybe_uninit)]
#![omit_gdb_pretty_printer_section]
-use std::mem::MaybeUninit;
-
enum ANilEnum {}
enum AnotherNilEnum {}
// The error from gdbr is expected since nil enums are not supposed to exist.
fn main() {
unsafe {
- let first: ANilEnum = MaybeUninit::uninitialized().into_inner();
- let second: AnotherNilEnum = MaybeUninit::uninitialized().into_inner();
+ let first: ANilEnum = ::std::mem::zeroed();
+ let second: AnotherNilEnum = ::std::mem::zeroed();
zzz(); // #break
}
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// ignore-wasm32-bare always compiled as panic=abort right now and this requires unwinding
-// This test checks that instantiating an uninhabited type via `mem::{uninitialized,zeroed}` results
-// in a runtime panic.
-
-#![feature(never_type)]
-
-use std::{mem, panic};
-
-#[allow(dead_code)]
-struct Foo {
- x: u8,
- y: !,
-}
-
-enum Bar {}
-
-fn main() {
- unsafe {
- assert_eq!(
- panic::catch_unwind(|| {
- mem::uninitialized::<!>()
- }).err().and_then(|a| a.downcast_ref::<String>().map(|s| {
- s == "Attempted to instantiate uninhabited type ! using mem::uninitialized"
- })),
- Some(true)
- );
-
- assert_eq!(
- panic::catch_unwind(|| {
- mem::zeroed::<!>()
- }).err().and_then(|a| a.downcast_ref::<String>().map(|s| {
- s == "Attempted to instantiate uninhabited type ! using mem::zeroed"
- })),
- Some(true)
- );
-
- assert_eq!(
- panic::catch_unwind(|| {
- mem::uninitialized::<Foo>()
- }).err().and_then(|a| a.downcast_ref::<String>().map(|s| {
- s == "Attempted to instantiate uninhabited type Foo using mem::uninitialized"
- })),
- Some(true)
- );
-
- assert_eq!(
- panic::catch_unwind(|| {
- mem::zeroed::<Foo>()
- }).err().and_then(|a| a.downcast_ref::<String>().map(|s| {
- s == "Attempted to instantiate uninhabited type Foo using mem::zeroed"
- })),
- Some(true)
- );
-
- assert_eq!(
- panic::catch_unwind(|| {
- mem::uninitialized::<Bar>()
- }).err().and_then(|a| a.downcast_ref::<String>().map(|s| {
- s == "Attempted to instantiate uninhabited type Bar using mem::uninitialized"
- })),
- Some(true)
- );
-
- assert_eq!(
- panic::catch_unwind(|| {
- mem::zeroed::<Bar>()
- }).err().and_then(|a| a.downcast_ref::<String>().map(|s| {
- s == "Attempted to instantiate uninhabited type Bar using mem::zeroed"
- })),
- Some(true)
- );
- }
-}
projects / rust.git / commitdiff