sp1-build 6.1.0

Build an SP1 program.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use std::{env, path::PathBuf, process::Command};

use crate::{BuildArgs, WarningLevel, HELPER_TARGET_SUBDIR};
use cargo_metadata::camino::Utf8PathBuf;
use dirs::home_dir;

use super::utils::{get_program_build_args, get_rust_compiler_flags};

#[allow(clippy::uninlined_format_args)]
/// Get the command to build the program locally.
pub(crate) fn create_local_command(
    args: &BuildArgs,
    program_dir: &Utf8PathBuf,
    program_metadata: &cargo_metadata::Metadata,
) -> Command {
    let mut command = Command::new("cargo");
    let canonicalized_program_dir =
        program_dir.canonicalize().expect("Failed to canonicalize program directory");

    // If CC_riscv32im_succinct_zkvm_elf is not set, set it to the default C++ toolchain
    // downloaded by 'sp1up --c-toolchain'.
    if env::var("CC_riscv32im_succinct_zkvm_elf").is_err() {
        if let Some(home_dir) = home_dir() {
            let cc_path = home_dir.join(".sp1").join("bin").join("riscv32-unknown-elf-gcc");
            if cc_path.exists() {
                command.env("CC_riscv32im_succinct_zkvm_elf", cc_path);
            }
        }
    }

    // If CC_riscv64im_succinct_zkvm_elf is not set, set it to the default C++ toolchain
    // downloaded by 'sp1up --c-toolchain'.
    if env::var("CC_riscv64im_succinct_zkvm_elf").is_err() {
        if let Some(home_dir) = home_dir() {
            let cc_path = home_dir.join(".sp1").join("bin").join("riscv64-unknown-elf-gcc");
            if cc_path.exists() {
                command.env("CC_riscv64im_succinct_zkvm_elf", cc_path);
            }
        }
    }

    let parsed_version = {
        let output = Command::new("rustc")
            .arg("--version")
            .env("RUSTUP_TOOLCHAIN", super::TOOLCHAIN_NAME)
            .output()
            .expect("rustc --version should succeed");

        if !output.status.success() {
            panic!(
                "Failed to run rustc --version {:?}\n{:?}",
                String::from_utf8_lossy(&output.stdout),
                String::from_utf8_lossy(&output.stderr)
            );
        }

        let stdout_string =
            String::from_utf8(output.stdout).expect("Can't parse rustc --version stdout");

        if matches!(args.warning_level, WarningLevel::All) {
            println!("cargo:warning=rustc +succinct --version: {stdout_string:?}");
        }

        super::utils::parse_rustc_version(&stdout_string)
    };

    let rustc_bin = {
        let output = Command::new("rustc")
            .env("RUSTUP_TOOLCHAIN", super::TOOLCHAIN_NAME)
            .arg("--print")
            .arg("sysroot")
            .output()
            .expect("rustc --print sysroot should succeed");

        let stdout_string =
            String::from_utf8(output.stdout).expect("Can't parse rustc --print rustc stdout");

        PathBuf::from(stdout_string.trim()).join("bin/rustc")
    };

    // When executing the local command:
    // 1. Set the target directory to a subdirectory of the program's target directory to avoid
    //    build
    // conflicts with the parent process. Source: https://github.com/rust-lang/cargo/issues/6412
    // 2. Set the rustup toolchain to succinct.
    // 3. Set the encoded rust flags.
    // 4. Remove the rustc configuration, otherwise in a build script it will attempt to compile the
    //    program with the toolchain of the normal build process, rather than the Succinct
    //    toolchain.
    // 5. Remove all the environment variables related to cargo activated features and configuration
    //    options.
    command
        .current_dir(canonicalized_program_dir)
        .env("CARGO_ENCODED_RUSTFLAGS", get_rust_compiler_flags(args, &parsed_version))
        .env_remove("RUSTC")
        .env("RUSTC", rustc_bin.display().to_string())
        .env("CARGO_TARGET_DIR", program_metadata.target_directory.join(HELPER_TARGET_SUBDIR))
        // TODO: remove once trim-paths is supported - https://github.com/rust-lang/rust/issues/111540
        .env("RUSTC_BOOTSTRAP", "1") // allows trim-paths.
        .args(get_program_build_args(args));
    env::vars()
        .map(|v| v.0)
        .filter(|v| v.starts_with("CARGO_FEATURE_") || v.starts_with("CARGO_CFG_"))
        .fold(&mut command, Command::env_remove);
    command
}