/rand
/regex
/simple-raytracer
-/stdsimd
+/portable-simd
[[package]]
name = "cranelift-bforest"
-version = "0.75.0"
-source = "git+https://github.com/bytecodealliance/wasmtime.git#5deda279775dca5e37449c829cda1f6276d6542b"
+version = "0.76.0"
+source = "git+https://github.com/bytecodealliance/wasmtime.git#9c550fcf41425942ed97c747f0169b2ca81f9c1b"
dependencies = [
"cranelift-entity",
]
[[package]]
name = "cranelift-codegen"
-version = "0.75.0"
-source = "git+https://github.com/bytecodealliance/wasmtime.git#5deda279775dca5e37449c829cda1f6276d6542b"
+version = "0.76.0"
+source = "git+https://github.com/bytecodealliance/wasmtime.git#9c550fcf41425942ed97c747f0169b2ca81f9c1b"
dependencies = [
"cranelift-bforest",
"cranelift-codegen-meta",
[[package]]
name = "cranelift-codegen-meta"
-version = "0.75.0"
-source = "git+https://github.com/bytecodealliance/wasmtime.git#5deda279775dca5e37449c829cda1f6276d6542b"
+version = "0.76.0"
+source = "git+https://github.com/bytecodealliance/wasmtime.git#9c550fcf41425942ed97c747f0169b2ca81f9c1b"
dependencies = [
"cranelift-codegen-shared",
"cranelift-entity",
[[package]]
name = "cranelift-codegen-shared"
-version = "0.75.0"
-source = "git+https://github.com/bytecodealliance/wasmtime.git#5deda279775dca5e37449c829cda1f6276d6542b"
+version = "0.76.0"
+source = "git+https://github.com/bytecodealliance/wasmtime.git#9c550fcf41425942ed97c747f0169b2ca81f9c1b"
[[package]]
name = "cranelift-entity"
-version = "0.75.0"
-source = "git+https://github.com/bytecodealliance/wasmtime.git#5deda279775dca5e37449c829cda1f6276d6542b"
+version = "0.76.0"
+source = "git+https://github.com/bytecodealliance/wasmtime.git#9c550fcf41425942ed97c747f0169b2ca81f9c1b"
[[package]]
name = "cranelift-frontend"
-version = "0.75.0"
-source = "git+https://github.com/bytecodealliance/wasmtime.git#5deda279775dca5e37449c829cda1f6276d6542b"
+version = "0.76.0"
+source = "git+https://github.com/bytecodealliance/wasmtime.git#9c550fcf41425942ed97c747f0169b2ca81f9c1b"
dependencies = [
"cranelift-codegen",
"log",
[[package]]
name = "cranelift-jit"
-version = "0.75.0"
-source = "git+https://github.com/bytecodealliance/wasmtime.git#5deda279775dca5e37449c829cda1f6276d6542b"
+version = "0.76.0"
+source = "git+https://github.com/bytecodealliance/wasmtime.git#9c550fcf41425942ed97c747f0169b2ca81f9c1b"
dependencies = [
"anyhow",
"cranelift-codegen",
[[package]]
name = "cranelift-module"
-version = "0.75.0"
-source = "git+https://github.com/bytecodealliance/wasmtime.git#5deda279775dca5e37449c829cda1f6276d6542b"
+version = "0.76.0"
+source = "git+https://github.com/bytecodealliance/wasmtime.git#9c550fcf41425942ed97c747f0169b2ca81f9c1b"
dependencies = [
"anyhow",
"cranelift-codegen",
[[package]]
name = "cranelift-native"
-version = "0.75.0"
-source = "git+https://github.com/bytecodealliance/wasmtime.git#5deda279775dca5e37449c829cda1f6276d6542b"
+version = "0.76.0"
+source = "git+https://github.com/bytecodealliance/wasmtime.git#9c550fcf41425942ed97c747f0169b2ca81f9c1b"
dependencies = [
"cranelift-codegen",
"libc",
[[package]]
name = "cranelift-object"
-version = "0.75.0"
-source = "git+https://github.com/bytecodealliance/wasmtime.git#5deda279775dca5e37449c829cda1f6276d6542b"
+version = "0.76.0"
+source = "git+https://github.com/bytecodealliance/wasmtime.git#9c550fcf41425942ed97c747f0169b2ca81f9c1b"
dependencies = [
"anyhow",
"cranelift-codegen",
[[package]]
name = "addr2line"
-version = "0.14.1"
+version = "0.16.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a55f82cfe485775d02112886f4169bde0c5894d75e79ead7eafe7e40a25e45f7"
+checksum = "3e61f2b7f93d2c7d2b08263acaa4a363b3e276806c68af6134c44f523bf1aacd"
dependencies = [
"compiler_builtins",
"gimli",
[[package]]
name = "cc"
-version = "1.0.69"
+version = "1.0.70"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e70cc2f62c6ce1868963827bd677764c62d07c3d9a3e1fb1177ee1a9ab199eb2"
+checksum = "d26a6ce4b6a484fa3edb70f7efa6fc430fd2b87285fe8b84304fd0936faa0dc0"
[[package]]
name = "cfg-if"
[[package]]
name = "compiler_builtins"
-version = "0.1.46"
+version = "0.1.50"
dependencies = [
"rustc-std-workspace-core",
]
[[package]]
name = "gimli"
-version = "0.23.0"
+version = "0.25.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6503fe142514ca4799d4c26297c4248239fe8838d827db6bd6065c6ed29a6ce"
+checksum = "f0a01e0497841a3b2db4f8afa483cce65f7e96a3498bd6c541734792aeac8fe7"
dependencies = [
"compiler_builtins",
"rustc-std-workspace-alloc",
[[package]]
name = "libc"
-version = "0.2.98"
+version = "0.2.102"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "320cfe77175da3a483efed4bc0adc1968ca050b098ce4f2f1c13a56626128790"
+checksum = "a2a5ac8f984bfcf3a823267e5fde638acc3325f6496633a5da6bb6eb2171e103"
dependencies = [
"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]]
name = "miniz_oxide"
version = "0.4.4"
[[package]]
name = "object"
-version = "0.22.0"
+version = "0.26.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d3b63360ec3cb337817c2dbd47ab4a0f170d285d8e5a2064600f3def1402397"
+checksum = "39f37e50073ccad23b6d09bcb5b263f4e76d3bb6038e4a3c08e52162ffa8abc2"
dependencies = [
"compiler_builtins",
+ "memchr",
"rustc-std-workspace-alloc",
"rustc-std-workspace-core",
]
[[package]]
name = "rustc-demangle"
-version = "0.1.20"
+version = "0.1.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dead70b0b5e03e9c814bcb6b01e03e68f7c57a80aa48c72ec92152ab3e818d49"
+checksum = "7ef03e0a2b150c7a90d01faf6254c9c48a41e95fb2a8c2ac1c6f0d2b9aefc342"
dependencies = [
"compiler_builtins",
"rustc-std-workspace-core",
[[package]]
name = "unicode-width"
-version = "0.1.8"
+version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3"
+checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
dependencies = [
"compiler_builtins",
"rustc-std-workspace-core",
);
clone_repo(
- "stdsimd",
- "https://github.com/rust-lang/stdsimd",
- "be96995d8ddec03fac9a0caf4d4c51c7fbc33507",
+ "portable-simd",
+ "https://github.com/rust-lang/portable-simd",
+ "8cf7a62e5d2552961df51e5200aaa5b7c890a4bf",
);
- apply_patches("stdsimd", Path::new("stdsimd"));
+ apply_patches("portable-simd", Path::new("portable-simd"));
clone_repo(
"simple-raytracer",
clone_repo(
"build_sysroot/compiler-builtins",
"https://github.com/rust-lang/compiler-builtins.git",
- "0.1.46",
+ "0.1.50",
);
apply_patches("compiler-builtins", Path::new("build_sysroot/compiler-builtins"));
}
rm -rf build_sysroot/{sysroot_src/,target/,compiler-builtins/,rustc_version}
rm -rf target/ build/ perf.data{,.old}
-rm -rf rand/ regex/ simple-raytracer/ stdsimd/
+rm -rf rand/ regex/ simple-raytracer/ portable-simd/
## 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.
> This requires all dependencies to be available as dynamic library.
-#![feature(start, core_intrinsics, alloc_prelude, alloc_error_handler)]
+#![feature(start, core_intrinsics, alloc_prelude, alloc_error_handler, box_syntax)]
#![no_std]
extern crate alloc;
-#![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]
#![allow(dead_code, non_camel_case_types)]
--- /dev/null
+From 6bfce5dc2cbf834c74dbccb7538adc08c6eb57e7 Mon Sep 17 00:00:00 2001
+From: bjorn3 <bjorn3@users.noreply.github.com>
+Date: Sun, 25 Jul 2021 18:39:31 +0200
+Subject: [PATCH] Disable unsupported tests
+
+---
+ crates/core_simd/src/vector.rs | 2 ++
+ crates/core_simd/src/math.rs | 4 ++++
+ crates/core_simd/tests/masks.rs | 12 ------------
+ crates/core_simd/tests/ops_macros.rs | 6 ++++++
+ crates/core_simd/tests/round.rs | 2 ++
+ 6 files changed, 15 insertions(+), 13 deletions(-)
+
+diff --git a/crates/core_simd/src/vector.rs b/crates/core_simd/src/vector.rs
+index 25c5309..2b3d819 100644
+--- a/crates/core_simd/src/vector.rs
++++ b/crates/core_simd/src/vector.rs
+@@ -22,6 +22,7 @@ where
+ self.0
+ }
+
++ /*
+ /// SIMD gather: construct a SIMD vector by reading from a slice, using potentially discontiguous indices.
+ /// If an index is out of bounds, that lane instead selects the value from the "or" vector.
+ /// ```
+@@ -150,6 +151,7 @@ where
+ // Cleared ☢️ *mut T Zone
+ }
+ }
++ */
+ }
+
+ impl<T, const LANES: usize> Copy for Simd<T, LANES>
+diff --git a/crates/core_simd/src/math.rs b/crates/core_simd/src/math.rs
+index 7290a28..e394730 100644
+--- a/crates/core_simd/src/math.rs
++++ b/crates/core_simd/src/math.rs
+@@ -2,6 +2,7 @@ macro_rules! impl_uint_arith {
+ ($($ty:ty),+) => {
+ $( impl<const LANES: usize> Simd<$ty, LANES> where LaneCount<LANES>: SupportedLaneCount {
+
++ /*
+ /// Lanewise saturating add.
+ ///
+ /// # Examples
+@@ -38,6 +39,7 @@ macro_rules! impl_uint_arith {
+ pub fn saturating_sub(self, second: Self) -> Self {
+ unsafe { crate::intrinsics::simd_saturating_sub(self, second) }
+ }
++ */
+ })+
+ }
+ }
+@@ -46,6 +48,7 @@ macro_rules! impl_int_arith {
+ ($($ty:ty),+) => {
+ $( impl<const LANES: usize> Simd<$ty, LANES> where LaneCount<LANES>: SupportedLaneCount {
+
++ /*
+ /// Lanewise saturating add.
+ ///
+ /// # Examples
+@@ -141,6 +144,7 @@ macro_rules! impl_int_arith {
+ pub fn saturating_neg(self) -> Self {
+ Self::splat(0).saturating_sub(self)
+ }
++ */
+ })+
+ }
+ }
+diff --git a/crates/core_simd/tests/masks.rs b/crates/core_simd/tests/masks.rs
+index 61d8e44..2bccae2 100644
+--- a/crates/core_simd/tests/masks.rs
++++ b/crates/core_simd/tests/masks.rs
+@@ -67,19 +67,6 @@ macro_rules! test_mask_api {
+ assert_eq!(int.to_array(), [-1, 0, 0, -1, 0, 0, -1, 0]);
+ assert_eq!(core_simd::Mask::<$type, 8>::from_int(int), mask);
+ }
+-
+- #[cfg(feature = "generic_const_exprs")]
+- #[test]
+- fn roundtrip_bitmask_conversion() {
+- let values = [
+- true, false, false, true, false, false, true, false,
+- true, true, false, false, false, false, false, true,
+- ];
+- let mask = core_simd::Mask::<$type, 16>::from_array(values);
+- let bitmask = mask.to_bitmask();
+- assert_eq!(bitmask, [0b01001001, 0b10000011]);
+- assert_eq!(core_simd::Mask::<$type, 16>::from_bitmask(bitmask), mask);
+- }
+ }
+ }
+ }
+diff --git a/crates/core_simd/tests/ops_macros.rs b/crates/core_simd/tests/ops_macros.rs
+index cb39e73..fc0ebe1 100644
+--- a/crates/core_simd/tests/ops_macros.rs
++++ b/crates/core_simd/tests/ops_macros.rs
+@@ -435,6 +435,7 @@ macro_rules! impl_float_tests {
+ )
+ }
+
++ /*
+ fn mul_add<const LANES: usize>() {
+ test_helpers::test_ternary_elementwise(
+ &Vector::<LANES>::mul_add,
+@@ -442,6 +443,7 @@ macro_rules! impl_float_tests {
+ &|_, _, _| true,
+ )
+ }
++ */
+
+ fn recip<const LANES: usize>() {
+ test_helpers::test_unary_elementwise(
+@@ -581,6 +585,7 @@ macro_rules! impl_float_tests {
+ });
+ }
+
++ /*
+ fn horizontal_max<const LANES: usize>() {
+ test_helpers::test_1(&|x| {
+ let vmax = Vector::<LANES>::from_array(x).horizontal_max();
+@@ -604,6 +609,7 @@ macro_rules! impl_float_tests {
+ Ok(())
+ });
+ }
++ */
+ }
+
+ #[cfg(feature = "std")]
+diff --git a/crates/core_simd/tests/round.rs b/crates/core_simd/tests/round.rs
+index 37044a7..4cdc6b7 100644
+--- a/crates/core_simd/tests/round.rs
++++ b/crates/core_simd/tests/round.rs
+@@ -25,6 +25,7 @@ macro_rules! float_rounding_test {
+ )
+ }
+
++ /*
+ fn round<const LANES: usize>() {
+ test_helpers::test_unary_elementwise(
+ &Vector::<LANES>::round,
+@@ -32,6 +33,7 @@ macro_rules! float_rounding_test {
+ &|_| true,
+ )
+ }
++ */
+
+ fn trunc<const LANES: usize>() {
+ test_helpers::test_unary_elementwise(
+--
+2.26.2.7.g19db9cfb68
+
+++ /dev/null
-From 6bfce5dc2cbf834c74dbccb7538adc08c6eb57e7 Mon Sep 17 00:00:00 2001
-From: bjorn3 <bjorn3@users.noreply.github.com>
-Date: Sun, 25 Jul 2021 18:39:31 +0200
-Subject: [PATCH] Disable unsupported tests
-
----
- crates/core_simd/src/array.rs | 2 ++
- crates/core_simd/src/lib.rs | 2 +-
- crates/core_simd/src/math.rs | 4 ++++
- crates/core_simd/tests/masks.rs | 12 ------------
- crates/core_simd/tests/ops_macros.rs | 6 ++++++
- crates/core_simd/tests/round.rs | 2 ++
- 6 files changed, 15 insertions(+), 13 deletions(-)
-
-diff --git a/crates/core_simd/src/array.rs b/crates/core_simd/src/array.rs
-index 25c5309..2b3d819 100644
---- a/crates/core_simd/src/array.rs
-+++ b/crates/core_simd/src/array.rs
-@@ -22,6 +22,7 @@ where
- #[must_use]
- fn splat(val: Self::Scalar) -> Self;
-
-+ /*
- /// SIMD gather: construct a SIMD vector by reading from a slice, using potentially discontiguous indices.
- /// If an index is out of bounds, that lane instead selects the value from the "or" vector.
- /// ```
-@@ -150,6 +151,7 @@ where
- // Cleared ☢️ *mut T Zone
- }
- }
-+ */
- }
-
- macro_rules! impl_simdarray_for {
-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
-index 7290a28..e394730 100644
---- a/crates/core_simd/src/math.rs
-+++ b/crates/core_simd/src/math.rs
-@@ -2,6 +2,7 @@ macro_rules! impl_uint_arith {
- ($(($name:ident, $n:ident)),+) => {
- $( impl<const LANES: usize> $name<LANES> where Self: crate::LanesAtMost32 {
-
-+ /*
- /// Lanewise saturating add.
- ///
- /// # Examples
-@@ -38,6 +39,7 @@ macro_rules! impl_uint_arith {
- pub fn saturating_sub(self, second: Self) -> Self {
- unsafe { crate::intrinsics::simd_saturating_sub(self, second) }
- }
-+ */
- })+
- }
- }
-@@ -46,6 +48,7 @@ macro_rules! impl_int_arith {
- ($(($name:ident, $n:ident)),+) => {
- $( impl<const LANES: usize> $name<LANES> where Self: crate::LanesAtMost32 {
-
-+ /*
- /// Lanewise saturating add.
- ///
- /// # Examples
-@@ -141,6 +144,7 @@ macro_rules! impl_int_arith {
- pub fn saturating_neg(self) -> Self {
- Self::splat(0).saturating_sub(self)
- }
-+ */
- })+
- }
- }
-diff --git a/crates/core_simd/tests/masks.rs b/crates/core_simd/tests/masks.rs
-index 61d8e44..2bccae2 100644
---- a/crates/core_simd/tests/masks.rs
-+++ b/crates/core_simd/tests/masks.rs
-@@ -67,18 +67,6 @@ macro_rules! test_mask_api {
- assert_eq!(int.to_array(), [-1, 0, 0, -1, 0, 0, -1, 0]);
- assert_eq!(core_simd::$name::<8>::from_int(int), mask);
- }
--
-- #[test]
-- fn roundtrip_bitmask_conversion() {
-- let values = [
-- true, false, false, true, false, false, true, false,
-- true, true, false, false, false, false, false, true,
-- ];
-- let mask = core_simd::$name::<16>::from_array(values);
-- let bitmask = mask.to_bitmask();
-- assert_eq!(bitmask, [0b01001001, 0b10000011]);
-- assert_eq!(core_simd::$name::<16>::from_bitmask(bitmask), mask);
-- }
- }
- }
- }
-diff --git a/crates/core_simd/tests/ops_macros.rs b/crates/core_simd/tests/ops_macros.rs
-index cb39e73..fc0ebe1 100644
---- a/crates/core_simd/tests/ops_macros.rs
-+++ b/crates/core_simd/tests/ops_macros.rs
-@@ -435,6 +435,7 @@ macro_rules! impl_float_tests {
- )
- }
-
-+ /*
- fn mul_add<const LANES: usize>() {
- test_helpers::test_ternary_elementwise(
- &Vector::<LANES>::mul_add,
-@@ -442,6 +443,7 @@ macro_rules! impl_float_tests {
- &|_, _, _| true,
- )
- }
-+ */
-
- fn sqrt<const LANES: usize>() {
- test_helpers::test_unary_elementwise(
-@@ -581,6 +585,7 @@ macro_rules! impl_float_tests {
- });
- }
-
-+ /*
- fn horizontal_max<const LANES: usize>() {
- test_helpers::test_1(&|x| {
- let vmax = Vector::<LANES>::from_array(x).horizontal_max();
-@@ -604,6 +609,7 @@ macro_rules! impl_float_tests {
- Ok(())
- });
- }
-+ */
- }
- }
- }
-diff --git a/crates/core_simd/tests/round.rs b/crates/core_simd/tests/round.rs
-index 37044a7..4cdc6b7 100644
---- a/crates/core_simd/tests/round.rs
-+++ b/crates/core_simd/tests/round.rs
-@@ -25,6 +25,7 @@ macro_rules! float_rounding_test {
- )
- }
-
-+ /*
- fn round<const LANES: usize>() {
- test_helpers::test_unary_elementwise(
- &Vector::<LANES>::round,
-@@ -32,6 +33,7 @@ macro_rules! float_rounding_test {
- &|_| true,
- )
- }
-+ */
-
- fn trunc<const LANES: usize>() {
- test_helpers::test_unary_elementwise(
---
-2.26.2.7.g19db9cfb68
-
-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>
Date: Thu, 18 Feb 2021 18:45:28 +0100
Subject: [PATCH] Disable 128bit atomic operations
library/core/src/panic/unwind_safe.rs | 6 -----
library/core/src/sync/atomic.rs | 38 ---------------------------
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
index 092b7cf..158cf71 100644
#[cfg(target_has_atomic_load_store = "8")]
#[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
-index 0194c58..25a0038 100644
+index d9de37e..8293fce 100644
--- a/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)",
u64 AtomicU64 ATOMIC_U64_INIT
}
#[cfg(target_has_atomic = "ptr")]
assert_eq!(align_of::<AtomicUsize>(), size_of::<AtomicUsize>());
#[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
[toolchain]
-channel = "nightly-2021-08-05"
+channel = "nightly-2021-09-19"
components = ["rust-src", "rustc-dev", "llvm-tools-preview"]
cargo install ripgrep
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
done
fi
popd
- pushd stdsimd
- echo "[TEST] rust-lang/stdsimd"
+ pushd portable-simd
+ echo "[TEST] rust-lang/portable-simd"
../build/cargo clean
../build/cargo build --all-targets --target $TARGET_TRIPLE
if [[ "$HOST_TRIPLE" = "$TARGET_TRIPLE" ]]; then
//! Creation of ar archives like for the lib and staticlib crate type
use std::collections::BTreeMap;
+use std::convert::TryFrom;
use std::fs::File;
+use std::io::{self, Read, Seek};
use std::path::{Path, PathBuf};
use rustc_codegen_ssa::back::archive::ArchiveBuilder;
use rustc_session::Session;
-use object::{Object, ObjectSymbol, SymbolKind};
+use object::read::archive::ArchiveFile;
+use object::{Object, ObjectSymbol, ReadCache, SymbolKind};
#[derive(Debug)]
enum ArchiveEntry {
- FromArchive { archive_index: usize, entry_index: usize },
+ FromArchive { archive_index: usize, file_range: (u64, u64) },
File(PathBuf),
}
use_gnu_style_archive: 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
// 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> {
fn new(sess: &'a Session, output: &Path, input: Option<&Path>) -> Self {
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 i = 0;
- while let Some(entry) = archive.next_entry() {
+ for entry in archive.members() {
let entry = entry.unwrap();
entries.push((
- String::from_utf8(entry.header().identifier().to_vec()).unwrap(),
- ArchiveEntry::FromArchive { archive_index: 0, entry_index: i },
+ entry.name().to_vec(),
+ 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 {
(vec![], Vec::new())
};
}
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) {
let index = self
.entries
.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");
self.entries.remove(index);
}
fn add_file(&mut self, file: &Path) {
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()),
));
}
where
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 mut i = 0;
- while let Some(entry) = archive.next_entry() {
- let entry = entry?;
- let file_name = String::from_utf8(entry.header().identifier().to_vec())
- .map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidData, err))?;
+ for entry in archive.members() {
+ let entry = entry.map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))?;
+ let file_name = String::from_utf8(entry.name().to_vec())
+ .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))?;
if !skip(&file_name) {
- self.entries
- .push((file_name, ArchiveEntry::FromArchive { archive_index, entry_index: i }));
+ self.entries.push((
+ 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(())
}
// 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.
let data = match entry {
- ArchiveEntry::FromArchive { archive_index, entry_index } => {
+ ArchiveEntry::FromArchive { archive_index, file_range } => {
// FIXME read symbols from symtab
- use std::io::Read;
- let (ref _src_archive_path, ref mut src_archive) =
- self.src_archives[archive_index];
- let mut entry = src_archive.jump_to_entry(entry_index).unwrap();
- let mut data = Vec::new();
- entry.read_to_end(&mut data).unwrap();
+ let src_read_cache = &mut self.src_archives[archive_index];
+
+ src_read_cache.seek(io::SeekFrom::Start(file_range.0)).unwrap();
+ let mut data = std::vec::from_elem(0, usize::try_from(file_range.1).unwrap());
+ src_read_cache.read_exact(&mut data).unwrap();
+
data
}
ArchiveEntry::File(file) => std::fs::read(file).unwrap_or_else(|err| {
match object::File::parse(&*data) {
Ok(object) => {
symbol_table.insert(
- entry_name.as_bytes().to_vec(),
+ entry_name.to_vec(),
object
.symbols()
.filter_map(|symbol| {
} else {
sess.fatal(&format!(
"error parsing `{}` during archive creation: {}",
- entry_name, err
+ String::from_utf8_lossy(&entry_name),
+ err
));
}
}
err
));
}),
- entries.iter().map(|(name, _)| name.as_bytes().to_vec()).collect(),
+ entries.iter().map(|(name, _)| name.clone()).collect(),
ar::GnuSymbolTableFormat::Size32,
symbol_table,
)
// Add all files
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 {
BuilderKind::Bsd(ref mut builder) => builder.append(&header, &mut &*data).unwrap(),
BuilderKind::Gnu(ref mut builder) => builder.append(&header, &mut &*data).unwrap(),
+++ /dev/null
-//! 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)
-}
#![feature(rustc_private, once_cell)]
+#![warn(rust_2018_idioms)]
+#![warn(unused_lifetimes)]
+#![warn(unreachable_pub)]
extern crate rustc_data_structures;
extern crate rustc_driver;
//! target crates.
#![feature(rustc_private)]
+#![warn(rust_2018_idioms)]
+#![warn(unused_lifetimes)]
+#![warn(unreachable_pub)]
-extern crate rustc_data_structures;
extern crate rustc_driver;
extern crate rustc_interface;
extern crate rustc_session;
//! Write the debuginfo into an object file.
+use cranelift_object::ObjectProduct;
use rustc_data_structures::fx::FxHashMap;
use gimli::write::{Address, AttributeValue, EndianVec, Result, Sections, Writer};
use gimli::{RunTimeEndian, SectionId};
-use crate::backend::WriteDebugInfo;
-
+use super::object::WriteDebugInfo;
use super::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 root = self.dwarf.unit.root();
let root = self.dwarf.unit.get_mut(root);
mod emit;
mod line_info;
+mod object;
mod unwind;
use crate::prelude::*;
--- /dev/null
+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();
+ }
+}
use cranelift_codegen::isa::{unwind::UnwindInfo, TargetIsa};
+use cranelift_object::ObjectProduct;
use gimli::write::{Address, CieId, EhFrame, FrameTable, Section};
use gimli::RunTimeEndian;
-use crate::backend::WriteDebugInfo;
+use super::object::WriteDebugInfo;
pub(crate) struct UnwindContext {
endian: RunTimeEndian,
}
}
- 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));
self.frame_table.write_eh_frame(&mut eh_frame).unwrap();
use rustc_middle::mir::mono::{CodegenUnit, MonoItem};
use rustc_session::cgu_reuse_tracker::CguReuse;
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};
}
}
+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(
tcx: TyCtxt<'_>,
backend_config: &BackendConfig,
let mono_items = cgu.items_in_deterministic_order(tcx);
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(
tcx,
tcx.sess.abort_if_errors();
let isa = crate::build_isa(tcx.sess, &backend_config);
- let mut allocator_module =
- crate::backend::make_module(tcx.sess, isa, "allocator_shim".to_string());
+ let mut allocator_module = make_module(tcx.sess, isa, "allocator_shim".to_string());
assert_eq!(pointer_ty(tcx), allocator_module.target_config().pointer_type());
let mut allocator_unwind_context = UnwindContext::new(tcx, allocator_module.isa(), true);
let created_alloc_shim =
let tmp_file =
tcx.output_filenames(()).temp_path(OutputType::Metadata, Some(&metadata_cgu_name));
- let obj = crate::backend::with_object(tcx.sess, &metadata_cgu_name, |object| {
- crate::metadata::write_metadata(tcx, object);
- });
+ let obj = crate::metadata::new_metadata_object(tcx, &metadata_cgu_name, &metadata);
if let Err(err) = std::fs::write(&tmp_file, obj) {
tcx.sess.fatal(&format!("error writing metadata object file: {}", err));
-#![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(unused_lifetimes)]
#![warn(unreachable_pub)]
mod allocator;
mod analyze;
mod archive;
-mod backend;
mod base;
mod cast;
mod codegen_i128;
//! Writing of the rustc metadata for dylibs
-use rustc_middle::ty::TyCtxt;
+use object::write::{Object, StandardSegment, Symbol, SymbolSection};
+use object::{SectionKind, SymbolFlags, SymbolKind, SymbolScope};
-use crate::backend::WriteMetadata;
+use rustc_middle::middle::cstore::EncodedMetadata;
+use rustc_middle::ty::TyCtxt;
// 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 std::io::Write;
- let metadata = tcx.encode_metadata();
let mut compressed = rustc_metadata::METADATA_HEADER.to_vec();
FrameEncoder::new(&mut compressed).write_all(&metadata.raw_data).unwrap();
- object.add_rustc_section(
- rustc_middle::middle::exported_symbols::metadata_symbol_name(tcx),
- compressed,
- );
+ let triple = crate::target_triple(tcx.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 => 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()
}
projects / rust.git / commitdiff