libcore_nofp.patch

diff -rub libcore_orig/clone.rs libcore/clone.rs
--- libcore_orig/clone.rs	2016-07-06 11:07:50.020716460 +0800
+++ libcore/clone.rs	2016-07-06 11:06:59.888814705 +0800
@@ -149,7 +149,9 @@
 clone_impl! { u32 }
 clone_impl! { u64 }
 
+#[cfg(not(disable_float))]
 clone_impl! { f32 }
+#[cfg(not(disable_float))]
 clone_impl! { f64 }
 
 clone_impl! { () }
diff -rub libcore_orig/default.rs libcore/default.rs
--- libcore_orig/default.rs	2016-07-06 11:07:50.020716460 +0800
+++ libcore/default.rs	2016-07-06 11:06:59.888814705 +0800
@@ -154,5 +154,7 @@
 default_impl! { i32, 0 }
 default_impl! { i64, 0 }
 
+#[cfg(not(disable_float))]
 default_impl! { f32, 0.0f32 }
+#[cfg(not(disable_float))]
 default_impl! { f64, 0.0f64 }
diff -rub libcore_orig/fmt/mod.rs libcore/fmt/mod.rs
--- libcore_orig/fmt/mod.rs	2016-07-06 11:07:50.024716452 +0800
+++ libcore/fmt/mod.rs	2016-07-06 11:06:59.888814705 +0800
@@ -17,6 +17,7 @@
 use cell::{UnsafeCell, Cell, RefCell, Ref, RefMut, BorrowState};
 use marker::PhantomData;
 use mem;
+#[cfg(not(disable_float))]
 use num::flt2dec;
 use ops::Deref;
 use result;
@@ -1053,6 +1054,7 @@
     /// Takes the formatted parts and applies the padding.
     /// Assumes that the caller already has rendered the parts with required precision,
     /// so that `self.precision` can be ignored.
+    #[cfg(not(disable_float))]
     fn pad_formatted_parts(&mut self, formatted: &flt2dec::Formatted) -> Result {
         if let Some(mut width) = self.width {
             // for the sign-aware zero padding, we render the sign first and
@@ -1089,6 +1091,7 @@
         }
     }
 
+    #[cfg(not(disable_float))]
     fn write_formatted_parts(&mut self, formatted: &flt2dec::Formatted) -> Result {
         fn write_bytes(buf: &mut Write, s: &[u8]) -> Result {
             buf.write_str(unsafe { str::from_utf8_unchecked(s) })
@@ -1477,6 +1480,7 @@
     }
 }
 
+#[cfg(not(disable_float))]
 // Common code of floating point Debug and Display.
 fn float_to_decimal_common<T>(fmt: &mut Formatter, num: &T, negative_zero: bool) -> Result
     where T: flt2dec::DecodableFloat
@@ -1501,6 +1505,7 @@
     fmt.pad_formatted_parts(&formatted)
 }
 
+#[cfg(not(disable_float))]
 // Common code of floating point LowerExp and UpperExp.
 fn float_to_exponential_common<T>(fmt: &mut Formatter, num: &T, upper: bool) -> Result
     where T: flt2dec::DecodableFloat
@@ -1554,7 +1559,9 @@
         }
     }
 } }
+#[cfg(not(disable_float))]
 floating! { f32 }
+#[cfg(not(disable_float))]
 floating! { f64 }
 
 // Implementation of Display/Debug for various core types
diff -rub libcore_orig/intrinsics.rs libcore/intrinsics.rs
--- libcore_orig/intrinsics.rs	2016-07-06 11:07:50.020716460 +0800
+++ libcore/intrinsics.rs	2016-07-06 11:06:59.888814705 +0800
@@ -435,7 +435,10 @@
     pub fn volatile_load<T>(src: *const T) -> T;
     /// Perform a volatile store to the `dst` pointer.
     pub fn volatile_store<T>(dst: *mut T, val: T);
+}
 
