[SOL] Adjust BPF customization after upgrading to rust 1.59.0

Author: dmakarov

compiler/rustc_codegen_gcc/src/type_.rs

@@ -26,10 +26,6 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
         }
     }
 
-    pub fn type_void(&self) -> Type<'gcc> {
-        self.context.new_type::<()>()
-    }
-
     pub fn type_size_t(&self) -> Type<'gcc> {
         self.context.new_type::<usize>()
     }
@@ -136,6 +132,10 @@ impl<'gcc, 'tcx> BaseTypeMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         unimplemented!("f16_f128")
     }
 
+    fn type_void(&self) -> Type<'gcc> {
+        self.context.new_type::<()>()
+    }
+
     fn type_func(&self, params: &[Type<'gcc>], return_type: Type<'gcc>) -> Type<'gcc> {
         self.context.new_function_pointer_type(None, return_type, params, false)
     }

library/core/tests/array.rs

@@ -511,6 +511,7 @@ fn array_rsplit_array_mut_out_of_bounds() {
 }
 
 #[test]
+#[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
 fn array_intoiter_advance_by() {
     use std::cell::Cell;
     struct DropCounter<'a>(usize, &'a Cell<usize>);
@@ -564,6 +565,7 @@ fn array_intoiter_advance_by() {
 }
 
 #[test]
+#[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
 fn array_intoiter_advance_back_by() {
     use std::cell::Cell;
     struct DropCounter<'a>(usize, &'a Cell<usize>);

library/std/src/io/mod.rs

@@ -344,6 +344,7 @@ mod util;
 
 const DEFAULT_BUF_SIZE: usize = crate::sys_common::io::DEFAULT_BUF_SIZE;
 
+#[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
 pub(crate) use stdio::cleanup;
 
 struct Guard<'a> {

library/std/src/io/stdio.rs

@@ -632,10 +632,6 @@ impl Read for Stdin {
     fn is_read_vectored(&self) -> bool {
         false
     }
-    #[inline]
-    unsafe fn initializer(&self) -> Initializer {
-        Initializer::nop()
-    }
     fn read_to_end(&mut self, _buf: &mut Vec<u8>) -> io::Result<usize> {
         Ok(0)
     }

library/std/src/panicking.rs

@@ -944,23 +944,6 @@ pub fn rust_begin_panic(info: &PanicInfo<'_>) -> ! {
     crate::sys::panic(info);
 }
 
-/// The entry point for panicking with a formatted message SBF version.
-#[cfg(any(target_arch = "bpf", target_arch = "sbf"))]
-#[unstable(feature = "libstd_sys_internals", reason = "used by the panic! macro", issue = "none")]
-#[cold]
-// If panic_immediate_abort, inline the abort call,
-// otherwise avoid inlining because of it is cold path.
-#[cfg_attr(not(feature = "panic_immediate_abort"), track_caller)]
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never))]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
-pub fn begin_panic_fmt(msg: &fmt::Arguments<'_>) -> ! {
-    let info = PanicInfo::internal_constructor(
-        Some(msg),
-        Location::caller(),
-    );
-    crate::sys::panic(&info);
-}
-
 /// Entry point of panicking for panic!() and assert!() SBF version.
 #[cfg(any(target_arch = "bpf", target_arch = "sbf"))]
 #[unstable(feature = "libstd_sys_internals", reason = "used by the panic! macro", issue = "none")]
@@ -978,3 +961,20 @@ pub fn begin_panic<M: Any + Send>(_msg: M) -> ! {
     );
     crate::sys::panic(&info);
 }
+
+/// The entry point for panicking with a formatted message SBF version.
+#[cfg(any(target_arch = "bpf", target_arch = "sbf"))]
+#[unstable(feature = "libstd_sys_internals", reason = "used by the panic! macro", issue = "none")]
+#[cold]
+// If panic_immediate_abort, inline the abort call,
+// otherwise avoid inlining because of it is cold path.
+#[cfg_attr(not(feature = "panic_immediate_abort"), track_caller)]
+#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never))]
+#[cfg_attr(feature = "panic_immediate_abort", inline)]
+pub fn begin_panic_fmt(msg: &fmt::Arguments<'_>) -> ! {
+    let info = PanicInfo::internal_constructor(
+        Some(msg),
+        Location::caller(),
+    );
+    crate::sys::panic(&info);
+}

library/std/src/rt.rs

@@ -20,8 +20,11 @@
 pub use crate::panicking::{begin_panic, panic_count};
 pub use core::panicking::{panic_display, panic_fmt};
 
+#[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
 use crate::sync::Once;
+#[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
 use crate::sys;
+#[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
 use crate::thread::{self, Thread};
 
 // Prints to the "panic output", depending on the platform this may be:
