[SOL] Adjust BPF customization after upgrading to rust 1.62.0

Author: dmakarov

compiler/rustc_codegen_ssa/src/back/linker.rs

@@ -449,7 +449,7 @@ impl<'a> GccLinker<'a> {
                 } else {
                     self.linker_arg("--entry=entrypoint");
                 }
-                if self.sess.opts.cg.target_cpu.as_ref().unwrap_or(&self.sess.target.cpu) == "sbfv2"
+                if self.sess.opts.cg.target_cpu.as_ref().unwrap_or(&self.sess.target.cpu.as_ref().to_string()) == "sbfv2"
                 {
                     self.linker_arg("--section-start=.text=0x100000000");
                     self.linker_arg("--pack-dyn-relocs=relr");

compiler/rustc_target/src/spec/bpfel_unknown_unknown.rs

@@ -3,10 +3,10 @@ use crate::spec::sbf_base;
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "bpfel".to_string(),
+        llvm_target: "bpfel".into(),
         pointer_width: 64,
-        arch: "bpf".to_string(),
-        data_layout: "e-m:e-p:64:64-i64:64-n32:64-S128".to_string(),
+        arch: "bpf".into(),
+        data_layout: "e-m:e-p:64:64-i64:64-n32:64-S128".into(),
         options: sbf_base::opts(),
     }
 }

compiler/rustc_target/src/spec/sbf_base.rs

@@ -1,6 +1,5 @@
 use crate::abi::Endian;
-use super::{LinkerFlavor, PanicStrategy, TargetOptions, LldFlavor};
-use std::{collections::BTreeMap};
+use super::{LinkArgs, LinkerFlavor, PanicStrategy, TargetOptions, LldFlavor};
 
 pub fn opts() -> TargetOptions {
     let linker_script = r"
@@ -30,38 +29,38 @@ SECTIONS
 }
 ";
     let mut lld_args = Vec::new();
-    lld_args.push("--threads=1".to_string());
-    lld_args.push("-z".to_string());
-    lld_args.push("notext".to_string());
-    let mut pre_link_args = BTreeMap::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::Lld(LldFlavor::Ld), lld_args);
 
     TargetOptions {
         allow_asm: true,
-        c_int_width: "64".to_string(),
-        dll_prefix: "".to_string(),
+        c_int_width: "64".into(),
+        dll_prefix: "".into(),
         dynamic_linking: true,
         eh_frame_header: false,
         emit_debug_gdb_scripts: false,
         endian: Endian::Little,
-        env: String::new(),
+        env: "".into(),
         executables: true,
-        features: "+solana".to_string(),
-        link_script: Some(linker_script.to_string()),
-        linker: Some("rust-lld".to_owned()),
+        features: "+solana".into(),
+        link_script: Some(linker_script.into()),
+        linker: Some("rust-lld".into()),
         linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld),
         linker_is_gnu: true,
         main_needs_argc_argv: false,
         max_atomic_width: Some(64),
         no_default_libraries: true,
         only_cdylib: true,
-        os: "solana".to_string(),
+        os: "solana".into(),
         panic_strategy: PanicStrategy::Abort,
         position_independent_executables: true,
         pre_link_args,
         requires_lto: false,
         singlethread: true,
-        vendor: "solana".to_string(),
+        vendor: "solana".into(),
         .. Default::default()
     }
 }

compiler/rustc_target/src/spec/sbf_solana_solana.rs

@@ -3,10 +3,10 @@ use crate::spec::sbf_base;
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "sbf".to_string(),
+        llvm_target: "sbf".into(),
         pointer_width: 64,
-        arch: "sbf".to_string(),
-        data_layout: "e-m:e-p:64:64-i64:64-n32:64-S128".to_string(),
+        arch: "sbf".into(),
+        data_layout: "e-m:e-p:64:64-i64:64-n32:64-S128".into(),
         options: sbf_base::opts(),
     }
 }

library/core/benches/lib.rs

@@ -1,7 +1,7 @@
 // wasm32 does not support benches (no time).
-#![cfg(not(target_arch = "wasm32"))]
 // Disabling in Miri as these would take too long.
 #![cfg(not(miri))]
+#![cfg(not(any(target_arch = "wasm32", target_arch = "bpf", target_arch = "sbf")))]
 #![feature(flt2dec)]
 #![feature(test)]
 #![feature(trusted_random_access)]

library/std/src/io/stdio.rs

@@ -13,7 +13,7 @@ use crate::panic::{RefUnwindSafe, UnwindSafe};
 #[cfg(not(target_os = "solana"))]
 use crate::io::{self, BorrowedCursor, BufReader, IoSlice, IoSliceMut, LineWriter, Lines, SpecReadByte};
 #[cfg(target_os = "solana")]
-use crate::io::{self, BufReader, IoSlice, IoSliceMut};
+use crate::io::{self, BufReader, IoSlice, IoSliceMut, LineWriter, Lines};
 #[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
 use crate::sync::atomic::{AtomicBool, Ordering};
 #[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
