1use std::env;
2use std::process::Command;
3use std::str;
4use std::string::String;
5
6// List of cfgs this build script is allowed to set. The list is needed to support check-cfg, as we
7// need to know all the possible cfgs that this script will set. If you need to set another cfg
8// make sure to add it to this list as well.
9const ALLOWED_CFGS: &'static [&'static str] = &[
10 "emscripten_new_stat_abi",
11 "freebsd10",
12 "freebsd11",
13 "freebsd12",
14 "freebsd13",
15 "freebsd14",
16 "libc_align",
17 "libc_cfg_target_vendor",
18 "libc_const_extern_fn",
19 "libc_const_extern_fn_unstable",
20 "libc_const_size_of",
21 "libc_core_cvoid",
22 "libc_deny_warnings",
23 "libc_int128",
24 "libc_long_array",
25 "libc_non_exhaustive",
26 "libc_packedN",
27 "libc_priv_mod_use",
28 "libc_ptr_addr_of",
29 "libc_thread_local",
30 "libc_underscore_const_names",
31 "libc_union",
32];
33
34// Extra values to allow for check-cfg.
35const CHECK_CFG_EXTRA: &'static [(&'static str, &'static [&'static str])] = &[
36 ("target_os", &["switch", "aix", "ohos", "hurd"]),
37 ("target_env", &["illumos", "wasi", "aix", "ohos"]),
38 (
39 "target_arch",
40 &["loongarch64", "mips32r6", "mips64r6", "csky"],
41 ),
42];
43
44fn main() {
45 // Avoid unnecessary re-building.
46 println!("cargo:rerun-if-changed=build.rs");
47
48 let (rustc_minor_ver, is_nightly) = rustc_minor_nightly();
49 let rustc_dep_of_std = env::var("CARGO_FEATURE_RUSTC_DEP_OF_STD").is_ok();
50 let align_cargo_feature = env::var("CARGO_FEATURE_ALIGN").is_ok();
51 let const_extern_fn_cargo_feature = env::var("CARGO_FEATURE_CONST_EXTERN_FN").is_ok();
52 let libc_ci = env::var("LIBC_CI").is_ok();
53 let libc_check_cfg = env::var("LIBC_CHECK_CFG").is_ok();
54
55 if env::var("CARGO_FEATURE_USE_STD").is_ok() {
56 println!(
57 "cargo:warning=\"libc's use_std cargo feature is deprecated since libc 0.2.55; \
58 please consider using the `std` cargo feature instead\""
59 );
60 }
61
62 // The ABI of libc used by std is backward compatible with FreeBSD 12.
63 // The ABI of libc from crates.io is backward compatible with FreeBSD 11.
64 //
65 // On CI, we detect the actual FreeBSD version and match its ABI exactly,
66 // running tests to ensure that the ABI is correct.
67 match which_freebsd() {
68 Some(10) if libc_ci => set_cfg("freebsd10"),
69 Some(11) if libc_ci => set_cfg("freebsd11"),
70 Some(12) if libc_ci || rustc_dep_of_std => set_cfg("freebsd12"),
71 Some(13) if libc_ci => set_cfg("freebsd13"),
72 Some(14) if libc_ci => set_cfg("freebsd14"),
73 Some(_) | None => set_cfg("freebsd11"),
74 }
75
76 match emcc_version_code() {
77 Some(v) if (v >= 30142) => set_cfg("emscripten_new_stat_abi"),
78 // Non-Emscripten or version < 3.1.42.
79 Some(_) | None => (),
80 }
81
82 // On CI: deny all warnings
83 if libc_ci {
84 set_cfg("libc_deny_warnings");
85 }
86
87 // Rust >= 1.15 supports private module use:
88 if rustc_minor_ver >= 15 || rustc_dep_of_std {
89 set_cfg("libc_priv_mod_use");
90 }
91
92 // Rust >= 1.19 supports unions:
93 if rustc_minor_ver >= 19 || rustc_dep_of_std {
94 set_cfg("libc_union");
95 }
96
97 // Rust >= 1.24 supports const mem::size_of:
98 if rustc_minor_ver >= 24 || rustc_dep_of_std {
99 set_cfg("libc_const_size_of");
100 }
101
102 // Rust >= 1.25 supports repr(align):
103 if rustc_minor_ver >= 25 || rustc_dep_of_std || align_cargo_feature {
104 set_cfg("libc_align");
105 }
106
107 // Rust >= 1.26 supports i128 and u128:
108 if rustc_minor_ver >= 26 || rustc_dep_of_std {
109 set_cfg("libc_int128");
110 }
111
112 // Rust >= 1.30 supports `core::ffi::c_void`, so libc can just re-export it.
113 // Otherwise, it defines an incompatible type to retaining
114 // backwards-compatibility.
115 if rustc_minor_ver >= 30 || rustc_dep_of_std {
116 set_cfg("libc_core_cvoid");
117 }
118
119 // Rust >= 1.33 supports repr(packed(N)) and cfg(target_vendor).
120 if rustc_minor_ver >= 33 || rustc_dep_of_std {
121 set_cfg("libc_packedN");
122 set_cfg("libc_cfg_target_vendor");
123 }
124
125 // Rust >= 1.40 supports #[non_exhaustive].
126 if rustc_minor_ver >= 40 || rustc_dep_of_std {
127 set_cfg("libc_non_exhaustive");
128 }
129
130 // Rust >= 1.47 supports long array:
131 if rustc_minor_ver >= 47 || rustc_dep_of_std {
132 set_cfg("libc_long_array");
133 }
134
135 if rustc_minor_ver >= 51 || rustc_dep_of_std {
136 set_cfg("libc_ptr_addr_of");
137 }
138
139 // Rust >= 1.37.0 allows underscores as anonymous constant names.
140 if rustc_minor_ver >= 37 || rustc_dep_of_std {
141 set_cfg("libc_underscore_const_names");
142 }
143
144 // #[thread_local] is currently unstable
145 if rustc_dep_of_std {
146 set_cfg("libc_thread_local");
147 }
148
149 // Rust >= 1.62.0 allows to use `const_extern_fn` for "Rust" and "C".
150 if rustc_minor_ver >= 62 {
151 set_cfg("libc_const_extern_fn");
152 } else {
153 // Rust < 1.62.0 requires a crate feature and feature gate.
154 if const_extern_fn_cargo_feature {
155 if !is_nightly || rustc_minor_ver < 40 {
156 panic!("const-extern-fn requires a nightly compiler >= 1.40");
157 }
158 set_cfg("libc_const_extern_fn_unstable");
159 set_cfg("libc_const_extern_fn");
160 }
161 }
162
163 // check-cfg is a nightly cargo/rustc feature to warn when unknown cfgs are used across the
164 // codebase. libc can configure it if the appropriate environment variable is passed. Since
165 // rust-lang/rust enforces it, this is useful when using a custom libc fork there.
166 //
167 // https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#check-cfg
168 if libc_check_cfg {
169 for cfg in ALLOWED_CFGS {
170 if rustc_minor_ver >= 75 {
171 println!("cargo:rustc-check-cfg=cfg({})", cfg);
172 } else {
173 println!("cargo:rustc-check-cfg=values({})", cfg);
174 }
175 }
176 for &(name, values) in CHECK_CFG_EXTRA {
177 let values = values.join("\",\"");
178 if rustc_minor_ver >= 75 {
179 println!("cargo:rustc-check-cfg=cfg({},values(\"{}\"))", name, values);
180 } else {
181 println!("cargo:rustc-check-cfg=values({},\"{}\")", name, values);
182 }
183 }
184 }
185}
186
187fn rustc_minor_nightly() -> (u32, bool) {
188 macro_rules! otry {
189 ($e:expr) => {
190 match $e {
191 Some(e) => e,
192 None => panic!("Failed to get rustc version"),
193 }
194 };
195 }
196
197 let rustc = otry!(env::var_os("RUSTC"));
198 let output = Command::new(rustc)
199 .arg("--version")
200 .output()
201 .ok()
202 .expect("Failed to get rustc version");
203 if !output.status.success() {
204 panic!(
205 "failed to run rustc: {}",
206 String::from_utf8_lossy(output.stderr.as_slice())
207 );
208 }
209
210 let version = otry!(str::from_utf8(&output.stdout).ok());
211 let mut pieces = version.split('.');
212
213 if pieces.next() != Some("rustc 1") {
214 panic!("Failed to get rustc version");
215 }
216
217 let minor = pieces.next();
218
219 // If `rustc` was built from a tarball, its version string
220 // will have neither a git hash nor a commit date
221 // (e.g. "rustc 1.39.0"). Treat this case as non-nightly,
222 // since a nightly build should either come from CI
223 // or a git checkout
224 let nightly_raw = otry!(pieces.next()).split('-').nth(1);
225 let nightly = nightly_raw
226 .map(|raw| raw.starts_with("dev") || raw.starts_with("nightly"))
227 .unwrap_or(false);
228 let minor = otry!(otry!(minor).parse().ok());
229
230 (minor, nightly)
231}
232
233fn which_freebsd() -> Option<i32> {
234 let output = std::process::Command::new("freebsd-version").output().ok();
235 if output.is_none() {
236 return None;
237 }
238 let output = output.unwrap();
239 if !output.status.success() {
240 return None;
241 }
242
243 let stdout = String::from_utf8(output.stdout).ok();
244 if stdout.is_none() {
245 return None;
246 }
247 let stdout = stdout.unwrap();
248
249 match &stdout {
250 s if s.starts_with("10") => Some(10),
251 s if s.starts_with("11") => Some(11),
252 s if s.starts_with("12") => Some(12),
253 s if s.starts_with("13") => Some(13),
254 s if s.starts_with("14") => Some(14),
255 _ => None,
256 }
257}
258
259fn emcc_version_code() -> Option<u64> {
260 let output = std::process::Command::new("emcc")
261 .arg("-dumpversion")
262 .output()
263 .ok();
264 if output.is_none() {
265 return None;
266 }
267 let output = output.unwrap();
268 if !output.status.success() {
269 return None;
270 }
271
272 let stdout = String::from_utf8(output.stdout).ok();
273 if stdout.is_none() {
274 return None;
275 }
276 let version = stdout.unwrap();
277 let mut pieces = version.trim().split('.');
278
279 let major = pieces.next().and_then(|x| x.parse().ok()).unwrap_or(0);
280 let minor = pieces.next().and_then(|x| x.parse().ok()).unwrap_or(0);
281 let patch = pieces.next().and_then(|x| x.parse().ok()).unwrap_or(0);
282
283 Some(major * 10000 + minor * 100 + patch)
284}
285
286fn set_cfg(cfg: &str) {
287 if !ALLOWED_CFGS.contains(&cfg) {
288 panic!("trying to set cfg {}, but it is not in ALLOWED_CFGS", cfg);
289 }
290 println!("cargo:rustc-cfg={}", cfg);
291}
292