rllvm 0.1.6

A tool to build whole-program LLVM bitcode files
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

//! Filepath-related utility functions

use std::{
    collections::hash_map::DefaultHasher,
    hash::{Hash, Hasher},
    path::{Path, PathBuf},
};

use crate::error::Error;

pub fn derive_object_and_bitcode_filepath<P>(
    src_filepath: P,
    is_compile_only: bool,
) -> Result<(PathBuf, PathBuf), Error>
where
    P: AsRef<Path>,
{
    let src_filepath = src_filepath.as_ref();
    if !src_filepath.is_absolute() {
        return Err(Error::InvalidArguments(format!(
            "'src_filepath' must be absolute: {:?}",
            src_filepath
        )));
    }

    // Parent directory
    let parent_dir = src_filepath.parent().expect(&format!(
        "Failed to obtain the parent directory: {:?}",
        src_filepath
    ));
    // With extension
    let file_name = src_filepath
        .file_name()
        .expect(&format!(
            "Failed to obtain the file name: {:?}",
            src_filepath
        ))
        .to_str()
        .expect(&format!(
            "Failed to convert OsStr to str: {:?}",
            src_filepath
        ));
    // Without extension
    let file_stem = src_filepath
        .file_stem()
        .expect(&format!(
            "Failed to obtain the file stem: {:?}",
            src_filepath
        ))
        .to_str()
        .expect(&format!(
            "Failed to convert OsStr to str: {:?}",
            src_filepath
        ));

    let object_file_name = if is_compile_only {
        // Compile only. We need to explicitly generate the object file
        format!("{file_name}.o")
    } else {
        // Hide the object file, as it is only for bitcode generation
        format!(".{file_stem}.o")
    };
    // We always hide the bitcode file
    let bitcode_file_name = format!(".{file_stem}.o.bc");

    let object_filepath = parent_dir.join(object_file_name);
    let bitcode_filepath = parent_dir.join(bitcode_file_name);

    Ok((object_filepath, bitcode_filepath))
}

pub fn calculate_filepath_hash<P>(filepath: P) -> u64
where
    P: AsRef<Path>,
{
    let filepath = filepath.as_ref();

    let mut hasher = DefaultHasher::new();
    filepath.hash(&mut hasher);
    hasher.finish()
}

#[cfg(test)]
mod tests {
    use std::path::Path;

    use super::*;

    #[test]
    fn test_derive_object_and_bitcode_filepath() {
        let test_inputs = [
            (
                Path::new("/tmp/foo.c"),
                false,
                (Path::new("/tmp/.foo.o"), Path::new("/tmp/.foo.o.bc")),
            ),
            (
                Path::new("/tmp/foo.c"),
                true,
                (Path::new("/tmp/foo.c.o"), Path::new("/tmp/.foo.o.bc")),
            ),
        ];

        assert!(test_inputs.iter().all(
            |&(
                src_filepath,
                is_compile_only,
                (expected_object_filepath, expected_bitcode_filepath),
            )| {
                derive_object_and_bitcode_filepath(src_filepath, is_compile_only).map_or(
                    false,
                    |(object_filepath, bitcode_filepath)| {
                        object_filepath == expected_object_filepath
                            && bitcode_filepath == expected_bitcode_filepath
                    },
                )
            },
        ));
    }
}