Such large. Very 128. Much bits.

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).

Author: nagisa

src/libcore/clone.rs

@@ -140,12 +140,16 @@ clone_impl! { i8 }
 clone_impl! { i16 }
 clone_impl! { i32 }
 clone_impl! { i64 }
+#[cfg(not(stage0))]
+clone_impl! { i128 }
 
 clone_impl! { usize }
 clone_impl! { u8 }
 clone_impl! { u16 }
 clone_impl! { u32 }
 clone_impl! { u64 }
+#[cfg(not(stage0))]
+clone_impl! { u128 }
 
 clone_impl! { f32 }
 clone_impl! { f64 }

src/libcore/cmp.rs

@@ -593,6 +593,8 @@ mod impls {
     partial_eq_impl! {
         bool char usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64
     }
+    #[cfg(not(stage0))]
+    partial_eq_impl! { u128 i128 }
 
     macro_rules! eq_impl {
         ($($t:ty)*) => ($(
@@ -602,6 +604,8 @@ mod impls {
     }
 
     eq_impl! { () bool char usize u8 u16 u32 u64 isize i8 i16 i32 i64 }
+    #[cfg(not(stage0))]
+    eq_impl! { u128 i128 }
 
     macro_rules! partial_ord_impl {
         ($($t:ty)*) => ($(
@@ -691,6 +695,8 @@ mod impls {
     }
 
     ord_impl! { char usize u8 u16 u32 u64 isize i8 i16 i32 i64 }
+    #[cfg(not(stage0))]
+    ord_impl! { u128 i128 }
 
     #[unstable(feature = "never_type", issue = "35121")]
     impl PartialEq for ! {

src/libcore/default.rs

@@ -144,12 +144,16 @@ default_impl! { u8, 0 }
 default_impl! { u16, 0 }
 default_impl! { u32, 0 }
 default_impl! { u64, 0 }
+#[cfg(not(stage0))]
+default_impl! { u128, 0 }
 
 default_impl! { isize, 0 }
 default_impl! { i8, 0 }
 default_impl! { i16, 0 }
 default_impl! { i32, 0 }
 default_impl! { i64, 0 }
+#[cfg(not(stage0))]
+default_impl! { i128, 0 }
 
 default_impl! { f32, 0.0f32 }
 default_impl! { f64, 0.0f64 }

src/libcore/fmt/num.rs

@@ -30,6 +30,8 @@ trait Int: Zero + PartialEq + PartialOrd + Div<Output=Self> + Rem<Output=Self> +
     fn to_u16(&self) -> u16;
     fn to_u32(&self) -> u32;
     fn to_u64(&self) -> u64;
+    #[cfg(not(stage0))]
+    fn to_u128(&self) -> u128;
 }
 
 macro_rules! doit {
@@ -39,9 +41,13 @@ macro_rules! doit {
         fn to_u16(&self) -> u16 { *self as u16 }
         fn to_u32(&self) -> u32 { *self as u32 }
         fn to_u64(&self) -> u64 { *self as u64 }
+        #[cfg(not(stage0))]
+        fn to_u128(&self) -> u128 { *self as u128 }
     })*)
 }
 doit! { i8 i16 i32 i64 isize u8 u16 u32 u64 usize }
+#[cfg(not(stage0))]
+doit! { i128 u128 }
 
 /// A type that represents a specific radix
 #[doc(hidden)]
@@ -59,11 +65,11 @@ trait GenericRadix {
 
     /// Format an integer using the radix using a formatter.
     fn fmt_int<T: Int>(&self, mut x: T, f: &mut fmt::Formatter) -> fmt::Result {
-        // The radix can be as low as 2, so we need a buffer of at least 64
+        // The radix can be as low as 2, so we need a buffer of at least 128
         // characters for a base 2 number.
         let zero = T::zero();
         let is_nonnegative = x >= zero;
-        let mut buf = [0; 64];
+        let mut buf = [0; 128];
         let mut curr = buf.len();
         let base = T::from_u8(self.base());
         if is_nonnegative {
@@ -182,6 +188,8 @@ integer! { i8, u8 }
 integer! { i16, u16 }
 integer! { i32, u32 }
 integer! { i64, u64 }
+#[cfg(not(stage0))]
+integer! { i128, u128 }
 
 const DEC_DIGITS_LUT: &'static[u8] =
     b"0001020304050607080910111213141516171819\
@@ -203,14 +211,15 @@ macro_rules! impl_Display {
                 // convert the negative num to positive by summing 1 to it's 2 complement
                 (!self.$conv_fn()).wrapping_add(1)
             };
-            let mut buf: [u8; 20] = unsafe { mem::uninitialized() };
+            let mut buf: [u8; 40] = unsafe { mem::uninitialized() };
             let mut curr = buf.len() as isize;
             let buf_ptr = buf.as_mut_ptr();
             let lut_ptr = DEC_DIGITS_LUT.as_ptr();
 
             unsafe {
-                // eagerly decode 4 characters at a time
-                if <$t>::max_value() as u64 >= 10000 {
+                // need at least 16 bits for the 4-characters-at-a-time to work.
+                if ::mem::size_of::<$t>() >= 2 {
+                    // eagerly decode 4 characters at a time
                     while n >= 10000 {
                         let rem = (n % 10000) as isize;
                         n /= 10000;
@@ -256,6 +265,8 @@ macro_rules! impl_Display {
 
 impl_Display!(i8, u8, i16, u16, i32, u32: to_u32);
 impl_Display!(i64, u64: to_u64);
+#[cfg(not(stage0))]
+impl_Display!(i128, u128: to_u128);
 #[cfg(target_pointer_width = "16")]
 impl_Display!(isize, usize: to_u16);
 #[cfg(target_pointer_width = "32")]

src/libcore/hash/mod.rs

@@ -177,6 +177,13 @@ pub trait Hasher {
     fn write_u64(&mut self, i: u64) {
         self.write(&unsafe { mem::transmute::<_, [u8; 8]>(i) })
     }
+    #[cfg(not(stage0))]
+    /// Write a single `u128` into this hasher.
+    #[inline]
+    #[unstable(feature = "i128", issue = "35118")]
+    fn write_u128(&mut self, i: u128) {
+        self.write(&unsafe { mem::transmute::<_, [u8; 16]>(i) })
+    }
     /// Write a single `usize` into this hasher.
     #[inline]
     #[stable(feature = "hasher_write", since = "1.3.0")]
@@ -211,6 +218,13 @@ pub trait Hasher {
     fn write_i64(&mut self, i: i64) {
         self.write_u64(i as u64)
     }
+    #[cfg(not(stage0))]
+    /// Write a single `i128` into this hasher.
+    #[inline]
+    #[unstable(feature = "i128", issue = "35118")]
+    fn write_i128(&mut self, i: i128) {
+        self.write_u128(i as u128)
+    }
     /// Write a single `isize` into this hasher.
     #[inline]
     #[stable(feature = "hasher_write", since = "1.3.0")]
@@ -319,6 +333,11 @@ mod impls {
         (i64, write_i64),
         (isize, write_isize),
     }
+    #[cfg(not(stage0))]
+    impl_write! {
+        (u128, write_u128),
+        (i128, write_i128),
+    }
 
     #[stable(feature = "rust1", since = "1.0.0")]
     impl Hash for bool {

src/libcore/lib.rs

@@ -118,12 +118,20 @@ mod uint_macros;
 #[path = "num/i32.rs"]   pub mod i32;
 #[path = "num/i64.rs"]   pub mod i64;
 
+// SNAP
+#[cfg(not(stage0))]
+#[path = "num/i128.rs"]   pub mod i128;
+
 #[path = "num/usize.rs"] pub mod usize;
 #[path = "num/u8.rs"]    pub mod u8;
 #[path = "num/u16.rs"]   pub mod u16;
 #[path = "num/u32.rs"]   pub mod u32;
 #[path = "num/u64.rs"]   pub mod u64;
 
+// SNAP
+#[cfg(not(stage0))]
+#[path = "num/u128.rs"]   pub mod u128;
+
 #[path = "num/f32.rs"]   pub mod f32;
 #[path = "num/f64.rs"]   pub mod f64;
 

src/libcore/nonzero.rs

@@ -30,6 +30,10 @@ 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.

src/libcore/num/i128.rs

@@ -0,0 +1,17 @@
+// Copyright 2016 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.
+
+//! The 128-bit signed integer type.
+//!
+//! *[See also the `i128` primitive type](../../std/primitive.i128.html).*
+
+#![unstable(feature = "i128", issue="35118")]
+
+int_module! { i128 }

src/libcore/num/i16.rs

@@ -14,4 +14,4 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-int_module! { i16, 16 }
+int_module! { i16 }

src/libcore/num/i32.rs

@@ -14,4 +14,4 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-int_module! { i32, 32 }
+int_module! { i32 }

src/libcore/num/i64.rs

@@ -14,4 +14,4 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-int_module! { i64, 64 }
+int_module! { i64 }

src/libcore/num/i8.rs

@@ -14,4 +14,4 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-int_module! { i8, 8 }
+int_module! { i8 }

src/libcore/num/int_macros.rs

@@ -10,7 +10,7 @@
 
 #![doc(hidden)]
 
-macro_rules! int_module { ($T:ident, $bits:expr) => (
+macro_rules! int_module { ($T:ident) => (
 
 /// The smallest value that can be represented by this integer type.
 #[stable(feature = "rust1", since = "1.0.0")]

src/libcore/num/isize.rs

@@ -14,9 +14,4 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-#[cfg(target_pointer_width = "16")]
-int_module! { isize, 16 }
-#[cfg(target_pointer_width = "32")]
-int_module! { isize, 32 }
-#[cfg(target_pointer_width = "64")]
-int_module! { isize, 64 }
+int_module! { isize }