apply libcore_nofp patch

9 files changed, 377 insertions, 10 deletions

diff --git a/libcore/clone.rs b/libcore/clone.rs
index a793502..6fb733f 100644
--- a/libcore/clone.rs
+++ b/libcore/clone.rs
@@ -105,7 +105,9 @@ clone_impl! { u16 }
 clone_impl! { u32 }
 clone_impl! { u64 }
 
+#[cfg(not(disable_float))]
 clone_impl! { f32 }
+#[cfg(not(disable_float))]
 clone_impl! { f64 }
 
 clone_impl! { () }
diff --git a/libcore/default.rs b/libcore/default.rs
index 12c4a5c..4ec4fb6 100644
--- a/libcore/default.rs
+++ b/libcore/default.rs
@@ -160,5 +160,7 @@ default_impl! { i16, 0 }
 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 --git a/libcore/fmt/mod.rs b/libcore/fmt/mod.rs
index 2f02f5c..3637238 100644
--- a/libcore/fmt/mod.rs
+++ b/libcore/fmt/mod.rs
@@ -17,6 +17,7 @@ use prelude::v1::*;
 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;
@@ -1023,6 +1024,7 @@ impl<'a> Formatter<'a> {
     /// 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
@@ -1059,6 +1061,7 @@ impl<'a> Formatter<'a> {
         }
     }
 
+    #[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) })
@@ -1447,6 +1450,7 @@ impl<'a, T: ?Sized> Pointer for &'a mut T {
     }
 }
 
+#[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
@@ -1471,6 +1475,7 @@ fn float_to_decimal_common<T>(fmt: &mut Formatter, num: &T, negative_zero: bool)
     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
@@ -1524,7 +1529,9 @@ macro_rules! floating { ($ty:ident) => {
         }
     }
 } }
+#[cfg(not(disable_float))]
 floating! { f32 }
+#[cfg(not(disable_float))]
 floating! { f64 }
 
 // Implementation of Display/Debug for various core types
