b0e55a83a8
This commit introduces 128-bit integers. Stage 2 builds and produces a working compiler which understands and supports 128-bit integers throughout. The general strategy used is to have rustc_i128 module which provides aliases for iu128, equal to iu64 in stage9 and iu128 later. Since nowhere in rustc we rely on large numbers being supported, this strategy is good enough to get past the first bootstrap stages to end up with a fully working 128-bit capable compiler. In order for this strategy to work, number of locations had to be changed to use associated max_value/min_value instead of MAX/MIN constants as well as the min_value (or was it max_value?) had to be changed to use xor instead of shift so both 64-bit and 128-bit based consteval works (former not necessarily producing the right results in stage1). This commit includes manual merge conflict resolution changes from a rebase by @est31.
63 lines
2.1 KiB
Rust
63 lines
2.1 KiB
Rust
// Copyright 2012-2014 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.
|
|
|
|
//! Exposes the NonZero lang item which provides optimization hints.
|
|
#![unstable(feature = "nonzero",
|
|
reason = "needs an RFC to flesh out the design",
|
|
issue = "27730")]
|
|
|
|
use ops::{CoerceUnsized, Deref};
|
|
|
|
/// Unsafe trait to indicate what types are usable with the NonZero struct
|
|
pub unsafe trait Zeroable {}
|
|
|
|
unsafe impl<T:?Sized> Zeroable for *const T {}
|
|
unsafe impl<T:?Sized> Zeroable for *mut T {}
|
|
unsafe impl Zeroable for isize {}
|
|
unsafe impl Zeroable for usize {}
|
|
unsafe impl Zeroable for i8 {}
|
|
unsafe impl Zeroable for u8 {}
|
|
unsafe impl Zeroable for i16 {}
|
|
unsafe impl Zeroable for u16 {}
|
|
unsafe impl Zeroable for i32 {}
|
|
unsafe impl Zeroable for u32 {}
|
|
unsafe impl Zeroable for i64 {}
|
|
unsafe impl Zeroable for u64 {}
|
|
#[cfg(not(stage0))]
|
|
unsafe impl Zeroable for i128 {}
|
|
#[cfg(not(stage0))]
|
|
unsafe impl Zeroable for u128 {}
|
|
|
|
/// A wrapper type for raw pointers and integers that will never be
|
|
/// NULL or 0 that might allow certain optimizations.
|
|
#[lang = "non_zero"]
|
|
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
|
|
pub struct NonZero<T: Zeroable>(T);
|
|
|
|
impl<T: Zeroable> NonZero<T> {
|
|
/// Creates an instance of NonZero with the provided value.
|
|
/// You must indeed ensure that the value is actually "non-zero".
|
|
#[inline(always)]
|
|
pub const unsafe fn new(inner: T) -> NonZero<T> {
|
|
NonZero(inner)
|
|
}
|
|
}
|
|
|
|
impl<T: Zeroable> Deref for NonZero<T> {
|
|
type Target = T;
|
|
|
|
#[inline]
|
|
fn deref(&self) -> &T {
|
|
let NonZero(ref inner) = *self;
|
|
inner
|
|
}
|
|
}
|
|
|
|
impl<T: Zeroable+CoerceUnsized<U>, U: Zeroable> CoerceUnsized<NonZero<U>> for NonZero<T> {}
|