refactor(test_runner): support more diverse linker script configurations

Author: yvt

Cargo.lock

@@ -15,6 +15,7 @@ probe-rs-rtt = { version = "0.11.0" }
 tokio-serial = { version = "5.4.1" }
 lazy_static = { version = "1.4.0" }
 env_logger = { version = "0.8.4" }
+fn-formats = { version = "0.0.5" }
 serde_json = { version = "1.0.57" }
 serialport = { version = "4.0.0" }
 itertools = { version = "0.10.0" }

src/r3_test_runner/Cargo.toml

@@ -102,45 +102,30 @@ impl TestDriver {
         target_arch_opt: targets::BuildOpt,
     ) -> impl Future<Output = Result<Self, TestDriverNewError>> {
         // Choose the right test driver for the given target architecture
-        let (crate_name, rustflags_linkarg) = match target_arch {
-            targets::Arch::Armv7A => (
-                "r3_port_arm_test_driver",
-                "-C link-arg=-Tlink_ram_harvard.x",
-            ),
-            targets::Arch::ArmM { .. } => ("r3_port_arm_m_test_driver", "-C link-arg=-Tlink.x"),
-            targets::Arch::Riscv { .. } => (
-                "r3_port_riscv_test_driver",
-                "-C link-arg=-Tmemory.x -C link-arg=-Tlink.x",
-            ),
+        let crate_name = match target_arch {
+            targets::Arch::Armv7A => "r3_port_arm_test_driver",
+            targets::Arch::ArmM { .. } => "r3_port_arm_m_test_driver",
+            targets::Arch::Riscv { .. } => "r3_port_riscv_test_driver",
         };
 
         // Locate the test driver's crate
         let crate_path = driver_base_path.join(crate_name);
         log::debug!("driver.crate_name = {:?}", crate_name);
-        log::debug!("driver.rustflags_linkarg = {:?}", rustflags_linkarg);
         log::debug!("driver.crate_path = {:?}", crate_path);
 
         async move {
             if !crate_path.is_dir() {
                 return Err(TestDriverNewError::BadDriverPath(crate_path));
             }
 
-            Self::new_inner(
-                crate_path,
-                target,
-                crate_name,
-                rustflags_linkarg,
-                target_arch_opt,
-            )
-            .await
+            Self::new_inner(crate_path, target, crate_name, target_arch_opt).await
         }
     }
 
     async fn new_inner(
         crate_path: PathBuf,
         target: &'static dyn targets::Target,
         crate_name: &'static str,
-        rustflags_linkarg: &'static str,
         target_arch_opt: targets::BuildOpt,
     ) -> Result<Self, TestDriverNewError> {
         // Move to the driver directory
@@ -194,20 +179,30 @@ impl TestDriver {
             .join(crate_name);
         log::debug!("exe_path = '{}'", exe_path.display());
 
-        // Put the linker script in a directory
+        // Put generated linker scripts in a directory
+        let linker_scripts = target.linker_scripts();
+        log::debug!("linker_scripts = {:?}", linker_scripts);
         let link_dir =
             tempdir::TempDir::new("r3_test_runner").map_err(TestDriverNewError::TempDirError)?;
-        {
-            let memory_x_path = link_dir.path().join("memory.x");
-            log::debug!("Writing '{}'", memory_x_path.display());
-            std::fs::write(&memory_x_path, target.memory_layout_script())
-                .map_err(|e| TestDriverNewError::WriteError(memory_x_path, e))?;
+
+        for (name, contents) in linker_scripts.generated_files {
+            let generated_file_path = link_dir.path().join(name);
+            log::debug!("Writing '{}'", generated_file_path.display());
+            std::fs::write(&generated_file_path, contents)
+                .map_err(|e| TestDriverNewError::WriteError(generated_file_path, e))?;
         }
 
+        let rustflags_linkarg = fn_formats::DisplayFmt(|f| {
+            for name in linker_scripts.inputs.iter() {
+                write!(f, " -C link-arg=-T{}", name)?;
+            }
+            Ok(())
+        });
+
         // Derive `RUSTFLAGS`.
         let target_features = &target_arch_opt.target_features;
         let rustflags = if target_features.is_empty() {
-            rustflags_linkarg.to_owned()
+            rustflags_linkarg.to_string()
         } else {
             format!(
                 "{} -C target-feature={}",

src/r3_test_runner/src/driverinterface.rs

@@ -20,15 +20,55 @@ pub trait Target: Send + Sync {
     /// `r3_port_*_test_driver`.
     fn cargo_features(&self) -> Vec<String>;
 
-    /// Generate the `memory.x` file to be included by the linker script of
-    /// `cortex-m-rt` or `r3_port_arm`, or to be used as the top-level
-    /// linker script by `r3_port_riscv_test_driver`.
-    fn memory_layout_script(&self) -> String;
+    /// The linker scripts used to link the test driver.
+    fn linker_scripts(&self) -> LinkerScripts;
 
     /// Connect to the target.
     fn connect(&self) -> Pin<Box<dyn Future<Output = Result<Box<dyn DebugProbe>>>>>;
 }
 
+#[derive(Debug)]
+pub struct LinkerScripts {
+    /// Linker scripts to specify with `-C link-arg=-T...` options. Note that
+    /// linker scripts may refer to others by `INCLUDE` directives, in which
+    /// case the referenced scripts shouldn't be specified here.
+    pub inputs: Vec<String>,
+    /// Temporary linker scripts to generate.
+    pub generated_files: Vec<(String, String)>,
+}
+
+impl LinkerScripts {
+    /// Create `LinkerScripts` to use the `link_ram_harvard.x` provided by
+    /// `r3_port_arm`. The specified string is written to `memory.x`, which will
+    /// be imported by `link_ram_harvard.x`.
+    fn arm_harvard(memory_definition: String) -> Self {
+        Self {
+            inputs: vec!["link_ram_harvard.x".to_owned()],
+            generated_files: vec![("memory.x".to_owned(), memory_definition)],
+        }
+    }
+
+    /// Create `LinkerScripts` to use the `link.x` provided by `cortex-m-rt`.
+    /// The specified string is written to `memory.x`, which will be imported by
+    /// `link_ram_harvard.x`.
+    fn arm_m_rt(memory_definition: String) -> Self {
+        Self {
+            inputs: vec!["link.x".to_owned()],
+            generated_files: vec![("memory.x".to_owned(), memory_definition)],
+        }
+    }
+
+    /// Create `LinkerScripts` to use the `link.x` provided by `riscv-rt`.
+    /// The specified string is written to `memory.x`, which defines memory
+    /// regions referenced by `link.x`.
+    fn riscv_rt(memory_definition: String) -> Self {
+        Self {
+            inputs: vec!["memory.x".to_owned(), "link.x".to_owned()],
+            generated_files: vec![("memory.x".to_owned(), memory_definition)],
+        }
+    }
+}
+
 pub trait DebugProbe: Send {
     /// Program the specified ELF image and run it from the beginning to
     /// capture its output.
@@ -66,8 +106,8 @@ impl<T: Target> Target for OverrideTargetArch<T> {
         self.1.cargo_features()
     }
 
-    fn memory_layout_script(&self) -> String {
-        self.1.memory_layout_script()
+    fn linker_scripts(&self) -> LinkerScripts {
+        self.1.linker_scripts()
     }
 
     fn connect(&self) -> Pin<Box<dyn Future<Output = Result<Box<dyn DebugProbe>>>>> {

src/r3_test_runner/src/targets.rs

@@ -15,7 +15,7 @@ use tokio::{
     task::spawn_blocking,
 };
 
-use super::{Arch, DebugProbe, DynAsyncRead, Target};
+use super::{Arch, DebugProbe, DynAsyncRead, LinkerScripts, Target};
 use crate::subprocess;
 
 /// SparkFun RED-V RedBoard or Things Plus
@@ -36,8 +36,9 @@ impl Target for RedV {
         ]
     }
 
-    fn memory_layout_script(&self) -> String {
-        r#"
+    fn linker_scripts(&self) -> LinkerScripts {
+        LinkerScripts::riscv_rt(
+            r#"
             MEMORY
             {
                 FLASH : ORIGIN = 0x20000000, LENGTH = 16M
@@ -55,10 +56,10 @@ impl Target for RedV {
             _stext = 0x20010000;
 
             _hart_stack_size = 1K;
-        "#
-        .to_owned()
+            "#
+            .to_owned(),
+        )
     }
-
     fn connect(&self) -> Pin<Box<dyn Future<Output = Result<Box<dyn DebugProbe>>>>> {
         Box::pin(std::future::ready(Ok(Box::new(Fe310JLinkDebugProbe) as _)))
     }

src/r3_test_runner/src/targets/jlink.rs

@@ -13,7 +13,7 @@ use tokio_serial::{SerialPort, SerialPortBuilderExt, SerialStream};
 use super::{
     demux::Demux,
     serial::{choose_serial, ChooseSerialError},
-    slip, Arch, DebugProbe, DynAsyncRead, Target,
+    slip, Arch, DebugProbe, DynAsyncRead, LinkerScripts, Target,
 };
 use crate::utils::retry_on_fail;
 
@@ -35,8 +35,9 @@ impl Target for Maix {
         ]
     }
 
-    fn memory_layout_script(&self) -> String {
-        r#"
+    fn linker_scripts(&self) -> LinkerScripts {
+        LinkerScripts::riscv_rt(
+            r#"
             MEMORY
             {
                 RAM : ORIGIN = 0x80000000, LENGTH = 6M
@@ -50,10 +51,10 @@ impl Target for Maix {
             REGION_ALIAS("REGION_STACK", RAM);
 
             _hart_stack_size = 1K;
-        "#
-        .to_owned()
+            "#
+            .to_owned(),
+        )
     }
-
     fn connect(&self) -> Pin<Box<dyn Future<Output = Result<Box<dyn DebugProbe>>>>> {
         Box::pin(async { KflashDebugProbe::new().await.map(|x| Box::new(x) as _) })
     }

src/r3_test_runner/src/targets/kflash.rs

@@ -12,7 +12,7 @@ use tokio::{
     process::Child,
 };
 
-use super::{Arch, DebugProbe, DynAsyncRead, Target};
+use super::{Arch, DebugProbe, DynAsyncRead, LinkerScripts, Target};
 use crate::subprocess;
 
 /// GR-PEACH
@@ -27,17 +27,18 @@ impl Target for GrPeach {
         vec!["board-rza1".to_owned()]
     }
 
-    fn memory_layout_script(&self) -> String {
-        "
+    fn linker_scripts(&self) -> LinkerScripts {
+        LinkerScripts::arm_harvard(
+            "
             MEMORY
             {
                 RAM_CODE : ORIGIN = 0x20000000, LENGTH = 5120K
                 RAM_DATA : ORIGIN = 0x20500000, LENGTH = 5120K
             }
-        "
-        .to_owned()
+            "
+            .to_owned(),
+        )
     }
-
     fn connect(&self) -> Pin<Box<dyn Future<Output = Result<Box<dyn DebugProbe>>>>> {
         Box::pin(async { Ok(Box::new(GrPeachOpenOcdDebugProbe::new()) as Box<dyn DebugProbe>) })
     }

src/r3_test_runner/src/targets/openocd.rs

@@ -16,7 +16,7 @@ use tokio::{
     time::{sleep, Sleep},
 };
 
-use super::{Arch, DebugProbe, DynAsyncRead, Target};
+use super::{Arch, DebugProbe, DynAsyncRead, LinkerScripts, Target};
 
 pub struct NucleoF401re;
 
@@ -29,8 +29,9 @@ impl Target for NucleoF401re {
         vec!["output-rtt".to_owned()]
     }
 
-    fn memory_layout_script(&self) -> String {
-        "
+    fn linker_scripts(&self) -> LinkerScripts {
+        LinkerScripts::arm_m_rt(
+            "
             MEMORY
             {
               /* NOTE K = KiBi = 1024 bytes */
@@ -42,10 +43,10 @@ impl Target for NucleoF401re {
             /* The stack is of the full descending type. */
             /* NOTE Do NOT modify `_stack_start` unless you know what you are doing */
             _stack_start = ORIGIN(RAM) + LENGTH(RAM);
-        "
-        .to_owned()
+            "
+            .to_owned(),
+        )
     }
-
     fn connect(&self) -> Pin<Box<dyn Future<Output = Result<Box<dyn DebugProbe>>>>> {
         Box::pin(async {
             spawn_blocking(|| {