diff --git a/libcore/intrinsics.rs b/libcore/intrinsics.rs
index 03bcf9c..4ab434d 100644
--- a/libcore/intrinsics.rs
+++ b/libcore/intrinsics.rs
@@ -448,7 +448,10 @@ extern "rust-intrinsic" {
     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`
@@ -570,8 +573,9 @@ extern "rust-intrinsic" {
     /// May assume inputs are finite.
     #[cfg(not(stage0))]
     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 --git a/libcore/lib.rs b/libcore/lib.rs
index fa5e905..e12c690 100644
--- a/libcore/lib.rs
+++ b/libcore/lib.rs
@@ -107,7 +107,9 @@ mod uint_macros;
 #[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 --git a/libcore/num/flt2dec/decoder.rs b/libcore/num/flt2dec/decoder.rs
index 6265691..0a28a14 100644
--- a/libcore/num/flt2dec/decoder.rs
+++ b/libcore/num/flt2dec/decoder.rs
@@ -12,6 +12,7 @@
 
 use prelude::v1::*;
 
+#[cfg(not(disable_float))]
 use {f32, f64};
 use num::{Float, FpCategory};
 
@@ -57,10 +58,12 @@ pub trait DecodableFloat: Float + Copy {
     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 --git a/libcore/num/mod.rs b/libcore/num/mod.rs
index 229a864..e966d1b 100644
--- a/libcore/num/mod.rs
+++ b/libcore/num/mod.rs
@@ -44,7 +44,9 @@ pub struct Wrapping<T>(#[stable(feature = "rust1", since = "1.0.0")] pub T);
 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;
@@ -111,6 +113,7 @@ macro_rules! zero_one_impl_float {
         }
     )*)
 }
+#[cfg(not(disable_float))]
 zero_one_impl_float! { f32 f64 }
 
 macro_rules! checked_op {
@@ -2213,6 +2216,7 @@ pub enum FpCategory {
 #[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",
@@ -2451,6 +2455,7 @@ impl fmt::Display for ParseIntError {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
+#[cfg(not(disable_float))]
 pub use num::dec2flt::ParseFloatError;
 
 // Conversion traits for primitive integer and float types
@@ -2498,6 +2503,9 @@ impl_from! { u32, i64 }
 // 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 }
@@ -2514,3 +2522,4 @@ impl_from! { u32, f64 }
 
 // Float -> Float
 impl_from! { f32, f64 }
+}
diff --git a/libcore/ops.rs b/libcore/ops.rs
index 44c498e..9c4bc3b 100644
--- a/libcore/ops.rs
+++ b/libcore/ops.rs
@@ -215,7 +215,9 @@ macro_rules! add_impl {
     )*)
 }
 
-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 @@ macro_rules! sub_impl {
     )*)
 }
 
-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 `*`.
 ///
@@ -321,7 +325,9 @@ macro_rules! mul_impl {
     )*)
 }
 
-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 `/`.
 ///
@@ -392,6 +398,7 @@ macro_rules! div_impl_float {
     )*)
 }
 
+#[cfg(not(disable_float))]
 div_impl_float! { f32 f64 }
 
 /// The `Rem` trait is used to specify the functionality of `%`.
@@ -463,6 +470,7 @@ macro_rules! rem_impl_float {
     )*)
 }
 
+#[cfg(not(disable_float))]
 rem_impl_float! { f32 f64 }
 
 /// The `Neg` trait is used to specify the functionality of unary `-`.
@@ -530,7 +538,9 @@ macro_rules! neg_impl_unsigned {
 }
 
 // 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 `!`.
 ///
@@ -928,7 +938,9 @@ macro_rules! add_assign_impl {
     )+)
 }
 
-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 `-=`.
 ///
@@ -972,7 +984,9 @@ macro_rules! sub_assign_impl {
     )+)
 }
 
-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 `*=`.
 ///
@@ -1016,7 +1030,9 @@ macro_rules! mul_assign_impl {
     )+)
 }
 
-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 `/=`.
 ///
@@ -1060,7 +1076,9 @@ macro_rules! div_assign_impl {
     )+)
 }
 
-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 `%=`.
 ///
@@ -1104,7 +1122,9 @@ macro_rules! rem_assign_impl {
     )+)
 }
 
-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 `&=`.
 ///
diff --git a/libcore_nofp.patch b/libcore_nofp.patch
new file mode 100644
index 0000000..8a52496
--- /dev/null
+++ b/libcore_nofp.patch
@@ -0,0 +1,318 @@
+diff -rub libcore_orig/clone.rs libcore/clone.rs
+--- libcore_orig/clone.rs	2016-03-22 09:59:58.933883699 +0800
++++ libcore/clone.rs	2016-03-22 09:35:09.084786455 +0800
+@@ -82,7 +82,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-03-22 09:59:58.933883699 +0800
++++ libcore/default.rs	2016-03-22 09:35:09.084786455 +0800
+@@ -160,5 +160,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-03-22 09:59:58.937883733 +0800
++++ libcore/fmt/mod.rs	2016-03-22 09:35:09.084786455 +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;
+@@ -1020,6 +1021,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
+@@ -1056,6 +1058,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) })
+@@ -1445,6 +1448,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
+@@ -1469,6 +1473,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
+@@ -1522,7 +1527,9 @@
+         }
+     }
+ } }
++#[cfg(not(disable_float))]
+ floating! { f32 }
++#[cfg(not(disable_float))]
+ floating! { f64 }
+
+ // Implementation of Display/Debug for various core types
+Only in libcore/fmt: mod.rs.orig
+diff -rub libcore_orig/intrinsics.rs libcore/intrinsics.rs
+--- libcore_orig/intrinsics.rs	2016-03-22 09:59:58.933883699 +0800
++++ libcore/intrinsics.rs	2016-03-22 09:35:09.084786455 +0800
+@@ -457,7 +457,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`
+@@ -579,8 +582,9 @@
+     /// May assume inputs are finite.
+     #[cfg(not(stage0))]
+     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;
+
+Only in libcore/: intrinsics.rs.orig
+Only in libcore/: intrinsics.rs.rej
+diff -rub libcore_orig/lib.rs libcore/lib.rs
+--- libcore_orig/lib.rs	2016-03-22 09:59:58.937883733 +0800
++++ libcore/lib.rs	2016-03-22 09:35:09.084786455 +0800
+@@ -103,7 +103,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]
+Only in libcore/: lib.rs.orig
+Only in libcore/: lib.rs.rej
+diff -rub libcore_orig/num/flt2dec/decoder.rs libcore/num/flt2dec/decoder.rs
+--- libcore_orig/num/flt2dec/decoder.rs	2016-03-22 09:59:58.937883733 +0800
++++ libcore/num/flt2dec/decoder.rs	2016-03-22 09:35:09.084786455 +0800
+@@ -12,6 +12,7 @@
+
+ use prelude::v1::*;
+
++#[cfg(not(disable_float))]
+ use {f32, f64};
+ use num::{Float, FpCategory};
+
+@@ -57,10 +58,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-03-22 09:59:58.941883767 +0800
++++ libcore/num/mod.rs	2016-03-22 09:35:09.084786455 +0800
+@@ -44,7 +44,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;
+@@ -111,6 +113,7 @@
+         }
+     )*)
+ }
++#[cfg(not(disable_float))]
+ zero_one_impl_float! { f32 f64 }
+
+ macro_rules! checked_op {
+@@ -2213,6 +2216,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",
+@@ -2451,6 +2455,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
+@@ -2498,6 +2503,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 }
+@@ -2514,3 +2522,4 @@
+
+ // Float -> Float
+ impl_from! { f32, f64 }
++}
+Only in libcore/num: mod.rs.orig
+Only in libcore/num: mod.rs.rej
+diff -rub libcore_orig/ops.rs libcore/ops.rs
+--- libcore_orig/ops.rs	2016-03-22 09:59:58.937883733 +0800
++++ libcore/ops.rs	2016-03-22 09:35:09.084786455 +0800
+@@ -215,7 +215,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 `*`.
+ ///
+@@ -321,7 +325,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 `/`.
+ ///
+@@ -392,6 +398,7 @@
+     )*)
+ }
+
++#[cfg(not(disable_float))]
+ div_impl_float! { f32 f64 }
+
+ /// The `Rem` trait is used to specify the functionality of `%`.
+@@ -463,6 +470,7 @@
+     )*)
+ }
+
++#[cfg(not(disable_float))]
+ rem_impl_float! { f32 f64 }
+
+ /// The `Neg` trait is used to specify the functionality of unary `-`.
+@@ -530,7 +538,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 `!`.
+ ///
+@@ -928,7 +938,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 `-=`.
+ ///
+@@ -972,7 +984,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 `*=`.
+ ///
+@@ -1016,7 +1030,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 `/=`.
+ ///
+@@ -1060,7 +1076,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 `%=`.
+ ///
+@@ -1104,7 +1122,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 `&=`.
+ ///
+Only in libcore/: ops.rs.orig
+Only in libcore/: ops.rs.rej