rllvm 0.1.9

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
121
122
123
124
125
126
127
128

//! Diagnostic utilities for version checking, install hints, and colored output.

use std::path::Path;

use owo_colors::OwoColorize;

use crate::utils::{execute_command_for_stdout_string, execute_llvm_config};

/// Extracts the major version number from a version string like "17.0.6" or "17".
fn parse_major_version(version: &str) -> Option<u32> {
    version.trim().split('.').next()?.parse().ok()
}

/// Checks whether the clang and LLVM tool versions are compatible.
///
/// Queries `clang --version` and `llvm-config --version`, compares major versions,
/// and emits a colored warning if they differ.
pub fn check_version_compatibility(clang_filepath: &Path, llvm_config_filepath: &Path) {
    let clang_version = match execute_command_for_stdout_string(clang_filepath, &["--version"]) {
        Ok(output) => output,
        Err(_) => return,
    };

    let llvm_version = match execute_llvm_config(llvm_config_filepath, &["--version"]) {
        Ok(v) => v,
        Err(_) => return,
    };

    // clang --version output looks like: "clang version 17.0.6 ..."
    // Extract the version number after "version"
    let clang_ver_str = clang_version
        .lines()
        .next()
        .and_then(|line| {
            line.split_whitespace()
                .skip_while(|&w| w != "version")
                .nth(1)
        })
        .unwrap_or("");

    let clang_major = match parse_major_version(clang_ver_str) {
        Some(v) => v,
        None => return,
    };

    let llvm_major = match parse_major_version(&llvm_version) {
        Some(v) => v,
        None => return,
    };

    if clang_major != llvm_major {
        eprintln!(
            "{} clang version ({}, major={}) does not match LLVM tools version ({}, major={}). \
             This may cause compatibility issues.",
            "warning:".yellow().bold(),
            clang_ver_str,
            clang_major,
            llvm_version.trim(),
            llvm_major,
        );
    }
}

/// Returns a platform-specific install suggestion for the given tool.
pub fn install_suggestion(tool_name: &str) -> String {
    if cfg!(target_os = "macos") {
        format!("brew install llvm  # provides {tool_name}")
    } else if cfg!(target_os = "windows") {
        format!("choco install llvm  # provides {tool_name}")
    } else {
        // Linux (Debian/Ubuntu-style as most common)
        format!("sudo apt install llvm clang  # provides {tool_name}")
    }
}

/// Prints a colored error message for a missing tool with an install suggestion.
pub fn print_missing_tool_error(tool_name: &str, searched_path: Option<&Path>) {
    if let Some(path) = searched_path {
        eprintln!(
            "{} required tool `{}` not found at configured path: {}",
            "error:".red().bold(),
            tool_name.bold(),
            path.display(),
        );
    } else {
        eprintln!(
            "{} required tool `{}` not found on this system",
            "error:".red().bold(),
            tool_name.bold(),
        );
    }
    eprintln!(
        "  {} install it with: {}",
        "hint:".cyan().bold(),
        install_suggestion(tool_name),
    );
}

/// Prints a colored warning message.
pub fn print_warning(message: &str) {
    eprintln!("{} {message}", "warning:".yellow().bold());
}

/// Prints a colored error message.
pub fn print_error(message: &str) {
    eprintln!("{} {message}", "error:".red().bold());
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_major_version() {
        assert_eq!(parse_major_version("17.0.6"), Some(17));
        assert_eq!(parse_major_version("18.1.0"), Some(18));
        assert_eq!(parse_major_version("15"), Some(15));
        assert_eq!(parse_major_version(""), None);
        assert_eq!(parse_major_version("abc"), None);
    }

    #[test]
    fn test_install_suggestion_contains_tool_name() {
        let suggestion = install_suggestion("llvm-config");
        assert!(suggestion.contains("llvm-config"));
        assert!(suggestion.contains("llvm"));
    }
}