+#[cfg(not(disable_float))]
+extern "rust-intrinsic" {
     /// Returns the square root of an `f32`
     pub fn sqrtf32(x: f32) -> f32;
     /// Returns the square root of an `f64`
@@ -552,8 +555,9 @@
     /// Float remainder that allows optimizations based on algebraic rules.
     /// May assume inputs are finite.
     pub fn frem_fast<T>(a: T, b: T) -> T;
+}
 
-
+extern "rust-intrinsic" {
     /// Returns the number of bits set in an integer type `T`
     pub fn ctpop<T>(x: T) -> T;
 
diff -rub libcore_orig/iter/traits.rs libcore/iter/traits.rs
--- libcore_orig/iter/traits.rs	2016-07-06 11:07:50.024716452 +0800
+++ libcore/iter/traits.rs	2016-07-06 11:06:59.888814705 +0800
@@ -624,4 +624,5 @@
 }
 
 integer_sum_product! { i8 i16 i32 i64 isize u8 u16 u32 u64 usize }
+#[cfg(not(disable_float))]
 float_sum_product! { f32 f64 }
diff -rub libcore_orig/lib.rs libcore/lib.rs
--- libcore_orig/lib.rs	2016-07-06 11:07:50.024716452 +0800
+++ libcore/lib.rs	2016-07-06 11:06:59.888814705 +0800
@@ -112,7 +112,9 @@
 #[path = "num/u32.rs"]  pub mod u32;
 #[path = "num/u64.rs"]  pub mod u64;
 
+#[cfg(not(disable_float))]
 #[path = "num/f32.rs"]   pub mod f32;
+#[cfg(not(disable_float))]
 #[path = "num/f64.rs"]   pub mod f64;
 
 #[macro_use]
diff -rub libcore_orig/num/flt2dec/decoder.rs libcore/num/flt2dec/decoder.rs
--- libcore_orig/num/flt2dec/decoder.rs	2016-07-06 11:07:50.024716452 +0800
+++ libcore/num/flt2dec/decoder.rs	2016-07-06 11:06:59.888814705 +0800
@@ -12,6 +12,7 @@
 
 use prelude::v1::*;
 
+#[cfg(not(disable_float))]
 use {f32, f64};
 use num::FpCategory;
 use num::dec2flt::rawfp::RawFloat;
@@ -58,10 +59,12 @@
     fn min_pos_norm_value() -> Self;
 }
 
+#[cfg(not(disable_float))]
 impl DecodableFloat for f32 {
     fn min_pos_norm_value() -> Self { f32::MIN_POSITIVE }
 }
 
+#[cfg(not(disable_float))]
 impl DecodableFloat for f64 {
     fn min_pos_norm_value() -> Self { f64::MIN_POSITIVE }
 }
diff -rub libcore_orig/num/mod.rs libcore/num/mod.rs
--- libcore_orig/num/mod.rs	2016-07-06 11:07:50.024716452 +0800
+++ libcore/num/mod.rs	2016-07-06 11:06:59.888814705 +0800
@@ -97,7 +97,9 @@
 mod wrapping;
 
 // All these modules are technically private and only exposed for libcoretest:
+#[cfg(not(disable_float))]
 pub mod flt2dec;
+#[cfg(not(disable_float))]
 pub mod dec2flt;
 pub mod bignum;
 pub mod diy_float;
@@ -172,6 +174,7 @@
         }
     )*)
 }
+#[cfg(not(disable_float))]
 zero_one_impl_float! { f32 f64 }
 
 macro_rules! checked_op {
@@ -2306,6 +2309,7 @@
 #[unstable(feature = "core_float",
            reason = "stable interface is via `impl f{32,64}` in later crates",
            issue = "32110")]
