Add Wrapping<T> and WrappingOps implementations

Adds a Wrapping<T> wrapper type and a WrappingOps trait for allowing
people to explictly opt-in to wrapping integer arithmetic.

This commit currently disables overflow checking in the build due to
cases of expected overflow triggering the panic.

Author: Aatch

mk/main.mk

@@ -157,8 +157,9 @@ endif
 # have to worry about the distribution of one file (with its native dynamic
 # dependencies)
 RUSTFLAGS_STAGE0 += -C prefer-dynamic
-RUSTFLAGS_STAGE1 += -C prefer-dynamic
-RUST_LIB_FLAGS_ST2 += -C prefer-dynamic
+# FIXME: Remove the -Z force-no-overflow-checks flags
+RUSTFLAGS_STAGE1 += -C prefer-dynamic -Z force-no-overflow-checks
+RUST_LIB_FLAGS_ST2 += -C prefer-dynamic -Z force-no-overflow-checks
 RUST_LIB_FLAGS_ST3 += -C prefer-dynamic
 
 # Landing pads require a lot of codegen. We can get through bootstrapping faster

src/libcore/intrinsics.rs

@@ -547,6 +547,7 @@ extern "rust-intrinsic" {
     pub fn u64_mul_with_overflow(x: u64, y: u64) -> (u64, bool);
 }
 
+#[cfg(not(stage1))]
 extern "rust-intrinsic" {
     /// Returns (a + b) mod 2^N, where N is the width of N in bits.
     pub fn overflowing_add<T>(a: T, b: T) -> T;
@@ -556,8 +557,6 @@ extern "rust-intrinsic" {
     pub fn overflowing_mul<T>(a: T, b: T) -> T;
 }
 
-#[cfg(not(stage0))]
-
 /// `TypeId` represents a globally unique identifier for a type
 #[lang="type_id"] // This needs to be kept in lockstep with the code in trans/intrinsic.rs and
                   // middle/lang_items.rs

src/libcore/num/mod.rs

@@ -29,6 +29,8 @@ use option::Option;
 use option::Option::{Some, None};
 use str::{FromStr, StrExt};
 
+pub mod wrapping;
+
 /// A built-in signed or unsigned integer.
 #[stable]
 pub trait Int

src/libcore/num/wrapping.rs

@@ -0,0 +1,90 @@
+#![allow(missing_docs)]
+
+use ops::*;
+
+#[cfg(not(stage0))]
+use intrinsics::{overflowing_add, overflowing_sub, overflowing_mul};
+
+pub trait WrappingOps {
+    fn wrapping_add(self, rhs: Self) -> Self;
+    fn wrapping_sub(self, rhs: Self) -> Self;
+    fn wrapping_mul(self, rhs: Self) -> Self;
+}
+
+#[cfg(not(stage0))]
+macro_rules! wrapping_impl {
+    ($($t:ty)*) => ($(
+        impl WrappingOps for $t {
+            #[inline(always)]
+            fn wrapping_add(self, rhs: $t) -> $t {
+                unsafe {
+                    overflowing_add(self, rhs)
+                }
+            }
+            #[inline(always)]
+            fn wrapping_sub(self, rhs: $t) -> $t {
+                unsafe {
+                    overflowing_sub(self, rhs)
+                }
+            }
+            #[inline(always)]
+            fn wrapping_mul(self, rhs: $t) -> $t {
+                unsafe {
+                    overflowing_mul(self, rhs)
+                }
+            }
+        }
+    )*)
+}
+
+#[cfg(stage0)]
+macro_rules! wrapping_impl {
+    ($($t:ty)*) => ($(
+        impl WrappingOps for $t {
+            #[inline(always)]
+            fn wrapping_add(self, rhs: $t) -> $t {
+                self + rhs
+            }
+            #[inline(always)]
+            fn wrapping_sub(self, rhs: $t) -> $t {
+                self - rhs
+            }
+            #[inline(always)]
+            fn wrapping_mul(self, rhs: $t) -> $t {
+                self * rhs
+            }
+        }
+    )*)
+}
+
+wrapping_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 }
+
+#[derive(PartialEq,Eq,PartialOrd,Ord,Clone)]
+pub struct Wrapping<T>(pub T);
+
+impl<T:WrappingOps> Add for Wrapping<T> {
+    type Output = Wrapping<T>;
+
+    #[inline(always)]
+    fn add(self, other: Wrapping<T>) -> Wrapping<T> {
+        Wrapping(self.0.wrapping_add(other.0))
+    }
+}
+
+impl<T:WrappingOps> Sub for Wrapping<T> {
+    type Output = Wrapping<T>;
+
+    #[inline(always)]
+    fn sub(self, other: Wrapping<T>) -> Wrapping<T> {
+        Wrapping(self.0.wrapping_sub(other.0))
+    }
+}
+
+impl<T:WrappingOps> Mul for Wrapping<T> {
+    type Output = Wrapping<T>;
+
+    #[inline(always)]
+    fn mul(self, other: Wrapping<T>) -> Wrapping<T> {
+        Wrapping(self.0.wrapping_mul(other.0))
+    }
+}

