[SOL] Adjust SBF customization after upgrading to rust 1.68.0

dmakarov · LucasSte · commit c8a63647d086 · 2024-08-22T14:23:46.000-03:00
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -76,6 +76,7 @@ jobs:
             os: ubuntu-20.04-16core-64gb
             env: {}
           - name: sbf-solana-solana
+            tidy: false
             os: ubuntu-latest
             env: {}
           - name: x86_64-gnu-tools
@@ -235,6 +236,9 @@ jobs:
       - name: install sccache
         run: src/ci/scripts/install-sccache.sh
         if: success() && !env.SKIP_JOB
+      - name: select Xcode
+        run: src/ci/scripts/select-xcode.sh
+        if: success() && !env.SKIP_JOB
       - name: install clang
         run: src/ci/scripts/install-clang.sh
         if: success() && !env.SKIP_JOB
diff --git a/compiler/rustc_target/src/spec/sbf_base.rs b/compiler/rustc_target/src/spec/sbf_base.rs
@@ -1,5 +1,5 @@
 use crate::abi::Endian;
-use super::{cvs, LinkArgs, LinkerFlavor, PanicStrategy, TargetOptions, LldFlavor};
+use super::{Cc, cvs, LinkerFlavor, Lld, PanicStrategy, TargetOptions};
 
 pub fn opts() -> TargetOptions {
     let linker_script = r"
@@ -28,13 +28,10 @@ SECTIONS
     }
 }
 ";
-    let mut lld_args = Vec::new();
-    lld_args.push("--threads=1".into());
-    lld_args.push("-z".into());
-    lld_args.push("notext".into());
-    let mut pre_link_args = LinkArgs::new();
-    pre_link_args.insert(LinkerFlavor::Ld, lld_args.clone());
-    pre_link_args.insert(LinkerFlavor::Lld(LldFlavor::Ld), lld_args);
+    let pre_link_args = TargetOptions::link_args(
+        LinkerFlavor::Gnu(Cc::No, Lld::No),
+        &["--threads=1", "-z", "notext"],
+    );
 
     TargetOptions {
         allow_asm: true,
@@ -50,8 +47,7 @@ SECTIONS
         families: cvs!["solana"],
         link_script: Some(linker_script.into()),
         linker: Some("rust-lld".into()),
-        linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld),
-        linker_is_gnu: true,
+        linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
         main_needs_argc_argv: false,
         max_atomic_width: Some(64),
         no_default_libraries: true,
diff --git a/config.toml b/config.toml
@@ -108,6 +108,8 @@ link-shared = false
 # Which LLVM projects to build along with the LLVM base libraries/tools
 enable-projects = "clang;lld;lldb"
 
+download-ci-llvm = false
+
 # =============================================================================
 # General build configuration options
 # =============================================================================
