use std::{collections::BTreeMap, env, sync::atomic::Ordering}; fn main() { println!("cargo:rerun-if-changed=build.rs"); let target = env::var("TARGET").unwrap(); let cwd = env::current_dir().unwrap(); println!("cargo:compiler-rt={}", cwd.join("compiler-rt").display()); // Activate libm's unstable features to make full use of Nightly. println!("cargo:rustc-cfg=feature=\"unstable\""); // Emscripten's runtime includes all the builtins if target.contains("emscripten") { return; } // OpenBSD provides compiler_rt by default, use it instead of rebuilding it from source if target.contains("openbsd") { println!("cargo:rustc-link-search=native=/usr/lib"); println!("cargo:rustc-link-lib=compiler_rt"); return; } // Forcibly enable memory intrinsics on wasm & SGX as we don't have a libc to // provide them. if (target.contains("wasm") && !target.contains("wasi")) || (target.contains("sgx") && target.contains("fortanix")) || target.contains("-none") || target.contains("nvptx") || target.contains("uefi") || target.contains("xous") { println!("cargo:rustc-cfg=feature=\"mem\""); } // These targets have hardware unaligned access support. if target.contains("x86_64") || target.contains("i686") || target.contains("aarch64") || target.contains("bpf") { println!("cargo:rustc-cfg=feature=\"mem-unaligned\""); } // NOTE we are going to assume that llvm-target, what determines our codegen option, matches the // target triple. This is usually correct for our built-in targets but can break in presence of // custom targets, which can have arbitrary names. let llvm_target = target.split('-').collect::>(); // Build missing intrinsics from compiler-rt C source code. If we're // mangling names though we assume that we're also in test mode so we don't // build anything and we rely on the upstream implementation of compiler-rt // functions if !cfg!(feature = "mangled-names") && cfg!(feature = "c") { // Don't use a C compiler for these targets: // // * wasm - clang for wasm is somewhat hard to come by and it's // unlikely that the C is really that much better than our own Rust. // * nvptx - everything is bitcode, not compatible with mixed C/Rust // * riscv - the rust-lang/rust distribution container doesn't have a C // compiler. if !target.contains("wasm") && !target.contains("nvptx") && (!target.starts_with("riscv") || target.contains("xous")) { #[cfg(feature = "c")] c::compile(&llvm_target, &target); } } // To compile intrinsics.rs for thumb targets, where there is no libc if llvm_target[0].starts_with("thumb") { println!("cargo:rustc-cfg=thumb") } // compiler-rt `cfg`s away some intrinsics for thumbv6m and thumbv8m.base because // these targets do not have full Thumb-2 support but only original Thumb-1. // We have to cfg our code accordingly. if llvm_target[0] == "thumbv6m" || llvm_target[0] == "thumbv8m.base" { println!("cargo:rustc-cfg=thumb_1") } // Only emit the ARM Linux atomic emulation on pre-ARMv6 architectures. This // includes the old androideabi. It is deprecated but it is available as a // rustc target (arm-linux-androideabi). if llvm_target[0] == "armv4t" || llvm_target[0] == "armv5te" || target == "arm-linux-androideabi" { println!("cargo:rustc-cfg=kernel_user_helpers") } if llvm_target[0].starts_with("aarch64") { generate_aarch64_outlined_atomics(); } } fn aarch64_symbol(ordering: Ordering) -> &'static str { match ordering { Ordering::Relaxed => "relax", Ordering::Acquire => "acq", Ordering::Release => "rel", Ordering::AcqRel => "acq_rel", _ => panic!("unknown symbol for {:?}", ordering), } } /// The `concat_idents` macro is extremely annoying and doesn't allow us to define new items. /// Define them from the build script instead. /// Note that the majority of the code is still defined in `aarch64.rs` through inline macros. fn generate_aarch64_outlined_atomics() { use std::fmt::Write; // #[macro_export] so that we can use this in tests let gen_macro = |name| format!("#[macro_export] macro_rules! foreach_{name} {{ ($macro:path) => {{\n"); // Generate different macros for add/clr/eor/set so that we can test them separately. let sym_names = ["cas", "ldadd", "ldclr", "ldeor", "ldset", "swp"]; let mut macros = BTreeMap::new(); for sym in sym_names { macros.insert(sym, gen_macro(sym)); } // Only CAS supports 16 bytes, and it has a different implementation that uses a different macro. let mut cas16 = gen_macro("cas16"); for ordering in [ Ordering::Relaxed, Ordering::Acquire, Ordering::Release, Ordering::AcqRel, ] { let sym_ordering = aarch64_symbol(ordering); for size in [1, 2, 4, 8] { for (sym, macro_) in &mut macros { let name = format!("__aarch64_{sym}{size}_{sym_ordering}"); writeln!(macro_, "$macro!( {ordering:?}, {size}, {name} );").unwrap(); } } let name = format!("__aarch64_cas16_{sym_ordering}"); writeln!(cas16, "$macro!( {ordering:?}, {name} );").unwrap(); } let mut buf = String::new(); for macro_def in macros.values().chain(std::iter::once(&cas16)) { buf += macro_def; buf += "}; }\n"; } let dst = std::env::var("OUT_DIR").unwrap() + "/outlined_atomics.rs"; std::fs::write(dst, buf).unwrap(); } #[cfg(feature = "c")] mod c { extern crate cc; use std::collections::{BTreeMap, HashSet}; use std::env; use std::fs::{self, File}; use std::io::Write; use std::path::{Path, PathBuf}; struct Sources { // SYMBOL -> PATH TO SOURCE map: BTreeMap<&'static str, &'static str>, } impl Sources { fn new() -> Sources { Sources { map: BTreeMap::new(), } } fn extend(&mut self, sources: &[(&'static str, &'static str)]) { // NOTE Some intrinsics have both a generic implementation (e.g. // `floatdidf.c`) and an arch optimized implementation // (`x86_64/floatdidf.c`). In those cases, we keep the arch optimized // implementation and discard the generic implementation. If we don't // and keep both implementations, the linker will yell at us about // duplicate symbols! for (symbol, src) in sources { if src.contains("/") { // Arch-optimized implementation (preferred) self.map.insert(symbol, src); } else { // Generic implementation if !self.map.contains_key(symbol) { self.map.insert(symbol, src); } } } } fn remove(&mut self, symbols: &[&str]) { for symbol in symbols { self.map.remove(*symbol).unwrap(); } } } /// Compile intrinsics from the compiler-rt C source code pub fn compile(llvm_target: &[&str], target: &String) { let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap(); let target_env = env::var("CARGO_CFG_TARGET_ENV").unwrap(); let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap(); let target_vendor = env::var("CARGO_CFG_TARGET_VENDOR").unwrap(); let mut consider_float_intrinsics = true; let cfg = &mut cc::Build::new(); // AArch64 GCCs exit with an error condition when they encounter any kind of floating point // code if the `nofp` and/or `nosimd` compiler flags have been set. // // Therefore, evaluate if those flags are present and set a boolean that causes any // compiler-rt intrinsics that contain floating point source to be excluded for this target. if target_arch == "aarch64" { let cflags_key = String::from("CFLAGS_") + &(target.to_owned().replace("-", "_")); if let Ok(cflags_value) = env::var(cflags_key) { if cflags_value.contains("+nofp") || cflags_value.contains("+nosimd") { consider_float_intrinsics = false; } } } cfg.warnings(false); if target_env == "msvc" { // Don't pull in extra libraries on MSVC cfg.flag("/Zl"); // Emulate C99 and C++11's __func__ for MSVC prior to 2013 CTP cfg.define("__func__", Some("__FUNCTION__")); } else { // Turn off various features of gcc and such, mostly copying // compiler-rt's build system already cfg.flag("-fno-builtin"); cfg.flag("-fvisibility=hidden"); cfg.flag("-ffreestanding"); // Avoid the following warning appearing once **per file**: // clang: warning: optimization flag '-fomit-frame-pointer' is not supported for target 'armv7' [-Wignored-optimization-argument] // // Note that compiler-rt's build system also checks // // `check_cxx_compiler_flag(-fomit-frame-pointer COMPILER_RT_HAS_FOMIT_FRAME_POINTER_FLAG)` // // in https://github.com/rust-lang/compiler-rt/blob/c8fbcb3/cmake/config-ix.cmake#L19. cfg.flag_if_supported("-fomit-frame-pointer"); cfg.define("VISIBILITY_HIDDEN", None); } // int_util.c tries to include stdlib.h if `_WIN32` is defined, // which it is when compiling UEFI targets with clang. This is // at odds with compiling with `-ffreestanding`, as the header // may be incompatible or not present. Create a minimal stub // header to use instead. if target_os == "uefi" { let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap()); let include_dir = out_dir.join("include"); if !include_dir.exists() { fs::create_dir(&include_dir).unwrap(); } fs::write(include_dir.join("stdlib.h"), "#include ").unwrap(); cfg.flag(&format!("-I{}", include_dir.to_str().unwrap())); } let mut sources = Sources::new(); sources.extend(&[ ("__absvdi2", "absvdi2.c"), ("__absvsi2", "absvsi2.c"), ("__addvdi3", "addvdi3.c"), ("__addvsi3", "addvsi3.c"), ("__clzdi2", "clzdi2.c"), ("__clzsi2", "clzsi2.c"), ("__cmpdi2", "cmpdi2.c"), ("__ctzdi2", "ctzdi2.c"), ("__ctzsi2", "ctzsi2.c"), ("__int_util", "int_util.c"), ("__mulvdi3", "mulvdi3.c"), ("__mulvsi3", "mulvsi3.c"), ("__negdi2", "negdi2.c"), ("__negvdi2", "negvdi2.c"), ("__negvsi2", "negvsi2.c"), ("__paritydi2", "paritydi2.c"), ("__paritysi2", "paritysi2.c"), ("__popcountdi2", "popcountdi2.c"), ("__popcountsi2", "popcountsi2.c"), ("__subvdi3", "subvdi3.c"), ("__subvsi3", "subvsi3.c"), ("__ucmpdi2", "ucmpdi2.c"), ]); if consider_float_intrinsics { sources.extend(&[ ("__divdc3", "divdc3.c"), ("__divsc3", "divsc3.c"), ("__divxc3", "divxc3.c"), ("__extendhfsf2", "extendhfsf2.c"), ("__muldc3", "muldc3.c"), ("__mulsc3", "mulsc3.c"), ("__mulxc3", "mulxc3.c"), ("__negdf2", "negdf2.c"), ("__negsf2", "negsf2.c"), ("__powixf2", "powixf2.c"), ("__truncdfhf2", "truncdfhf2.c"), ("__truncsfhf2", "truncsfhf2.c"), ]); } // When compiling in rustbuild (the rust-lang/rust repo) this library // also needs to satisfy intrinsics that jemalloc or C in general may // need, so include a few more that aren't typically needed by // LLVM/Rust. if cfg!(feature = "rustbuild") { sources.extend(&[("__ffsdi2", "ffsdi2.c")]); } // On iOS and 32-bit OSX these are all just empty intrinsics, no need to // include them. if target_os != "ios" && target_os != "watchos" && target_os != "tvos" && (target_vendor != "apple" || target_arch != "x86") { sources.extend(&[ ("__absvti2", "absvti2.c"), ("__addvti3", "addvti3.c"), ("__clzti2", "clzti2.c"), ("__cmpti2", "cmpti2.c"), ("__ctzti2", "ctzti2.c"), ("__ffsti2", "ffsti2.c"), ("__mulvti3", "mulvti3.c"), ("__negti2", "negti2.c"), ("__parityti2", "parityti2.c"), ("__popcountti2", "popcountti2.c"), ("__subvti3", "subvti3.c"), ("__ucmpti2", "ucmpti2.c"), ]); if consider_float_intrinsics { sources.extend(&[("__negvti2", "negvti2.c")]); } } if target_vendor == "apple" { sources.extend(&[ ("atomic_flag_clear", "atomic_flag_clear.c"), ("atomic_flag_clear_explicit", "atomic_flag_clear_explicit.c"), ("atomic_flag_test_and_set", "atomic_flag_test_and_set.c"), ( "atomic_flag_test_and_set_explicit", "atomic_flag_test_and_set_explicit.c", ), ("atomic_signal_fence", "atomic_signal_fence.c"), ("atomic_thread_fence", "atomic_thread_fence.c"), ]); } if target_env == "msvc" { if target_arch == "x86_64" { sources.extend(&[("__floatdixf", "x86_64/floatdixf.c")]); } } else { // None of these seem to be used on x86_64 windows, and they've all // got the wrong ABI anyway, so we want to avoid them. if target_os != "windows" { if target_arch == "x86_64" { sources.extend(&[ ("__floatdixf", "x86_64/floatdixf.c"), ("__floatundixf", "x86_64/floatundixf.S"), ]); } } if target_arch == "x86" { sources.extend(&[ ("__ashldi3", "i386/ashldi3.S"), ("__ashrdi3", "i386/ashrdi3.S"), ("__divdi3", "i386/divdi3.S"), ("__floatdixf", "i386/floatdixf.S"), ("__floatundixf", "i386/floatundixf.S"), ("__lshrdi3", "i386/lshrdi3.S"), ("__moddi3", "i386/moddi3.S"), ("__muldi3", "i386/muldi3.S"), ("__udivdi3", "i386/udivdi3.S"), ("__umoddi3", "i386/umoddi3.S"), ]); } } if target_arch == "arm" && target_os != "ios" && target_os != "watchos" && target_os != "tvos" && target_env != "msvc" { sources.extend(&[ ("__aeabi_div0", "arm/aeabi_div0.c"), ("__aeabi_drsub", "arm/aeabi_drsub.c"), ("__aeabi_frsub", "arm/aeabi_frsub.c"), ("__bswapdi2", "arm/bswapdi2.S"), ("__bswapsi2", "arm/bswapsi2.S"), ("__clzdi2", "arm/clzdi2.S"), ("__clzsi2", "arm/clzsi2.S"), ("__divmodsi4", "arm/divmodsi4.S"), ("__divsi3", "arm/divsi3.S"), ("__modsi3", "arm/modsi3.S"), ("__switch16", "arm/switch16.S"), ("__switch32", "arm/switch32.S"), ("__switch8", "arm/switch8.S"), ("__switchu8", "arm/switchu8.S"), ("__sync_synchronize", "arm/sync_synchronize.S"), ("__udivmodsi4", "arm/udivmodsi4.S"), ("__udivsi3", "arm/udivsi3.S"), ("__umodsi3", "arm/umodsi3.S"), ]); if target_os == "freebsd" { sources.extend(&[("__clear_cache", "clear_cache.c")]); } // First of all aeabi_cdcmp and aeabi_cfcmp are never called by LLVM. // Second are little-endian only, so build fail on big-endian targets. // Temporally workaround: exclude these files for big-endian targets. if !llvm_target[0].starts_with("thumbeb") && !llvm_target[0].starts_with("armeb") { sources.extend(&[ ("__aeabi_cdcmp", "arm/aeabi_cdcmp.S"), ("__aeabi_cdcmpeq_check_nan", "arm/aeabi_cdcmpeq_check_nan.c"), ("__aeabi_cfcmp", "arm/aeabi_cfcmp.S"), ("__aeabi_cfcmpeq_check_nan", "arm/aeabi_cfcmpeq_check_nan.c"), ]); } } if llvm_target[0] == "armv7" { sources.extend(&[ ("__sync_fetch_and_add_4", "arm/sync_fetch_and_add_4.S"), ("__sync_fetch_and_add_8", "arm/sync_fetch_and_add_8.S"), ("__sync_fetch_and_and_4", "arm/sync_fetch_and_and_4.S"), ("__sync_fetch_and_and_8", "arm/sync_fetch_and_and_8.S"), ("__sync_fetch_and_max_4", "arm/sync_fetch_and_max_4.S"), ("__sync_fetch_and_max_8", "arm/sync_fetch_and_max_8.S"), ("__sync_fetch_and_min_4", "arm/sync_fetch_and_min_4.S"), ("__sync_fetch_and_min_8", "arm/sync_fetch_and_min_8.S"), ("__sync_fetch_and_nand_4", "arm/sync_fetch_and_nand_4.S"), ("__sync_fetch_and_nand_8", "arm/sync_fetch_and_nand_8.S"), ("__sync_fetch_and_or_4", "arm/sync_fetch_and_or_4.S"), ("__sync_fetch_and_or_8", "arm/sync_fetch_and_or_8.S"), ("__sync_fetch_and_sub_4", "arm/sync_fetch_and_sub_4.S"), ("__sync_fetch_and_sub_8", "arm/sync_fetch_and_sub_8.S"), ("__sync_fetch_and_umax_4", "arm/sync_fetch_and_umax_4.S"), ("__sync_fetch_and_umax_8", "arm/sync_fetch_and_umax_8.S"), ("__sync_fetch_and_umin_4", "arm/sync_fetch_and_umin_4.S"), ("__sync_fetch_and_umin_8", "arm/sync_fetch_and_umin_8.S"), ("__sync_fetch_and_xor_4", "arm/sync_fetch_and_xor_4.S"), ("__sync_fetch_and_xor_8", "arm/sync_fetch_and_xor_8.S"), ]); } if llvm_target.last().unwrap().ends_with("eabihf") { if !llvm_target[0].starts_with("thumbv7em") && !llvm_target[0].starts_with("thumbv8m.main") { // The FPU option chosen for these architectures in cc-rs, ie: // -mfpu=fpv4-sp-d16 for thumbv7em // -mfpu=fpv5-sp-d16 for thumbv8m.main // do not support double precision floating points conversions so the files // that include such instructions are not included for these targets. sources.extend(&[ ("__fixdfsivfp", "arm/fixdfsivfp.S"), ("__fixunsdfsivfp", "arm/fixunsdfsivfp.S"), ("__floatsidfvfp", "arm/floatsidfvfp.S"), ("__floatunssidfvfp", "arm/floatunssidfvfp.S"), ]); } sources.extend(&[ ("__fixsfsivfp", "arm/fixsfsivfp.S"), ("__fixunssfsivfp", "arm/fixunssfsivfp.S"), ("__floatsisfvfp", "arm/floatsisfvfp.S"), ("__floatunssisfvfp", "arm/floatunssisfvfp.S"), ("__floatunssisfvfp", "arm/floatunssisfvfp.S"), ("__restore_vfp_d8_d15_regs", "arm/restore_vfp_d8_d15_regs.S"), ("__save_vfp_d8_d15_regs", "arm/save_vfp_d8_d15_regs.S"), ("__negdf2vfp", "arm/negdf2vfp.S"), ("__negsf2vfp", "arm/negsf2vfp.S"), ]); } if target_arch == "aarch64" && consider_float_intrinsics { sources.extend(&[ ("__comparetf2", "comparetf2.c"), ("__extenddftf2", "extenddftf2.c"), ("__extendsftf2", "extendsftf2.c"), ("__fixtfdi", "fixtfdi.c"), ("__fixtfsi", "fixtfsi.c"), ("__fixtfti", "fixtfti.c"), ("__fixunstfdi", "fixunstfdi.c"), ("__fixunstfsi", "fixunstfsi.c"), ("__fixunstfti", "fixunstfti.c"), ("__floatditf", "floatditf.c"), ("__floatsitf", "floatsitf.c"), ("__floatunditf", "floatunditf.c"), ("__floatunsitf", "floatunsitf.c"), ("__trunctfdf2", "trunctfdf2.c"), ("__trunctfsf2", "trunctfsf2.c"), ("__addtf3", "addtf3.c"), ("__multf3", "multf3.c"), ("__subtf3", "subtf3.c"), ("__divtf3", "divtf3.c"), ("__powitf2", "powitf2.c"), ("__fe_getround", "fp_mode.c"), ("__fe_raise_inexact", "fp_mode.c"), ]); if target_os != "windows" { sources.extend(&[("__multc3", "multc3.c")]); } } if target_arch == "mips" { sources.extend(&[("__bswapsi2", "bswapsi2.c")]); } if target_arch == "mips64" { sources.extend(&[ ("__extenddftf2", "extenddftf2.c"), ("__netf2", "comparetf2.c"), ("__addtf3", "addtf3.c"), ("__multf3", "multf3.c"), ("__subtf3", "subtf3.c"), ("__fixtfsi", "fixtfsi.c"), ("__floatsitf", "floatsitf.c"), ("__fixunstfsi", "fixunstfsi.c"), ("__floatunsitf", "floatunsitf.c"), ("__fe_getround", "fp_mode.c"), ("__divtf3", "divtf3.c"), ("__trunctfdf2", "trunctfdf2.c"), ("__trunctfsf2", "trunctfsf2.c"), ]); } // Remove the assembly implementations that won't compile for the target if llvm_target[0] == "thumbv6m" || llvm_target[0] == "thumbv8m.base" || target_os == "uefi" { let mut to_remove = Vec::new(); for (k, v) in sources.map.iter() { if v.ends_with(".S") { to_remove.push(*k); } } sources.remove(&to_remove); // But use some generic implementations where possible sources.extend(&[("__clzdi2", "clzdi2.c"), ("__clzsi2", "clzsi2.c")]) } if llvm_target[0] == "thumbv7m" || llvm_target[0] == "thumbv7em" { sources.remove(&["__aeabi_cdcmp", "__aeabi_cfcmp"]); } // Android uses emulated TLS so we need a runtime support function. if target_os == "android" { sources.extend(&[("__emutls_get_address", "emutls.c")]); // Work around a bug in the NDK headers (fixed in // https://r.android.com/2038949 which will be released in a future // NDK version) by providing a definition of LONG_BIT. cfg.define("LONG_BIT", "(8 * sizeof(long))"); } // OpenHarmony also uses emulated TLS. if target_env == "ohos" { sources.extend(&[("__emutls_get_address", "emutls.c")]); } // When compiling the C code we require the user to tell us where the // source code is, and this is largely done so when we're compiling as // part of rust-lang/rust we can use the same llvm-project repository as // rust-lang/rust. let root = match env::var_os("RUST_COMPILER_RT_ROOT") { Some(s) => PathBuf::from(s), None => panic!("RUST_COMPILER_RT_ROOT is not set"), }; if !root.exists() { panic!("RUST_COMPILER_RT_ROOT={} does not exist", root.display()); } // Support deterministic builds by remapping the __FILE__ prefix if the // compiler supports it. This fixes the nondeterminism caused by the // use of that macro in lib/builtins/int_util.h in compiler-rt. cfg.flag_if_supported(&format!("-ffile-prefix-map={}=.", root.display())); // Include out-of-line atomics for aarch64, which are all generated by supplying different // sets of flags to the same source file. // Note: Out-of-line aarch64 atomics are not supported by the msvc toolchain (#430). let src_dir = root.join("lib/builtins"); if target_arch == "aarch64" && target_env != "msvc" { // See below for why we're building these as separate libraries. build_aarch64_out_of_line_atomics_libraries(&src_dir, cfg); // Some run-time CPU feature detection is necessary, as well. sources.extend(&[("__aarch64_have_lse_atomics", "cpu_model.c")]); } let mut added_sources = HashSet::new(); for (sym, src) in sources.map.iter() { let src = src_dir.join(src); if added_sources.insert(src.clone()) { cfg.file(&src); println!("cargo:rerun-if-changed={}", src.display()); } println!("cargo:rustc-cfg={}=\"optimized-c\"", sym); } cfg.compile("libcompiler-rt.a"); } fn build_aarch64_out_of_line_atomics_libraries(builtins_dir: &Path, cfg: &mut cc::Build) { let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap()); let outlined_atomics_file = builtins_dir.join("aarch64/lse.S"); println!("cargo:rerun-if-changed={}", outlined_atomics_file.display()); cfg.include(&builtins_dir); for instruction_type in &["cas", "swp", "ldadd", "ldclr", "ldeor", "ldset"] { for size in &[1, 2, 4, 8, 16] { if *size == 16 && *instruction_type != "cas" { continue; } for (model_number, model_name) in &[(1, "relax"), (2, "acq"), (3, "rel"), (4, "acq_rel")] { // The original compiler-rt build system compiles the same // source file multiple times with different compiler // options. Here we do something slightly different: we // create multiple .S files with the proper #defines and // then include the original file. // // This is needed because the cc crate doesn't allow us to // override the name of object files and libtool requires // all objects in an archive to have unique names. let path = out_dir.join(format!("lse_{}{}_{}.S", instruction_type, size, model_name)); let mut file = File::create(&path).unwrap(); writeln!(file, "#define L_{}", instruction_type).unwrap(); writeln!(file, "#define SIZE {}", size).unwrap(); writeln!(file, "#define MODEL {}", model_number).unwrap(); writeln!( file, "#include \"{}\"", outlined_atomics_file.canonicalize().unwrap().display() ) .unwrap(); drop(file); cfg.file(path); let sym = format!("__aarch64_{}{}_{}", instruction_type, size, model_name); println!("cargo:rustc-cfg={}=\"optimized-c\"", sym); } } } } }