src/libcore/ops.rs

@@ -773,6 +773,7 @@ macro_rules! shr_impl {
 
 shr_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 }
 
+
 /// The `Index` trait is used to specify the functionality of indexing operations
 /// like `arr[idx]` when used in an immutable context.
 ///

src/libcore/prelude.rs

@@ -32,6 +32,8 @@
 pub use marker::{Copy, Send, Sized, Sync};
 pub use ops::{Drop, Fn, FnMut, FnOnce, FullRange};
 
+pub use num::wrapping::{Wrapping, WrappingOps};
+
 // Reexported functions
 pub use iter::range;
 pub use mem::drop;

src/librand/isaac.rs

@@ -307,6 +307,7 @@ impl Isaac64Rng {
                 let mut $var = 0x9e3779b97f4a7c13;
             )
         }
+
         init!(a); init!(b); init!(c); init!(d);
         init!(e); init!(f); init!(g); init!(h);
 

src/librustc/session/config.rs

@@ -300,7 +300,7 @@ debugging_opts! {
         UNSTABLE_OPTIONS,
         PRINT_ENUM_SIZES,
         FORCE_OVERFLOW_CHECKS,
-        FORCE_NO_OVERFLOW_CHECKS,
+        FORCE_NO_OVERFLOW_CHECKS
     ]
     0
 }
@@ -354,8 +354,8 @@ pub fn debugging_opts_map() -> Vec<(&'static str, &'static str, u64)> {
      ("unstable-options", "Adds unstable command line options to rustc interface",
       UNSTABLE_OPTIONS),
      ("print-enum-sizes", "Print the size of enums and their variants", PRINT_ENUM_SIZES),
-     ("force-overflow-checks", "Force arithmatic overflow checking", FORCE_OVERFLOW_CHECKS),
-     ("force-no-overflow-checks", "Force arithmatic overflow checking", FORCE_NO_OVERFLOW_CHECKS),
+     ("force-overflow-checks", "Force arithmetic overflow checking on", FORCE_OVERFLOW_CHECKS),
+     ("force-no-overflow-checks", "Force arithmetic overflow checking off", FORCE_NO_OVERFLOW_CHECKS),
     ]
 }
 

src/librustc_trans/trans/base.rs

@@ -3111,8 +3111,9 @@ pub fn trans_crate<'tcx>(analysis: ty::CrateAnalysis<'tcx>)
     let ty::CrateAnalysis { ty_cx: tcx, export_map, reachable, name, .. } = analysis;
     let krate = tcx.map.krate();
 
-    let check_overflow = tcx.sess.opts.debugging_opts & config::FORCE_OVERFLOW_CHECKS != 0
-        || !attr::contains_name(krate.config[], "ndebug");
+    let check_overflow = tcx.sess.opts.debugging_opts & config::FORCE_NO_OVERFLOW_CHECKS == 0
+        && (tcx.sess.opts.debugging_opts & config::FORCE_OVERFLOW_CHECKS != 0
+            || !attr::contains_name(krate.config[], "ndebug"));
 
     // Before we touch LLVM, make sure that multithreading is enabled.
     unsafe {

src/librustc_trans/trans/intrinsic.rs

@@ -506,9 +506,9 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
             with_overflow_intrinsic(bcx, "llvm.umul.with.overflow.i64", ret_ty,
                                     llargs[0], llargs[1]),
 
-        (_, "overflowing_add") => Add(bcx, llargs[0], llargs[1])
-        (_, "overflowing_sub") => Sub(bcx, llargs[0], llargs[1])
-        (_, "overflowing_mul") => Mul(bcx, llargs[0], llargs[1])
+        (_, "overflowing_add") => Add(bcx, llargs[0], llargs[1]),
+        (_, "overflowing_sub") => Sub(bcx, llargs[0], llargs[1]),
+        (_, "overflowing_mul") => Mul(bcx, llargs[0], llargs[1]),
 
         (_, "return_address") => {
             if !fcx.caller_expects_out_pointer {

src/librustc_typeck/check/mod.rs

@@ -5763,6 +5763,9 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) {
                 (0, vec!(tcx.types.u64, tcx.types.u64),
                 ty::mk_tup(tcx, vec!(tcx.types.u64, tcx.types.bool))),
 
+            "overflowing_add" | "overflowing_sub" | "overflowing_mul" =>
+                (1, vec![param(ccx, 0), param(ccx, 0)], param(ccx, 0)),
+
             "return_address" => (0, vec![], ty::mk_imm_ptr(tcx, tcx.types.u8)),
 
             "assume" => (0, vec![tcx.types.bool], ty::mk_nil(tcx)),