027eab2f87
A new target, `s390x-unknown-linux-gnu`, has been added to the compiler and can be used to build no_core/no_std Rust programs. Known limitations: - librustc_trans/cabi_s390x.rs is missing. This means no support for `extern "C" fn`. - No support for this arch in libc. This means std can be cross compiled for this target.
550 lines
17 KiB
Rust
550 lines
17 KiB
Rust
// 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;SystemZ")
|
|
.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");
|
|
}
|