rustbuild: work around the stdarch cfg(bootstrap) bug.

eddyb · eddyb · commit 892ef6fa48bd · 2019-08-16T20:12:10.000+03:00
diff --git a/src/bootstrap/bin/rustc.rs b/src/bootstrap/bin/rustc.rs
@@ -102,8 +102,13 @@ fn main() {
     // FIXME: the fact that core here is excluded is due to core_arch from our stdarch submodule
     // being broken on the beta compiler with bootstrap passed, so this is a temporary workaround
     // (we've just snapped, so there are no cfg(bootstrap) related annotations in core).
-    if stage == "0" && crate_name != Some("core") {
-        cmd.arg("--cfg").arg("bootstrap");
+    if stage == "0" {
+        if crate_name != Some("core") {
+            cmd.arg("--cfg").arg("bootstrap");
+        } else {
+            // NOTE(eddyb) see FIXME above, except now we need annotations again in core.
+            cmd.arg("--cfg").arg("boostrap_stdarch_ignore_this");
+        }
     }
 
     // Print backtrace in case of ICE
diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs
@@ -1293,38 +1293,38 @@ extern "rust-intrinsic" {
     /// The stabilized versions of this intrinsic are available on the integer
     /// primitives via the `wrapping_add` method. For example,
     /// [`std::u32::wrapping_add`](../../std/primitive.u32.html#method.wrapping_add)
-    #[cfg(bootstrap)]
+    #[cfg(boostrap_stdarch_ignore_this)]
     pub fn overflowing_add<T>(a: T, b: T) -> T;
     /// Returns (a - b) mod 2<sup>N</sup>, where N is the width of T in bits.
     /// The stabilized versions of this intrinsic are available on the integer
     /// primitives via the `wrapping_sub` method. For example,
     /// [`std::u32::wrapping_sub`](../../std/primitive.u32.html#method.wrapping_sub)
-    #[cfg(bootstrap)]
+    #[cfg(boostrap_stdarch_ignore_this)]
     pub fn overflowing_sub<T>(a: T, b: T) -> T;
     /// Returns (a * b) mod 2<sup>N</sup>, where N is the width of T in bits.
     /// The stabilized versions of this intrinsic are available on the integer
     /// primitives via the `wrapping_mul` method. For example,
     /// [`std::u32::wrapping_mul`](../../std/primitive.u32.html#method.wrapping_mul)
-    #[cfg(bootstrap)]
+    #[cfg(boostrap_stdarch_ignore_this)]
     pub fn overflowing_mul<T>(a: T, b: T) -> T;
 
     /// Returns (a + b) mod 2<sup>N</sup>, where N is the width of T in bits.
     /// The stabilized versions of this intrinsic are available on the integer
     /// primitives via the `wrapping_add` method. For example,
     /// [`std::u32::wrapping_add`](../../std/primitive.u32.html#method.wrapping_add)
-    #[cfg(not(bootstrap))]
+    #[cfg(not(boostrap_stdarch_ignore_this))]
     pub fn wrapping_add<T>(a: T, b: T) -> T;
     /// Returns (a - b) mod 2<sup>N</sup>, where N is the width of T in bits.
     /// The stabilized versions of this intrinsic are available on the integer
     /// primitives via the `wrapping_sub` method. For example,
     /// [`std::u32::wrapping_sub`](../../std/primitive.u32.html#method.wrapping_sub)
-    #[cfg(not(bootstrap))]
+    #[cfg(not(boostrap_stdarch_ignore_this))]
     pub fn wrapping_sub<T>(a: T, b: T) -> T;
     /// Returns (a * b) mod 2<sup>N</sup>, where N is the width of T in bits.
     /// The stabilized versions of this intrinsic are available on the integer
     /// primitives via the `wrapping_mul` method. For example,
     /// [`std::u32::wrapping_mul`](../../std/primitive.u32.html#method.wrapping_mul)
-    #[cfg(not(bootstrap))]
+    #[cfg(not(boostrap_stdarch_ignore_this))]
     pub fn wrapping_mul<T>(a: T, b: T) -> T;
 
     /// Computes `a + b`, while saturating at numeric bounds.
diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs
@@ -1112,11 +1112,11 @@ $EndFeature, "
                           without modifying the original"]
             #[inline]
             pub const fn wrapping_add(self, rhs: Self) -> Self {
-                #[cfg(bootstrap)] {
+                #[cfg(boostrap_stdarch_ignore_this)] {
                     intrinsics::overflowing_add(self, rhs)
                 }
 
-                #[cfg(not(bootstrap))] {
+                #[cfg(not(boostrap_stdarch_ignore_this))] {
                     intrinsics::wrapping_add(self, rhs)
                 }
             }
@@ -1141,11 +1141,11 @@ $EndFeature, "
                           without modifying the original"]
             #[inline]
             pub const fn wrapping_sub(self, rhs: Self) -> Self {
-                #[cfg(bootstrap)] {
+                #[cfg(boostrap_stdarch_ignore_this)] {
                     intrinsics::overflowing_sub(self, rhs)
                 }
 
-                #[cfg(not(bootstrap))] {
+                #[cfg(not(boostrap_stdarch_ignore_this))] {
                     intrinsics::wrapping_sub(self, rhs)
                 }
             }
