| 1 |
use std::env::var; |
| 2 |
use std::io::Write; |
| 3 |
|
| 4 |
/// The directory for inline asm. |
| 5 |
const ASM_PATH: &str = "src/backend/linux_raw/arch"; |
| 6 |
|
| 7 |
fn main() { |
| 8 |
// Don't rerun this on changes other than build.rs, as we only depend on |
| 9 |
// the rustc version. |
| 10 |
println!("cargo:rerun-if-changed=build.rs"); |
| 11 |
|
| 12 |
// Gather target information. |
| 13 |
let arch = var("CARGO_CFG_TARGET_ARCH").unwrap(); |
| 14 |
let env = var("CARGO_CFG_TARGET_ENV").unwrap(); |
| 15 |
let inline_asm_name = format!("{}/{}.rs", ASM_PATH, arch); |
| 16 |
let inline_asm_name_present = std::fs::metadata(inline_asm_name).is_ok(); |
| 17 |
let os = var("CARGO_CFG_TARGET_OS").unwrap(); |
| 18 |
let pointer_width = var("CARGO_CFG_TARGET_POINTER_WIDTH").unwrap(); |
| 19 |
let endian = var("CARGO_CFG_TARGET_ENDIAN").unwrap(); |
| 20 |
|
| 21 |
// Check for special target variants. |
| 22 |
let is_x32 = arch == "x86_64" && pointer_width == "32"; |
| 23 |
let is_arm64_ilp32 = arch == "aarch64" && pointer_width == "32"; |
| 24 |
let is_powerpc64be = arch == "powerpc64" && endian == "big"; |
| 25 |
let is_mipseb = (arch == "mips" || arch == "mips32r6") && endian == "big"; |
| 26 |
let is_mips64eb = arch.contains("mips64") && endian == "big"; |
| 27 |
let is_unsupported_abi = is_x32 || is_arm64_ilp32 || is_powerpc64be || is_mipseb || is_mips64eb; |
| 28 |
|
| 29 |
// Check for `--features=use-libc`. This allows crate users to enable the |
| 30 |
// libc backend. |
| 31 |
let feature_use_libc = var("CARGO_FEATURE_USE_LIBC").is_ok(); |
| 32 |
|
| 33 |
// Check for `RUSTFLAGS=--cfg=rustix_use_libc`. This allows end users to |
| 34 |
// enable the libc backend even if rustix is depended on transitively. |
| 35 |
let cfg_use_libc = var("CARGO_CFG_RUSTIX_USE_LIBC").is_ok(); |
| 36 |
|
| 37 |
// Check for `--features=rustc-dep-of-std`. |
| 38 |
let rustc_dep_of_std = var("CARGO_FEATURE_RUSTC_DEP_OF_STD").is_ok(); |
| 39 |
|
| 40 |
// Check for eg. `RUSTFLAGS=--cfg=rustix_use_experimental_features`. This |
| 41 |
// is a rustc flag rather than a cargo feature flag because it's |
| 42 |
// experimental and not something we want accidentally enabled via |
| 43 |
// `--all-features`. |
| 44 |
let rustix_use_experimental_features = |
| 45 |
var("CARGO_CFG_RUSTIX_USE_EXPERIMENTAL_FEATURES").is_ok(); |
| 46 |
|
| 47 |
// Check for eg. `RUSTFLAGS=--cfg=rustix_use_experimental_asm`. This is a |
| 48 |
// rustc flag rather than a cargo feature flag because it's experimental |
| 49 |
// and not something we want accidentally enabled via `--all-features`. |
| 50 |
let rustix_use_experimental_asm = var("CARGO_CFG_RUSTIX_USE_EXPERIMENTAL_ASM").is_ok(); |
| 51 |
|
| 52 |
// Miri doesn't support inline asm, and has builtin support for recognizing |
| 53 |
// libc FFI calls, so if we're running under miri, use the libc backend. |
| 54 |
let miri = var("CARGO_CFG_MIRI").is_ok(); |
| 55 |
|
| 56 |
// If experimental features are enabled, auto-detect and use available |
| 57 |
// features. |
| 58 |
if rustc_dep_of_std { |
| 59 |
use_feature("rustc_attrs"); |
| 60 |
use_feature("core_intrinsics"); |
| 61 |
} else if rustix_use_experimental_features { |
| 62 |
use_feature_or_nothing("rustc_attrs"); |
| 63 |
use_feature_or_nothing("core_intrinsics"); |
| 64 |
} |
| 65 |
|
| 66 |
// Features needed only in no-std configurations. |
| 67 |
#[cfg(not(feature = "std"))] |
| 68 |
{ |
| 69 |
use_feature_or_nothing("core_c_str"); |
| 70 |
use_feature_or_nothing("core_ffi_c"); |
| 71 |
use_feature_or_nothing("alloc_c_string"); |
| 72 |
use_feature_or_nothing("alloc_ffi"); |
| 73 |
} |
| 74 |
|
| 75 |
// Feature needed for testing. |
| 76 |
if use_static_assertions() { |
| 77 |
use_feature("static_assertions"); |
| 78 |
} |
| 79 |
|
| 80 |
// WASI support can utilize wasi_ext if present. |
| 81 |
if os == "wasi" { |
| 82 |
use_feature_or_nothing("wasi_ext"); |
| 83 |
} |
| 84 |
|
| 85 |
// If the libc backend is requested, or if we're not on a platform for |
| 86 |
// which we have linux_raw support, use the libc backend. |
| 87 |
// |
| 88 |
// For now Android uses the libc backend; in theory it could use the |
| 89 |
// linux_raw backend, but to do that we'll need to figure out how to |
| 90 |
// install the toolchain for it. |
| 91 |
let libc = feature_use_libc |
| 92 |
|| cfg_use_libc |
| 93 |
|| os != "linux" |
| 94 |
|| !inline_asm_name_present |
| 95 |
|| is_unsupported_abi |
| 96 |
|| miri |
| 97 |
|| ((arch == "powerpc64" || arch.starts_with("mips")) && !rustix_use_experimental_asm); |
| 98 |
if libc { |
| 99 |
// Use the libc backend. |
| 100 |
use_feature("libc"); |
| 101 |
} else { |
| 102 |
// Use the linux_raw backend. |
| 103 |
use_feature("linux_raw"); |
| 104 |
if rustix_use_experimental_asm { |
| 105 |
use_feature("asm_experimental_arch"); |
| 106 |
} |
| 107 |
} |
| 108 |
|
| 109 |
// Detect whether the compiler requires us to use thumb mode on ARM. |
| 110 |
if arch == "arm" && use_thumb_mode() { |
| 111 |
use_feature("thumb_mode"); |
| 112 |
} |
| 113 |
|
| 114 |
// Rust's libc crate groups some OS's together which have similar APIs; |
| 115 |
// create similarly-named features to make `cfg` tests more concise. |
| 116 |
let freebsdlike = os == "freebsd" || os == "dragonfly"; |
| 117 |
if freebsdlike { |
| 118 |
use_feature("freebsdlike"); |
| 119 |
} |
| 120 |
let netbsdlike = os == "openbsd" || os == "netbsd"; |
| 121 |
if netbsdlike { |
| 122 |
use_feature("netbsdlike"); |
| 123 |
} |
| 124 |
let apple = os == "macos" || os == "ios" || os == "tvos" || os == "visionos" || os == "watchos"; |
| 125 |
if apple { |
| 126 |
use_feature("apple"); |
| 127 |
} |
| 128 |
if os == "linux" || os == "l4re" || os == "android" || os == "emscripten" { |
| 129 |
use_feature("linux_like"); |
| 130 |
} |
| 131 |
if os == "solaris" || os == "illumos" { |
| 132 |
use_feature("solarish"); |
| 133 |
} |
| 134 |
if apple || freebsdlike || netbsdlike { |
| 135 |
use_feature("bsd"); |
| 136 |
} |
| 137 |
|
| 138 |
// Add some additional common target combinations. |
| 139 |
|
| 140 |
// Android and "regular" Linux both use the Linux kernel. |
| 141 |
if os == "android" || os == "linux" { |
| 142 |
use_feature("linux_kernel"); |
| 143 |
} |
| 144 |
|
| 145 |
// These platforms have a 32-bit `time_t`. |
| 146 |
if libc |
| 147 |
&& (arch == "arm" |
| 148 |
|| arch == "mips" |
| 149 |
|| arch == "sparc" |
| 150 |
|| arch == "x86" |
| 151 |
|| (arch == "wasm32" && os == "emscripten")) |
| 152 |
&& (apple |
| 153 |
|| os == "android" |
| 154 |
|| os == "emscripten" |
| 155 |
|| os == "haiku" |
| 156 |
|| env == "gnu" |
| 157 |
|| (env == "musl" && arch == "x86")) |
| 158 |
{ |
| 159 |
use_feature("fix_y2038"); |
| 160 |
} |
| 161 |
|
| 162 |
println!("cargo:rerun-if-env-changed=CARGO_CFG_RUSTIX_USE_EXPERIMENTAL_ASM"); |
| 163 |
println!("cargo:rerun-if-env-changed=CARGO_CFG_RUSTIX_USE_LIBC"); |
| 164 |
|
| 165 |
// Rerun this script if any of our features or configuration flags change, |
| 166 |
// or if the toolchain we used for feature detection changes. |
| 167 |
println!("cargo:rerun-if-env-changed=CARGO_FEATURE_USE_LIBC"); |
| 168 |
println!("cargo:rerun-if-env-changed=CARGO_FEATURE_RUSTC_DEP_OF_STD"); |
| 169 |
println!("cargo:rerun-if-env-changed=CARGO_CFG_MIRI"); |
| 170 |
} |
| 171 |
|
| 172 |
fn use_static_assertions() -> bool { |
| 173 |
// `offset_from` was made const in Rust 1.65. |
| 174 |
can_compile("const unsafe fn foo(p: *const u8) -> isize { p.offset_from(p) }") |
| 175 |
} |
| 176 |
|
| 177 |
fn use_thumb_mode() -> bool { |
| 178 |
// In thumb mode, r7 is reserved. |
| 179 |
!can_compile("pub unsafe fn f() { core::arch::asm!(\"udf #16\", in(\"r7\") 0); }") |
| 180 |
} |
| 181 |
|
| 182 |
fn use_feature_or_nothing(feature: &str) { |
| 183 |
if has_feature(feature) { |
| 184 |
use_feature(feature); |
| 185 |
} |
| 186 |
} |
| 187 |
|
| 188 |
fn use_feature(feature: &str) { |
| 189 |
println!("cargo:rustc-cfg={}", feature); |
| 190 |
} |
| 191 |
|
| 192 |
/// Test whether the rustc at `var("RUSTC")` supports the given feature. |
| 193 |
fn has_feature(feature: &str) -> bool { |
| 194 |
can_compile(format!( |
| 195 |
"#![allow(stable_features)]\n#![feature({})]", |
| 196 |
feature |
| 197 |
)) |
| 198 |
} |
| 199 |
|
| 200 |
/// Test whether the rustc at `var("RUSTC")` can compile the given code. |
| 201 |
fn can_compile<T: AsRef<str>>(test: T) -> bool { |
| 202 |
use std::process::Stdio; |
| 203 |
|
| 204 |
let out_dir = var("OUT_DIR").unwrap(); |
| 205 |
let rustc = var("RUSTC").unwrap(); |
| 206 |
let target = var("TARGET").unwrap(); |
| 207 |
|
| 208 |
// Use `RUSTC_WRAPPER` if it's set, unless it's set to an empty string, as |
| 209 |
// documented [here]. |
| 210 |
// [here]: https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-reads |
| 211 |
let wrapper = var("RUSTC_WRAPPER") |
| 212 |
.ok() |
| 213 |
.and_then(|w| if w.is_empty() { None } else { Some(w) }); |
| 214 |
|
| 215 |
let mut cmd = if let Some(wrapper) = wrapper { |
| 216 |
let mut cmd = std::process::Command::new(wrapper); |
| 217 |
// The wrapper's first argument is supposed to be the path to rustc. |
| 218 |
cmd.arg(rustc); |
| 219 |
cmd |
| 220 |
} else { |
| 221 |
std::process::Command::new(rustc) |
| 222 |
}; |
| 223 |
|
| 224 |
cmd.arg("--crate-type=rlib") // Don't require `main`. |
| 225 |
.arg("--emit=metadata") // Do as little as possible but still parse. |
| 226 |
.arg("--target") |
| 227 |
.arg(target) |
| 228 |
.arg("--out-dir") |
| 229 |
.arg(out_dir); // Put the output somewhere inconsequential. |
| 230 |
|
| 231 |
// If Cargo wants to set RUSTFLAGS, use that. |
| 232 |
if let Ok(rustflags) = var("CARGO_ENCODED_RUSTFLAGS") { |
| 233 |
if !rustflags.is_empty() { |
| 234 |
for arg in rustflags.split('\x1f') { |
| 235 |
cmd.arg(arg); |
| 236 |
} |
| 237 |
} |
| 238 |
} |
| 239 |
|
| 240 |
let mut child = cmd |
| 241 |
.arg("-") // Read from stdin. |
| 242 |
.stdin(Stdio::piped()) // Stdin is a pipe. |
| 243 |
.stderr(Stdio::null()) // Errors from feature detection aren't interesting and can be confusing. |
| 244 |
.spawn() |
| 245 |
.unwrap(); |
| 246 |
|
| 247 |
writeln!(child.stdin.take().unwrap(), "{}", test.as_ref()).unwrap(); |
| 248 |
|
| 249 |
child.wait().unwrap().success() |
| 250 |
} |