automate, automate

Author: jonas-schievink

asm-toolchain

@@ -0,0 +1 @@
+nightly-2020-08-26

asm.rs

@@ -14,11 +14,20 @@
 //! assembly.
 //!
 //! For developers and contributors to `cortex-m`, this setup means that they don't have to install
-//! any binutils, assembler, or C compiler to hack on the crate. All they need is a nightly rustc
-//! and run `cargo xtask assemble` to rebuild the archives from this file.
+//! any binutils, assembler, or C compiler to hack on the crate. All they need is to run `cargo
+//! xtask assemble` to rebuild the archives from this file.
 //!
 //! Cool, right?
 //!
+//! # Rust version management
+//!
+//! Since inline assembly is still unstable, and we want to ensure that the created blobs are
+//! up-to-date in CI, we have to pin the nightly version we use for this. The nightly toolchain is
+//! stored in `asm-toolchain`.
+//!
+//! The `cargo xtask` automation will automatically install the `asm-toolchain` as well as all
+//! Cortex-M targets needed to generate the blobs.
+//!
 //! [linker plugin LTO]: https://doc.rust-lang.org/stable/rustc/linker-plugin-lto.html
 
 #![feature(asm)]

bin/thumbv6m-none-eabi-lto.a

@@ -5,19 +5,6 @@ main() {
         thumbv*-none-eabi*)
             rustup target add $TARGET
             ;;
-        x86_64-unknown-linux-gnu)
-            # We need *all* targets and nightly as we're checking the blobs.
-            rustup install nightly
-            rustup target add \
-                thumbv6m-none-eabi \
-                thumbv7m-none-eabi \
-                thumbv7em-none-eabi \
-                thumbv7em-none-eabihf \
-                thumbv8m.base-none-eabi \
-                thumbv8m.main-none-eabi \
-                thumbv8m.main-none-eabihf \
-                --toolchain nightly
-            ;;
     esac
 }
 

bin/thumbv6m-none-eabi.a

@@ -4,16 +4,24 @@
 //!
 //! Also see the docs in `asm.rs`.
 
+use process::Stdio;
 use std::env::{self, current_dir};
 use std::{
     collections::BTreeMap,
     fs::{self, File},
     process::{self, Command},
 };
 
+fn toolchain() -> String {
+    fs::read_to_string("asm-toolchain")
+        .unwrap()
+        .trim()
+        .to_string()
+}
+
 fn rustc() -> Command {
     let mut cmd = Command::new("rustc");
-    cmd.arg("+nightly");
+    cmd.arg(format!("+{}", toolchain()));
     cmd
 }
 
@@ -105,6 +113,34 @@ static TARGETS: &[(&str, &[&str])] = &[
 ];
 
 fn assemble_blobs() {
+    let mut cmd = rustc();
+    cmd.arg("-V");
+    cmd.stdout(Stdio::null());
+    let status = cmd.status().unwrap();
+
+    if !status.success() {
+        let toolchain = toolchain();
+        println!(
+            "asm toolchain {} does not seem to be installed. installing it now.",
+            toolchain
+        );
+
+        let mut rustup = Command::new("rustup");
+        let status = rustup.arg("install").arg(&toolchain).status().unwrap();
+        assert!(status.success(), "rustup command failed: {:?}", rustup);
+
+        let mut rustup = Command::new("rustup");
+        let status = rustup
+            .arg("target")
+            .arg("add")
+            .args(TARGETS.iter().map(|(target, _)| *target))
+            .arg("--toolchain")
+            .arg(toolchain)
+            .status()
+            .unwrap();
+        assert!(status.success(), "rustup command failed: {:?}", rustup);
+    }
+
     for (target, cfgs) in TARGETS {
         println!("building artifacts for {}", target);
         assemble(target, cfgs);