| // Copyright 2015 The Rust Project Developers. See the COPYRIGHT |
| // file at the top-level directory of this distribution and at |
| // http://rust-lang.org/COPYRIGHT. |
| // |
| // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or |
| // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your |
| // option. This file may not be copied, modified, or distributed |
| // except according to those terms. |
| |
| //! Compilation of native dependencies like LLVM. |
| //! |
| //! Native projects like LLVM unfortunately aren't suited just yet for |
| //! compilation in build scripts that Cargo has. This is because thie |
| //! compilation takes a *very* long time but also because we don't want to |
| //! compile LLVM 3 times as part of a normal bootstrap (we want it cached). |
| //! |
| //! LLVM and compiler-rt are essentially just wired up to everything else to |
| //! ensure that they're always in place if needed. |
| |
| use std::path::Path; |
| use std::process::Command; |
| use std::fs::{self, File}; |
| |
| use build_helper::output; |
| use cmake; |
| use gcc; |
| |
| use Build; |
| use util::{staticlib, up_to_date}; |
| |
| /// Compile LLVM for `target`. |
| pub fn llvm(build: &Build, target: &str) { |
| // If we're using a custom LLVM bail out here, but we can only use a |
| // custom LLVM for the build triple. |
| if let Some(config) = build.config.target_config.get(target) { |
| if let Some(ref s) = config.llvm_config { |
| return check_llvm_version(build, s); |
| } |
| } |
| |
| // If the cleaning trigger is newer than our built artifacts (or if the |
| // artifacts are missing) then we keep going, otherwise we bail out. |
| let dst = build.llvm_out(target); |
| let stamp = build.src.join("src/rustllvm/llvm-auto-clean-trigger"); |
| let done_stamp = dst.join("llvm-finished-building"); |
| build.clear_if_dirty(&dst, &stamp); |
| if fs::metadata(&done_stamp).is_ok() { |
| return |
| } |
| |
| println!("Building LLVM for {}", target); |
| |
| let _ = fs::remove_dir_all(&dst.join("build")); |
| t!(fs::create_dir_all(&dst.join("build"))); |
| let assertions = if build.config.llvm_assertions {"ON"} else {"OFF"}; |
| |
| // http://llvm.org/docs/CMake.html |
| let mut cfg = cmake::Config::new(build.src.join("src/llvm")); |
| if build.config.ninja { |
| cfg.generator("Ninja"); |
| } |
| cfg.target(target) |
| .host(&build.config.build) |
| .out_dir(&dst) |
| .profile(if build.config.llvm_optimize {"Release"} else {"Debug"}) |
| .define("LLVM_ENABLE_ASSERTIONS", assertions) |
| .define("LLVM_TARGETS_TO_BUILD", "X86;ARM;AArch64;Mips;PowerPC") |
| .define("LLVM_INCLUDE_EXAMPLES", "OFF") |
| .define("LLVM_INCLUDE_TESTS", "OFF") |
| .define("LLVM_INCLUDE_DOCS", "OFF") |
| .define("LLVM_ENABLE_ZLIB", "OFF") |
| .define("WITH_POLLY", "OFF") |
| .define("LLVM_ENABLE_TERMINFO", "OFF") |
| .define("LLVM_ENABLE_LIBEDIT", "OFF") |
| .define("LLVM_PARALLEL_COMPILE_JOBS", build.jobs().to_string()); |
| |
| if target.starts_with("i686") { |
| cfg.define("LLVM_BUILD_32_BITS", "ON"); |
| } |
| |
| // http://llvm.org/docs/HowToCrossCompileLLVM.html |
| if target != build.config.build { |
| // FIXME: if the llvm root for the build triple is overridden then we |
| // should use llvm-tblgen from there, also should verify that it |
| // actually exists most of the time in normal installs of LLVM. |
| let host = build.llvm_out(&build.config.build).join("bin/llvm-tblgen"); |
| cfg.define("CMAKE_CROSSCOMPILING", "True") |
| .define("LLVM_TARGET_ARCH", target.split('-').next().unwrap()) |
| .define("LLVM_TABLEGEN", &host) |
| .define("LLVM_DEFAULT_TARGET_TRIPLE", target); |
| } |
| |
| // MSVC handles compiler business itself |
| if !target.contains("msvc") { |
| if build.config.ccache { |
| cfg.define("CMAKE_C_COMPILER", "ccache") |
| .define("CMAKE_C_COMPILER_ARG1", build.cc(target)) |
| .define("CMAKE_CXX_COMPILER", "ccache") |
| .define("CMAKE_CXX_COMPILER_ARG1", build.cxx(target)); |
| } else { |
| cfg.define("CMAKE_C_COMPILER", build.cc(target)) |
| .define("CMAKE_CXX_COMPILER", build.cxx(target)); |
| } |
| cfg.build_arg("-j").build_arg(build.jobs().to_string()); |
| |
| cfg.define("CMAKE_C_FLAGS", build.cflags(target).join(" ")); |
| cfg.define("CMAKE_CXX_FLAGS", build.cflags(target).join(" ")); |
| } |
| |
| // FIXME: we don't actually need to build all LLVM tools and all LLVM |
| // libraries here, e.g. we just want a few components and a few |
| // tools. Figure out how to filter them down and only build the right |
| // tools and libs on all platforms. |
| cfg.build(); |
| |
| t!(File::create(&done_stamp)); |
| } |
| |
| fn check_llvm_version(build: &Build, llvm_config: &Path) { |
| if !build.config.llvm_version_check { |
| return |
| } |
| |
| let mut cmd = Command::new(llvm_config); |
| let version = output(cmd.arg("--version")); |
| if version.starts_with("3.5") || version.starts_with("3.6") || |
| version.starts_with("3.7") { |
| return |
| } |
| panic!("\n\nbad LLVM version: {}, need >=3.5\n\n", version) |
| } |
| |
| /// Compiles the `compiler-rt` library, or at least the builtins part of it. |
| /// |
| /// Note that while compiler-rt has a build system associated with it, we |
| /// specifically don't use it here. The compiler-rt build system, written in |
| /// CMake, is actually *very* difficult to work with in terms of getting it to |
| /// compile on all the relevant platforms we want it to compile on. In the end |
| /// it became so much pain to work with local patches, work around the oddities |
| /// of the build system, etc, that we're just building everything by hand now. |
| /// |
| /// In general compiler-rt is just a bunch of intrinsics that are in practice |
| /// *very* stable. We just need to make sure that all the relevant functions and |
| /// such are compiled somewhere and placed in an object file somewhere. |
| /// Eventually, these should all be written in Rust! |
| /// |
| /// So below you'll find a listing of every single file in the compiler-rt repo |
| /// that we're compiling. We just reach in and compile with the `gcc` crate |
| /// which should have all the relevant flags and such already configured. |
| /// |
| /// The risk here is that if we update compiler-rt we may need to compile some |
| /// new intrinsics, but to be honest we surely don't use all of the intrinsics |
| /// listed below today so the likelihood of us actually needing a new intrinsic |
| /// is quite low. The failure case is also just that someone reports a link |
| /// error (if any) and then we just add it to the list. Overall, that cost is |
| /// far far less than working with compiler-rt's build system over time. |
| pub fn compiler_rt(build: &Build, target: &str) { |
| let build_dir = build.compiler_rt_out(target); |
| let output = build_dir.join(staticlib("compiler-rt", target)); |
| build.compiler_rt_built.borrow_mut().insert(target.to_string(), |
| output.clone()); |
| t!(fs::create_dir_all(&build_dir)); |
| |
| let mut cfg = gcc::Config::new(); |
| cfg.cargo_metadata(false) |
| .out_dir(&build_dir) |
| .target(target) |
| .host(&build.config.build) |
| .opt_level(2) |
| .debug(false); |
| |
| if target.contains("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("-fomit-frame-pointer"); |
| cfg.flag("-ffreestanding"); |
| } |
| |
| let mut sources = vec![ |
| "absvdi2.c", |
| "absvsi2.c", |
| "adddf3.c", |
| "addsf3.c", |
| "addvdi3.c", |
| "addvsi3.c", |
| "apple_versioning.c", |
| "ashldi3.c", |
| "ashrdi3.c", |
| "clear_cache.c", |
| "clzdi2.c", |
| "clzsi2.c", |
| "cmpdi2.c", |
| "comparedf2.c", |
| "comparesf2.c", |
| "ctzdi2.c", |
| "ctzsi2.c", |
| "divdc3.c", |
| "divdf3.c", |
| "divdi3.c", |
| "divmoddi4.c", |
| "divmodsi4.c", |
| "divsc3.c", |
| "divsf3.c", |
| "divsi3.c", |
| "divxc3.c", |
| "extendsfdf2.c", |
| "extendhfsf2.c", |
| "ffsdi2.c", |
| "fixdfdi.c", |
| "fixdfsi.c", |
| "fixsfdi.c", |
| "fixsfsi.c", |
| "fixunsdfdi.c", |
| "fixunsdfsi.c", |
| "fixunssfdi.c", |
| "fixunssfsi.c", |
| "fixunsxfdi.c", |
| "fixunsxfsi.c", |
| "fixxfdi.c", |
| "floatdidf.c", |
| "floatdisf.c", |
| "floatdixf.c", |
| "floatsidf.c", |
| "floatsisf.c", |
| "floatundidf.c", |
| "floatundisf.c", |
| "floatundixf.c", |
| "floatunsidf.c", |
| "floatunsisf.c", |
| "int_util.c", |
| "lshrdi3.c", |
| "moddi3.c", |
| "modsi3.c", |
| "muldc3.c", |
| "muldf3.c", |
| "muldi3.c", |
| "mulodi4.c", |
| "mulosi4.c", |
| "muloti4.c", |
| "mulsc3.c", |
| "mulsf3.c", |
| "mulvdi3.c", |
| "mulvsi3.c", |
| "mulxc3.c", |
| "negdf2.c", |
| "negdi2.c", |
| "negsf2.c", |
| "negvdi2.c", |
| "negvsi2.c", |
| "paritydi2.c", |
| "paritysi2.c", |
| "popcountdi2.c", |
| "popcountsi2.c", |
| "powidf2.c", |
| "powisf2.c", |
| "powixf2.c", |
| "subdf3.c", |
| "subsf3.c", |
| "subvdi3.c", |
| "subvsi3.c", |
| "truncdfhf2.c", |
| "truncdfsf2.c", |
| "truncsfhf2.c", |
| "ucmpdi2.c", |
| "udivdi3.c", |
| "udivmoddi4.c", |
| "udivmodsi4.c", |
| "udivsi3.c", |
| "umoddi3.c", |
| "umodsi3.c", |
| ]; |
| |
| if !target.contains("ios") { |
| sources.extend(vec![ |
| "absvti2.c", |
| "addtf3.c", |
| "addvti3.c", |
| "ashlti3.c", |
| "ashrti3.c", |
| "clzti2.c", |
| "cmpti2.c", |
| "ctzti2.c", |
| "divtf3.c", |
| "divti3.c", |
| "ffsti2.c", |
| "fixdfti.c", |
| "fixsfti.c", |
| "fixunsdfti.c", |
| "fixunssfti.c", |
| "fixunsxfti.c", |
| "fixxfti.c", |
| "floattidf.c", |
| "floattisf.c", |
| "floattixf.c", |
| "floatuntidf.c", |
| "floatuntisf.c", |
| "floatuntixf.c", |
| "lshrti3.c", |
| "modti3.c", |
| "multf3.c", |
| "multi3.c", |
| "mulvti3.c", |
| "negti2.c", |
| "negvti2.c", |
| "parityti2.c", |
| "popcountti2.c", |
| "powitf2.c", |
| "subtf3.c", |
| "subvti3.c", |
| "trampoline_setup.c", |
| "ucmpti2.c", |
| "udivmodti4.c", |
| "udivti3.c", |
| "umodti3.c", |
| ]); |
| } |
| |
| if target.contains("apple") { |
| sources.extend(vec![ |
| "atomic_flag_clear.c", |
| "atomic_flag_clear_explicit.c", |
| "atomic_flag_test_and_set.c", |
| "atomic_flag_test_and_set_explicit.c", |
| "atomic_signal_fence.c", |
| "atomic_thread_fence.c", |
| ]); |
| } |
| |
| if !target.contains("windows") { |
| sources.push("emutls.c"); |
| } |
| |
| if target.contains("msvc") { |
| if target.contains("x86_64") { |
| sources.extend(vec![ |
| "x86_64/floatdidf.c", |
| "x86_64/floatdisf.c", |
| "x86_64/floatdixf.c", |
| ]); |
| } |
| } else { |
| if !target.contains("freebsd") { |
| sources.push("gcc_personality_v0.c"); |
| } |
| |
| if target.contains("x86_64") { |
| sources.extend(vec![ |
| "x86_64/chkstk.S", |
| "x86_64/chkstk2.S", |
| "x86_64/floatdidf.c", |
| "x86_64/floatdisf.c", |
| "x86_64/floatdixf.c", |
| "x86_64/floatundidf.S", |
| "x86_64/floatundisf.S", |
| "x86_64/floatundixf.S", |
| ]); |
| } |
| |
| if target.contains("i386") || |
| target.contains("i586") || |
| target.contains("i686") { |
| sources.extend(vec![ |
| "i386/ashldi3.S", |
| "i386/ashrdi3.S", |
| "i386/chkstk.S", |
| "i386/chkstk2.S", |
| "i386/divdi3.S", |
| "i386/floatdidf.S", |
| "i386/floatdisf.S", |
| "i386/floatdixf.S", |
| "i386/floatundidf.S", |
| "i386/floatundisf.S", |
| "i386/floatundixf.S", |
| "i386/lshrdi3.S", |
| "i386/moddi3.S", |
| "i386/muldi3.S", |
| "i386/udivdi3.S", |
| "i386/umoddi3.S", |
| ]); |
| } |
| } |
| |
| if target.contains("arm") && !target.contains("ios") { |
| sources.extend(vec![ |
| "arm/aeabi_cdcmp.S", |
| "arm/aeabi_cdcmpeq_check_nan.c", |
| "arm/aeabi_cfcmp.S", |
| "arm/aeabi_cfcmpeq_check_nan.c", |
| "arm/aeabi_dcmp.S", |
| "arm/aeabi_div0.c", |
| "arm/aeabi_drsub.c", |
| "arm/aeabi_fcmp.S", |
| "arm/aeabi_frsub.c", |
| "arm/aeabi_idivmod.S", |
| "arm/aeabi_ldivmod.S", |
| "arm/aeabi_memcmp.S", |
| "arm/aeabi_memcpy.S", |
| "arm/aeabi_memmove.S", |
| "arm/aeabi_memset.S", |
| "arm/aeabi_uidivmod.S", |
| "arm/aeabi_uldivmod.S", |
| "arm/bswapdi2.S", |
| "arm/bswapsi2.S", |
| "arm/clzdi2.S", |
| "arm/clzsi2.S", |
| "arm/comparesf2.S", |
| "arm/divmodsi4.S", |
| "arm/divsi3.S", |
| "arm/modsi3.S", |
| "arm/switch16.S", |
| "arm/switch32.S", |
| "arm/switch8.S", |
| "arm/switchu8.S", |
| "arm/sync_synchronize.S", |
| "arm/udivmodsi4.S", |
| "arm/udivsi3.S", |
| "arm/umodsi3.S", |
| ]); |
| } |
| |
| if target.contains("armv7") { |
| sources.extend(vec![ |
| "arm/sync_fetch_and_add_4.S", |
| "arm/sync_fetch_and_add_8.S", |
| "arm/sync_fetch_and_and_4.S", |
| "arm/sync_fetch_and_and_8.S", |
| "arm/sync_fetch_and_max_4.S", |
| "arm/sync_fetch_and_max_8.S", |
| "arm/sync_fetch_and_min_4.S", |
| "arm/sync_fetch_and_min_8.S", |
| "arm/sync_fetch_and_nand_4.S", |
| "arm/sync_fetch_and_nand_8.S", |
| "arm/sync_fetch_and_or_4.S", |
| "arm/sync_fetch_and_or_8.S", |
| "arm/sync_fetch_and_sub_4.S", |
| "arm/sync_fetch_and_sub_8.S", |
| "arm/sync_fetch_and_umax_4.S", |
| "arm/sync_fetch_and_umax_8.S", |
| "arm/sync_fetch_and_umin_4.S", |
| "arm/sync_fetch_and_umin_8.S", |
| "arm/sync_fetch_and_xor_4.S", |
| "arm/sync_fetch_and_xor_8.S", |
| ]); |
| } |
| |
| if target.contains("eabihf") { |
| sources.extend(vec![ |
| "arm/adddf3vfp.S", |
| "arm/addsf3vfp.S", |
| "arm/divdf3vfp.S", |
| "arm/divsf3vfp.S", |
| "arm/eqdf2vfp.S", |
| "arm/eqsf2vfp.S", |
| "arm/extendsfdf2vfp.S", |
| "arm/fixdfsivfp.S", |
| "arm/fixsfsivfp.S", |
| "arm/fixunsdfsivfp.S", |
| "arm/fixunssfsivfp.S", |
| "arm/floatsidfvfp.S", |
| "arm/floatsisfvfp.S", |
| "arm/floatunssidfvfp.S", |
| "arm/floatunssisfvfp.S", |
| "arm/gedf2vfp.S", |
| "arm/gesf2vfp.S", |
| "arm/gtdf2vfp.S", |
| "arm/gtsf2vfp.S", |
| "arm/ledf2vfp.S", |
| "arm/lesf2vfp.S", |
| "arm/ltdf2vfp.S", |
| "arm/ltsf2vfp.S", |
| "arm/muldf3vfp.S", |
| "arm/mulsf3vfp.S", |
| "arm/negdf2vfp.S", |
| "arm/negsf2vfp.S", |
| "arm/nedf2vfp.S", |
| "arm/nesf2vfp.S", |
| "arm/restore_vfp_d8_d15_regs.S", |
| "arm/save_vfp_d8_d15_regs.S", |
| "arm/subdf3vfp.S", |
| "arm/subsf3vfp.S", |
| "arm/truncdfsf2vfp.S", |
| "arm/unorddf2vfp.S", |
| "arm/unordsf2vfp.S", |
| ]); |
| } |
| |
| if target.contains("aarch64") { |
| sources.extend(vec![ |
| "comparetf2.c", |
| "extenddftf2.c", |
| "extendsftf2.c", |
| "fixtfdi.c", |
| "fixtfsi.c", |
| "fixtfti.c", |
| "fixunstfdi.c", |
| "fixunstfsi.c", |
| "fixunstfti.c", |
| "floatditf.c", |
| "floatsitf.c", |
| "floatunditf.c", |
| "floatunsitf.c", |
| "multc3.c", |
| "trunctfdf2.c", |
| "trunctfsf2.c", |
| ]); |
| } |
| |
| let mut out_of_date = false; |
| for src in sources { |
| let src = build.src.join("src/compiler-rt/lib/builtins").join(src); |
| out_of_date = out_of_date || !up_to_date(&src, &output); |
| cfg.file(src); |
| } |
| if !out_of_date { |
| return |
| } |
| cfg.compile("libcompiler-rt.a"); |
| } |
| |
| /// Compiles the `rust_test_helpers.c` library which we used in various |
| /// `run-pass` test suites for ABI testing. |
| pub fn test_helpers(build: &Build, target: &str) { |
| let dst = build.test_helpers_out(target); |
| let src = build.src.join("src/rt/rust_test_helpers.c"); |
| if up_to_date(&src, &dst.join("librust_test_helpers.a")) { |
| return |
| } |
| |
| println!("Building test helpers"); |
| t!(fs::create_dir_all(&dst)); |
| let mut cfg = gcc::Config::new(); |
| cfg.cargo_metadata(false) |
| .out_dir(&dst) |
| .target(target) |
| .host(&build.config.build) |
| .opt_level(0) |
| .debug(false) |
| .file(build.src.join("src/rt/rust_test_helpers.c")) |
| .compile("librust_test_helpers.a"); |
| } |