@@ -357,49 +357,6 @@ pub fn stdin() -> Stdin {
     Stdin {}
 }
 
-/// Constructs a new locked handle to the standard input of the current
-/// process.
-///
-/// Each handle returned is a guard granting locked access to a shared
-/// global buffer whose access is synchronized via a mutex. If you need
-/// more explicit control over locking, for example, in a multi-threaded
-/// program, use the [`io::stdin`] function to obtain an unlocked handle,
-/// along with the [`Stdin::lock`] method.
-///
-/// The lock is released when the returned guard goes out of scope. The
-/// returned guard also implements the [`Read`] and [`BufRead`] traits for
-/// accessing the underlying data.
-///
-/// **Note**: The mutex locked by this handle is not reentrant. Even in a
-/// single-threaded program, calling other code that accesses [`Stdin`]
-/// could cause a deadlock or panic, if this locked handle is held across
-/// that call.
-///
-/// ### Note: Windows Portability Consideration
-/// When operating in a console, the Windows implementation of this stream does not support
-/// non-UTF-8 byte sequences. Attempting to read bytes that are not valid UTF-8 will return
-/// an error.
-///
-/// # Examples
-///
-/// ```no_run
-/// #![feature(stdio_locked)]
-/// use std::io::{self, BufRead};
-///
-/// fn main() -> io::Result<()> {
-///     let mut buffer = String::new();
-///     let mut handle = io::stdin_locked();
-///
-///     handle.read_line(&mut buffer)?;
-///     Ok(())
-/// }
-/// ```
-#[unstable(feature = "stdio_locked", issue = "86845")]
-#[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
-pub fn stdin_locked() -> StdinLock<'static> {
-    stdin().into_locked()
-}
-
 impl Stdin {
     /// Locks this handle to the standard input stream, returning a readable
     /// guard.
@@ -423,7 +380,7 @@ impl Stdin {
     /// }
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[cfg(not(target_os = "solana"))]
+    #[cfg(not(any(target_arch = "bpf", target_arch = "sbf")))]
     pub fn lock(&self) -> StdinLock<'static> {
         // Locks this handle with 'static lifetime. This depends on the
         // implementation detail that the underlying `Mutex` is static.
@@ -468,45 +425,6 @@ impl Stdin {
         self.lock().read_line(buf)
     }
 
-    // Locks this handle with any lifetime. This depends on the
-    // implementation detail that the underlying `Mutex` is static.
-    #[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
-    fn lock_any<'a>(&self) -> StdinLock<'a> {
-        StdinLock { inner: self.inner.lock().unwrap_or_else(|e| e.into_inner()) }
-    }
-
-    /// Consumes this handle to the standard input stream, locking the
-    /// shared global buffer associated with the stream and returning a
-    /// readable guard.
-    ///
-    /// The lock is released when the returned guard goes out of scope. The
-    /// returned guard also implements the [`Read`] and [`BufRead`] traits
-    /// for accessing the underlying data.
-    ///
-    /// It is often simpler to directly get a locked handle using the
-    /// [`stdin_locked`] function instead, unless nearby code also needs to
-    /// use an unlocked handle.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// #![feature(stdio_locked)]
-    /// use std::io::{self, BufRead};
-    ///
-    /// fn main() -> io::Result<()> {
-    ///     let mut buffer = String::new();
-    ///     let mut handle = io::stdin().into_locked();
-    ///
-    ///     handle.read_line(&mut buffer)?;
-    ///     Ok(())
-    /// }
-    /// ```
-    #[unstable(feature = "stdio_locked", issue = "86845")]
-    #[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
-    pub fn into_locked(self) -> StdinLock<'static> {
-        self.lock_any()
-    }
-
     /// Consumes this handle and returns an iterator over input lines.
     ///
     /// For detailed semantics of this method, see the documentation on
@@ -524,34 +442,10 @@ impl Stdin {
     /// ```
     #[must_use = "`self` will be dropped if the result is not used"]
     #[stable(feature = "stdin_forwarders", since = "1.62.0")]
-    #[cfg(not(target_os = "solana"))]
+    #[cfg(not(any(target_arch = "bpf", target_arch = "sbf")))]
     pub fn lines(self) -> Lines<StdinLock<'static>> {
         self.lock().lines()
     }
-
-    /// Consumes this handle and returns an iterator over input bytes,
-    /// split at the specified byte value.
-    ///
-    /// For detailed semantics of this method, see the documentation on
-    /// [`BufRead::split`].
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// #![feature(stdin_forwarders)]
-    /// use std::io;
-    ///
-    /// let splits = io::stdin().split(b'-');
-    /// for split in splits {
-    ///     println!("got a chunk: {}", String::from_utf8_lossy(&split.unwrap()));
-    /// }
-    /// ```
-    #[must_use = "`self` will be dropped if the result is not used"]
-    #[unstable(feature = "stdin_forwarders", issue = "87096")]
-    #[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
-    pub fn split(self, byte: u8) -> Split<StdinLock<'static>> {
-        self.into_locked().split(byte)
-    }
 }
 
 #[stable(feature = "std_debug", since = "1.16.0")]
