axbuild 0.4.15

An OS build lib toolkit used by arceos
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use std::collections::BTreeSet;

const C_DEFINE_FEATURE_PREFIX: &str = "c-define:";

pub(super) fn dynamic_pie_for_c_app(features: &[String]) -> bool {
    has_feature(features, "plat-dyn")
}

pub(super) fn c_config_features(features: &[String]) -> BTreeSet<String> {
    let mut config_features: BTreeSet<_> = features
        .iter()
        .filter_map(|feature| {
            if feature.starts_with(C_DEFINE_FEATURE_PREFIX) {
                return None;
            }
            if feature.starts_with("ax-hal/") || feature.starts_with("ax-driver/") {
                return None;
            }
            feature
                .strip_prefix("ax-libc/")
                .or_else(|| feature.strip_prefix("ax-feat/"))
                .or_else(|| feature.strip_prefix("ax-std/"))
                .or(Some(feature.as_str()))
        })
        .filter(|feature| {
            !matches!(
                *feature,
                "ax-libc" | "ax-feat" | "ax-std" | "defplat" | "myplat" | "plat-dyn"
            ) && !feature.contains('/')
        })
        .map(str::to_string)
        .collect();
    if has_feature(features, "plat-dyn") {
        config_features.insert("smp".to_string());
    }
    config_features
}

pub(super) fn c_defines(features: &[String]) -> BTreeSet<String> {
    features
        .iter()
        .filter_map(|feature| feature.strip_prefix(C_DEFINE_FEATURE_PREFIX))
        .map(str::to_string)
        .collect()
}

pub(super) fn c_compiler_features(
    cargo_features: &[String],
    case_features: &[String],
) -> Vec<String> {
    let mut features = cargo_features.to_vec();
    features.extend(
        case_features
            .iter()
            .filter(|feature| feature.starts_with(C_DEFINE_FEATURE_PREFIX))
            .cloned(),
    );
    features
}

pub(super) fn has_feature(features: &[String], name: &str) -> bool {
    features.iter().any(|feature| {
        feature == name
            || feature.strip_prefix("ax-libc/") == Some(name)
            || feature.strip_prefix("ax-feat/") == Some(name)
            || feature.strip_prefix("ax-std/") == Some(name)
    })
}

pub(super) fn c_define_name(feature: &str) -> String {
    feature.replace('-', "_").to_uppercase()
}

pub(super) fn map_c_app_features(
    case_features: &[String],
    base_features: &[String],
) -> Vec<String> {
    const LIB_FEATURES: &[&str] = &[
        "fp-simd",
        "irq",
        "alloc",
        "multitask",
        "lockdep",
        "fs",
        "net",
        "fd",
        "pipe",
        "select",
        "epoll",
    ];

    let mut features = BTreeSet::new();
    for feature in base_features {
        let normalized = feature
            .strip_prefix("ax-feat/")
            .or_else(|| feature.strip_prefix("ax-std/"))
            .or_else(|| feature.strip_prefix("ax-libc/"))
            .unwrap_or(feature);
        if feature.starts_with("ax-hal/") || feature.starts_with("ax-driver/") {
            features.insert(feature.clone());
            continue;
        }
        match normalized {
            "ax-std" | "ax-feat" | "ax-libc" => {}
            "defplat" | "myplat" | "plat-dyn" => {
                features.insert(normalized.to_string());
            }
            "smp" => {
                features.insert("smp".to_string());
            }
            feature if LIB_FEATURES.contains(&feature) => {
                features.insert(feature.to_string());
            }
            feature => {
                features.insert(format!("ax-feat/{feature}"));
            }
        }
    }
    for feature in case_features {
        if feature.starts_with(C_DEFINE_FEATURE_PREFIX) {
            continue;
        }
        let normalized = feature
            .strip_prefix("ax-feat/")
            .or_else(|| feature.strip_prefix("ax-std/"))
            .or_else(|| feature.strip_prefix("ax-libc/"))
            .unwrap_or(feature);
        if feature.starts_with("ax-hal/") || feature.starts_with("ax-driver/") {
            features.insert(feature.clone());
            continue;
        }
        if LIB_FEATURES.contains(&normalized)
            || matches!(normalized, "defplat" | "myplat" | "plat-dyn" | "smp")
        {
            features.insert(normalized.to_string());
        } else {
            features.insert(format!("ax-feat/{normalized}"));
        }
    }
    if features
        .iter()
        .any(|feature| matches!(feature.as_str(), "fs" | "net" | "pipe" | "select" | "epoll"))
    {
        features.insert("fd".to_string());
    }
    if features.contains("plat-dyn") {
        features.insert("smp".to_string());
    }
    features.into_iter().collect()
}