@@ -1169,11 +1169,11 @@ $EndFeature, "
                           without modifying the original"]
             #[inline]
             pub const fn wrapping_mul(self, rhs: Self) -> Self {
-                #[cfg(bootstrap)] {
+                #[cfg(boostrap_stdarch_ignore_this)] {
                     intrinsics::overflowing_mul(self, rhs)
                 }
 
-                #[cfg(not(bootstrap))] {
+                #[cfg(not(boostrap_stdarch_ignore_this))] {
                     intrinsics::wrapping_mul(self, rhs)
                 }
             }
@@ -3049,11 +3049,11 @@ $EndFeature, "
                           without modifying the original"]
             #[inline]
             pub const fn wrapping_add(self, rhs: Self) -> Self {
-                #[cfg(bootstrap)] {
+                #[cfg(boostrap_stdarch_ignore_this)] {
                     intrinsics::overflowing_add(self, rhs)
                 }
 
-                #[cfg(not(bootstrap))] {
+                #[cfg(not(boostrap_stdarch_ignore_this))] {
                     intrinsics::wrapping_add(self, rhs)
                 }
             }
@@ -3077,11 +3077,11 @@ $EndFeature, "
                           without modifying the original"]
             #[inline]
             pub const fn wrapping_sub(self, rhs: Self) -> Self {
-                #[cfg(bootstrap)] {
+                #[cfg(boostrap_stdarch_ignore_this)] {
                     intrinsics::overflowing_sub(self, rhs)
                 }
 
-                #[cfg(not(bootstrap))] {
+                #[cfg(not(boostrap_stdarch_ignore_this))] {
                     intrinsics::wrapping_sub(self, rhs)
                 }
             }
@@ -3106,11 +3106,11 @@ $EndFeature, "
                           without modifying the original"]
         #[inline]
         pub const fn wrapping_mul(self, rhs: Self) -> Self {
-            #[cfg(bootstrap)] {
+            #[cfg(boostrap_stdarch_ignore_this)] {
                 intrinsics::overflowing_mul(self, rhs)
             }
 
-            #[cfg(not(bootstrap))] {
+            #[cfg(not(boostrap_stdarch_ignore_this))] {
                 intrinsics::wrapping_mul(self, rhs)
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -1112,11 +1112,11 @@ $EndFeature, "`
`1112`	`1112`	`without modifying the original"]`
`1113`	`1113`	`#[inline]`
`1114`	`1114`	`pub const fn wrapping_add(self, rhs: Self) -> Self {`
`1115`		`- #[cfg(bootstrap)] {`
	`1115`	`+ #[cfg(boostrap_stdarch_ignore_this)] {`
`1116`	`1116`	`intrinsics::overflowing_add(self, rhs)`
`1117`	`1117`	`}`
`1118`	`1118`
`1119`		`- #[cfg(not(bootstrap))] {`
	`1119`	`+ #[cfg(not(boostrap_stdarch_ignore_this))] {`