@@ -89,6 +92,7 @@ macro_rules! rtunwrap {
 // Even though it is an `u8`, it only ever has 4 values. These are documented in
 // `compiler/rustc_session/src/config/sigpipe.rs`.
 #[cfg_attr(test, allow(dead_code))]
+#[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
 unsafe fn init(argc: isize, argv: *const *const u8, sigpipe: u8) {
     unsafe {
         sys::init(argc, argv, sigpipe);
@@ -102,6 +106,7 @@ unsafe fn init(argc: isize, argv: *const *const u8, sigpipe: u8) {
 // One-time runtime cleanup.
 // Runs after `main` or at program exit.
 // NOTE: this is not guaranteed to run, for example when the program aborts.
+#[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
 pub(crate) fn cleanup() {
     static CLEANUP: Once = Once::new();
     CLEANUP.call_once(|| unsafe {

library/std/src/sys/sbf/fs.rs

@@ -1,7 +1,7 @@
 use crate::ffi::OsString;
 use crate::fmt;
 use crate::hash::{Hash, Hasher};
-use crate::io::{self, SeekFrom, IoSlice, IoSliceMut};
+use crate::io::{self, SeekFrom, IoSlice, IoSliceMut, ReadBuf};
 use crate::path::{Path, PathBuf};
 use crate::sys::time::SystemTime;
 use crate::sys::{unsupported, Void};
@@ -209,6 +209,10 @@ impl File {
         false
     }
 
+    pub fn read_buf(&self, _buf: &mut ReadBuf<'_>) -> io::Result<()> {
+        match self.0 {}
+    }
+
     pub fn write(&self, _buf: &[u8]) -> io::Result<usize> {
         match self.0 {}
     }

library/std/src/sys/sbf/thread.rs

@@ -31,13 +31,6 @@ impl Thread {
     }
 }
 
-pub fn available_concurrency() -> io::Result<NonZeroUsize> {
+pub fn available_parallelism() -> io::Result<NonZeroUsize> {
     unsupported()
 }
-
-pub mod guard {
-    pub type Guard = !;
-    pub unsafe fn current() -> Option<Guard> {
-        None
-    }
-}

library/std/src/thread/mod.rs

@@ -175,6 +175,7 @@ use crate::str;
 use crate::sync::atomic::{AtomicUsize, Ordering};
 use crate::sync::Arc;
 use crate::sys::thread as imp;
+use crate::sys_common::thread;
 use crate::sys_common::thread_parking::Parker;
 use crate::sys_common::{AsInner, IntoInner};
 use crate::time::{Duration, Instant};
@@ -595,17 +596,15 @@ impl Builder {
     {
         let Builder { name, stack_size } = self;
         let stack_size = stack_size.unwrap_or_else(thread::min_stack);
-        let my_thread = Thread::new(name);
+        let my_thread = Thread::new(name.map(|name| {
+            CString::new(name).expect("thread name may not contain interior null bytes")
+        }));
         let their_thread = my_thread.clone();
         let my_packet: Arc<UnsafeCell<Option<Result<T>>>> = Arc::new(UnsafeCell::new(None));
         let main = move || {
             if let Some(name) = their_thread.cname() {
                 imp::Thread::set_name(name);
             }
-            // SAFETY: the stack guard passed is the one for the current thread.
-            // This means the current thread's stack and the new thread's stack
-            // are properly set and protected from each other.
-            thread_info::set(unsafe { imp::guard::current() }, their_thread);
         };
 
         Ok(JoinHandle(JoinInner {
@@ -789,13 +788,23 @@ pub(crate) fn try_current() -> Option<Thread> {
 /// ```
 #[must_use]
 #[stable(feature = "rust1", since = "1.0.0")]
+#[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
 pub fn current() -> Thread {
     try_current().expect(
         "use of std::thread::current() is not possible \
          after the thread's local data has been destroyed",
     )
 }
 
+/// SBF dummy version
+///
+#[must_use]
+#[stable(feature = "rust1", since = "1.0.0")]
+#[cfg(any(target_arch = "bpf", target_arch = "sbf"))]
+pub fn current() -> Thread {
+    Thread::new(None)
+}
+
 /// Cooperatively gives up a timeslice to the OS scheduler.
 ///
 /// This calls the underlying OS scheduler's yield primitive, signaling

library/test/src/cli.rs

@@ -239,6 +239,7 @@ macro_rules! unstable_optflag {
 }
 
 // Gets the option value and checks if unstable features are enabled.
+#[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
 macro_rules! unstable_optopt {
     ($matches:ident, $allow_unstable:ident, $option_name:literal) => {{
         let opt = $matches.opt_str($option_name);
@@ -325,6 +326,8 @@ fn parse_opts_impl(_matches: getopts::Matches) -> OptRes {
         nocapture: true,
         color: ColorConfig::NeverColor,
         format: OutputFormat::Pretty,
+        shuffle: false,
+        shuffle_seed: None,
         test_threads: Some(1),
         skip: Vec::new(),
         time_options: None,
@@ -366,6 +369,7 @@ fn get_time_options(
     Ok(options)
 }
 
+#[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
 fn get_shuffle(matches: &getopts::Matches, allow_unstable: bool) -> OptPartRes<bool> {
     let mut shuffle = unstable_optflag!(matches, allow_unstable, "shuffle");
     if !shuffle && allow_unstable {
@@ -378,6 +382,7 @@ fn get_shuffle(matches: &getopts::Matches, allow_unstable: bool) -> OptPartRes<b
     Ok(shuffle)
 }
 
+#[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
 fn get_shuffle_seed(matches: &getopts::Matches, allow_unstable: bool) -> OptPartRes<Option<u64>> {
     let mut shuffle_seed = match unstable_optopt!(matches, allow_unstable, "shuffle-seed") {
         Some(n_str) => match n_str.parse::<u64>() {