bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Auto merge of #89092 - bjorn3:sync_cg_clif-2021-09-19, r=bjorn3

Browse source 
Sync rustc_codegen_cranelift

Nothing exciting this time. Mostly internal refactorings.

r? `@ghost`

`@rustbot` label +A-codegen +A-cranelift +T-compiler
This commit is contained in:
bors 2021-09-26 23:31:01 +00:00
commit b2804655f5
24 changed files with 332 additions and 293 deletions
Download patch file Download diff file Expand all files Collapse all files

2
compiler/rustc_codegen_cranelift/.gitignore vendored
View file

@ -15,4 +15,4 @@ perf.data.old
/rand /rand
/regex /regex
/simple-raytracer /simple-raytracer
/stdsimd /portable-simd

40
compiler/rustc_codegen_cranelift/Cargo.lock
View file

@ -33,16 +33,16 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
[[package]] [[package]]
name = "cranelift-bforest" name = "cranelift-bforest"
version = "0.75.0" version = "0.76.0"
source = "git+https://github.com/bytecodealliance/wasmtime.git#5deda279775dca5e37449c829cda1f6276d6542b" source = "git+https://github.com/bytecodealliance/wasmtime.git#9c550fcf41425942ed97c747f0169b2ca81f9c1b"
dependencies = [ dependencies = [
"cranelift-entity", "cranelift-entity",
] ]
[[package]] [[package]]
name = "cranelift-codegen" name = "cranelift-codegen"
version = "0.75.0" version = "0.76.0"
source = "git+https://github.com/bytecodealliance/wasmtime.git#5deda279775dca5e37449c829cda1f6276d6542b" source = "git+https://github.com/bytecodealliance/wasmtime.git#9c550fcf41425942ed97c747f0169b2ca81f9c1b"
dependencies = [ dependencies = [
"cranelift-bforest", "cranelift-bforest",
"cranelift-codegen-meta", "cranelift-codegen-meta",
@ -57,8 +57,8 @@ dependencies = [
[[package]] [[package]]
name = "cranelift-codegen-meta" name = "cranelift-codegen-meta"
version = "0.75.0" version = "0.76.0"
source = "git+https://github.com/bytecodealliance/wasmtime.git#5deda279775dca5e37449c829cda1f6276d6542b" source = "git+https://github.com/bytecodealliance/wasmtime.git#9c550fcf41425942ed97c747f0169b2ca81f9c1b"
dependencies = [ dependencies = [
"cranelift-codegen-shared", "cranelift-codegen-shared",
"cranelift-entity", "cranelift-entity",
@ -66,18 +66,18 @@ dependencies = [
[[package]] [[package]]
name = "cranelift-codegen-shared" name = "cranelift-codegen-shared"
version = "0.75.0" version = "0.76.0"
source = "git+https://github.com/bytecodealliance/wasmtime.git#5deda279775dca5e37449c829cda1f6276d6542b" source = "git+https://github.com/bytecodealliance/wasmtime.git#9c550fcf41425942ed97c747f0169b2ca81f9c1b"
[[package]] [[package]]
name = "cranelift-entity" name = "cranelift-entity"
version = "0.75.0" version = "0.76.0"
source = "git+https://github.com/bytecodealliance/wasmtime.git#5deda279775dca5e37449c829cda1f6276d6542b" source = "git+https://github.com/bytecodealliance/wasmtime.git#9c550fcf41425942ed97c747f0169b2ca81f9c1b"
[[package]] [[package]]
name = "cranelift-frontend" name = "cranelift-frontend"
version = "0.75.0" version = "0.76.0"
source = "git+https://github.com/bytecodealliance/wasmtime.git#5deda279775dca5e37449c829cda1f6276d6542b" source = "git+https://github.com/bytecodealliance/wasmtime.git#9c550fcf41425942ed97c747f0169b2ca81f9c1b"
dependencies = [ dependencies = [
"cranelift-codegen", "cranelift-codegen",
"log", "log",
@ -87,8 +87,8 @@ dependencies = [
[[package]] [[package]]
name = "cranelift-jit" name = "cranelift-jit"
version = "0.75.0" version = "0.76.0"
source = "git+https://github.com/bytecodealliance/wasmtime.git#5deda279775dca5e37449c829cda1f6276d6542b" source = "git+https://github.com/bytecodealliance/wasmtime.git#9c550fcf41425942ed97c747f0169b2ca81f9c1b"
dependencies = [ dependencies = [
"anyhow", "anyhow",
"cranelift-codegen", "cranelift-codegen",
@ -104,8 +104,8 @@ dependencies = [
[[package]] [[package]]
name = "cranelift-module" name = "cranelift-module"
version = "0.75.0" version = "0.76.0"
source = "git+https://github.com/bytecodealliance/wasmtime.git#5deda279775dca5e37449c829cda1f6276d6542b" source = "git+https://github.com/bytecodealliance/wasmtime.git#9c550fcf41425942ed97c747f0169b2ca81f9c1b"
dependencies = [ dependencies = [
"anyhow", "anyhow",
"cranelift-codegen", "cranelift-codegen",
@ -115,8 +115,8 @@ dependencies = [
[[package]] [[package]]
name = "cranelift-native" name = "cranelift-native"
version = "0.75.0" version = "0.76.0"
source = "git+https://github.com/bytecodealliance/wasmtime.git#5deda279775dca5e37449c829cda1f6276d6542b" source = "git+https://github.com/bytecodealliance/wasmtime.git#9c550fcf41425942ed97c747f0169b2ca81f9c1b"
dependencies = [ dependencies = [
"cranelift-codegen", "cranelift-codegen",
"libc", "libc",
@ -125,8 +125,8 @@ dependencies = [
[[package]] [[package]]
name = "cranelift-object" name = "cranelift-object"
version = "0.75.0" version = "0.76.0"
source = "git+https://github.com/bytecodealliance/wasmtime.git#5deda279775dca5e37449c829cda1f6276d6542b" source = "git+https://github.com/bytecodealliance/wasmtime.git#9c550fcf41425942ed97c747f0169b2ca81f9c1b"
dependencies = [ dependencies = [
"anyhow", "anyhow",
"cranelift-codegen", "cranelift-codegen",

41
compiler/rustc_codegen_cranelift/build_sysroot/Cargo.lock
View file

@ -4,9 +4,9 @@ version = 3
[[package]] [[package]]
name = "addr2line" name = "addr2line"
version = "0.14.1" version = "0.16.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a55f82cfe485775d02112886f4169bde0c5894d75e79ead7eafe7e40a25e45f7" checksum = "3e61f2b7f93d2c7d2b08263acaa4a363b3e276806c68af6134c44f523bf1aacd"
dependencies = [ dependencies = [
"compiler_builtins", "compiler_builtins",
"gimli", "gimli",
@ -40,9 +40,9 @@ checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
[[package]] [[package]]
name = "cc" name = "cc"
version = "1.0.69" version = "1.0.70"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e70cc2f62c6ce1868963827bd677764c62d07c3d9a3e1fb1177ee1a9ab199eb2" checksum = "d26a6ce4b6a484fa3edb70f7efa6fc430fd2b87285fe8b84304fd0936faa0dc0"
[[package]] [[package]]
name = "cfg-if" name = "cfg-if"
@ -56,7 +56,7 @@ dependencies = [
[[package]] [[package]]
name = "compiler_builtins" name = "compiler_builtins"
version = "0.1.46" version = "0.1.50"
dependencies = [ dependencies = [
"rustc-std-workspace-core", "rustc-std-workspace-core",
] ]
@ -99,9 +99,9 @@ dependencies = [
[[package]] [[package]]
name = "gimli" name = "gimli"
version = "0.23.0" version = "0.25.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6503fe142514ca4799d4c26297c4248239fe8838d827db6bd6065c6ed29a6ce" checksum = "f0a01e0497841a3b2db4f8afa483cce65f7e96a3498bd6c541734792aeac8fe7"
dependencies = [ dependencies = [
"compiler_builtins", "compiler_builtins",
"rustc-std-workspace-alloc", "rustc-std-workspace-alloc",
@ -132,13 +132,23 @@ dependencies = [
[[package]] [[package]]
name = "libc" name = "libc"
version = "0.2.98" version = "0.2.102"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "320cfe77175da3a483efed4bc0adc1968ca050b098ce4f2f1c13a56626128790" checksum = "a2a5ac8f984bfcf3a823267e5fde638acc3325f6496633a5da6bb6eb2171e103"
dependencies = [ dependencies = [
"rustc-std-workspace-core", "rustc-std-workspace-core",
] ]
[[package]]
name = "memchr"
version = "2.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
dependencies = [
"compiler_builtins",
"rustc-std-workspace-core",
]
[[package]] [[package]]
name = "miniz_oxide" name = "miniz_oxide"
version = "0.4.4" version = "0.4.4"
@ -154,11 +164,12 @@ dependencies = [
[[package]] [[package]]
name = "object" name = "object"
version = "0.22.0" version = "0.26.2"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8d3b63360ec3cb337817c2dbd47ab4a0f170d285d8e5a2064600f3def1402397" checksum = "39f37e50073ccad23b6d09bcb5b263f4e76d3bb6038e4a3c08e52162ffa8abc2"
dependencies = [ dependencies = [
"compiler_builtins", "compiler_builtins",
"memchr",
"rustc-std-workspace-alloc", "rustc-std-workspace-alloc",
"rustc-std-workspace-core", "rustc-std-workspace-core",
] ]
@ -195,9 +206,9 @@ dependencies = [
[[package]] [[package]]
name = "rustc-demangle" name = "rustc-demangle"
version = "0.1.20" version = "0.1.21"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dead70b0b5e03e9c814bcb6b01e03e68f7c57a80aa48c72ec92152ab3e818d49" checksum = "7ef03e0a2b150c7a90d01faf6254c9c48a41e95fb2a8c2ac1c6f0d2b9aefc342"
dependencies = [ dependencies = [
"compiler_builtins", "compiler_builtins",
"rustc-std-workspace-core", "rustc-std-workspace-core",
@ -286,9 +297,9 @@ dependencies = [
[[package]] [[package]]
name = "unicode-width" name = "unicode-width"
version = "0.1.8" version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3" checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
dependencies = [ dependencies = [
"compiler_builtins", "compiler_builtins",
"rustc-std-workspace-core", "rustc-std-workspace-core",

10
compiler/rustc_codegen_cranelift/build_system/prepare.rs
View file

@ -28,11 +28,11 @@ pub(crate) fn prepare() {
); );
clone_repo( clone_repo(
"stdsimd", "portable-simd",
"https://github.com/rust-lang/stdsimd", "https://github.com/rust-lang/portable-simd",
"be96995d8ddec03fac9a0caf4d4c51c7fbc33507", "8cf7a62e5d2552961df51e5200aaa5b7c890a4bf",
); );
apply_patches("stdsimd", Path::new("stdsimd")); apply_patches("portable-simd", Path::new("portable-simd"));
clone_repo( clone_repo(
"simple-raytracer", "simple-raytracer",
@ -92,7 +92,7 @@ fn prepare_sysroot() {
clone_repo( clone_repo(
"build_sysroot/compiler-builtins", "build_sysroot/compiler-builtins",
"https://github.com/rust-lang/compiler-builtins.git", "https://github.com/rust-lang/compiler-builtins.git",
"0.1.46", "0.1.50",
); );
apply_patches("compiler-builtins", Path::new("build_sysroot/compiler-builtins")); apply_patches("compiler-builtins", Path::new("build_sysroot/compiler-builtins"));
} }

2
compiler/rustc_codegen_cranelift/clean_all.sh
View file

@ -3,4 +3,4 @@ set -e
rm -rf build_sysroot/{sysroot_src/,target/,compiler-builtins/,rustc_version} rm -rf build_sysroot/{sysroot_src/,target/,compiler-builtins/,rustc_version}
rm -rf target/ build/ perf.data{,.old} rm -rf target/ build/ perf.data{,.old}
rm -rf rand/ regex/ simple-raytracer/ stdsimd/ rm -rf rand/ regex/ simple-raytracer/ portable-simd/

2
compiler/rustc_codegen_cranelift/docs/usage.md
View file

@ -24,6 +24,8 @@ $ $cg_clif_dir/build/bin/cg_clif my_crate.rs
## Jit mode ## Jit mode
> ⚠⚠⚠ The JIT mode is highly experimental. It may be slower than AOT compilation due to lack of incremental compilation. It may also be hard to setup if you have cargo dependencies. ⚠⚠⚠
In jit mode cg_clif will immediately execute your code without creating an executable file. In jit mode cg_clif will immediately execute your code without creating an executable file.
> This requires all dependencies to be available as dynamic library. > This requires all dependencies to be available as dynamic library.

2
compiler/rustc_codegen_cranelift/example/alloc_example.rs
View file

@ -1,4 +1,4 @@
#![feature(start, core_intrinsics, alloc_prelude, alloc_error_handler)] #![feature(start, core_intrinsics, alloc_prelude, alloc_error_handler, box_syntax)]
#![no_std] #![no_std]
extern crate alloc; extern crate alloc;

2
compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs
View file

@ -1,4 +1,4 @@
#![feature(no_core, lang_items, never_type, linkage, extern_types, thread_local)] #![feature(no_core, lang_items, never_type, linkage, extern_types, thread_local, box_syntax)]
#![no_core] #![no_core]
#![allow(dead_code, non_camel_case_types)] #![allow(dead_code, non_camel_case_types)]

51
compiler/rustc_codegen_cranelift/patches/0001-stdsimd-Disable-unsupported-tests.patch → compiler/rustc_codegen_cranelift/patches/0001-portable-simd-Disable-unsupported-tests.patch
View file

@ -4,21 +4,20 @@ Date: Sun, 25 Jul 2021 18:39:31 +0200
Subject: [PATCH] Disable unsupported tests Subject: [PATCH] Disable unsupported tests
--- ---
crates/core_simd/src/array.rs | 2 ++ crates/core_simd/src/vector.rs | 2 ++
crates/core_simd/src/lib.rs | 2 +-
crates/core_simd/src/math.rs | 4 ++++ crates/core_simd/src/math.rs | 4 ++++
crates/core_simd/tests/masks.rs | 12 ------------ crates/core_simd/tests/masks.rs | 12 ------------
crates/core_simd/tests/ops_macros.rs | 6 ++++++ crates/core_simd/tests/ops_macros.rs | 6 ++++++
crates/core_simd/tests/round.rs | 2 ++ crates/core_simd/tests/round.rs | 2 ++
6 files changed, 15 insertions(+), 13 deletions(-) 6 files changed, 15 insertions(+), 13 deletions(-)
diff --git a/crates/core_simd/src/array.rs b/crates/core_simd/src/array.rs diff --git a/crates/core_simd/src/vector.rs b/crates/core_simd/src/vector.rs
index 25c5309..2b3d819 100644 index 25c5309..2b3d819 100644
--- a/crates/core_simd/src/array.rs --- a/crates/core_simd/src/vector.rs
+++ b/crates/core_simd/src/array.rs +++ b/crates/core_simd/src/vector.rs
@@ -22,6 +22,7 @@ where @@ -22,6 +22,7 @@ where
#[must_use] self.0
fn splat(val: Self::Scalar) -> Self; }
+ /* + /*
/// SIMD gather: construct a SIMD vector by reading from a slice, using potentially discontiguous indices. /// SIMD gather: construct a SIMD vector by reading from a slice, using potentially discontiguous indices.
@ -31,27 +30,14 @@ index 25c5309..2b3d819 100644
+ */ + */
} }
macro_rules! impl_simdarray_for { impl<T, const LANES: usize> Copy for Simd<T, LANES>
diff --git a/crates/core_simd/src/lib.rs b/crates/core_simd/src/lib.rs
index a64904d..299eb11 100644
--- a/crates/core_simd/src/lib.rs
+++ b/crates/core_simd/src/lib.rs
@@ -1,7 +1,7 @@
#![no_std]
#![allow(incomplete_features)]
#![feature(
- const_generics,
+ const_generics,
platform_intrinsics,
repr_simd,
simd_ffi,
diff --git a/crates/core_simd/src/math.rs b/crates/core_simd/src/math.rs diff --git a/crates/core_simd/src/math.rs b/crates/core_simd/src/math.rs
index 7290a28..e394730 100644 index 7290a28..e394730 100644
--- a/crates/core_simd/src/math.rs --- a/crates/core_simd/src/math.rs
+++ b/crates/core_simd/src/math.rs +++ b/crates/core_simd/src/math.rs
@@ -2,6 +2,7 @@ macro_rules! impl_uint_arith { @@ -2,6 +2,7 @@ macro_rules! impl_uint_arith {
($(($name:ident, $n:ident)),+) => { ($($ty:ty),+) => {
$( impl<const LANES: usize> $name<LANES> where Self: crate::LanesAtMost32 { $( impl<const LANES: usize> Simd<$ty, LANES> where LaneCount<LANES>: SupportedLaneCount {
+ /* + /*
/// Lanewise saturating add. /// Lanewise saturating add.
@ -66,8 +52,8 @@ index 7290a28..e394730 100644
} }
} }
@@ -46,6 +48,7 @@ macro_rules! impl_int_arith { @@ -46,6 +48,7 @@ macro_rules! impl_int_arith {
($(($name:ident, $n:ident)),+) => { ($($ty:ty),+) => {
$( impl<const LANES: usize> $name<LANES> where Self: crate::LanesAtMost32 { $( impl<const LANES: usize> Simd<$ty, LANES> where LaneCount<LANES>: SupportedLaneCount {
+ /* + /*
/// Lanewise saturating add. /// Lanewise saturating add.
@ -85,21 +71,22 @@ diff --git a/crates/core_simd/tests/masks.rs b/crates/core_simd/tests/masks.rs
index 61d8e44..2bccae2 100644 index 61d8e44..2bccae2 100644
--- a/crates/core_simd/tests/masks.rs --- a/crates/core_simd/tests/masks.rs
+++ b/crates/core_simd/tests/masks.rs +++ b/crates/core_simd/tests/masks.rs
@@ -67,18 +67,6 @@ macro_rules! test_mask_api { @@ -67,19 +67,6 @@ macro_rules! test_mask_api {
assert_eq!(int.to_array(), [-1, 0, 0, -1, 0, 0, -1, 0]); assert_eq!(int.to_array(), [-1, 0, 0, -1, 0, 0, -1, 0]);
assert_eq!(core_simd::$name::<8>::from_int(int), mask); assert_eq!(core_simd::Mask::<$type, 8>::from_int(int), mask);
} }
- -
- #[cfg(feature = "generic_const_exprs")]
- #[test] - #[test]
- fn roundtrip_bitmask_conversion() { - fn roundtrip_bitmask_conversion() {
- let values = [ - let values = [
- true, false, false, true, false, false, true, false, - true, false, false, true, false, false, true, false,
- true, true, false, false, false, false, false, true, - true, true, false, false, false, false, false, true,
- ]; - ];
- let mask = core_simd::$name::<16>::from_array(values); - let mask = core_simd::Mask::<$type, 16>::from_array(values);
- let bitmask = mask.to_bitmask(); - let bitmask = mask.to_bitmask();
- assert_eq!(bitmask, [0b01001001, 0b10000011]); - assert_eq!(bitmask, [0b01001001, 0b10000011]);
- assert_eq!(core_simd::$name::<16>::from_bitmask(bitmask), mask); - assert_eq!(core_simd::Mask::<$type, 16>::from_bitmask(bitmask), mask);
- } - }
} }
} }
@ -122,7 +109,7 @@ index cb39e73..fc0ebe1 100644
} }
+ */ + */
fn sqrt<const LANES: usize>() { fn recip<const LANES: usize>() {
test_helpers::test_unary_elementwise( test_helpers::test_unary_elementwise(
@@ -581,6 +585,7 @@ macro_rules! impl_float_tests { @@ -581,6 +585,7 @@ macro_rules! impl_float_tests {
}); });
@ -138,8 +125,8 @@ index cb39e73..fc0ebe1 100644
} }
+ */ + */
} }
}
} #[cfg(feature = "std")]
diff --git a/crates/core_simd/tests/round.rs b/crates/core_simd/tests/round.rs diff --git a/crates/core_simd/tests/round.rs b/crates/core_simd/tests/round.rs
index 37044a7..4cdc6b7 100644 index 37044a7..4cdc6b7 100644
--- a/crates/core_simd/tests/round.rs --- a/crates/core_simd/tests/round.rs

41
compiler/rustc_codegen_cranelift/patches/0027-sysroot-128bit-atomic-operations.patch
View file

@ -1,4 +1,4 @@
From 6a4e6f5dc8c8a529a822eb9b57f9e57519595439 Mon Sep 17 00:00:00 2001 From ad7ffe71baba46865f2e65266ab025920dfdc20b Mon Sep 17 00:00:00 2001
From: bjorn3 <bjorn3@users.noreply.github.com> From: bjorn3 <bjorn3@users.noreply.github.com>
Date: Thu, 18 Feb 2021 18:45:28 +0100 Date: Thu, 18 Feb 2021 18:45:28 +0100
Subject: [PATCH] Disable 128bit atomic operations Subject: [PATCH] Disable 128bit atomic operations
@ -8,7 +8,8 @@ Cranelift doesn't support them yet
library/core/src/panic/unwind_safe.rs | 6 ----- library/core/src/panic/unwind_safe.rs | 6 -----
library/core/src/sync/atomic.rs | 38 --------------------------- library/core/src/sync/atomic.rs | 38 ---------------------------
library/core/tests/atomic.rs | 4 --- library/core/tests/atomic.rs | 4 ---
3 files changed, 48 deletions(-) library/std/src/time/monotonic.rs | 6 +++--
4 files changed, 4 insertions(+), 50 deletions(-)
diff --git a/library/core/src/panic/unwind_safe.rs b/library/core/src/panic/unwind_safe.rs diff --git a/library/core/src/panic/unwind_safe.rs b/library/core/src/panic/unwind_safe.rs
index 092b7cf..158cf71 100644 index 092b7cf..158cf71 100644
@ -35,10 +36,10 @@ index 092b7cf..158cf71 100644
#[cfg(target_has_atomic_load_store = "8")] #[cfg(target_has_atomic_load_store = "8")]
#[stable(feature = "unwind_safe_atomic_refs", since = "1.14.0")] #[stable(feature = "unwind_safe_atomic_refs", since = "1.14.0")]
diff --git a/library/core/src/sync/atomic.rs b/library/core/src/sync/atomic.rs diff --git a/library/core/src/sync/atomic.rs b/library/core/src/sync/atomic.rs
index 0194c58..25a0038 100644 index d9de37e..8293fce 100644
--- a/library/core/src/sync/atomic.rs --- a/library/core/src/sync/atomic.rs
+++ b/library/core/src/sync/atomic.rs +++ b/library/core/src/sync/atomic.rs
@@ -2229,44 +2229,6 @@ atomic_int! { @@ -2234,44 +2234,6 @@ atomic_int! {
"AtomicU64::new(0)", "AtomicU64::new(0)",
u64 AtomicU64 ATOMIC_U64_INIT u64 AtomicU64 ATOMIC_U64_INIT
} }
@ -98,6 +99,38 @@ index b735957..ea728b6 100644
#[cfg(target_has_atomic = "ptr")] #[cfg(target_has_atomic = "ptr")]
assert_eq!(align_of::<AtomicUsize>(), size_of::<AtomicUsize>()); assert_eq!(align_of::<AtomicUsize>(), size_of::<AtomicUsize>());
#[cfg(target_has_atomic = "ptr")] #[cfg(target_has_atomic = "ptr")]
diff --git a/library/std/src/time/monotonic.rs b/library/std/src/time/monotonic.rs
index fa96b7a..2854f9c 100644
--- a/library/std/src/time/monotonic.rs
+++ b/library/std/src/time/monotonic.rs
@@ -5,7 +5,7 @@ pub(super) fn monotonize(raw: time::Instant) -> time::Instant {
inner::monotonize(raw)
}
-#[cfg(all(target_has_atomic = "64", not(target_has_atomic = "128")))]
+#[cfg(target_has_atomic = "64")]
pub mod inner {
use crate::sync::atomic::AtomicU64;
use crate::sync::atomic::Ordering::*;
@@ -70,6 +70,7 @@ pub mod inner {
}
}
+/*
#[cfg(target_has_atomic = "128")]
pub mod inner {
use crate::sync::atomic::AtomicU128;
@@ -94,8 +95,9 @@ pub mod inner {
ZERO.checked_add_duration(&Duration::new(secs, nanos)).unwrap()
}
}
+*/
-#[cfg(not(any(target_has_atomic = "64", target_has_atomic = "128")))]
+#[cfg(not(target_has_atomic = "64"))]
pub mod inner {
use crate::cmp;
use crate::sys::time;
-- --
2.26.2.7.g19db9cfb68 2.26.2.7.g19db9cfb68

2
compiler/rustc_codegen_cranelift/rust-toolchain
View file

@ -1,3 +1,3 @@
[toolchain] [toolchain]
channel = "nightly-2021-08-05" channel = "nightly-2021-09-19"
components = ["rust-src", "rustc-dev", "llvm-tools-preview"] components = ["rust-src", "rustc-dev", "llvm-tools-preview"]

2
compiler/rustc_codegen_cranelift/scripts/test_rustc_tests.sh
View file

@ -11,7 +11,7 @@ pushd rust
cargo install ripgrep cargo install ripgrep
rm -r src/test/ui/{extern/,panics/,unsized-locals/,thinlto/,simd*,*lto*.rs,linkage*,unwind-*.rs} || true rm -r src/test/ui/{extern/,panics/,unsized-locals/,thinlto/,simd*,*lto*.rs,linkage*,unwind-*.rs} || true
for test in $(rg --files-with-matches "asm!|catch_unwind|should_panic|lto" src/test/ui); do for test in $(rg --files-with-matches "asm!|catch_unwind|should_panic|lto|// needs-asm-support" src/test/ui); do
rm $test rm $test
done done

4
compiler/rustc_codegen_cranelift/scripts/tests.sh
View file

@ -137,8 +137,8 @@ function extended_sysroot_tests() {
fi fi
popd popd
pushd stdsimd pushd portable-simd
echo "[TEST] rust-lang/stdsimd" echo "[TEST] rust-lang/portable-simd"
../build/cargo clean ../build/cargo clean
../build/cargo build --all-targets --target $TARGET_TRIPLE ../build/cargo build --all-targets --target $TARGET_TRIPLE
if [[ "$HOST_TRIPLE" = "$TARGET_TRIPLE" ]]; then if [[ "$HOST_TRIPLE" = "$TARGET_TRIPLE" ]]; then

74
compiler/rustc_codegen_cranelift/src/archive.rs
View file

@ -1,17 +1,20 @@
//! Creation of ar archives like for the lib and staticlib crate type //! Creation of ar archives like for the lib and staticlib crate type
use std::collections::BTreeMap; use std::collections::BTreeMap;
use std::convert::TryFrom;
use std::fs::File; use std::fs::File;
use std::io::{self, Read, Seek};
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
use rustc_codegen_ssa::back::archive::ArchiveBuilder; use rustc_codegen_ssa::back::archive::ArchiveBuilder;
use rustc_session::Session; use rustc_session::Session;
use object::{Object, ObjectSymbol, SymbolKind}; use object::read::archive::ArchiveFile;
use object::{Object, ObjectSymbol, ReadCache, SymbolKind};
#[derive(Debug)] #[derive(Debug)]
enum ArchiveEntry { enum ArchiveEntry {
FromArchive { archive_index: usize, entry_index: usize }, FromArchive { archive_index: usize, file_range: (u64, u64) },
File(PathBuf), File(PathBuf),
} }
@ -21,29 +24,28 @@ pub(crate) struct ArArchiveBuilder<'a> {
use_gnu_style_archive: bool, use_gnu_style_archive: bool,
no_builtin_ranlib: bool, no_builtin_ranlib: bool,
src_archives: Vec<(PathBuf, ar::Archive<File>)>, src_archives: Vec<File>,
// Don't use `HashMap` here, as the order is important. `rust.metadata.bin` must always be at // Don't use `HashMap` here, as the order is important. `rust.metadata.bin` must always be at
// the end of an archive for linkers to not get confused. // the end of an archive for linkers to not get confused.
entries: Vec<(String, ArchiveEntry)>, entries: Vec<(Vec<u8>, ArchiveEntry)>,
} }
impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> { impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> {
fn new(sess: &'a Session, output: &Path, input: Option<&Path>) -> Self { fn new(sess: &'a Session, output: &Path, input: Option<&Path>) -> Self {
let (src_archives, entries) = if let Some(input) = input { let (src_archives, entries) = if let Some(input) = input {
let mut archive = ar::Archive::new(File::open(input).unwrap()); let read_cache = ReadCache::new(File::open(input).unwrap());
let archive = ArchiveFile::parse(&read_cache).unwrap();
let mut entries = Vec::new(); let mut entries = Vec::new();
let mut i = 0; for entry in archive.members() {
while let Some(entry) = archive.next_entry() {
let entry = entry.unwrap(); let entry = entry.unwrap();
entries.push(( entries.push((
String::from_utf8(entry.header().identifier().to_vec()).unwrap(), entry.name().to_vec(),
ArchiveEntry::FromArchive { archive_index: 0, entry_index: i }, ArchiveEntry::FromArchive { archive_index: 0, file_range: entry.file_range() },
)); ));
i += 1;
} }
(vec![(input.to_owned(), archive)], entries) (vec![read_cache.into_inner()], entries)
} else { } else {
(vec![], Vec::new()) (vec![], Vec::new())
}; };
@ -61,21 +63,21 @@ impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> {
} }
fn src_files(&mut self) -> Vec<String> { fn src_files(&mut self) -> Vec<String> {
self.entries.iter().map(|(name, _)| name.clone()).collect() self.entries.iter().map(|(name, _)| String::from_utf8(name.clone()).unwrap()).collect()
} }
fn remove_file(&mut self, name: &str) { fn remove_file(&mut self, name: &str) {
let index = self let index = self
.entries .entries
.iter() .iter()
.position(|(entry_name, _)| entry_name == name) .position(|(entry_name, _)| entry_name == name.as_bytes())
.expect("Tried to remove file not existing in src archive"); .expect("Tried to remove file not existing in src archive");
self.entries.remove(index); self.entries.remove(index);
} }
fn add_file(&mut self, file: &Path) { fn add_file(&mut self, file: &Path) {
self.entries.push(( self.entries.push((
file.file_name().unwrap().to_str().unwrap().to_string(), file.file_name().unwrap().to_str().unwrap().to_string().into_bytes(),
ArchiveEntry::File(file.to_owned()), ArchiveEntry::File(file.to_owned()),
)); ));
} }
@ -84,22 +86,23 @@ impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> {
where where
F: FnMut(&str) -> bool + 'static, F: FnMut(&str) -> bool + 'static,
{ {
let mut archive = ar::Archive::new(std::fs::File::open(&archive_path)?); let read_cache = ReadCache::new(std::fs::File::open(&archive_path)?);
let archive = ArchiveFile::parse(&read_cache).unwrap();
let archive_index = self.src_archives.len(); let archive_index = self.src_archives.len();
let mut i = 0; for entry in archive.members() {
while let Some(entry) = archive.next_entry() { let entry = entry.map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))?;
let entry = entry?; let file_name = String::from_utf8(entry.name().to_vec())
let file_name = String::from_utf8(entry.header().identifier().to_vec()) .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))?;
.map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidData, err))?;
if !skip(&file_name) { if !skip(&file_name) {
self.entries self.entries.push((
.push((file_name, ArchiveEntry::FromArchive { archive_index, entry_index: i })); file_name.into_bytes(),
ArchiveEntry::FromArchive { archive_index, file_range: entry.file_range() },
));
} }
i += 1;
} }
self.src_archives.push((archive_path.to_owned(), archive)); self.src_archives.push(read_cache.into_inner());
Ok(()) Ok(())
} }
@ -121,14 +124,14 @@ impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> {
// FIXME only read the symbol table of the object files to avoid having to keep all // FIXME only read the symbol table of the object files to avoid having to keep all
// object files in memory at once, or read them twice. // object files in memory at once, or read them twice.
let data = match entry { let data = match entry {
ArchiveEntry::FromArchive { archive_index, entry_index } => { ArchiveEntry::FromArchive { archive_index, file_range } => {
// FIXME read symbols from symtab // FIXME read symbols from symtab
use std::io::Read; let src_read_cache = &mut self.src_archives[archive_index];
let (ref _src_archive_path, ref mut src_archive) =
self.src_archives[archive_index]; src_read_cache.seek(io::SeekFrom::Start(file_range.0)).unwrap();
let mut entry = src_archive.jump_to_entry(entry_index).unwrap(); let mut data = std::vec::from_elem(0, usize::try_from(file_range.1).unwrap());
let mut data = Vec::new(); src_read_cache.read_exact(&mut data).unwrap();
entry.read_to_end(&mut data).unwrap();
data data
} }
ArchiveEntry::File(file) => std::fs::read(file).unwrap_or_else(|err| { ArchiveEntry::File(file) => std::fs::read(file).unwrap_or_else(|err| {
@ -143,7 +146,7 @@ impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> {
match object::File::parse(&*data) { match object::File::parse(&*data) {
Ok(object) => { Ok(object) => {
symbol_table.insert( symbol_table.insert(
entry_name.as_bytes().to_vec(), entry_name.to_vec(),
object object
.symbols() .symbols()
.filter_map(|symbol| { .filter_map(|symbol| {
@ -168,7 +171,8 @@ impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> {
} else { } else {
sess.fatal(&format!( sess.fatal(&format!(
"error parsing `{}` during archive creation: {}", "error parsing `{}` during archive creation: {}",
entry_name, err String::from_utf8_lossy(&entry_name),
err
)); ));
} }
} }
@ -187,7 +191,7 @@ impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> {
err err
)); ));
}), }),
entries.iter().map(|(name, _)| name.as_bytes().to_vec()).collect(), entries.iter().map(|(name, _)| name.clone()).collect(),
ar::GnuSymbolTableFormat::Size32, ar::GnuSymbolTableFormat::Size32,
symbol_table, symbol_table,
) )
@ -210,7 +214,7 @@ impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> {
// Add all files // Add all files
for (entry_name, data) in entries.into_iter() { for (entry_name, data) in entries.into_iter() {
let header = ar::Header::new(entry_name.into_bytes(), data.len() as u64); let header = ar::Header::new(entry_name, data.len() as u64);
match builder { match builder {
BuilderKind::Bsd(ref mut builder) => builder.append(&header, &mut &*data).unwrap(), BuilderKind::Bsd(ref mut builder) => builder.append(&header, &mut &*data).unwrap(),
BuilderKind::Gnu(ref mut builder) => builder.append(&header, &mut &*data).unwrap(), BuilderKind::Gnu(ref mut builder) => builder.append(&header, &mut &*data).unwrap(),

152
compiler/rustc_codegen_cranelift/src/backend.rs
View file

@ -1,152 +0,0 @@
//! Abstraction around the object writing crate
use std::convert::{TryFrom, TryInto};
use rustc_data_structures::fx::FxHashMap;
use rustc_session::Session;
use cranelift_codegen::isa::TargetIsa;
use cranelift_module::FuncId;
use cranelift_object::{ObjectBuilder, ObjectModule, ObjectProduct};
use object::write::*;
use object::{RelocationEncoding, SectionKind, SymbolFlags};
use gimli::SectionId;
use crate::debuginfo::{DebugReloc, DebugRelocName};
pub(crate) trait WriteMetadata {
fn add_rustc_section(&mut self, symbol_name: String, data: Vec<u8>);
}
impl WriteMetadata for object::write::Object {
fn add_rustc_section(&mut self, symbol_name: String, data: Vec<u8>) {
let segment = self.segment_name(object::write::StandardSegment::Data).to_vec();
let section_id = self.add_section(segment, b".rustc".to_vec(), object::SectionKind::Data);
let offset = self.append_section_data(section_id, &data, 1);
// For MachO and probably PE this is necessary to prevent the linker from throwing away the
// .rustc section. For ELF this isn't necessary, but it also doesn't harm.
self.add_symbol(object::write::Symbol {
name: symbol_name.into_bytes(),
value: offset,
size: data.len() as u64,
kind: object::SymbolKind::Data,
scope: object::SymbolScope::Dynamic,
weak: false,
section: SymbolSection::Section(section_id),
flags: SymbolFlags::None,
});
}
}
pub(crate) trait WriteDebugInfo {
type SectionId: Copy;
fn add_debug_section(&mut self, name: SectionId, data: Vec<u8>) -> Self::SectionId;
fn add_debug_reloc(
&mut self,
section_map: &FxHashMap<SectionId, Self::SectionId>,
from: &Self::SectionId,
reloc: &DebugReloc,
);
}
impl WriteDebugInfo for ObjectProduct {
type SectionId = (object::write::SectionId, object::write::SymbolId);
fn add_debug_section(
&mut self,
id: SectionId,
data: Vec<u8>,
) -> (object::write::SectionId, object::write::SymbolId) {
let name = if self.object.format() == object::BinaryFormat::MachO {
id.name().replace('.', "__") // machO expects __debug_info instead of .debug_info
} else {
id.name().to_string()
}
.into_bytes();
let segment = self.object.segment_name(StandardSegment::Debug).to_vec();
// FIXME use SHT_X86_64_UNWIND for .eh_frame
let section_id = self.object.add_section(
segment,
name,
if id == SectionId::EhFrame { SectionKind::ReadOnlyData } else { SectionKind::Debug },
);
self.object
.section_mut(section_id)
.set_data(data, if id == SectionId::EhFrame { 8 } else { 1 });
let symbol_id = self.object.section_symbol(section_id);
(section_id, symbol_id)
}
fn add_debug_reloc(
&mut self,
section_map: &FxHashMap<SectionId, Self::SectionId>,
from: &Self::SectionId,
reloc: &DebugReloc,
) {
let (symbol, symbol_offset) = match reloc.name {
DebugRelocName::Section(id) => (section_map.get(&id).unwrap().1, 0),
DebugRelocName::Symbol(id) => {
let symbol_id = self.function_symbol(FuncId::from_u32(id.try_into().unwrap()));
self.object
.symbol_section_and_offset(symbol_id)
.expect("Debug reloc for undef sym???")
}
};
self.object
.add_relocation(
from.0,
Relocation {
offset: u64::from(reloc.offset),
symbol,
kind: reloc.kind,
encoding: RelocationEncoding::Generic,
size: reloc.size * 8,
addend: i64::try_from(symbol_offset).unwrap() + reloc.addend,
},
)
.unwrap();
}
}
pub(crate) fn with_object(sess: &Session, name: &str, f: impl FnOnce(&mut Object)) -> Vec<u8> {
let triple = crate::target_triple(sess);
let binary_format = match triple.binary_format {
target_lexicon::BinaryFormat::Elf => object::BinaryFormat::Elf,
target_lexicon::BinaryFormat::Coff => object::BinaryFormat::Coff,
target_lexicon::BinaryFormat::Macho => object::BinaryFormat::MachO,
binary_format => sess.fatal(&format!("binary format {} is unsupported", binary_format)),
};
let architecture = match triple.architecture {
target_lexicon::Architecture::X86_32(_) => object::Architecture::I386,
target_lexicon::Architecture::X86_64 => object::Architecture::X86_64,
target_lexicon::Architecture::Arm(_) => object::Architecture::Arm,
target_lexicon::Architecture::Aarch64(_) => object::Architecture::Aarch64,
architecture => {
sess.fatal(&format!("target architecture {:?} is unsupported", architecture,))
}
};
let endian = match triple.endianness().unwrap() {
target_lexicon::Endianness::Little => object::Endianness::Little,
target_lexicon::Endianness::Big => object::Endianness::Big,
};
let mut metadata_object = object::write::Object::new(binary_format, architecture, endian);
metadata_object.add_file_symbol(name.as_bytes().to_vec());
f(&mut metadata_object);
metadata_object.write().unwrap()
}
pub(crate) fn make_module(sess: &Session, isa: Box<dyn TargetIsa>, name: String) -> ObjectModule {
let mut builder =
ObjectBuilder::new(isa, name + ".o", cranelift_module::default_libcall_names()).unwrap();
// Unlike cg_llvm, cg_clif defaults to disabling -Zfunction-sections. For cg_llvm binary size
// is important, while cg_clif cares more about compilation times. Enabling -Zfunction-sections
// can easily double the amount of time necessary to perform linking.
builder.per_function_section(sess.opts.debugging_opts.function_sections.unwrap_or(false));
ObjectModule::new(builder)
}

3
compiler/rustc_codegen_cranelift/src/bin/cg_clif.rs
View file

@ -1,4 +1,7 @@
#![feature(rustc_private, once_cell)] #![feature(rustc_private, once_cell)]
#![warn(rust_2018_idioms)]
#![warn(unused_lifetimes)]
#![warn(unreachable_pub)]
extern crate rustc_data_structures; extern crate rustc_data_structures;
extern crate rustc_driver; extern crate rustc_driver;

3
compiler/rustc_codegen_cranelift/src/bin/cg_clif_build_sysroot.rs
View file

@ -7,6 +7,9 @@
//! target crates. //! target crates.
#![feature(rustc_private)] #![feature(rustc_private)]
#![warn(rust_2018_idioms)]
#![warn(unused_lifetimes)]
#![warn(unreachable_pub)]
extern crate rustc_driver; extern crate rustc_driver;
extern crate rustc_interface; extern crate rustc_interface;

6
compiler/rustc_codegen_cranelift/src/debuginfo/emit.rs
View file

@ -1,16 +1,16 @@
//! Write the debuginfo into an object file. //! Write the debuginfo into an object file.
use cranelift_object::ObjectProduct;
use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::fx::FxHashMap;
use gimli::write::{Address, AttributeValue, EndianVec, Result, Sections, Writer}; use gimli::write::{Address, AttributeValue, EndianVec, Result, Sections, Writer};
use gimli::{RunTimeEndian, SectionId}; use gimli::{RunTimeEndian, SectionId};
use crate::backend::WriteDebugInfo; use super::object::WriteDebugInfo;
use super::DebugContext; use super::DebugContext;
impl DebugContext<'_> { impl DebugContext<'_> {
pub(crate) fn emit<P: WriteDebugInfo>(&mut self, product: &mut P) { pub(crate) fn emit(&mut self, product: &mut ObjectProduct) {
let unit_range_list_id = self.dwarf.unit.ranges.add(self.unit_range_list.clone()); let unit_range_list_id = self.dwarf.unit.ranges.add(self.unit_range_list.clone());
let root = self.dwarf.unit.root(); let root = self.dwarf.unit.root();
let root = self.dwarf.unit.get_mut(root); let root = self.dwarf.unit.get_mut(root);

1
compiler/rustc_codegen_cranelift/src/debuginfo/mod.rs
View file

@ -2,6 +2,7 @@
mod emit; mod emit;
mod line_info; mod line_info;
mod object;
mod unwind; mod unwind;
use crate::prelude::*; use crate::prelude::*;

85
compiler/rustc_codegen_cranelift/src/debuginfo/object.rs Normal file
View file

@ -0,0 +1,85 @@
use std::convert::{TryFrom, TryInto};
use rustc_data_structures::fx::FxHashMap;
use cranelift_module::FuncId;
use cranelift_object::ObjectProduct;
use object::write::{Relocation, StandardSegment};
use object::{RelocationEncoding, SectionKind};
use gimli::SectionId;
use crate::debuginfo::{DebugReloc, DebugRelocName};
pub(super) trait WriteDebugInfo {
type SectionId: Copy;
fn add_debug_section(&mut self, name: SectionId, data: Vec<u8>) -> Self::SectionId;
fn add_debug_reloc(
&mut self,
section_map: &FxHashMap<SectionId, Self::SectionId>,
from: &Self::SectionId,
reloc: &DebugReloc,
);
}
impl WriteDebugInfo for ObjectProduct {
type SectionId = (object::write::SectionId, object::write::SymbolId);
fn add_debug_section(
&mut self,
id: SectionId,
data: Vec<u8>,
) -> (object::write::SectionId, object::write::SymbolId) {
let name = if self.object.format() == object::BinaryFormat::MachO {
id.name().replace('.', "__") // machO expects __debug_info instead of .debug_info
} else {
id.name().to_string()
}
.into_bytes();
let segment = self.object.segment_name(StandardSegment::Debug).to_vec();
// FIXME use SHT_X86_64_UNWIND for .eh_frame
let section_id = self.object.add_section(
segment,
name,
if id == SectionId::EhFrame { SectionKind::ReadOnlyData } else { SectionKind::Debug },
);
self.object
.section_mut(section_id)
.set_data(data, if id == SectionId::EhFrame { 8 } else { 1 });
let symbol_id = self.object.section_symbol(section_id);
(section_id, symbol_id)
}
fn add_debug_reloc(
&mut self,
section_map: &FxHashMap<SectionId, Self::SectionId>,
from: &Self::SectionId,
reloc: &DebugReloc,
) {
let (symbol, symbol_offset) = match reloc.name {
DebugRelocName::Section(id) => (section_map.get(&id).unwrap().1, 0),
DebugRelocName::Symbol(id) => {
let symbol_id = self.function_symbol(FuncId::from_u32(id.try_into().unwrap()));
self.object
.symbol_section_and_offset(symbol_id)
.expect("Debug reloc for undef sym???")
}
};
self.object
.add_relocation(
from.0,
Relocation {
offset: u64::from(reloc.offset),
symbol,
kind: reloc.kind,
encoding: RelocationEncoding::Generic,
size: reloc.size * 8,
addend: i64::try_from(symbol_offset).unwrap() + reloc.addend,
},
)
.unwrap();
}
}

5
compiler/rustc_codegen_cranelift/src/debuginfo/unwind.rs
View file

@ -4,10 +4,11 @@ use crate::prelude::*;
use cranelift_codegen::isa::{unwind::UnwindInfo, TargetIsa}; use cranelift_codegen::isa::{unwind::UnwindInfo, TargetIsa};
use cranelift_object::ObjectProduct;
use gimli::write::{Address, CieId, EhFrame, FrameTable, Section}; use gimli::write::{Address, CieId, EhFrame, FrameTable, Section};
use gimli::RunTimeEndian; use gimli::RunTimeEndian;
use crate::backend::WriteDebugInfo; use super::object::WriteDebugInfo;
pub(crate) struct UnwindContext { pub(crate) struct UnwindContext {
endian: RunTimeEndian, endian: RunTimeEndian,
@ -55,7 +56,7 @@ impl UnwindContext {
} }
} }
pub(crate) fn emit<P: WriteDebugInfo>(self, product: &mut P) { pub(crate) fn emit(self, product: &mut ObjectProduct) {
let mut eh_frame = EhFrame::from(super::emit::WriterRelocate::new(self.endian)); let mut eh_frame = EhFrame::from(super::emit::WriterRelocate::new(self.endian));
self.frame_table.write_eh_frame(&mut eh_frame).unwrap(); self.frame_table.write_eh_frame(&mut eh_frame).unwrap();

23
compiler/rustc_codegen_cranelift/src/driver/aot.rs
View file

@ -11,8 +11,10 @@ use rustc_middle::middle::cstore::EncodedMetadata;
use rustc_middle::mir::mono::{CodegenUnit, MonoItem}; use rustc_middle::mir::mono::{CodegenUnit, MonoItem};
use rustc_session::cgu_reuse_tracker::CguReuse; use rustc_session::cgu_reuse_tracker::CguReuse;
use rustc_session::config::{DebugInfo, OutputType}; use rustc_session::config::{DebugInfo, OutputType};
use rustc_session::Session;
use cranelift_object::ObjectModule; use cranelift_codegen::isa::TargetIsa;
use cranelift_object::{ObjectBuilder, ObjectModule};
use crate::{prelude::*, BackendConfig}; use crate::{prelude::*, BackendConfig};
@ -24,6 +26,16 @@ impl<HCX> HashStable<HCX> for ModuleCodegenResult {
} }
} }
fn make_module(sess: &Session, isa: Box<dyn TargetIsa>, name: String) -> ObjectModule {
let mut builder =
ObjectBuilder::new(isa, name + ".o", cranelift_module::default_libcall_names()).unwrap();
// Unlike cg_llvm, cg_clif defaults to disabling -Zfunction-sections. For cg_llvm binary size
// is important, while cg_clif cares more about compilation times. Enabling -Zfunction-sections
// can easily double the amount of time necessary to perform linking.
builder.per_function_section(sess.opts.debugging_opts.function_sections.unwrap_or(false));
ObjectModule::new(builder)
}
fn emit_module( fn emit_module(
tcx: TyCtxt<'_>, tcx: TyCtxt<'_>,
backend_config: &BackendConfig, backend_config: &BackendConfig,
@ -104,7 +116,7 @@ fn module_codegen(
let mono_items = cgu.items_in_deterministic_order(tcx); let mono_items = cgu.items_in_deterministic_order(tcx);
let isa = crate::build_isa(tcx.sess, &backend_config); let isa = crate::build_isa(tcx.sess, &backend_config);
let mut module = crate::backend::make_module(tcx.sess, isa, cgu_name.as_str().to_string()); let mut module = make_module(tcx.sess, isa, cgu_name.as_str().to_string());
let mut cx = crate::CodegenCx::new( let mut cx = crate::CodegenCx::new(
tcx, tcx,
@ -227,8 +239,7 @@ pub(crate) fn run_aot(
tcx.sess.abort_if_errors(); tcx.sess.abort_if_errors();
let isa = crate::build_isa(tcx.sess, &backend_config); let isa = crate::build_isa(tcx.sess, &backend_config);
let mut allocator_module = let mut allocator_module = make_module(tcx.sess, isa, "allocator_shim".to_string());
crate::backend::make_module(tcx.sess, isa, "allocator_shim".to_string());
assert_eq!(pointer_ty(tcx), allocator_module.target_config().pointer_type()); assert_eq!(pointer_ty(tcx), allocator_module.target_config().pointer_type());
let mut allocator_unwind_context = UnwindContext::new(tcx, allocator_module.isa(), true); let mut allocator_unwind_context = UnwindContext::new(tcx, allocator_module.isa(), true);
let created_alloc_shim = let created_alloc_shim =
@ -266,9 +277,7 @@ pub(crate) fn run_aot(
let tmp_file = let tmp_file =
tcx.output_filenames(()).temp_path(OutputType::Metadata, Some(&metadata_cgu_name)); tcx.output_filenames(()).temp_path(OutputType::Metadata, Some(&metadata_cgu_name));
let obj = crate::backend::with_object(tcx.sess, &metadata_cgu_name, |object| { let obj = crate::metadata::new_metadata_object(tcx, &metadata_cgu_name, &metadata);
crate::metadata::write_metadata(tcx, object);
});
if let Err(err) = std::fs::write(&tmp_file, obj) { if let Err(err) = std::fs::write(&tmp_file, obj) {
tcx.sess.fatal(&format!("error writing metadata object file: {}", err)); tcx.sess.fatal(&format!("error writing metadata object file: {}", err));

4
compiler/rustc_codegen_cranelift/src/lib.rs
View file

@ -1,4 +1,5 @@
#![feature(rustc_private, decl_macro, never_type, hash_drain_filter, vec_into_raw_parts, once_cell)] #![feature(rustc_private, decl_macro)]
#![cfg_attr(feature = "jit", feature(never_type, vec_into_raw_parts, once_cell))]
#![warn(rust_2018_idioms)] #![warn(rust_2018_idioms)]
#![warn(unused_lifetimes)] #![warn(unused_lifetimes)]
#![warn(unreachable_pub)] #![warn(unreachable_pub)]
@ -44,7 +45,6 @@ mod abi;
mod allocator; mod allocator;
mod analyze; mod analyze;
mod archive; mod archive;
mod backend;
mod base; mod base;
mod cast; mod cast;
mod codegen_i128; mod codegen_i128;

68
compiler/rustc_codegen_cranelift/src/metadata.rs
View file

@ -1,20 +1,72 @@
//! Writing of the rustc metadata for dylibs //! Writing of the rustc metadata for dylibs
use object::write::{Object, StandardSegment, Symbol, SymbolSection};
use object::{SectionKind, SymbolFlags, SymbolKind, SymbolScope};
use rustc_middle::middle::cstore::EncodedMetadata;
use rustc_middle::ty::TyCtxt; use rustc_middle::ty::TyCtxt;
use crate::backend::WriteMetadata;
// Adapted from https://github.com/rust-lang/rust/blob/da573206f87b5510de4b0ee1a9c044127e409bd3/src/librustc_codegen_llvm/base.rs#L47-L112 // Adapted from https://github.com/rust-lang/rust/blob/da573206f87b5510de4b0ee1a9c044127e409bd3/src/librustc_codegen_llvm/base.rs#L47-L112
pub(crate) fn write_metadata<O: WriteMetadata>(tcx: TyCtxt<'_>, object: &mut O) { pub(crate) fn new_metadata_object(tcx: TyCtxt<'_>, cgu_name: &str, metadata: &EncodedMetadata) -> Vec<u8> {
use snap::write::FrameEncoder; use snap::write::FrameEncoder;
use std::io::Write; use std::io::Write;
let metadata = tcx.encode_metadata();
let mut compressed = rustc_metadata::METADATA_HEADER.to_vec(); let mut compressed = rustc_metadata::METADATA_HEADER.to_vec();
FrameEncoder::new(&mut compressed).write_all(&metadata.raw_data).unwrap(); FrameEncoder::new(&mut compressed).write_all(&metadata.raw_data).unwrap();
object.add_rustc_section( let triple = crate::target_triple(tcx.sess);
rustc_middle::middle::exported_symbols::metadata_symbol_name(tcx),
compressed, let binary_format = match triple.binary_format {
); target_lexicon::BinaryFormat::Elf => object::BinaryFormat::Elf,
target_lexicon::BinaryFormat::Coff => object::BinaryFormat::Coff,
target_lexicon::BinaryFormat::Macho => object::BinaryFormat::MachO,
binary_format => tcx.sess.fatal(&format!("binary format {} is unsupported", binary_format)),
};
let architecture = match triple.architecture {
target_lexicon::Architecture::Aarch64(_) => object::Architecture::Aarch64,
target_lexicon::Architecture::Arm(_) => object::Architecture::Arm,
target_lexicon::Architecture::Avr => object::Architecture::Avr,
target_lexicon::Architecture::Hexagon => object::Architecture::Hexagon,
target_lexicon::Architecture::Mips32(_) => object::Architecture::Mips,
target_lexicon::Architecture::Mips64(_) => object::Architecture::Mips64,
target_lexicon::Architecture::Msp430 => object::Architecture::Msp430,
target_lexicon::Architecture::Powerpc => object::Architecture::PowerPc,
target_lexicon::Architecture::Powerpc64 => object::Architecture::PowerPc64,
target_lexicon::Architecture::Powerpc64le => todo!(),
target_lexicon::Architecture::Riscv32(_) => object::Architecture::Riscv32,
target_lexicon::Architecture::Riscv64(_) => object::Architecture::Riscv64,
target_lexicon::Architecture::S390x => object::Architecture::S390x,
target_lexicon::Architecture::Sparc64 => object::Architecture::Sparc64,
target_lexicon::Architecture::Sparcv9 => object::Architecture::Sparc64,
target_lexicon::Architecture::X86_32(_) => object::Architecture::I386,
target_lexicon::Architecture::X86_64 => object::Architecture::X86_64,
architecture => {
tcx.sess.fatal(&format!("target architecture {:?} is unsupported", architecture,))
}
};
let endian = match triple.endianness().unwrap() {
target_lexicon::Endianness::Little => object::Endianness::Little,
target_lexicon::Endianness::Big => object::Endianness::Big,
};
let mut object = Object::new(binary_format, architecture, endian);
object.add_file_symbol(cgu_name.as_bytes().to_vec());
let segment = object.segment_name(StandardSegment::Data).to_vec();
let section_id = object.add_section(segment, b".rustc".to_vec(), SectionKind::Data);
let offset = object.append_section_data(section_id, &compressed, 1);
// For MachO and probably PE this is necessary to prevent the linker from throwing away the
// .rustc section. For ELF this isn't necessary, but it also doesn't harm.
object.add_symbol(Symbol {
name: rustc_middle::middle::exported_symbols::metadata_symbol_name(tcx).into_bytes(),
value: offset,
size: compressed.len() as u64,
kind: SymbolKind::Data,
scope: SymbolScope::Dynamic,
weak: false,
section: SymbolSection::Section(section_id),
flags: SymbolFlags::None,
});
object.write().unwrap()
} }