@@ -891,52 +785,13 @@ impl Stdout {
     /// }
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[cfg(not(target_os = "solana"))]
+    #[cfg(not(any(target_arch = "bpf", target_arch = "sbf")))]
     pub fn lock(&self) -> StdoutLock<'static> {
         // Locks this handle with 'static lifetime. This depends on the
         // implementation detail that the underlying `ReentrantMutex` is
         // static.
         StdoutLock { inner: self.inner.lock() }
     }
-
-    // Locks this handle with any lifetime. This depends on the
-    // implementation detail that the underlying `ReentrantMutex` is
-    // static.
-    #[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
-    fn lock_any<'a>(&self) -> StdoutLock<'a> {
-        StdoutLock { inner: self.inner.lock() }
-    }
-
-    /// Consumes this handle to the standard output stream, locking the
-    /// shared global buffer associated with the stream and returning a
-    /// writable guard.
-    ///
-    /// The lock is released when the returned lock goes out of scope. The
-    /// returned guard also implements the [`Write`] trait for writing data.
-    ///
-    /// It is often simpler to directly get a locked handle using the
-    /// [`io::stdout_locked`] function instead, unless nearby code also
-    /// needs to use an unlocked handle.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// #![feature(stdio_locked)]
-    /// use std::io::{self, Write};
-    ///
-    /// fn main() -> io::Result<()> {
-    ///     let mut handle = io::stdout().into_locked();
-    ///
-    ///     handle.write_all(b"hello world")?;
-    ///
-    ///     Ok(())
-    /// }
-    /// ```
-    #[unstable(feature = "stdio_locked", issue = "86845")]
-    #[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
-    pub fn into_locked(self) -> StdoutLock<'static> {
-        self.lock_any()
-    }
 }
 
 #[stable(feature = "catch_unwind", since = "1.9.0")]
@@ -1198,36 +1053,6 @@ pub fn stderr() -> Stderr {
     Stderr {}
 }
 
-/// Constructs a new locked handle to the standard error of the current
-/// process.
-///
-/// This handle is not buffered.
-///
-/// ### Note: Windows Portability Consideration
-/// When operating in a console, the Windows implementation of this stream does not support
-/// non-UTF-8 byte sequences. Attempting to write bytes that are not valid UTF-8 will return
-/// an error.
-///
-/// # Example
-///
-/// ```no_run
-/// #![feature(stdio_locked)]
-/// use std::io::{self, Write};
-///
-/// fn main() -> io::Result<()> {
-///     let mut handle = io::stderr_locked();
-///
-///     handle.write_all(b"hello world")?;
-///
-///     Ok(())
-/// }
-/// ```
-#[unstable(feature = "stdio_locked", issue = "86845")]
-#[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
-pub fn stderr_locked() -> StderrLock<'static> {
-    stderr().into_locked()
-}
-
 impl Stderr {
     /// Locks this handle to the standard error stream, returning a writable
     /// guard.
@@ -1250,49 +1075,13 @@ impl Stderr {
     /// }
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[cfg(not(target_os = "solana"))]
+    #[cfg(not(any(target_arch = "bpf", target_arch = "sbf")))]
     pub fn lock(&self) -> StderrLock<'static> {
         // Locks this handle with 'static lifetime. This depends on the
         // implementation detail that the underlying `ReentrantMutex` is
         // static.
         StderrLock { inner: self.inner.lock() }
     }
-
-    // Locks this handle with any lifetime. This depends on the
-    // implementation detail that the underlying `ReentrantMutex` is
-    // static.
-    #[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
-    fn lock_any<'a>(&self) -> StderrLock<'a> {
-        StderrLock { inner: self.inner.lock() }
-    }
-
-    /// Locks and consumes this handle to the standard error stream,
-    /// returning a writable guard.
-    ///
-    /// The lock is released when the returned guard goes out of scope. The
-    /// returned guard also implements the [`Write`] trait for writing
-    /// data.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(stdio_locked)]
-    /// use std::io::{self, Write};
-    ///
-    /// fn foo() -> io::Result<()> {
-    ///     let stderr = io::stderr();
-    ///     let mut handle = stderr.into_locked();
-    ///
-    ///     handle.write_all(b"hello world")?;
-    ///
-    ///     Ok(())
-    /// }
-    /// ```
-    #[unstable(feature = "stdio_locked", issue = "86845")]
-    #[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
-    pub fn into_locked(self) -> StderrLock<'static> {
-        self.lock_any()
-    }
 }
 
 #[stable(feature = "catch_unwind", since = "1.9.0")]