+#[cfg(not(disable_float))]
 pub trait Float: Sized {
     /// Returns the NaN value.
     #[unstable(feature = "float_extras", reason = "needs removal",
@@ -2656,6 +2660,7 @@
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
+#[cfg(not(disable_float))]
 pub use num::dec2flt::ParseFloatError;
 
 // Conversion traits for primitive integer and float types
@@ -2703,6 +2708,9 @@
 // they fit in the significand, which is 24 bits in f32 and 53 bits in f64.
 // Lossy float conversions are not implemented at this time.
 
+#[cfg(not(disable_float))]
+mod _int_flot_conv {
+use convert::From;
 // Signed -> Float
 impl_from! { i8, f32 }
 impl_from! { i8, f64 }
@@ -2719,3 +2727,4 @@
 
 // Float -> Float
 impl_from! { f32, f64 }
+}
diff -rub libcore_orig/ops.rs libcore/ops.rs
--- libcore_orig/ops.rs	2016-07-06 11:07:50.020716460 +0800
+++ libcore/ops.rs	2016-07-06 11:06:59.888814705 +0800
@@ -214,7 +214,9 @@
     )*)
 }
 
-add_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 }
+add_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 }
+#[cfg(not(disable_float))]
+add_impl! { f32 f64 }
 
 /// The `Sub` trait is used to specify the functionality of `-`.
 ///
@@ -268,7 +270,9 @@
     )*)
 }
 
-sub_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 }
+sub_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 }
+#[cfg(not(disable_float))]
+sub_impl! { f32 f64 }
 
 /// The `Mul` trait is used to specify the functionality of `*`.
 ///
@@ -322,7 +326,9 @@
     )*)
 }
 
-mul_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 }
+mul_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 }
+#[cfg(not(disable_float))]
+mul_impl! { f32 f64 }
 
 /// The `Div` trait is used to specify the functionality of `/`.
 ///
@@ -393,6 +399,7 @@
     )*)
 }
 
+#[cfg(not(disable_float))]
 div_impl_float! { f32 f64 }
 
 /// The `Rem` trait is used to specify the functionality of `%`.
@@ -464,6 +471,7 @@
     )*)
 }
 
+#[cfg(not(disable_float))]
 rem_impl_float! { f32 f64 }
 
 /// The `Neg` trait is used to specify the functionality of unary `-`.
@@ -532,7 +540,9 @@
 }
 
 // neg_impl_unsigned! { usize u8 u16 u32 u64 }
-neg_impl_numeric! { isize i8 i16 i32 i64 f32 f64 }
+neg_impl_numeric! { isize i8 i16 i32 i64 }
+#[cfg(not(disable_float))]
+neg_impl_numeric! { f32 f64 }
 
 /// The `Not` trait is used to specify the functionality of unary `!`.
 ///
@@ -933,7 +943,9 @@
     )+)
 }
 
-add_assign_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 }
+add_assign_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 }
+#[cfg(not(disable_float))]
+add_assign_impl! { f32 f64 }
 
 /// The `SubAssign` trait is used to specify the functionality of `-=`.
 ///
@@ -978,7 +990,9 @@
     )+)
 }
 
-sub_assign_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 }
+sub_assign_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 }
+#[cfg(not(disable_float))]
+sub_assign_impl! { f32 f64 }
 
 /// The `MulAssign` trait is used to specify the functionality of `*=`.
 ///
@@ -1023,7 +1037,9 @@
     )+)
 }
 
-mul_assign_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 }
+mul_assign_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 }
+#[cfg(not(disable_float))]
+mul_assign_impl! { f32 f64 }
 
 /// The `DivAssign` trait is used to specify the functionality of `/=`.
 ///
@@ -1067,7 +1083,9 @@
     )+)
 }
 
-div_assign_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 }
+div_assign_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 }
+#[cfg(not(disable_float))]
+div_assign_impl! { f32 f64 }
 
 /// The `RemAssign` trait is used to specify the functionality of `%=`.
 ///
@@ -1111,7 +1129,9 @@
     )+)
 }
 
-rem_assign_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 }
+rem_assign_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 }
+#[cfg(not(disable_float))]
+rem_assign_impl! { f32 f64 }
 
 /// The `BitAndAssign` trait is used to specify the functionality of `&=`.
 ///