1 //! Performs autodetection of the host for the purposes of running
2 //! Cranelift to generate code to run on the same machine.
3
4 #![deny(missing_docs)]
5
6 use cranelift_codegen::isa;
7 use cranelift_codegen::settings::Configurable;
8 use target_lexicon::Triple;
9
10 #[cfg(all(target_arch = "riscv64", target_os = "linux"))]
11 mod riscv;
12
13 /// Return an `isa` builder configured for the current host
14 /// machine, or `Err(())` if the host machine is not supported
15 /// in the current configuration.
builder() -> Result<isa::Builder, &'static str>16 pub fn builder() -> Result<isa::Builder, &'static str> {
17 builder_with_options(true)
18 }
19
20 /// Return an `isa` builder configured for the current host
21 /// machine, or `Err(())` if the host machine is not supported
22 /// in the current configuration.
23 ///
24 /// Selects the given backend variant specifically; this is
25 /// useful when more than one backend exists for a given target
26 /// (e.g., on x86-64).
builder_with_options(infer_native_flags: bool) -> Result<isa::Builder, &'static str>27 pub fn builder_with_options(infer_native_flags: bool) -> Result<isa::Builder, &'static str> {
28 let mut isa_builder = isa::lookup(Triple::host()).map_err(|err| match err {
29 isa::LookupError::SupportDisabled => "support for architecture disabled at compile time",
30 isa::LookupError::Unsupported => "unsupported architecture",
31 })?;
32 if infer_native_flags {
33 self::infer_native_flags(&mut isa_builder)?;
34 }
35 Ok(isa_builder)
36 }
37
38 /// Return an `isa` builder configured for the current host
39 /// machine, or `Err(())` if the host machine is not supported
40 /// in the current configuration.
41 ///
42 /// Selects the given backend variant specifically; this is
43 /// useful when more than one backend exists for a given target
44 /// (e.g., on x86-64).
infer_native_flags(isa_builder: &mut dyn Configurable) -> Result<(), &'static str>45 pub fn infer_native_flags(isa_builder: &mut dyn Configurable) -> Result<(), &'static str> {
46 #[cfg(target_arch = "x86_64")]
47 {
48 if !std::is_x86_feature_detected!("sse2") {
49 return Err("x86 support requires SSE2");
50 }
51
52 if std::is_x86_feature_detected!("cmpxchg16b") {
53 isa_builder.enable("has_cmpxchg16b").unwrap();
54 }
55 if std::is_x86_feature_detected!("sse3") {
56 isa_builder.enable("has_sse3").unwrap();
57 }
58 if std::is_x86_feature_detected!("ssse3") {
59 isa_builder.enable("has_ssse3").unwrap();
60 }
61 if std::is_x86_feature_detected!("sse4.1") {
62 isa_builder.enable("has_sse41").unwrap();
63 }
64 if std::is_x86_feature_detected!("sse4.2") {
65 isa_builder.enable("has_sse42").unwrap();
66 }
67 if std::is_x86_feature_detected!("popcnt") {
68 isa_builder.enable("has_popcnt").unwrap();
69 }
70 if std::is_x86_feature_detected!("avx") {
71 isa_builder.enable("has_avx").unwrap();
72 }
73 if std::is_x86_feature_detected!("avx2") {
74 isa_builder.enable("has_avx2").unwrap();
75 }
76 if std::is_x86_feature_detected!("fma") {
77 isa_builder.enable("has_fma").unwrap();
78 }
79 if std::is_x86_feature_detected!("bmi1") {
80 isa_builder.enable("has_bmi1").unwrap();
81 }
82 if std::is_x86_feature_detected!("bmi2") {
83 isa_builder.enable("has_bmi2").unwrap();
84 }
85 if std::is_x86_feature_detected!("avx512bitalg") {
86 isa_builder.enable("has_avx512bitalg").unwrap();
87 }
88 if std::is_x86_feature_detected!("avx512dq") {
89 isa_builder.enable("has_avx512dq").unwrap();
90 }
91 if std::is_x86_feature_detected!("avx512f") {
92 isa_builder.enable("has_avx512f").unwrap();
93 }
94 if std::is_x86_feature_detected!("avx512vl") {
95 isa_builder.enable("has_avx512vl").unwrap();
96 }
97 if std::is_x86_feature_detected!("avx512vbmi") {
98 isa_builder.enable("has_avx512vbmi").unwrap();
99 }
100 if std::is_x86_feature_detected!("lzcnt") {
101 isa_builder.enable("has_lzcnt").unwrap();
102 }
103 }
104
105 #[cfg(target_arch = "aarch64")]
106 {
107 if std::arch::is_aarch64_feature_detected!("lse") {
108 isa_builder.enable("has_lse").unwrap();
109 }
110
111 if std::arch::is_aarch64_feature_detected!("paca") {
112 isa_builder.enable("has_pauth").unwrap();
113 }
114
115 if std::arch::is_aarch64_feature_detected!("fp16") {
116 isa_builder.enable("has_fp16").unwrap();
117 }
118
119 if cfg!(target_os = "macos") {
120 // Pointer authentication is always available on Apple Silicon.
121 isa_builder.enable("sign_return_address").unwrap();
122 // macOS enforces the use of the B key for return addresses.
123 isa_builder.enable("sign_return_address_with_bkey").unwrap();
124 }
125 }
126
127 // `is_s390x_feature_detected` is nightly only for now, so use the
128 // STORE FACILITY LIST EXTENDED instruction as a temporary measure.
129 #[cfg(target_arch = "s390x")]
130 {
131 let mut facility_list: [u64; 4] = [0; 4];
132 unsafe {
133 core::arch::asm!(
134 "stfle 0({})",
135 in(reg_addr) facility_list.as_mut_ptr() ,
136 inout("r0") facility_list.len() as u64 - 1 => _,
137 options(nostack)
138 );
139 }
140 let get_facility_bit = |n: usize| {
141 // NOTE: bits are numbered from the left.
142 facility_list[n / 64] & (1 << (63 - (n % 64))) != 0
143 };
144
145 if get_facility_bit(61) {
146 isa_builder.enable("has_mie3").unwrap();
147 }
148 if get_facility_bit(84) {
149 isa_builder.enable("has_mie4").unwrap();
150 }
151 if get_facility_bit(148) {
152 isa_builder.enable("has_vxrs_ext2").unwrap();
153 }
154 if get_facility_bit(198) {
155 isa_builder.enable("has_vxrs_ext3").unwrap();
156 }
157 }
158
159 // `is_riscv_feature_detected` is nightly only for now, use
160 // getauxval from the libc crate directly as a temporary measure.
161 #[cfg(all(target_arch = "riscv64", target_os = "linux"))]
162 {
163 // Try both hwcap and cpuinfo
164 // HWCAP only returns single letter extensions, cpuinfo returns all of
165 // them but may not be available in some systems (QEMU < 8.1).
166 riscv::hwcap_detect(isa_builder)?;
167
168 // Ignore errors for cpuinfo. QEMU versions prior to 8.1 do not emulate
169 // the cpuinfo interface, so we can't rely on it being present for now.
170 let _ = riscv::cpuinfo_detect(isa_builder);
171 }
172
173 // On all other architectures (e.g. wasm32) we won't infer any native flags,
174 // but still need to use the `isa_builder` to avoid compiler warnings.
175 let _ = isa_builder;
176 Ok(())
177 }
178
179 /// Version number of this crate.
180 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
181
182 #[cfg(test)]
183 mod tests {
184 use super::builder;
185 use cranelift_codegen::isa::CallConv;
186 use cranelift_codegen::settings;
187
188 #[test]
test()189 fn test() {
190 if let Ok(isa_builder) = builder() {
191 let flag_builder = settings::builder();
192 let isa = isa_builder
193 .finish(settings::Flags::new(flag_builder))
194 .unwrap();
195
196 if cfg!(all(target_os = "macos", target_arch = "aarch64")) {
197 assert_eq!(isa.default_call_conv(), CallConv::AppleAarch64);
198 } else if cfg!(unix) {
199 assert_eq!(isa.default_call_conv(), CallConv::SystemV);
200 } else if cfg!(windows) {
201 assert_eq!(isa.default_call_conv(), CallConv::WindowsFastcall);
202 }
203
204 if cfg!(target_pointer_width = "64") {
205 assert_eq!(isa.pointer_bits(), 64);
206 } else if cfg!(target_pointer_width = "32") {
207 assert_eq!(isa.pointer_bits(), 32);
208 } else if cfg!(target_pointer_width = "16") {
209 assert_eq!(isa.pointer_bits(), 16);
210 }
211 }
212 }
213 }
214