calyx 0.7.1

Compiler Infrastructure for Hardware Accelerator Generation
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

use std::{env, fs, io::Result, path};

/// Location to install the primitives library
const PRIM_DIR: &str = "CALYX_PRIMITIVES_DIR";

struct PrimState {
    base: path::PathBuf,
    old_prims: Option<path::PathBuf>,
    new_prims: path::PathBuf,
}

/// Move the old primitives directory to a different location if present and create a new one.
fn move_primitives() -> Result<PrimState> {
    let base: path::PathBuf = match env::var_os(PRIM_DIR) {
        Some(v) => path::PathBuf::from(v),
        None => {
            let mut path: path::PathBuf = env::var_os("HOME").unwrap().into();
            path.push(".calyx");
            path
        }
    };
    let mut prims = base.clone();
    prims.push("primitives");

    // If there is already a primitives directory, move it to `old_primitves`.
    let old_prims = if prims.exists() {
        let mut old_prims = base.clone();
        old_prims.push("old_primitives");
        // If old_primitives already exists, remove it first.
        if old_prims.exists() {
            fs::remove_dir_all(&old_prims)?;
        }

        match fs::rename(&prims, &old_prims) {
            Ok(_) => (),
            Err(e) => {
                println!(
                    "cargo:warning=Failed to move primitives directory: {e}"
                );
                return Err(e);
            }
        };
        Some(old_prims)
    } else {
        None
    };

    // Create the directory again
    fs::create_dir_all(&prims)?;
    Ok(PrimState {
        base,
        old_prims,
        new_prims: prims,
    })
}

fn write_primitive(prims: &path::Path) -> Result<()> {
    // Get the OUT_DIR environment variable from Cargo.
    // Write the compile primitives
    for (loc, src) in calyx_stdlib::KNOWN_LIBS
        .into_iter()
        .flat_map(|(_, info)| info)
        .chain(Some(calyx_stdlib::COMPILE_LIB))
    {
        let mut path = prims.to_owned().clone();
        path.push(loc);
        // Make sure the parent of the file exists
        fs::create_dir_all(path.parent().unwrap())?;
        match fs::write(path, src) {
            Ok(_) => (),
            Err(e) => {
                println!(
                    "cargo:warning=Failed to write primitive: {loc}. Error: {e}"
                );
                return Err(e);
            }
        }
    }
    Ok(())
}

fn create_primitives() -> Result<path::PathBuf> {
    let PrimState {
        base,
        old_prims,
        new_prims: prims,
    } = move_primitives()?;
    match write_primitive(prims.as_path()) {
        Ok(_) => {
            if let Some(old) = old_prims {
                fs::remove_dir_all(old)?;
            }
        }
        Err(e) => {
            // Move the old primitives back
            println!("cargo:warning=Failed to write primitives directory. Restoring old directory: {e}");
            if let Some(old) = old_prims {
                fs::rename(old, &prims)?;
            }
            return Err(e);
        }
    }
    Ok(base)
}

// The build script does not fail
fn main() {
    println!("cargo:rerun-if-changed=src/build.rs");
    println!("cargo:rerun-if-changed=src/cmdline.rs");
    match create_primitives() {
        Ok(p) => {
            // The build succeeded. We're going to define the CALYX_PRIMITVE_DIR environment variable
            // so that it can be used by the compiler.
            println!("cargo:rustc-env={PRIM_DIR}={}", p.to_string_lossy());
        }
        Err(e) => {
            println!(
                "cargo:warning=Failed to create the `primitives` folder. Importing `primitives` will require passing an explicit `-l` when running the Calyx compiler. Error: {e}",
            );
        }
    }
}