fcoreutils 0.9.0

High-performance GNU coreutils replacement with SIMD and parallelism
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use std::env;
use std::process::Command;

fn main() {
    // Re-run the build script if the assembly source changes.
    println!("cargo:rerun-if-changed=assembly/yes/fyes.asm");
    println!("cargo:rerun-if-changed=assembly/yes/build.py");
    println!("cargo:rerun-if-changed=assembly/yes/fyes_arm64.s");

    let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
    let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default();

    // Assembly build only applies to Linux.
    if target_os != "linux" {
        return;
    }

    let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
    let out_dir = env::var("OUT_DIR").unwrap();

    match target_arch.as_str() {
        "x86_64" => build_x86_64(&manifest_dir, &out_dir),
        "aarch64" => build_aarch64(&manifest_dir, &out_dir),
        _ => {}
    }
}

fn build_x86_64(manifest_dir: &str, out_dir: &str) {
    // Check for required tools.
    let has_nasm = Command::new("nasm")
        .arg("--version")
        .output()
        .map(|o| o.status.success())
        .unwrap_or(false);

    let has_python = Command::new("python3")
        .arg("--version")
        .output()
        .map(|o| o.status.success())
        .unwrap_or(false);

    if !has_nasm || !has_python {
        println!(
            "cargo:warning=fyes assembly (x86_64): nasm or python3 not found — using Rust fallback"
        );
        return;
    }

    // Build the assembly binary into OUT_DIR.
    let asm_dir = format!("{}/assembly/yes", manifest_dir);
    let fyes_asm_out = format!("{}/fyes_asm", out_dir);

    let status = Command::new("python3")
        .arg("build.py")
        .arg("-o")
        .arg(&fyes_asm_out)
        .arg("--no-verify")
        .current_dir(&asm_dir)
        .status();

    match status {
        Ok(s) if s.success() => {
            println!(
                "cargo:warning=fyes assembly (x86_64): built at {}",
                fyes_asm_out
            );
            println!("cargo:rustc-env=FYES_ASM_PATH={}", fyes_asm_out);
            println!("cargo:rustc-cfg=fyes_has_asm");
        }
        _ => {
            println!("cargo:warning=fyes assembly (x86_64): build failed — using Rust fallback");
        }
    }
}

fn build_aarch64(manifest_dir: &str, out_dir: &str) {
    // Check for required tools: GNU assembler (as) and linker (ld).
    let has_as = Command::new("as")
        .arg("--version")
        .output()
        .map(|o| o.status.success())
        .unwrap_or(false);

    let has_ld = Command::new("ld")
        .arg("--version")
        .output()
        .map(|o| o.status.success())
        .unwrap_or(false);

    if !has_as || !has_ld {
        println!(
            "cargo:warning=fyes assembly (aarch64): 'as' or 'ld' not found — using Rust fallback"
        );
        return;
    }

    let asm_src = format!("{}/assembly/yes/fyes_arm64.s", manifest_dir);
    let obj_out = format!("{}/fyes_arm64.o", out_dir);
    let fyes_asm_out = format!("{}/fyes_asm", out_dir);

    // Assemble.
    let as_status = Command::new("as").args(["-o", &obj_out, &asm_src]).status();

    if !matches!(as_status, Ok(s) if s.success()) {
        println!("cargo:warning=fyes assembly (aarch64): 'as' failed — using Rust fallback");
        return;
    }

    // Link.
    let ld_status = Command::new("ld")
        .args([
            "-static",
            "-s",
            "-e",
            "_start",
            "-o",
            &fyes_asm_out,
            &obj_out,
        ])
        .status();

    match ld_status {
        Ok(s) if s.success() => {
            println!(
                "cargo:warning=fyes assembly (aarch64): built at {}",
                fyes_asm_out
            );
            println!("cargo:rustc-env=FYES_ASM_PATH={}", fyes_asm_out);
            println!("cargo:rustc-cfg=fyes_has_asm");
        }
        _ => {
            println!("cargo:warning=fyes assembly (aarch64): 'ld' failed — using Rust fallback");
        }
    }
}