`1120`	`1120`	`intrinsics::wrapping_add(self, rhs)`
`1121`	`1121`	`}`
`1122`	`1122`	`}`
`@@ -1141,11 +1141,11 @@ $EndFeature, "`
`1141`	`1141`	`without modifying the original"]`
`1142`	`1142`	`#[inline]`
`1143`	`1143`	`pub const fn wrapping_sub(self, rhs: Self) -> Self {`
`1144`		`- #[cfg(bootstrap)] {`
	`1144`	`+ #[cfg(boostrap_stdarch_ignore_this)] {`
`1145`	`1145`	`intrinsics::overflowing_sub(self, rhs)`
`1146`	`1146`	`}`
`1147`	`1147`
`1148`		`- #[cfg(not(bootstrap))] {`
	`1148`	`+ #[cfg(not(boostrap_stdarch_ignore_this))] {`
`1149`	`1149`	`intrinsics::wrapping_sub(self, rhs)`
`1150`	`1150`	`}`
`1151`	`1151`	`}`
`@@ -1169,11 +1169,11 @@ $EndFeature, "`
`1169`	`1169`	`without modifying the original"]`
`1170`	`1170`	`#[inline]`
`1171`	`1171`	`pub const fn wrapping_mul(self, rhs: Self) -> Self {`
`1172`		`- #[cfg(bootstrap)] {`
	`1172`	`+ #[cfg(boostrap_stdarch_ignore_this)] {`
`1173`	`1173`	`intrinsics::overflowing_mul(self, rhs)`
`1174`	`1174`	`}`
`1175`	`1175`
`1176`		`- #[cfg(not(bootstrap))] {`
	`1176`	`+ #[cfg(not(boostrap_stdarch_ignore_this))] {`
`1177`	`1177`	`intrinsics::wrapping_mul(self, rhs)`
`1178`	`1178`	`}`
`1179`	`1179`	`}`
`@@ -3049,11 +3049,11 @@ $EndFeature, "`
`3049`	`3049`	`without modifying the original"]`
`3050`	`3050`	`#[inline]`
`3051`	`3051`	`pub const fn wrapping_add(self, rhs: Self) -> Self {`
`3052`		`- #[cfg(bootstrap)] {`
	`3052`	`+ #[cfg(boostrap_stdarch_ignore_this)] {`
`3053`	`3053`	`intrinsics::overflowing_add(self, rhs)`
`3054`	`3054`	`}`
`3055`	`3055`
`3056`		`- #[cfg(not(bootstrap))] {`
	`3056`	`+ #[cfg(not(boostrap_stdarch_ignore_this))] {`
`3057`	`3057`	`intrinsics::wrapping_add(self, rhs)`
`3058`	`3058`	`}`
`3059`	`3059`	`}`
`@@ -3077,11 +3077,11 @@ $EndFeature, "`
`3077`	`3077`	`without modifying the original"]`
`3078`	`3078`	`#[inline]`
`3079`	`3079`	`pub const fn wrapping_sub(self, rhs: Self) -> Self {`
`3080`		`- #[cfg(bootstrap)] {`
	`3080`	`+ #[cfg(boostrap_stdarch_ignore_this)] {`
`3081`	`3081`	`intrinsics::overflowing_sub(self, rhs)`
`3082`	`3082`	`}`
`3083`	`3083`
`3084`		`- #[cfg(not(bootstrap))] {`
	`3084`	`+ #[cfg(not(boostrap_stdarch_ignore_this))] {`
`3085`	`3085`	`intrinsics::wrapping_sub(self, rhs)`
`3086`	`3086`	`}`
`3087`	`3087`	`}`
`@@ -3106,11 +3106,11 @@ $EndFeature, "`
`3106`	`3106`	`without modifying the original"]`
`3107`	`3107`	`#[inline]`
`3108`	`3108`	`pub const fn wrapping_mul(self, rhs: Self) -> Self {`
`3109`		`- #[cfg(bootstrap)] {`
	`3109`	`+ #[cfg(boostrap_stdarch_ignore_this)] {`
`3110`	`3110`	`intrinsics::overflowing_mul(self, rhs)`
`3111`	`3111`	`}`
`3112`	`3112`
`3113`		`- #[cfg(not(bootstrap))] {`
	`3113`	`+ #[cfg(not(boostrap_stdarch_ignore_this))] {`
`3114`	`3114`	`intrinsics::wrapping_mul(self, rhs)`
`3115`	`3115`	`}`
`3116`	`3116`	`}`