diff --git a/library/core/tests/slice.rs b/library/core/tests/slice.rs
@@ -1801,19 +1801,19 @@ fn brute_force_rotate_test_1() {
 }
 
 #[test]
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(not(any(target_arch = "wasm32", target_family = "solana")))]
 fn sort_unstable() {
     use core::cmp::Ordering::{Equal, Greater, Less};
     use core::slice::heapsort;
     use rand::{seq::SliceRandom, Rng};
 
     // Miri is too slow (but still need to `chain` to make the types match)
-    let lens = if cfg!(miri) { (2..20).chain(0..0) } else { (2..25).chain(200..210) };
+    let lens = if cfg!(miri) { (2..20).chain(0..0) } else { (2..25).chain(500..510) };
     let rounds = if cfg!(miri) { 1 } else { 100 };
 
-    let mut v = [0; 300];
-    let mut tmp = [0; 300];
-    let mut rng = StdRng::seed_from_u64(0);
+    let mut v = [0; 600];
+    let mut tmp = [0; 600];
+    let mut rng = crate::test_rng();
 
     for len in lens {
         let v = &mut v[0..len];
@@ -1875,16 +1875,16 @@ fn sort_unstable() {
 }
 
 #[test]
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(not(any(target_arch = "wasm32", target_family = "solana")))]
 #[cfg_attr(miri, ignore)] // Miri is too slow
 fn select_nth_unstable() {
     use core::cmp::Ordering::{Equal, Greater, Less};
     use rand::seq::SliceRandom;
     use rand::Rng;
 
-    let mut rng = StdRng::seed_from_u64(0);
+    let mut rng = crate::test_rng();
 
-    for len in (2..21).chain(200..201) {
+    for len in (2..21).chain(500..501) {
         let mut orig = vec![0; len];
 
         for &modulus in &[5, 10, 1000] {
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
@@ -23,7 +23,7 @@ hashbrown = { version = "0.14", default-features = false, features = ['rustc-dep
 std_detect = { path = "../stdarch/crates/std_detect", default-features = false, features = ['rustc-dep-of-std'] }
 
 # Dependencies of the `backtrace` crate
-[target.'cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))'.dependencies]
+[target.'cfg(not(target_family = "solana"))'.dependencies]
 addr2line = { version = "0.21.0", optional = true, default-features = false }
 rustc-demangle = { version = "0.1.21", features = ['rustc-dep-of-std'] }
 
diff --git a/library/std/src/error.rs b/library/std/src/error.rs
@@ -4,7 +4,7 @@
 #[cfg(test)]
 mod tests;
 
-#[cfg(not(target_os = "solana"))]
+#[cfg(not(target_family = "solana"))]
 use crate::backtrace::Backtrace;
 use crate::fmt::{self, Write};
 
@@ -450,6 +450,7 @@ impl<E> Report<E>
 where
     E: Error,
 {
+    #[cfg(not(target_family = "solana"))]
     fn backtrace(&self) -> Option<&Backtrace> {
         // have to grab the backtrace on the first error directly since that error may not be
         // 'static
@@ -500,6 +501,7 @@ where
             }
         }
 
+        #[cfg(not(target_family = "solana"))]
         if self.show_backtrace {
             let backtrace = self.backtrace();
 
diff --git a/library/std/src/io/mod.rs b/library/std/src/io/mod.rs
@@ -310,6 +310,7 @@ use core::slice::memchr;
 pub use self::buffered::WriterPanicked;
 #[unstable(feature = "raw_os_error_ty", issue = "107792")]
 pub use self::error::RawOsError;
+#[cfg(not(target_family = "solana"))]
 pub(crate) use self::stdio::attempt_print_to_stderr;
 #[stable(feature = "is_terminal", since = "1.70.0")]
 pub use self::stdio::IsTerminal;
diff --git a/library/std/src/io/stdio.rs b/library/std/src/io/stdio.rs
@@ -8,6 +8,7 @@ use crate::io::prelude::*;
 #[cfg(not(target_family = "solana"))]
 use crate::cell::{Cell, RefCell};
 use crate::fmt;
+#[cfg(not(target_family = "solana"))]
 use crate::fs::File;
 #[cfg(not(target_os = "solana"))]
 use crate::io::{
@@ -1337,6 +1338,7 @@ where
     }
 }
 
+#[cfg(not(target_family = "solana"))]
 fn print_to_buffer_if_capture_used(args: fmt::Arguments<'_>) -> bool {
     OUTPUT_CAPTURE_USED.load(Ordering::Relaxed)
         && OUTPUT_CAPTURE.try_with(|s| {
@@ -1353,6 +1355,7 @@ fn print_to_buffer_if_capture_used(args: fmt::Arguments<'_>) -> bool {
 /// Used by impl Termination for Result to print error after `main` or a test
 /// has returned. Should avoid panicking, although we can't help it if one of
 /// the Display impls inside args decides to.
+#[cfg(not(target_family = "solana"))]
 pub(crate) fn attempt_print_to_stderr(args: fmt::Arguments<'_>) {
     if print_to_buffer_if_capture_used(args) {
         return;
@@ -1384,6 +1387,7 @@ pub trait IsTerminal: crate::sealed::Sealed {
     fn is_terminal(&self) -> bool;
 }
 
+#[cfg(not(target_family = "solana"))]
 macro_rules! impl_is_terminal {
     ($($t:ty),*$(,)?) => {$(
         #[unstable(feature = "sealed", issue = "none")]
@@ -1399,6 +1403,7 @@ macro_rules! impl_is_terminal {
     )*}
 }
 
+#[cfg(not(target_family = "solana"))]
 impl_is_terminal!(File, Stdin, StdinLock<'_>, Stdout, StdoutLock<'_>, Stderr, StderrLock<'_>);
 
 #[unstable(
diff --git a/library/std/src/panicking.rs b/library/std/src/panicking.rs
@@ -25,14 +25,13 @@ use crate::mem;
 use crate::process;
 #[cfg(not(target_family = "solana"))]
 use crate::sync::atomic::{AtomicBool, Ordering};
+#[cfg(not(target_family = "solana"))]
 use crate::sync::{PoisonError, RwLock};
-#[cfg(not(target_os = "solana"))]
+#[cfg(not(target_family = "solana"))]
 use crate::sys::stdio::panic_output;
 #[cfg(not(target_family = "solana"))]
 use crate::sys_common::backtrace;
 #[cfg(not(target_family = "solana"))]
-use crate::sys_common::rwlock::StaticRwLock;
-#[cfg(not(target_family = "solana"))]
 use crate::sys_common::thread_info;
 #[cfg(not(target_family = "solana"))]
 use crate::thread;
@@ -83,7 +82,7 @@ extern "C" fn __rust_foreign_exception() -> ! {
     rtabort!("Rust cannot catch foreign exceptions");
 }
 
-#[cfg(not(target_os = "solana"))]
+#[cfg(not(target_family = "solana"))]
 enum Hook {
     Default,
     Custom(Box<dyn Fn(&PanicInfo<'_>) + 'static + Sync + Send>),
@@ -100,15 +99,15 @@ impl Hook {
     }
 }
 
-#[cfg(not(target_os = "solana"))]
+#[cfg(not(target_family = "solana"))]
 impl Default for Hook {
     #[inline]
     fn default() -> Hook {
         Hook::Default
     }
 }
 
-#[cfg(not(target_os = "solana"))]
+#[cfg(not(target_family = "solana"))]
 static HOOK: RwLock<Hook> = RwLock::new(Hook::Default);
 
 /// Registers a custom panic hook, replacing the previously registered hook.
@@ -448,7 +447,7 @@ pub mod panic_count {
     //
     // This also updates thread-local state to keep track of whether a panic
     // hook is currently executing.
-    #[cfg(not(target_os = "solana"))]
+    #[cfg(not(target_family = "solana"))]
     pub fn increase(run_panic_hook: bool) -> Option<MustAbort> {
         let global_count = GLOBAL_PANIC_COUNT.fetch_add(1, Ordering::Relaxed);
         if global_count & ALWAYS_ABORT_FLAG != 0 {
@@ -516,7 +515,7 @@ pub mod panic_count {
 
     // Slow path is in a separate function to reduce the amount of code
     // inlined from `count_is_zero`.
-    #[cfg(not(target_os = "solana"))]
+    #[cfg(not(target_family = "solana"))]
     #[inline(never)]
     #[cold]
     fn is_zero_slow_path() -> bool {
diff --git a/library/std/src/process.rs b/library/std/src/process.rs
@@ -2441,10 +2441,15 @@ impl<T: Termination, E: fmt::Debug> Termination for Result<T, E> {
     fn report(self) -> ExitCode {
         match self {
             Ok(val) => val.report(),
+            #[cfg(not(target_family = "solana"))]
             Err(err) => {
                 io::attempt_print_to_stderr(format_args_nl!("Error: {err:?}"));
                 ExitCode::FAILURE
             }
+            #[cfg(target_family = "solana")]
+            Err(_err) => {
+                ExitCode::FAILURE
+            }
         }
     }
 }
diff --git a/library/std/src/rt.rs b/library/std/src/rt.rs
@@ -179,6 +179,7 @@ fn lang_start<T: crate::process::Termination + 'static>(
     main: fn() -> T,
     _argc: isize,
     _argv: *const *const u8,
+    _sigpipe: u8,
 ) -> isize {
     main().report().to_i32() as isize
 }
diff --git a/library/std/src/sync/mod.rs b/library/std/src/sync/mod.rs
@@ -185,6 +185,7 @@ pub use self::lazy_lock::LazyLock;
 pub use self::once_lock::OnceLock;
 
 #[unstable(feature = "reentrant_lock", issue = "121440")]
+#[cfg(not(target_family = "solana"))]
 pub use self::reentrant_lock::{ReentrantLock, ReentrantLockGuard};
 
 pub mod mpsc;
diff --git a/library/std/src/sync/mpmc/utils.rs b/library/std/src/sync/mpmc/utils.rs
@@ -3,6 +3,7 @@ use crate::ops::{Deref, DerefMut};
 
 /// Pads and aligns a value to the length of a cache line.
 #[derive(Clone, Copy, Default, Hash, PartialEq, Eq)]
+#[cfg_attr(target_family = "solana", repr(align(8)))]
 // Starting from Intel's Sandy Bridge, spatial prefetcher is now pulling pairs of 64-byte cache
 // lines at a time, so we have to align to 128 bytes rather than 64.
 //
@@ -66,6 +67,7 @@ use crate::ops::{Deref, DerefMut};
         target_arch = "mips64r6",
         target_arch = "riscv64",
         target_arch = "s390x",
+        target_family = "solana",
     )),
     repr(align(64))
 )]
diff --git a/library/std/src/sys/sbf/futex.rs b/library/std/src/sys/sbf/futex.rs
@@ -0,0 +1,14 @@
+use crate::sync::atomic::AtomicU32;
+use crate::time::Duration;
+
+pub fn futex_wait(_futex: &AtomicU32, _expected: u32, _timeout: Option<Duration>) -> bool {
+    false
+}
+
+#[inline]
+pub fn futex_wake(_futex: &AtomicU32) -> bool {
+    false
+}
+
+#[inline]
+pub fn futex_wake_all(_futex: &AtomicU32) {}
diff --git a/library/std/src/sys/sbf/mod.rs b/library/std/src/sys/sbf/mod.rs
@@ -20,6 +20,7 @@ pub mod args;
 pub mod cmath;
 pub mod env;
 pub mod fs;
+pub mod futex;
 pub mod io;
 pub mod memchr;
 pub mod net;
@@ -34,16 +35,17 @@ pub mod time;
 #[path = "../unix/os_str.rs"]
 pub mod os_str;
 
-pub mod condvar;
-pub mod mutex;
-pub mod rwlock;
 pub mod thread_local_dtor;
 pub mod thread_local_key;
 
+#[path = "../unix/locks"]
 pub mod locks {
-    pub use super::condvar::*;
-    pub use super::mutex::*;
-    pub use super::rwlock::*;
+    mod futex_condvar;
+    mod futex_mutex;
+    mod futex_rwlock;
+    pub(crate) use futex_condvar::Condvar;
+    pub(crate) use futex_mutex::Mutex;
+    pub(crate) use futex_rwlock::RwLock;
 }
 
 #[cfg(not(target_feature = "static-syscalls"))]
diff --git a/library/std/src/sys/sbf/pipe.rs b/library/std/src/sys/sbf/pipe.rs
@@ -18,6 +18,10 @@ impl AnonPipe {
         false
     }
 
+    pub fn read_to_end(&self, _buf: &mut Vec<u8>) -> io::Result<usize> {
+        match self.0 {}
+    }
+
     pub fn write(&self, _buf: &[u8]) -> io::Result<usize> {
         match self.0 {}
     }
diff --git a/library/std/src/sys/sbf/process.rs b/library/std/src/sys/sbf/process.rs
@@ -65,6 +65,10 @@ impl Command {
         unsupported()
     }
 
+    pub fn output(&mut self) -> io::Result<(ExitStatus, Vec<u8>, Vec<u8>)> {
+        unsupported()
+    }
+
     pub fn get_args(&self) -> CommandArgs<'_> {
         let mut iter = self.args.iter();
         iter.next();
diff --git a/library/std/src/sys/sbf/thread_local_key.rs b/library/std/src/sys/sbf/thread_local_key.rs
@@ -1,3 +1,4 @@
+#![allow(fuzzy_provenance_casts)]
 use crate::boxed::Box;
 use crate::ptr;
 
@@ -33,8 +34,3 @@ pub unsafe fn destroy(key: Key) {
         f(key.value);
     }
 }
-
-#[inline]
-pub fn requires_synchronized_create() -> bool {
-    false
-}
diff --git a/library/std/src/sys/sync/once/mod.rs b/library/std/src/sys/sync/once/mod.rs
@@ -17,6 +17,7 @@ cfg_if::cfg_if! {
         target_os = "dragonfly",
         target_os = "fuchsia",
         target_os = "hermit",
+        target_os = "solana",
     ))] {
         mod futex;
         pub use futex::{Once, OnceState};
diff --git a/library/std/src/thread/mod.rs b/library/std/src/thread/mod.rs
@@ -1298,7 +1298,7 @@ impl ThreadId {
                         Err(id) => last = id,
                     }
                 }
-            } else if #[cfg(not(target_os = "solana"))] {
+            } else if #[cfg(not(target_family = "solana"))] {
                 use crate::sync::{Mutex, PoisonError};
 
                 static COUNTER: Mutex<u64> = Mutex::new(0);
diff --git a/library/test/src/cli.rs b/library/test/src/cli.rs
diff --git a/library/test/src/lib.rs b/library/test/src/lib.rs
diff --git a/src/ci/docker/host-x86_64/sbf-solana-solana/Dockerfile b/src/ci/docker/host-x86_64/sbf-solana-solana/Dockerfile
diff --git a/src/ci/github-actions/ci.yml b/src/ci/github-actions/ci.yml

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`	`#[cfg(test)]`
`5`	`5`	`mod tests;`
`6`	`6`
`7`		`-#[cfg(not(target_os = "solana"))]`
	`7`	`+#[cfg(not(target_family = "solana"))]`
`8`	`8`	`use crate::backtrace::Backtrace;`
`9`	`9`	`use crate::fmt::{self, Write};`
`10`	`10`
`@@ -450,6 +450,7 @@ impl<E> Report<E>`
`450`	`450`	`where`
`451`	`451`	`E: Error,`
`452`	`452`	`{`
	`453`	`+ #[cfg(not(target_family = "solana"))]`
`453`	`454`	`fn backtrace(&self) -> Option<&Backtrace> {`
`454`	`455`	`// have to grab the backtrace on the first error directly since that error may not be`
`455`	`456`	`// 'static`
`@@ -500,6 +501,7 @@ where`
`500`	`501`	`}`
`501`	`502`	`}`
`502`	`503`
	`504`	`+ #[cfg(not(target_family = "solana"))]`
`503`	`505`	`if self.show_backtrace {`
`504`	`506`	`let backtrace = self.backtrace();`
`505`	`507`
Original file line number	Diff line number	Diff line change
`@@ -2441,10 +2441,15 @@ impl<T: Termination, E: fmt::Debug> Termination for Result<T, E> {`
`2441`	`2441`	`fn report(self) -> ExitCode {`
`2442`	`2442`	`match self {`
`2443`	`2443`	`Ok(val) => val.report(),`
	`2444`	`+ #[cfg(not(target_family = "solana"))]`
`2444`	`2445`	`Err(err) => {`
`2445`	`2446`	`io::attempt_print_to_stderr(format_args_nl!("Error: {err:?}"));`
`2446`	`2447`	`ExitCode::FAILURE`
`2447`	`2448`	`}`
	`2449`	`+ #[cfg(target_family = "solana")]`
	`2450`	`+ Err(_err) => {`
	`2451`	`+ ExitCode::FAILURE`
	`2452`	`+ }`
`2448`	`2453`	`}`
`2449`	`2454`	`}`
`2450`	`2455`	`}`