std: begin moving platform support modules into `pal`

18 files changed, 0 insertions, 2259 deletions

diff --git a/library/std/src/sys/solid/abi/fs.rs b/library/std/src/sys/solid/abi/fs.rs
deleted file mode 100644
index 32800bd9a9d..00000000000
--- a/library/std/src/sys/solid/abi/fs.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-//! `solid_fs.h`
-use crate::os::raw::{c_char, c_int, c_uchar};
-pub use libc::{
-    blksize_t, dev_t, ino_t, off_t, stat, time_t, O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR,
-    O_TRUNC, O_WRONLY, SEEK_CUR, SEEK_END, SEEK_SET, S_IEXEC, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO,
-    S_IFMT, S_IFREG, S_IREAD, S_IWRITE,
-};
-
-pub const O_ACCMODE: c_int = 0x3;
-
-pub const SOLID_MAX_PATH: usize = 256;
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct dirent {
-    pub d_ino: ino_t,
-    pub d_type: c_uchar,
-    pub d_name: [c_char; 256usize],
-}
-
-pub const DT_UNKNOWN: c_uchar = 0;
-pub const DT_FIFO: c_uchar = 1;
-pub const DT_CHR: c_uchar = 2;
-pub const DT_DIR: c_uchar = 4;
-pub const DT_BLK: c_uchar = 6;
-pub const DT_REG: c_uchar = 8;
-pub const DT_LNK: c_uchar = 10;
-pub const DT_SOCK: c_uchar = 12;
-pub const DT_WHT: c_uchar = 14;
-
-pub type S_DIR = c_int;
-
-extern "C" {
-    pub fn SOLID_FS_Open(fd: *mut c_int, path: *const c_char, mode: c_int) -> c_int;
-    pub fn SOLID_FS_Close(fd: c_int) -> c_int;
-    pub fn SOLID_FS_Read(fd: c_int, buf: *mut u8, size: usize, result: *mut usize) -> c_int;
-    pub fn SOLID_FS_Write(fd: c_int, buf: *const u8, size: usize, result: *mut usize) -> c_int;
-    pub fn SOLID_FS_Lseek(fd: c_int, offset: off_t, whence: c_int) -> c_int;
-    pub fn SOLID_FS_Sync(fd: c_int) -> c_int;
-    pub fn SOLID_FS_Ftell(fd: c_int, result: *mut off_t) -> c_int;
-    pub fn SOLID_FS_Feof(fd: c_int, result: *mut c_int) -> c_int;
-    pub fn SOLID_FS_Fsize(fd: c_int, result: *mut usize) -> c_int;
-    pub fn SOLID_FS_Truncate(path: *const c_char, size: off_t) -> c_int;
-    pub fn SOLID_FS_OpenDir(path: *const c_char, pDir: *mut S_DIR) -> c_int;
-    pub fn SOLID_FS_CloseDir(dir: S_DIR) -> c_int;
-    pub fn SOLID_FS_ReadDir(dir: S_DIR, dirp: *mut dirent) -> c_int;
-    pub fn SOLID_FS_Stat(path: *const c_char, buf: *mut stat) -> c_int;
-    pub fn SOLID_FS_Unlink(path: *const c_char) -> c_int;
-    pub fn SOLID_FS_Rename(oldpath: *const c_char, newpath: *const c_char) -> c_int;
-    pub fn SOLID_FS_Chmod(path: *const c_char, mode: c_int) -> c_int;
-    pub fn SOLID_FS_Utime(path: *const c_char, time: time_t) -> c_int;
-    pub fn SOLID_FS_Mkdir(path: *const c_char) -> c_int;
-}
diff --git a/library/std/src/sys/solid/abi/mod.rs b/library/std/src/sys/solid/abi/mod.rs
deleted file mode 100644
index 8440d572cfb..00000000000
--- a/library/std/src/sys/solid/abi/mod.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-use crate::os::raw::c_int;
-
-mod fs;
-pub mod sockets;
-pub use self::fs::*;
-
-// `solid_types.h`
-pub use super::itron::abi::{ER, ER_ID, E_TMOUT, ID};
-
-pub const SOLID_ERR_NOTFOUND: ER = -1000;
-pub const SOLID_ERR_NOTSUPPORTED: ER = -1001;
-pub const SOLID_ERR_EBADF: ER = -1002;
-pub const SOLID_ERR_INVALIDCONTENT: ER = -1003;
-pub const SOLID_ERR_NOTUSED: ER = -1004;
-pub const SOLID_ERR_ALREADYUSED: ER = -1005;
-pub const SOLID_ERR_OUTOFBOUND: ER = -1006;
-pub const SOLID_ERR_BADSEQUENCE: ER = -1007;
-pub const SOLID_ERR_UNKNOWNDEVICE: ER = -1008;
-pub const SOLID_ERR_BUSY: ER = -1009;
-pub const SOLID_ERR_TIMEOUT: ER = -1010;
-pub const SOLID_ERR_INVALIDACCESS: ER = -1011;
-pub const SOLID_ERR_NOTREADY: ER = -1012;
-
-// `solid_rtc.h`
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct SOLID_RTC_TIME {
-    pub tm_sec: c_int,
-    pub tm_min: c_int,
-    pub tm_hour: c_int,
-    pub tm_mday: c_int,
-    pub tm_mon: c_int,
-    pub tm_year: c_int,
-    pub tm_wday: c_int,
-}
-
-extern "C" {
-    pub fn SOLID_RTC_ReadTime(time: *mut SOLID_RTC_TIME) -> c_int;
-}
-
-// `solid_log.h`
-extern "C" {
-    pub fn SOLID_LOG_write(s: *const u8, l: usize);
-}
-
-// `solid_mem.h`
-extern "C" {
-    pub fn SOLID_TLS_AddDestructor(id: i32, dtor: unsafe extern "C" fn(*mut u8));
-}
-
-// `solid_rng.h`
-extern "C" {
-    pub fn SOLID_RNG_SampleRandomBytes(buffer: *mut u8, length: usize) -> c_int;
-}
-
-// `rwlock.h`
-extern "C" {
-    pub fn rwl_loc_rdl(id: ID) -> ER;
-    pub fn rwl_loc_wrl(id: ID) -> ER;
-    pub fn rwl_ploc_rdl(id: ID) -> ER;
-    pub fn rwl_ploc_wrl(id: ID) -> ER;
-    pub fn rwl_unl_rwl(id: ID) -> ER;
-    pub fn rwl_acre_rwl() -> ER_ID;
-    pub fn rwl_del_rwl(id: ID) -> ER;
-}
diff --git a/library/std/src/sys/solid/abi/sockets.rs b/library/std/src/sys/solid/abi/sockets.rs
deleted file mode 100644
index eb06a6dd927..00000000000
--- a/library/std/src/sys/solid/abi/sockets.rs
+++ /dev/null
@@ -1,277 +0,0 @@
-use crate::os::raw::{c_char, c_uint, c_void};
-pub use libc::{c_int, c_long, size_t, ssize_t, suseconds_t, time_t, timeval};
-
-pub const SOLID_NET_ERR_BASE: c_int = -2000;
-pub const EINPROGRESS: c_int = SOLID_NET_ERR_BASE - libc::EINPROGRESS;
-
-pub const AF_INET6: i32 = 10;
-pub const AF_INET: i32 = 2;
-pub const IPPROTO_IP: i32 = 0;
-pub const IPPROTO_IPV6: i32 = 41;
-pub const IPPROTO_TCP: i32 = 6;
-pub const IPV6_ADD_MEMBERSHIP: i32 = 12;
-pub const IPV6_DROP_MEMBERSHIP: i32 = 13;
-pub const IPV6_MULTICAST_LOOP: i32 = 19;
-pub const IPV6_V6ONLY: i32 = 27;
-pub const IP_TTL: i32 = 2;
-pub const IP_MULTICAST_TTL: i32 = 5;
-pub const IP_MULTICAST_LOOP: i32 = 7;
-pub const IP_ADD_MEMBERSHIP: i32 = 3;
-pub const IP_DROP_MEMBERSHIP: i32 = 4;
-pub const SHUT_RD: i32 = 0;
-pub const SHUT_RDWR: i32 = 2;
-pub const SHUT_WR: i32 = 1;
-pub const SOCK_DGRAM: i32 = 2;
-pub const SOCK_STREAM: i32 = 1;
-pub const SOL_SOCKET: i32 = 4095;
-pub const SO_BROADCAST: i32 = 32;
-pub const SO_ERROR: i32 = 4103;
-pub const SO_RCVTIMEO: i32 = 4102;
-pub const SO_REUSEADDR: i32 = 4;
-pub const SO_SNDTIMEO: i32 = 4101;
-pub const SO_LINGER: i32 = 128;
-pub const TCP_NODELAY: i32 = 1;
-pub const MSG_PEEK: c_int = 1;
-pub const FIONBIO: c_long = 0x8008667eu32 as c_long;
-pub const EAI_NONAME: i32 = -2200;
-pub const EAI_SERVICE: i32 = -2201;
-pub const EAI_FAIL: i32 = -2202;
-pub const EAI_MEMORY: i32 = -2203;
-pub const EAI_FAMILY: i32 = -2204;
-
-pub type sa_family_t = u8;
-pub type socklen_t = u32;
-pub type in_addr_t = u32;
-pub type in_port_t = u16;
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct in_addr {
-    pub s_addr: in_addr_t,
-}
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct in6_addr {
-    pub s6_addr: [u8; 16],
-}
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ip_mreq {
-    pub imr_multiaddr: in_addr,
-    pub imr_interface: in_addr,
-}
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct ipv6_mreq {
-    pub ipv6mr_multiaddr: in6_addr,
-    pub ipv6mr_interface: c_uint,
-}
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct msghdr {
-    pub msg_name: *mut c_void,
-    pub msg_namelen: socklen_t,
-    pub msg_iov: *mut iovec,
-    pub msg_iovlen: c_int,
-    pub msg_control: *mut c_void,
-    pub msg_controllen: socklen_t,
-    pub msg_flags: c_int,
-}
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct sockaddr {
-    pub sa_len: u8,
-    pub sa_family: sa_family_t,
-    pub sa_data: [c_char; 14usize],
-}
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct sockaddr_in {
-    pub sin_len: u8,
-    pub sin_family: sa_family_t,
-    pub sin_port: in_port_t,
-    pub sin_addr: in_addr,
-    pub sin_zero: [c_char; 8usize],
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct sockaddr_in6 {
-    pub sin6_len: u8,
-    pub sin6_family: sa_family_t,
-    pub sin6_port: in_port_t,
-    pub sin6_flowinfo: u32,
-    pub sin6_addr: in6_addr,
-    pub sin6_scope_id: u32,
-}
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct sockaddr_storage {
-    pub s2_len: u8,
-    pub ss_family: sa_family_t,
-    pub s2_data1: [c_char; 2usize],
-    pub s2_data2: [u32; 3usize],
-}
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct addrinfo {
-    pub ai_flags: c_int,
-    pub ai_family: c_int,
-    pub ai_socktype: c_int,
-    pub ai_protocol: c_int,
-    pub ai_addrlen: socklen_t,
-    pub ai_addr: *mut sockaddr,
-    pub ai_canonname: *mut c_char,
-    pub ai_next: *mut addrinfo,
-}
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct linger {
-    pub l_onoff: c_int,
-    pub l_linger: c_int,
-}
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct iovec {
-    pub iov_base: *mut c_void,
-    pub iov_len: usize,
-}
-
-/// This value can be chosen by an application
-pub const SOLID_NET_FD_SETSIZE: usize = 1;
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct fd_set {
-    pub num_fds: usize,
-    pub fds: [c_int; SOLID_NET_FD_SETSIZE],
-}
-
-extern "C" {
-    #[link_name = "SOLID_NET_StrError"]
-    pub fn strerror(errnum: c_int) -> *const c_char;
-
-    pub fn SOLID_NET_GetLastError() -> c_int;
-
-    #[link_name = "SOLID_NET_Accept"]
-    pub fn accept(s: c_int, addr: *mut sockaddr, addrlen: *mut socklen_t) -> c_int;
-
-    #[link_name = "SOLID_NET_Bind"]
-    pub fn bind(s: c_int, name: *const sockaddr, namelen: socklen_t) -> c_int;
-
-    #[link_name = "SOLID_NET_Connect"]
-    pub fn connect(s: c_int, name: *const sockaddr, namelen: socklen_t) -> c_int;
-
-    #[link_name = "SOLID_NET_Close"]
-    pub fn close(s: c_int) -> c_int;
-
-    #[link_name = "SOLID_NET_Dup"]
-    pub fn dup(s: c_int) -> c_int;
-
-    #[link_name = "SOLID_NET_GetPeerName"]
-    pub fn getpeername(s: c_int, name: *mut sockaddr, namelen: *mut socklen_t) -> c_int;
-
-    #[link_name = "SOLID_NET_GetSockName"]
-    pub fn getsockname(s: c_int, name: *mut sockaddr, namelen: *mut socklen_t) -> c_int;
-
-    #[link_name = "SOLID_NET_GetSockOpt"]
-    pub fn getsockopt(
-        s: c_int,
-        level: c_int,
-        optname: c_int,
-        optval: *mut c_void,
-        optlen: *mut socklen_t,
-    ) -> c_int;
-
-    #[link_name = "SOLID_NET_SetSockOpt"]
-    pub fn setsockopt(
-        s: c_int,
-        level: c_int,
-        optname: c_int,
-        optval: *const c_void,
-        optlen: socklen_t,
-    ) -> c_int;
-
-    #[link_name = "SOLID_NET_Ioctl"]
-    pub fn ioctl(s: c_int, cmd: c_long, argp: *mut c_void) -> c_int;
-
-    #[link_name = "SOLID_NET_Listen"]
-    pub fn listen(s: c_int, backlog: c_int) -> c_int;
-
-    #[link_name = "SOLID_NET_Recv"]
-    pub fn recv(s: c_int, mem: *mut c_void, len: size_t, flags: c_int) -> ssize_t;
-
-    #[link_name = "SOLID_NET_Read"]
-    pub fn read(s: c_int, mem: *mut c_void, len: size_t) -> ssize_t;
-
-    #[link_name = "SOLID_NET_Readv"]
-    pub fn readv(s: c_int, bufs: *const iovec, bufcnt: c_int) -> ssize_t;
-
-    #[link_name = "SOLID_NET_RecvFrom"]
-    pub fn recvfrom(
-        s: c_int,
-        mem: *mut c_void,
-        len: size_t,
-        flags: c_int,
-        from: *mut sockaddr,
-        fromlen: *mut socklen_t,
-    ) -> ssize_t;
-
-    #[link_name = "SOLID_NET_Send"]
-    pub fn send(s: c_int, mem: *const c_void, len: size_t, flags: c_int) -> ssize_t;
-
-    #[link_name = "SOLID_NET_SendMsg"]
-    pub fn sendmsg(s: c_int, message: *const msghdr, flags: c_int) -> ssize_t;
-
-    #[link_name = "SOLID_NET_SendTo"]
-    pub fn sendto(
-        s: c_int,
-        mem: *const c_void,
-        len: size_t,
-        flags: c_int,
-        to: *const sockaddr,
-        tolen: socklen_t,
-    ) -> ssize_t;
-
-    #[link_name = "SOLID_NET_Shutdown"]
-    pub fn shutdown(s: c_int, how: c_int) -> c_int;
-
-    #[link_name = "SOLID_NET_Socket"]
-    pub fn socket(domain: c_int, type_: c_int, protocol: c_int) -> c_int;
-
-    #[link_name = "SOLID_NET_Write"]
-    pub fn write(s: c_int, mem: *const c_void, len: size_t) -> ssize_t;
-
-    #[link_name = "SOLID_NET_Writev"]
-    pub fn writev(s: c_int, bufs: *const iovec, bufcnt: c_int) -> ssize_t;
-
-    #[link_name = "SOLID_NET_FreeAddrInfo"]
-    pub fn freeaddrinfo(ai: *mut addrinfo);
-
-    #[link_name = "SOLID_NET_GetAddrInfo"]
-    pub fn getaddrinfo(
-        nodename: *const c_char,
-        servname: *const c_char,
-        hints: *const addrinfo,
-        res: *mut *mut addrinfo,
-    ) -> c_int;
-
-    #[link_name = "SOLID_NET_Select"]
-    pub fn select(
-        maxfdp1: c_int,
-        readset: *mut fd_set,
-        writeset: *mut fd_set,
-        exceptset: *mut fd_set,
-        timeout: *mut timeval,
-    ) -> c_int;
-}
diff --git a/library/std/src/sys/solid/alloc.rs b/library/std/src/sys/solid/alloc.rs
deleted file mode 100644
index d013bd87610..00000000000
--- a/library/std/src/sys/solid/alloc.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-use crate::{
-    alloc::{GlobalAlloc, Layout, System},
-    sys::common::alloc::{realloc_fallback, MIN_ALIGN},
-};
-
-#[stable(feature = "alloc_system_type", since = "1.28.0")]
-unsafe impl GlobalAlloc for System {
-    #[inline]
-    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
-            unsafe { libc::malloc(layout.size()) as *mut u8 }
-        } else {
-            unsafe { libc::memalign(layout.align(), layout.size()) as *mut u8 }
-        }
-    }
-
-    #[inline]
-    unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
-        unsafe { libc::free(ptr as *mut libc::c_void) }
-    }
-
-    #[inline]
-    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
-        unsafe {
-            if layout.align() <= MIN_ALIGN && layout.align() <= new_size {
-                libc::realloc(ptr as *mut libc::c_void, new_size) as *mut u8
-            } else {
-                realloc_fallback(self, ptr, layout, new_size)
-            }
-        }
-    }
-}
diff --git a/library/std/src/sys/solid/env.rs b/library/std/src/sys/solid/env.rs
deleted file mode 100644
index 6855c113b28..00000000000
--- a/library/std/src/sys/solid/env.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-pub mod os {
-    pub const FAMILY: &str = "itron";
-    pub const OS: &str = "solid";
-    pub const DLL_PREFIX: &str = "";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
diff --git a/library/std/src/sys/solid/error.rs b/library/std/src/sys/solid/error.rs
deleted file mode 100644
index 547b4f3a984..00000000000
--- a/library/std/src/sys/solid/error.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-use super::{abi, itron, net};
-use crate::io::ErrorKind;
-
-pub use self::itron::error::{expect_success, ItronError as SolidError};
-
-/// Describe the specified SOLID error code. Returns `None` if it's an
-/// undefined error code.
-///
-/// The SOLID error codes are a superset of μITRON error codes.
-pub fn error_name(er: abi::ER) -> Option<&'static str> {
-    match er {
-        // Success
-        er if er >= 0 => None,
-        er if er < abi::sockets::SOLID_NET_ERR_BASE => net::error_name(er),
-
-        abi::SOLID_ERR_NOTFOUND => Some("not found"),
-        abi::SOLID_ERR_NOTSUPPORTED => Some("not supported"),
-        abi::SOLID_ERR_EBADF => Some("bad flags"),
-        abi::SOLID_ERR_INVALIDCONTENT => Some("invalid content"),
-        abi::SOLID_ERR_NOTUSED => Some("not used"),
-        abi::SOLID_ERR_ALREADYUSED => Some("already used"),
-        abi::SOLID_ERR_OUTOFBOUND => Some("out of bounds"),
-        abi::SOLID_ERR_BADSEQUENCE => Some("bad sequence"),
-        abi::SOLID_ERR_UNKNOWNDEVICE => Some("unknown device"),
-        abi::SOLID_ERR_BUSY => Some("busy"),
-        abi::SOLID_ERR_TIMEOUT => Some("operation timed out"),
-        abi::SOLID_ERR_INVALIDACCESS => Some("invalid access"),
-        abi::SOLID_ERR_NOTREADY => Some("not ready"),
-
-        _ => itron::error::error_name(er),
-    }
-}
-
-pub fn decode_error_kind(er: abi::ER) -> ErrorKind {
-    match er {
-        // Success
-        er if er >= 0 => ErrorKind::Uncategorized,
-        er if er < abi::sockets::SOLID_NET_ERR_BASE => net::decode_error_kind(er),
-
-        abi::SOLID_ERR_NOTFOUND => ErrorKind::NotFound,
-        abi::SOLID_ERR_NOTSUPPORTED => ErrorKind::Unsupported,
-        abi::SOLID_ERR_EBADF => ErrorKind::InvalidInput,
-        abi::SOLID_ERR_INVALIDCONTENT => ErrorKind::InvalidData,
-        // abi::SOLID_ERR_NOTUSED
-        // abi::SOLID_ERR_ALREADYUSED
-        abi::SOLID_ERR_OUTOFBOUND => ErrorKind::InvalidInput,
-        // abi::SOLID_ERR_BADSEQUENCE
-        abi::SOLID_ERR_UNKNOWNDEVICE => ErrorKind::NotFound,
-        // abi::SOLID_ERR_BUSY
-        abi::SOLID_ERR_TIMEOUT => ErrorKind::TimedOut,
-        // abi::SOLID_ERR_INVALIDACCESS
-        // abi::SOLID_ERR_NOTREADY
-        _ => itron::error::decode_error_kind(er),
-    }
-}
diff --git a/library/std/src/sys/solid/fs.rs b/library/std/src/sys/solid/fs.rs
deleted file mode 100644
index 6c66b93a3e1..00000000000
--- a/library/std/src/sys/solid/fs.rs
+++ /dev/null
@@ -1,588 +0,0 @@
-use super::{abi, error};
-use crate::{
-    ffi::{CStr, CString, OsStr, OsString},
-    fmt,
-    io::{self, BorrowedCursor, IoSlice, IoSliceMut, SeekFrom},
-    mem::MaybeUninit,
-    os::raw::{c_int, c_short},
-    os::solid::ffi::OsStrExt,
-    path::{Path, PathBuf},
-    sync::Arc,
-    sys::time::SystemTime,
-    sys::unsupported,
-};
-
-pub use crate::sys_common::fs::try_exists;
-
-/// A file descriptor.
-#[derive(Clone, Copy)]
-#[rustc_layout_scalar_valid_range_start(0)]
-// libstd/os/raw/mod.rs assures me that every libstd-supported platform has a
-// 32-bit c_int. Below is -2, in two's complement, but that only works out
-// because c_int is 32 bits.
-#[rustc_layout_scalar_valid_range_end(0xFF_FF_FF_FE)]
-struct FileDesc {
-    fd: c_int,
-}
-
-impl FileDesc {
-    #[inline]
-    fn new(fd: c_int) -> FileDesc {
-        assert_ne!(fd, -1i32);
-        // Safety: we just asserted that the value is in the valid range and
-        // isn't `-1` (the only value bigger than `0xFF_FF_FF_FE` unsigned)
-        unsafe { FileDesc { fd } }
-    }
-
-    #[inline]
-    fn raw(&self) -> c_int {
-        self.fd
-    }
-}
-
-pub struct File {
-    fd: FileDesc,
-}
-
-#[derive(Clone)]
-pub struct FileAttr {
-    stat: abi::stat,
-}
-
-// all DirEntry's will have a reference to this struct
-struct InnerReadDir {
-    dirp: abi::S_DIR,
-    root: PathBuf,
-}
-
-pub struct ReadDir {
-    inner: Arc<InnerReadDir>,
-}
-
-pub struct DirEntry {
-    entry: abi::dirent,
-    inner: Arc<InnerReadDir>,
-}
-
-#[derive(Clone, Debug)]
-pub struct OpenOptions {
-    // generic
-    read: bool,
-    write: bool,
-    append: bool,
-    truncate: bool,
-    create: bool,
-    create_new: bool,
-    // system-specific
-    custom_flags: i32,
-}
-
-#[derive(Copy, Clone, Debug, Default)]
-pub struct FileTimes {}
-
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub struct FilePermissions(c_short);
-
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
-pub struct FileType(c_short);
-
-#[derive(Debug)]
-pub struct DirBuilder {}
-
-impl FileAttr {
-    pub fn size(&self) -> u64 {
-        self.stat.st_size as u64
-    }
-
-    pub fn perm(&self) -> FilePermissions {
-        FilePermissions(self.stat.st_mode)
-    }
-
-    pub fn file_type(&self) -> FileType {
-        FileType(self.stat.st_mode)
-    }
-
-    pub fn modified(&self) -> io::Result<SystemTime> {
-        Ok(SystemTime::from_time_t(self.stat.st_mtime))
-    }
-
-    pub fn accessed(&self) -> io::Result<SystemTime> {
-        Ok(SystemTime::from_time_t(self.stat.st_atime))
-    }
-
-    pub fn created(&self) -> io::Result<SystemTime> {
-        Ok(SystemTime::from_time_t(self.stat.st_ctime))
-    }
-}
-
-impl FilePermissions {
-    pub fn readonly(&self) -> bool {
-        (self.0 & abi::S_IWRITE) == 0
-    }
-
-    pub fn set_readonly(&mut self, readonly: bool) {
-        if readonly {
-            self.0 &= !abi::S_IWRITE;
-        } else {
-            self.0 |= abi::S_IWRITE;
-        }
-    }
-}
-
-impl FileTimes {
-    pub fn set_accessed(&mut self, _t: SystemTime) {}
-    pub fn set_modified(&mut self, _t: SystemTime) {}
-}
-
-impl FileType {
-    pub fn is_dir(&self) -> bool {
-        self.is(abi::S_IFDIR)
-    }
-    pub fn is_file(&self) -> bool {
-        self.is(abi::S_IFREG)
-    }
-    pub fn is_symlink(&self) -> bool {
-        false
-    }
-
-    pub fn is(&self, mode: c_short) -> bool {
-        self.0 & abi::S_IFMT == mode
-    }
-}
-
-pub fn readdir(p: &Path) -> io::Result<ReadDir> {
-    unsafe {
-        let mut dir = MaybeUninit::uninit();
-        error::SolidError::err_if_negative(abi::SOLID_FS_OpenDir(
-            cstr(p)?.as_ptr(),
-            dir.as_mut_ptr(),
-        ))
-        .map_err(|e| e.as_io_error())?;
-        let inner = Arc::new(InnerReadDir { dirp: dir.assume_init(), root: p.to_owned() });
-        Ok(ReadDir { inner })
-    }
-}
-
-impl fmt::Debug for ReadDir {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // This will only be called from std::fs::ReadDir, which will add a "ReadDir()" frame.
-        // Thus the result will be e g 'ReadDir("/home")'
-        fmt::Debug::fmt(&*self.inner.root, f)
-    }
-}
-
-impl Iterator for ReadDir {
-    type Item = io::Result<DirEntry>;
-
-    fn next(&mut self) -> Option<io::Result<DirEntry>> {
-        let entry = unsafe {
-            let mut out_entry = MaybeUninit::uninit();
-            match error::SolidError::err_if_negative(abi::SOLID_FS_ReadDir(
-                self.inner.dirp,
-                out_entry.as_mut_ptr(),
-            )) {
-                Ok(_) => out_entry.assume_init(),
-                Err(e) if e.as_raw() == abi::SOLID_ERR_NOTFOUND => return None,
-                Err(e) => return Some(Err(e.as_io_error())),
-            }
-        };
-
-        (entry.d_name[0] != 0).then(|| Ok(DirEntry { entry, inner: Arc::clone(&self.inner) }))
-    }
-}
-
-impl Drop for InnerReadDir {
-    fn drop(&mut self) {
-        unsafe { abi::SOLID_FS_CloseDir(self.dirp) };
-    }
-}
-
-impl DirEntry {
-    pub fn path(&self) -> PathBuf {
-        self.inner.root.join(OsStr::from_bytes(
-            unsafe { CStr::from_ptr(self.entry.d_name.as_ptr()) }.to_bytes(),
-        ))
-    }
-
-    pub fn file_name(&self) -> OsString {
-        OsStr::from_bytes(unsafe { CStr::from_ptr(self.entry.d_name.as_ptr()) }.to_bytes())
-            .to_os_string()
-    }
-
-    pub fn metadata(&self) -> io::Result<FileAttr> {
-        lstat(&self.path())
-    }
-
-    pub fn file_type(&self) -> io::Result<FileType> {
-        match self.entry.d_type {
-            abi::DT_CHR => Ok(FileType(abi::S_IFCHR)),
-            abi::DT_FIFO => Ok(FileType(abi::S_IFIFO)),
-            abi::DT_REG => Ok(FileType(abi::S_IFREG)),
-            abi::DT_DIR => Ok(FileType(abi::S_IFDIR)),
-            abi::DT_BLK => Ok(FileType(abi::S_IFBLK)),
-            _ => lstat(&self.path()).map(|m| m.file_type()),
-        }
-    }
-}
-
-impl OpenOptions {
-    pub fn new() -> OpenOptions {
-        OpenOptions {
-            // generic
-            read: false,
-            write: false,
-            append: false,
-            truncate: false,
-            create: false,
-            create_new: false,
-            // system-specific
-            custom_flags: 0,
-        }
-    }
-
-    pub fn read(&mut self, read: bool) {
-        self.read = read;
-    }
-    pub fn write(&mut self, write: bool) {
-        self.write = write;
-    }
-    pub fn append(&mut self, append: bool) {
-        self.append = append;
-    }
-    pub fn truncate(&mut self, truncate: bool) {
-        self.truncate = truncate;
-    }
-    pub fn create(&mut self, create: bool) {
-        self.create = create;
-    }
-    pub fn create_new(&mut self, create_new: bool) {
-        self.create_new = create_new;
-    }
-
-    pub fn custom_flags(&mut self, flags: i32) {
-        self.custom_flags = flags;
-    }
-    pub fn mode(&mut self, _mode: u32) {}
-
-    fn get_access_mode(&self) -> io::Result<c_int> {
-        match (self.read, self.write, self.append) {
-            (true, false, false) => Ok(abi::O_RDONLY),
-            (false, true, false) => Ok(abi::O_WRONLY),
-            (true, true, false) => Ok(abi::O_RDWR),
-            (false, _, true) => Ok(abi::O_WRONLY | abi::O_APPEND),
-            (true, _, true) => Ok(abi::O_RDWR | abi::O_APPEND),
-            (false, false, false) => Err(io::Error::from_raw_os_error(libc::EINVAL)),
-        }
-    }
-
-    fn get_creation_mode(&self) -> io::Result<c_int> {
-        match (self.write, self.append) {
-            (true, false) => {}
-            (false, false) => {
-                if self.truncate || self.create || self.create_new {
-                    return Err(io::Error::from_raw_os_error(libc::EINVAL));
-                }
-            }
-            (_, true) => {
-                if self.truncate && !self.create_new {
-                    return Err(io::Error::from_raw_os_error(libc::EINVAL));
-                }
-            }
-        }
-
-        Ok(match (self.create, self.truncate, self.create_new) {
-            (false, false, false) => 0,
-            (true, false, false) => abi::O_CREAT,
-            (false, true, false) => abi::O_TRUNC,
-            (true, true, false) => abi::O_CREAT | abi::O_TRUNC,
-            (_, _, true) => abi::O_CREAT | abi::O_EXCL,
-        })
-    }
-}
-
-fn cstr(path: &Path) -> io::Result<CString> {
-    let path = path.as_os_str().as_bytes();
-
-    if !path.starts_with(br"\") {
-        // Relative paths aren't supported
-        return Err(crate::io::const_io_error!(
-            crate::io::ErrorKind::Unsupported,
-            "relative path is not supported on this platform",
-        ));
-    }
-
-    // Apply the thread-safety wrapper
-    const SAFE_PREFIX: &[u8] = br"\TS";
-    let wrapped_path = [SAFE_PREFIX, &path, &[0]].concat();
-
-    CString::from_vec_with_nul(wrapped_path).map_err(|_| {
-        crate::io::const_io_error!(
-            io::ErrorKind::InvalidInput,
-            "path provided contains a nul byte",
-        )
-    })
-}
-
-impl File {
-    pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<File> {
-        let flags = opts.get_access_mode()?
-            | opts.get_creation_mode()?
-            | (opts.custom_flags as c_int & !abi::O_ACCMODE);
-        unsafe {
-            let mut fd = MaybeUninit::uninit();
-            error::SolidError::err_if_negative(abi::SOLID_FS_Open(
-                fd.as_mut_ptr(),
-                cstr(path)?.as_ptr(),
-                flags,
-            ))
-            .map_err(|e| e.as_io_error())?;
-            Ok(File { fd: FileDesc::new(fd.assume_init()) })
-        }
-    }
-
-    pub fn file_attr(&self) -> io::Result<FileAttr> {
-        unsupported()
-    }
-
-    pub fn fsync(&self) -> io::Result<()> {
-        self.flush()
-    }
-
-    pub fn datasync(&self) -> io::Result<()> {
-        self.flush()
-    }
-
-    pub fn truncate(&self, _size: u64) -> io::Result<()> {
-        unsupported()
-    }
-
-    pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
-        unsafe {
-            let mut out_num_bytes = MaybeUninit::uninit();
-            error::SolidError::err_if_negative(abi::SOLID_FS_Read(
-                self.fd.raw(),
-                buf.as_mut_ptr(),
-                buf.len(),
-                out_num_bytes.as_mut_ptr(),
-            ))
-            .map_err(|e| e.as_io_error())?;
-            Ok(out_num_bytes.assume_init())
-        }
-    }
-
-    pub fn read_buf(&self, mut cursor: BorrowedCursor<'_>) -> io::Result<()> {
-        unsafe {
-            let len = cursor.capacity();
-            let mut out_num_bytes = MaybeUninit::uninit();
-            error::SolidError::err_if_negative(abi::SOLID_FS_Read(
-                self.fd.raw(),
-                cursor.as_mut().as_mut_ptr() as *mut u8,
-                len,
-                out_num_bytes.as_mut_ptr(),
-            ))
-            .map_err(|e| e.as_io_error())?;
-
-            // Safety: `out_num_bytes` is filled by the successful call to
-            // `SOLID_FS_Read`
-            let num_bytes_read = out_num_bytes.assume_init();
-
-            // Safety: `num_bytes_read` bytes were written to the unfilled
-            // portion of the buffer
-            cursor.advance(num_bytes_read);
-
-            Ok(())
-        }
-    }
-
-    pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
-        crate::io::default_read_vectored(|buf| self.read(buf), bufs)
-    }
-
-    pub fn is_read_vectored(&self) -> bool {
-        false
-    }
-
-    pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
-        unsafe {
-            let mut out_num_bytes = MaybeUninit::uninit();
-            error::SolidError::err_if_negative(abi::SOLID_FS_Write(
-                self.fd.raw(),
-                buf.as_ptr(),
-                buf.len(),
-                out_num_bytes.as_mut_ptr(),
-            ))
-            .map_err(|e| e.as_io_error())?;
-            Ok(out_num_bytes.assume_init())
-        }
-    }
-
-    pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        crate::io::default_write_vectored(|buf| self.write(buf), bufs)
-    }
-
-    pub fn is_write_vectored(&self) -> bool {
-        false
-    }
-
-    pub fn flush(&self) -> io::Result<()> {
-        error::SolidError::err_if_negative(unsafe { abi::SOLID_FS_Sync(self.fd.raw()) })
-            .map_err(|e| e.as_io_error())?;
-        Ok(())
-    }
-
-    pub fn seek(&self, pos: SeekFrom) -> io::Result<u64> {
-        let (whence, pos) = match pos {
-            // Casting to `i64` is fine, too large values will end up as
-            // negative which will cause an error in `SOLID_FS_Lseek`.
-            SeekFrom::Start(off) => (abi::SEEK_SET, off as i64),
-            SeekFrom::End(off) => (abi::SEEK_END, off),
-            SeekFrom::Current(off) => (abi::SEEK_CUR, off),
-        };
-        error::SolidError::err_if_negative(unsafe {
-            abi::SOLID_FS_Lseek(self.fd.raw(), pos, whence)
-        })
-        .map_err(|e| e.as_io_error())?;
-
-        // Get the new offset
-        unsafe {
-            let mut out_offset = MaybeUninit::uninit();
-            error::SolidError::err_if_negative(abi::SOLID_FS_Ftell(
-                self.fd.raw(),
-                out_offset.as_mut_ptr(),
-            ))
-            .map_err(|e| e.as_io_error())?;
-            Ok(out_offset.assume_init() as u64)
-        }
-    }
-
-    pub fn duplicate(&self) -> io::Result<File> {
-        unsupported()
-    }
-
-    pub fn set_permissions(&self, _perm: FilePermissions) -> io::Result<()> {
-        unsupported()
-    }
-
-    pub fn set_times(&self, _times: FileTimes) -> io::Result<()> {
-        unsupported()
-    }
-}
-
-impl Drop for File {
-    fn drop(&mut self) {
-        unsafe { abi::SOLID_FS_Close(self.fd.raw()) };
-    }
-}
-
-impl DirBuilder {
-    pub fn new() -> DirBuilder {
-        DirBuilder {}
-    }
-
-    pub fn mkdir(&self, p: &Path) -> io::Result<()> {
-        error::SolidError::err_if_negative(unsafe { abi::SOLID_FS_Mkdir(cstr(p)?.as_ptr()) })
-            .map_err(|e| e.as_io_error())?;
-        Ok(())
-    }
-}
-
-impl fmt::Debug for File {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("File").field("fd", &self.fd.raw()).finish()
-    }
-}
-
-pub fn unlink(p: &Path) -> io::Result<()> {
-    if stat(p)?.file_type().is_dir() {
-        Err(io::const_io_error!(io::ErrorKind::IsADirectory, "is a directory"))
-    } else {
-        error::SolidError::err_if_negative(unsafe { abi::SOLID_FS_Unlink(cstr(p)?.as_ptr()) })
-            .map_err(|e| e.as_io_error())?;
-        Ok(())
-    }
-}
-
-pub fn rename(old: &Path, new: &Path) -> io::Result<()> {
-    error::SolidError::err_if_negative(unsafe {
-        abi::SOLID_FS_Rename(cstr(old)?.as_ptr(), cstr(new)?.as_ptr())
-    })
-    .map_err(|e| e.as_io_error())?;
-    Ok(())
-}
-
-pub fn set_perm(p: &Path, perm: FilePermissions) -> io::Result<()> {
-    error::SolidError::err_if_negative(unsafe {
-        abi::SOLID_FS_Chmod(cstr(p)?.as_ptr(), perm.0.into())
-    })
-    .map_err(|e| e.as_io_error())?;
-    Ok(())
-}
-
-pub fn rmdir(p: &Path) -> io::Result<()> {
-    if stat(p)?.file_type().is_dir() {
-        error::SolidError::err_if_negative(unsafe { abi::SOLID_FS_Unlink(cstr(p)?.as_ptr()) })
-            .map_err(|e| e.as_io_error())?;
-        Ok(())
-    } else {
-        Err(io::const_io_error!(io::ErrorKind::NotADirectory, "not a directory"))
-    }
-}
-
-pub fn remove_dir_all(path: &Path) -> io::Result<()> {
-    for child in readdir(path)? {
-        let child = child?;
-        let child_type = child.file_type()?;
-        if child_type.is_dir() {
-            remove_dir_all(&child.path())?;
-        } else {
-            unlink(&child.path())?;
-        }
-    }
-    rmdir(path)
-}
-
-pub fn readlink(p: &Path) -> io::Result<PathBuf> {
-    // This target doesn't support symlinks
-    stat(p)?;
-    Err(io::const_io_error!(io::ErrorKind::InvalidInput, "not a symbolic link"))
-}
-
-pub fn symlink(_original: &Path, _link: &Path) -> io::Result<()> {
-    // This target doesn't support symlinks
-    unsupported()
-}
-
-pub fn link(_src: &Path, _dst: &Path) -> io::Result<()> {
-    // This target doesn't support symlinks
-    unsupported()
-}
-
-pub fn stat(p: &Path) -> io::Result<FileAttr> {
-    // This target doesn't support symlinks
-    lstat(p)
-}
-
-pub fn lstat(p: &Path) -> io::Result<FileAttr> {
-    unsafe {
-        let mut out_stat = MaybeUninit::uninit();
-        error::SolidError::err_if_negative(abi::SOLID_FS_Stat(
-            cstr(p)?.as_ptr(),
-            out_stat.as_mut_ptr(),
-        ))
-        .map_err(|e| e.as_io_error())?;
-        Ok(FileAttr { stat: out_stat.assume_init() })
-    }
-}
-
-pub fn canonicalize(_p: &Path) -> io::Result<PathBuf> {
-    unsupported()
-}
-
-pub fn copy(from: &Path, to: &Path) -> io::Result<u64> {
-    use crate::fs::File;
-
-    let mut reader = File::open(from)?;
-    let mut writer = File::create(to)?;
-
-    io::copy(&mut reader, &mut writer)
-}
diff --git a/library/std/src/sys/solid/io.rs b/library/std/src/sys/solid/io.rs
deleted file mode 100644
index a862bb78702..00000000000
--- a/library/std/src/sys/solid/io.rs
+++ /dev/null
@@ -1,81 +0,0 @@
-use crate::marker::PhantomData;
-use crate::slice;
-
-use super::abi::sockets::iovec;
-use libc::c_void;
-
-#[derive(Copy, Clone)]
-#[repr(transparent)]
-pub struct IoSlice<'a> {
-    vec: iovec,
-    _p: PhantomData<&'a [u8]>,
-}
-
-impl<'a> IoSlice<'a> {
-    #[inline]
-    pub fn new(buf: &'a [u8]) -> IoSlice<'a> {
-        IoSlice {
-            vec: iovec { iov_base: buf.as_ptr() as *mut u8 as *mut c_void, iov_len: buf.len() },
-            _p: PhantomData,
-        }
-    }
-
-    #[inline]
-    pub fn advance(&mut self, n: usize) {
-        if self.vec.iov_len < n {
-            panic!("advancing IoSlice beyond its length");
-        }
-
-        unsafe {
-            self.vec.iov_len -= n;
-            self.vec.iov_base = self.vec.iov_base.add(n);
-        }
-    }
-
-    #[inline]
-    pub fn as_slice(&self) -> &[u8] {
-        unsafe { slice::from_raw_parts(self.vec.iov_base as *mut u8, self.vec.iov_len) }
-    }
-}
-
-#[repr(transparent)]
-pub struct IoSliceMut<'a> {
-    vec: iovec,
-    _p: PhantomData<&'a mut [u8]>,
-}
-
-impl<'a> IoSliceMut<'a> {
-    #[inline]
-    pub fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
-        IoSliceMut {
-            vec: iovec { iov_base: buf.as_mut_ptr() as *mut c_void, iov_len: buf.len() },
-            _p: PhantomData,
-        }
-    }
-
-    #[inline]
-    pub fn advance(&mut self, n: usize) {
-        if self.vec.iov_len < n {
-            panic!("advancing IoSliceMut beyond its length");
-        }
-
-        unsafe {
-            self.vec.iov_len -= n;
-            self.vec.iov_base = self.vec.iov_base.add(n);
-        }
-    }
-
-    #[inline]
-    pub fn as_slice(&self) -> &[u8] {
-        unsafe { slice::from_raw_parts(self.vec.iov_base as *mut u8, self.vec.iov_len) }
-    }
-
-    #[inline]
-    pub fn as_mut_slice(&mut self) -> &mut [u8] {
-        unsafe { slice::from_raw_parts_mut(self.vec.iov_base as *mut u8, self.vec.iov_len) }
-    }
-}
-
-pub fn is_terminal<T>(_: &T) -> bool {
-    false
-}
diff --git a/library/std/src/sys/solid/memchr.rs b/library/std/src/sys/solid/memchr.rs
deleted file mode 100644
index 452b7a3de1b..00000000000
--- a/library/std/src/sys/solid/memchr.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-pub fn memchr(needle: u8, haystack: &[u8]) -> Option<usize> {
-    let p = unsafe {
-        libc::memchr(
-            haystack.as_ptr() as *const libc::c_void,
-            needle as libc::c_int,
-            haystack.len(),
-        )
-    };
-    if p.is_null() { None } else { Some(p as usize - (haystack.as_ptr() as usize)) }
-}
-
-pub fn memrchr(needle: u8, haystack: &[u8]) -> Option<usize> {
-    let p = unsafe {
-        libc::memrchr(
-            haystack.as_ptr() as *const libc::c_void,
-            needle as libc::c_int,
-            haystack.len(),
-        )
-    };
-    if p.is_null() { None } else { Some(p as usize - (haystack.as_ptr() as usize)) }
-}
diff --git a/library/std/src/sys/solid/mod.rs b/library/std/src/sys/solid/mod.rs
deleted file mode 100644
index 5af83653cf8..00000000000
--- a/library/std/src/sys/solid/mod.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-#![allow(dead_code)]
-#![allow(missing_docs, nonstandard_style)]
-#![deny(unsafe_op_in_unsafe_fn)]
-
-mod abi;
-
-#[path = "../itron"]
-mod itron {
-    pub(super) mod abi;
-    pub mod condvar;
-    pub(super) mod error;
-    pub mod mutex;
-    pub(super) mod spin;
-    pub(super) mod task;
-    pub mod thread;
-    pub mod thread_parking;
-    pub(super) mod time;
-    use super::unsupported;
-}
-
-pub mod alloc;
-#[path = "../unsupported/args.rs"]
-pub mod args;
-#[path = "../unix/cmath.rs"]
-pub mod cmath;
-pub mod env;
-// `error` is `pub(crate)` so that it can be accessed by `itron/error.rs` as
-// `crate::sys::error`
-pub(crate) mod error;
-pub mod fs;
-pub mod io;
-pub mod net;
-pub mod os;
-#[path = "../unix/os_str.rs"]
-pub mod os_str;
-pub mod path;
-#[path = "../unsupported/pipe.rs"]
-pub mod pipe;
-#[path = "../unsupported/process.rs"]
-pub mod process;
-pub mod stdio;
-pub use self::itron::thread;
-pub mod memchr;
-pub mod thread_local_dtor;
-pub mod thread_local_key;
-pub use self::itron::thread_parking;
-pub mod time;
-
-mod rwlock;
-
-pub mod locks {
-    pub use super::itron::condvar::*;
-    pub use super::itron::mutex::*;
-    pub use super::rwlock::*;
-}
-
-// SAFETY: must be called only once during runtime initialization.
-// NOTE: this is not guaranteed to run, for example when Rust code is called externally.
-pub unsafe fn init(_argc: isize, _argv: *const *const u8, _sigpipe: u8) {}
-
-// SAFETY: must be called only once during runtime cleanup.
-pub unsafe fn cleanup() {}
-
-pub fn unsupported<T>() -> crate::io::Result<T> {
-    Err(unsupported_err())
-}
-
-pub fn unsupported_err() -> crate::io::Error {
-    crate::io::const_io_error!(
-        crate::io::ErrorKind::Unsupported,
-        "operation not supported on this platform",
-    )
-}
-
-#[inline]
-pub fn is_interrupted(code: i32) -> bool {
-    net::is_interrupted(code)
-}
-
-pub fn decode_error_kind(code: i32) -> crate::io::ErrorKind {
-    error::decode_error_kind(code)
-}
-
-#[inline]
-pub fn abort_internal() -> ! {
-    unsafe { libc::abort() }
-}
-
-pub fn hashmap_random_keys() -> (u64, u64) {
-    unsafe {
-        let mut out = crate::mem::MaybeUninit::<[u64; 2]>::uninit();
-        let result = abi::SOLID_RNG_SampleRandomBytes(out.as_mut_ptr() as *mut u8, 16);
-        assert_eq!(result, 0, "SOLID_RNG_SampleRandomBytes failed: {result}");
-        let [x1, x2] = out.assume_init();
-        (x1, x2)
-    }
-}
diff --git a/library/std/src/sys/solid/net.rs b/library/std/src/sys/solid/net.rs
deleted file mode 100644
index a768e2406c8..00000000000
--- a/library/std/src/sys/solid/net.rs
+++ /dev/null
@@ -1,435 +0,0 @@
-use super::abi;
-use crate::{
-    cmp,
-    ffi::CStr,
-    io::{self, BorrowedBuf, BorrowedCursor, ErrorKind, IoSlice, IoSliceMut},
-    mem,
-    net::{Shutdown, SocketAddr},
-    os::solid::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd},
-    ptr, str,
-    sys_common::net::{getsockopt, setsockopt, sockaddr_to_addr},
-    sys_common::{FromInner, IntoInner},
-    time::Duration,
-};
-
-use self::netc::{sockaddr, socklen_t, MSG_PEEK};
-use libc::{c_int, c_void, size_t};
-
-pub mod netc {
-    pub use super::super::abi::sockets::*;
-}
-
-pub type wrlen_t = size_t;
-
-const READ_LIMIT: usize = libc::ssize_t::MAX as usize;
-
-const fn max_iov() -> usize {
-    // Judging by the source code, it's unlimited, but specify a lower
-    // value just in case.
-    1024
-}
-
-#[doc(hidden)]
-pub trait IsMinusOne {
-    fn is_minus_one(&self) -> bool;
-}
-
-macro_rules! impl_is_minus_one {
-    ($($t:ident)*) => ($(impl IsMinusOne for $t {
-        fn is_minus_one(&self) -> bool {
-            *self == -1
-        }
-    })*)
-}
-
-impl_is_minus_one! { i8 i16 i32 i64 isize }
-
-pub fn cvt<T: IsMinusOne>(t: T) -> io::Result<T> {
-    if t.is_minus_one() { Err(last_error()) } else { Ok(t) }
-}
-
-/// A variant of `cvt` for `getaddrinfo` which return 0 for a success.
-pub fn cvt_gai(err: c_int) -> io::Result<()> {
-    if err == 0 {
-        Ok(())
-    } else {
-        let msg: &dyn crate::fmt::Display = match err {
-            netc::EAI_NONAME => &"name or service not known",
-            netc::EAI_SERVICE => &"service not supported",
-            netc::EAI_FAIL => &"non-recoverable failure in name resolution",
-            netc::EAI_MEMORY => &"memory allocation failure",
-            netc::EAI_FAMILY => &"family not supported",
-            _ => &err,
-        };
-        Err(io::Error::new(
-            io::ErrorKind::Uncategorized,
-            &format!("failed to lookup address information: {msg}")[..],
-        ))
-    }
-}
-
-/// Just to provide the same interface as sys/unix/net.rs
-pub fn cvt_r<T, F>(mut f: F) -> io::Result<T>
-where
-    T: IsMinusOne,
-    F: FnMut() -> T,
-{
-    cvt(f())
-}
-
-/// Returns the last error from the network subsystem.
-fn last_error() -> io::Error {
-    io::Error::from_raw_os_error(unsafe { netc::SOLID_NET_GetLastError() })
-}
-
-pub(super) fn error_name(er: abi::ER) -> Option<&'static str> {
-    unsafe { CStr::from_ptr(netc::strerror(er)) }.to_str().ok()
-}
-
-#[inline]
-pub fn is_interrupted(er: abi::ER) -> bool {
-    er == netc::SOLID_NET_ERR_BASE - libc::EINTR
-}
-
-pub(super) fn decode_error_kind(er: abi::ER) -> ErrorKind {
-    let errno = netc::SOLID_NET_ERR_BASE - er;
-    match errno as libc::c_int {
-        libc::ECONNREFUSED => ErrorKind::ConnectionRefused,
-        libc::ECONNRESET => ErrorKind::ConnectionReset,
-        libc::EPERM | libc::EACCES => ErrorKind::PermissionDenied,
-        libc::EPIPE => ErrorKind::BrokenPipe,
-        libc::ENOTCONN => ErrorKind::NotConnected,
-        libc::ECONNABORTED => ErrorKind::ConnectionAborted,
-        libc::EADDRNOTAVAIL => ErrorKind::AddrNotAvailable,
-        libc::EADDRINUSE => ErrorKind::AddrInUse,
-        libc::ENOENT => ErrorKind::NotFound,
-        libc::EINTR => ErrorKind::Interrupted,
-        libc::EINVAL => ErrorKind::InvalidInput,
-        libc::ETIMEDOUT => ErrorKind::TimedOut,
-        libc::EEXIST => ErrorKind::AlreadyExists,
-        libc::ENOSYS => ErrorKind::Unsupported,
-        libc::ENOMEM => ErrorKind::OutOfMemory,
-        libc::EAGAIN => ErrorKind::WouldBlock,
-
-        _ => ErrorKind::Uncategorized,
-    }
-}
-
-pub fn init() {}
-
-pub struct Socket(OwnedFd);
-
-impl Socket {
-    pub fn new(addr: &SocketAddr, ty: c_int) -> io::Result<Socket> {
-        let fam = match *addr {
-            SocketAddr::V4(..) => netc::AF_INET,
-            SocketAddr::V6(..) => netc::AF_INET6,
-        };
-        Socket::new_raw(fam, ty)
-    }
-
-    pub fn new_raw(fam: c_int, ty: c_int) -> io::Result<Socket> {
-        unsafe {
-            let fd = cvt(netc::socket(fam, ty, 0))?;
-            Ok(Self::from_raw_fd(fd))
-        }
-    }
-
-    pub fn connect(&self, addr: &SocketAddr) -> io::Result<()> {
-        let (addr, len) = addr.into_inner();
-        cvt(unsafe { netc::connect(self.as_raw_fd(), addr.as_ptr(), len) })?;
-        Ok(())
-    }
-
-    pub fn connect_timeout(&self, addr: &SocketAddr, timeout: Duration) -> io::Result<()> {
-        self.set_nonblocking(true)?;
-        let r = self.connect(addr);
-        self.set_nonblocking(false)?;
-
-        match r {
-            Ok(_) => return Ok(()),
-            // there's no ErrorKind for EINPROGRESS
-            Err(ref e) if e.raw_os_error() == Some(netc::EINPROGRESS) => {}
-            Err(e) => return Err(e),
-        }
-
-        if timeout.as_secs() == 0 && timeout.subsec_nanos() == 0 {
-            return Err(io::const_io_error!(
-                io::ErrorKind::InvalidInput,
-                "cannot set a 0 duration timeout",
-            ));
-        }
-
-        let mut timeout =
-            netc::timeval { tv_sec: timeout.as_secs() as _, tv_usec: timeout.subsec_micros() as _ };
-        if timeout.tv_sec == 0 && timeout.tv_usec == 0 {
-            timeout.tv_usec = 1;
-        }
-
-        let fds = netc::fd_set { num_fds: 1, fds: [self.as_raw_fd()] };
-
-        let mut writefds = fds;
-        let mut errorfds = fds;
-
-        let n = unsafe {
-            cvt(netc::select(
-                self.as_raw_fd() + 1,
-                ptr::null_mut(),
-                &mut writefds,
-                &mut errorfds,
-                &mut timeout,
-            ))?
-        };
-
-        match n {
-            0 => Err(io::const_io_error!(io::ErrorKind::TimedOut, "connection timed out")),
-            _ => {
-                let can_write = writefds.num_fds != 0;
-                if !can_write {
-                    if let Some(e) = self.take_error()? {
-                        return Err(e);
-                    }
-                }
-                Ok(())
-            }
-        }
-    }
-
-    pub fn accept(&self, storage: *mut sockaddr, len: *mut socklen_t) -> io::Result<Socket> {
-        let fd = cvt_r(|| unsafe { netc::accept(self.as_raw_fd(), storage, len) })?;
-        unsafe { Ok(Self::from_raw_fd(fd)) }
-    }
-
-    pub fn duplicate(&self) -> io::Result<Socket> {
-        Ok(Self(self.0.try_clone()?))
-    }
-
-    fn recv_with_flags(&self, mut buf: BorrowedCursor<'_>, flags: c_int) -> io::Result<()> {
-        let ret = cvt(unsafe {
-            netc::recv(self.as_raw_fd(), buf.as_mut().as_mut_ptr().cast(), buf.capacity(), flags)
-        })?;
-        unsafe {
-            buf.advance(ret as usize);
-        }
-        Ok(())
-    }
-
-    pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
-        let mut buf = BorrowedBuf::from(buf);
-        self.recv_with_flags(buf.unfilled(), 0)?;
-        Ok(buf.len())
-    }
-
-    pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
-        let mut buf = BorrowedBuf::from(buf);
-        self.recv_with_flags(buf.unfilled(), MSG_PEEK)?;
-        Ok(buf.len())
-    }
-
-    pub fn read_buf(&self, buf: BorrowedCursor<'_>) -> io::Result<()> {
-        self.recv_with_flags(buf, 0)
-    }
-
-    pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
-        let ret = cvt(unsafe {
-            netc::readv(
-                self.as_raw_fd(),
-                bufs.as_ptr() as *const netc::iovec,
-                cmp::min(bufs.len(), max_iov()) as c_int,
-            )
-        })?;
-        Ok(ret as usize)
-    }
-
-    #[inline]
-    pub fn is_read_vectored(&self) -> bool {
-        true
-    }
-
-    fn recv_from_with_flags(
-        &self,
-        buf: &mut [u8],
-        flags: c_int,
-    ) -> io::Result<(usize, SocketAddr)> {
-        let mut storage: netc::sockaddr_storage = unsafe { mem::zeroed() };
-        let mut addrlen = mem::size_of_val(&storage) as netc::socklen_t;
-
-        let n = cvt(unsafe {
-            netc::recvfrom(
-                self.as_raw_fd(),
-                buf.as_mut_ptr() as *mut c_void,
-                buf.len(),
-                flags,
-                &mut storage as *mut _ as *mut _,
-                &mut addrlen,
-            )
-        })?;
-        Ok((n as usize, sockaddr_to_addr(&storage, addrlen as usize)?))
-    }
-
-    pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
-        self.recv_from_with_flags(buf, 0)
-    }
-
-    pub fn peek_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
-        self.recv_from_with_flags(buf, MSG_PEEK)
-    }
-
-    pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
-        let ret = cvt(unsafe {
-            netc::write(
-                self.as_raw_fd(),
-                buf.as_ptr() as *const c_void,
-                cmp::min(buf.len(), READ_LIMIT),
-            )
-        })?;
-        Ok(ret as usize)
-    }
-
-    pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let ret = cvt(unsafe {
-            netc::writev(
-                self.as_raw_fd(),
-                bufs.as_ptr() as *const netc::iovec,
-                cmp::min(bufs.len(), max_iov()) as c_int,
-            )
-        })?;
-        Ok(ret as usize)
-    }
-
-    #[inline]
-    pub fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    pub fn set_timeout(&self, dur: Option<Duration>, kind: c_int) -> io::Result<()> {
-        let timeout = match dur {
-            Some(dur) => {
-                if dur.as_secs() == 0 && dur.subsec_nanos() == 0 {
-                    return Err(io::const_io_error!(
-                        io::ErrorKind::InvalidInput,
-                        "cannot set a 0 duration timeout",
-                    ));
-                }
-
-                let secs = if dur.as_secs() > netc::c_long::MAX as u64 {
-                    netc::c_long::MAX
-                } else {
-                    dur.as_secs() as netc::c_long
-                };
-                let mut timeout = netc::timeval { tv_sec: secs, tv_usec: dur.subsec_micros() as _ };
-                if timeout.tv_sec == 0 && timeout.tv_usec == 0 {
-                    timeout.tv_usec = 1;
-                }
-                timeout
-            }
-            None => netc::timeval { tv_sec: 0, tv_usec: 0 },
-        };
-        setsockopt(self, netc::SOL_SOCKET, kind, timeout)
-    }
-
-    pub fn timeout(&self, kind: c_int) -> io::Result<Option<Duration>> {
-        let raw: netc::timeval = getsockopt(self, netc::SOL_SOCKET, kind)?;
-        if raw.tv_sec == 0 && raw.tv_usec == 0 {
-            Ok(None)
-        } else {
-            let sec = raw.tv_sec as u64;
-            let nsec = (raw.tv_usec as u32) * 1000;
-            Ok(Some(Duration::new(sec, nsec)))
-        }
-    }
-
-    pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
-        let how = match how {
-            Shutdown::Write => netc::SHUT_WR,
-            Shutdown::Read => netc::SHUT_RD,
-            Shutdown::Both => netc::SHUT_RDWR,
-        };
-        cvt(unsafe { netc::shutdown(self.as_raw_fd(), how) })?;
-        Ok(())
-    }
-
-    pub fn set_linger(&self, linger: Option<Duration>) -> io::Result<()> {
-        let linger = netc::linger {
-            l_onoff: linger.is_some() as netc::c_int,
-            l_linger: linger.unwrap_or_default().as_secs() as netc::c_int,
-        };
-
-        setsockopt(self, netc::SOL_SOCKET, netc::SO_LINGER, linger)
-    }
-
-    pub fn linger(&self) -> io::Result<Option<Duration>> {
-        let val: netc::linger = getsockopt(self, netc::SOL_SOCKET, netc::SO_LINGER)?;
-
-        Ok((val.l_onoff != 0).then(|| Duration::from_secs(val.l_linger as u64)))
-    }
-
-    pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
-        setsockopt(self, netc::IPPROTO_TCP, netc::TCP_NODELAY, nodelay as c_int)
-    }
-
-    pub fn nodelay(&self) -> io::Result<bool> {
-        let raw: c_int = getsockopt(self, netc::IPPROTO_TCP, netc::TCP_NODELAY)?;
-        Ok(raw != 0)
-    }
-
-    pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
-        let mut nonblocking = nonblocking as c_int;
-        cvt(unsafe {
-            netc::ioctl(self.as_raw_fd(), netc::FIONBIO, (&mut nonblocking) as *mut c_int as _)
-        })
-        .map(drop)
-    }
-
-    pub fn take_error(&self) -> io::Result<Option<io::Error>> {
-        let raw: c_int = getsockopt(self, netc::SOL_SOCKET, netc::SO_ERROR)?;
-        if raw == 0 { Ok(None) } else { Ok(Some(io::Error::from_raw_os_error(raw as i32))) }
-    }
-
-    // This method is used by sys_common code to abstract over targets.
-    pub fn as_raw(&self) -> c_int {
-        self.as_raw_fd()
-    }
-}
-
-impl FromInner<OwnedFd> for Socket {
-    #[inline]
-    fn from_inner(sock: OwnedFd) -> Socket {
-        Socket(sock)
-    }
-}
-
-impl IntoInner<OwnedFd> for Socket {
-    #[inline]
-    fn into_inner(self) -> OwnedFd {
-        self.0
-    }
-}
-
-impl AsFd for Socket {
-    #[inline]
-    fn as_fd(&self) -> BorrowedFd<'_> {
-        self.0.as_fd()
-    }
-}
-
-impl AsRawFd for Socket {
-    #[inline]
-    fn as_raw_fd(&self) -> c_int {
-        self.0.as_raw_fd()
-    }
-}
-
-impl FromRawFd for Socket {
-    #[inline]
-    unsafe fn from_raw_fd(fd: c_int) -> Socket {
-        unsafe { Self(FromRawFd::from_raw_fd(fd)) }
-    }
-}
-
-impl IntoRawFd for Socket {
-    #[inline]
-    fn into_raw_fd(self) -> c_int {
-        self.0.into_raw_fd()
-    }
-}
diff --git a/library/std/src/sys/solid/os.rs b/library/std/src/sys/solid/os.rs
deleted file mode 100644
index ff81544ba91..00000000000
--- a/library/std/src/sys/solid/os.rs
+++ /dev/null
@@ -1,228 +0,0 @@
-use super::unsupported;
-use crate::error::Error as StdError;
-use crate::ffi::{CStr, OsStr, OsString};
-use crate::fmt;
-use crate::io;
-use crate::os::{
-    raw::{c_char, c_int},
-    solid::ffi::{OsStrExt, OsStringExt},
-};
-use crate::path::{self, PathBuf};
-use crate::sync::{PoisonError, RwLock};
-use crate::sys::common::small_c_string::run_with_cstr;
-use crate::vec;
-
-use super::{error, itron, memchr};
-
-// `solid` directly maps `errno`s to μITRON error codes.
-impl itron::error::ItronError {
-    #[inline]
-    pub(crate) fn as_io_error(self) -> crate::io::Error {
-        crate::io::Error::from_raw_os_error(self.as_raw())
-    }
-}
-
-pub fn errno() -> i32 {
-    0
-}
-
-pub fn error_string(errno: i32) -> String {
-    if let Some(name) = error::error_name(errno) { name.to_owned() } else { format!("{errno}") }
-}
-
-pub fn getcwd() -> io::Result<PathBuf> {
-    unsupported()
-}
-
-pub fn chdir(_: &path::Path) -> io::Result<()> {
-    unsupported()
-}
-
-pub struct SplitPaths<'a>(&'a !);
-
-pub fn split_paths(_unparsed: &OsStr) -> SplitPaths<'_> {
-    panic!("unsupported")
-}
-
-impl<'a> Iterator for SplitPaths<'a> {
-    type Item = PathBuf;
-    fn next(&mut self) -> Option<PathBuf> {
-        *self.0
-    }
-}
-
-#[derive(Debug)]
-pub struct JoinPathsError;
-
-pub fn join_paths<I, T>(_paths: I) -> Result<OsString, JoinPathsError>
-where
-    I: Iterator<Item = T>,
-    T: AsRef<OsStr>,
-{
-    Err(JoinPathsError)
-}
-
-impl fmt::Display for JoinPathsError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        "not supported on this platform yet".fmt(f)
-    }
-}
-
-impl StdError for JoinPathsError {
-    #[allow(deprecated)]
-    fn description(&self) -> &str {
-        "not supported on this platform yet"
-    }
-}
-
-pub fn current_exe() -> io::Result<PathBuf> {
-    unsupported()
-}
-
-static ENV_LOCK: RwLock<()> = RwLock::new(());
-
-pub fn env_read_lock() -> impl Drop {
-    ENV_LOCK.read().unwrap_or_else(PoisonError::into_inner)
-}
-
-pub struct Env {
-    iter: vec::IntoIter<(OsString, OsString)>,
-}
-
-// FIXME(https://github.com/rust-lang/rust/issues/114583): Remove this when <OsStr as Debug>::fmt matches <str as Debug>::fmt.
-pub struct EnvStrDebug<'a> {
-    slice: &'a [(OsString, OsString)],
-}
-
-impl fmt::Debug for EnvStrDebug<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let Self { slice } = self;
-        f.debug_list()
-            .entries(slice.iter().map(|(a, b)| (a.to_str().unwrap(), b.to_str().unwrap())))
-            .finish()
-    }
-}
-
-impl Env {
-    pub fn str_debug(&self) -> impl fmt::Debug + '_ {
-        let Self { iter } = self;
-        EnvStrDebug { slice: iter.as_slice() }
-    }
-}
-
-impl fmt::Debug for Env {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let Self { iter } = self;
-        f.debug_list().entries(iter.as_slice()).finish()
-    }
-}
-
-impl !Send for Env {}
-impl !Sync for Env {}
-
-impl Iterator for Env {
-    type Item = (OsString, OsString);
-    fn next(&mut self) -> Option<(OsString, OsString)> {
-        self.iter.next()
-    }
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
-    }
-}
-
-/// Returns a vector of (variable, value) byte-vector pairs for all the
-/// environment variables of the current process.
-pub fn env() -> Env {
-    extern "C" {
-        static mut environ: *const *const c_char;
-    }
-
-    unsafe {
-        let _guard = env_read_lock();
-        let mut result = Vec::new();
-        if !environ.is_null() {
-            while !(*environ).is_null() {
-                if let Some(key_value) = parse(CStr::from_ptr(*environ).to_bytes()) {
-                    result.push(key_value);
-                }
-                environ = environ.add(1);
-            }
-        }
-        return Env { iter: result.into_iter() };
-    }
-
-    fn parse(input: &[u8]) -> Option<(OsString, OsString)> {
-        // Strategy (copied from glibc): Variable name and value are separated
-        // by an ASCII equals sign '='. Since a variable name must not be
-        // empty, allow variable names starting with an equals sign. Skip all
-        // malformed lines.
-        if input.is_empty() {
-            return None;
-        }
-        let pos = memchr::memchr(b'=', &input[1..]).map(|p| p + 1);
-        pos.map(|p| {
-            (
-                OsStringExt::from_vec(input[..p].to_vec()),
-                OsStringExt::from_vec(input[p + 1..].to_vec()),
-            )
-        })
-    }
-}
-
-pub fn getenv(k: &OsStr) -> Option<OsString> {
-    // environment variables with a nul byte can't be set, so their value is
-    // always None as well
-    run_with_cstr(k.as_bytes(), |k| {
-        let _guard = env_read_lock();
-        let v = unsafe { libc::getenv(k.as_ptr()) } as *const libc::c_char;
-
-        if v.is_null() {
-            Ok(None)
-        } else {
-            // SAFETY: `v` cannot be mutated while executing this line since we've a read lock
-            let bytes = unsafe { CStr::from_ptr(v) }.to_bytes().to_vec();
-
-            Ok(Some(OsStringExt::from_vec(bytes)))
-        }
-    })
-    .ok()
-    .flatten()
-}
-
-pub fn setenv(k: &OsStr, v: &OsStr) -> io::Result<()> {
-    run_with_cstr(k.as_bytes(), |k| {
-        run_with_cstr(v.as_bytes(), |v| {
-            let _guard = ENV_LOCK.write();
-            cvt_env(unsafe { libc::setenv(k.as_ptr(), v.as_ptr(), 1) }).map(drop)
-        })
-    })
-}
-
-pub fn unsetenv(n: &OsStr) -> io::Result<()> {
-    run_with_cstr(n.as_bytes(), |nbuf| {
-        let _guard = ENV_LOCK.write();
-        cvt_env(unsafe { libc::unsetenv(nbuf.as_ptr()) }).map(drop)
-    })
-}
-
-/// In kmclib, `setenv` and `unsetenv` don't always set `errno`, so this
-/// function just returns a generic error.
-fn cvt_env(t: c_int) -> io::Result<c_int> {
-    if t == -1 { Err(io::const_io_error!(io::ErrorKind::Uncategorized, "failure")) } else { Ok(t) }
-}
-
-pub fn temp_dir() -> PathBuf {
-    panic!("no standard temporary directory on this platform")
-}
-
-pub fn home_dir() -> Option<PathBuf> {
-    None
-}
-
-pub fn exit(code: i32) -> ! {
-    rtabort!("exit({}) called", code);
-}
-
-pub fn getpid() -> u32 {
-    panic!("no pids on this platform")
-}
diff --git a/library/std/src/sys/solid/path.rs b/library/std/src/sys/solid/path.rs
deleted file mode 100644
index 7045c9be25b..00000000000
--- a/library/std/src/sys/solid/path.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-use crate::ffi::OsStr;
-use crate::io;
-use crate::path::{Path, PathBuf, Prefix};
-use crate::sys::unsupported;
-
-#[inline]
-pub fn is_sep_byte(b: u8) -> bool {
-    b == b'\\'
-}
-
-#[inline]
-pub fn is_verbatim_sep(b: u8) -> bool {
-    b == b'\\'
-}
-
-pub fn parse_prefix(_: &OsStr) -> Option<Prefix<'_>> {
-    None
-}
-
-pub const MAIN_SEP_STR: &str = "\\";
-pub const MAIN_SEP: char = '\\';
-
-pub(crate) fn absolute(_path: &Path) -> io::Result<PathBuf> {
-    unsupported()
-}
diff --git a/library/std/src/sys/solid/rwlock.rs b/library/std/src/sys/solid/rwlock.rs
deleted file mode 100644
index ecb4eb83b9b..00000000000
--- a/library/std/src/sys/solid/rwlock.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-//! A readers-writer lock implementation backed by the SOLID kernel extension.
-use super::{
-    abi,
-    itron::{
-        error::{expect_success, expect_success_aborting, fail, ItronError},
-        spin::SpinIdOnceCell,
-    },
-};
-
-pub struct RwLock {
-    /// The ID of the underlying mutex object
-    rwl: SpinIdOnceCell<()>,
-}
-
-// Safety: `num_readers` is protected by `mtx_num_readers`
-unsafe impl Send for RwLock {}
-unsafe impl Sync for RwLock {}
-
-fn new_rwl() -> Result<abi::ID, ItronError> {
-    ItronError::err_if_negative(unsafe { abi::rwl_acre_rwl() })
-}
-
-impl RwLock {
-    #[inline]
-    pub const fn new() -> RwLock {
-        RwLock { rwl: SpinIdOnceCell::new() }
-    }
-
-    /// Get the inner mutex's ID, which is lazily created.
-    fn raw(&self) -> abi::ID {
-        match self.rwl.get_or_try_init(|| new_rwl().map(|id| (id, ()))) {
-            Ok((id, ())) => id,
-            Err(e) => fail(e, &"rwl_acre_rwl"),
-        }
-    }
-
-    #[inline]
-    pub fn read(&self) {
-        let rwl = self.raw();
-        expect_success(unsafe { abi::rwl_loc_rdl(rwl) }, &"rwl_loc_rdl");
-    }
-
-    #[inline]
-    pub fn try_read(&self) -> bool {
-        let rwl = self.raw();
-        match unsafe { abi::rwl_ploc_rdl(rwl) } {
-            abi::E_TMOUT => false,
-            er => {
-                expect_success(er, &"rwl_ploc_rdl");
-                true
-            }
-        }
-    }
-
-    #[inline]
-    pub fn write(&self) {
-        let rwl = self.raw();
-        expect_success(unsafe { abi::rwl_loc_wrl(rwl) }, &"rwl_loc_wrl");
-    }
-
-    #[inline]
-    pub fn try_write(&self) -> bool {
-        let rwl = self.raw();
-        match unsafe { abi::rwl_ploc_wrl(rwl) } {
-            abi::E_TMOUT => false,
-            er => {
-                expect_success(er, &"rwl_ploc_wrl");
-                true
-            }
-        }
-    }
-
-    #[inline]
-    pub unsafe fn read_unlock(&self) {
-        let rwl = self.raw();
-        expect_success_aborting(unsafe { abi::rwl_unl_rwl(rwl) }, &"rwl_unl_rwl");
-    }
-
-    #[inline]
-    pub unsafe fn write_unlock(&self) {
-        let rwl = self.raw();
-        expect_success_aborting(unsafe { abi::rwl_unl_rwl(rwl) }, &"rwl_unl_rwl");
-    }
-}
-
-impl Drop for RwLock {
-    #[inline]
-    fn drop(&mut self) {
-        if let Some(rwl) = self.rwl.get().map(|x| x.0) {
-            expect_success_aborting(unsafe { abi::rwl_del_rwl(rwl) }, &"rwl_del_rwl");
-        }
-    }
-}
diff --git a/library/std/src/sys/solid/stdio.rs b/library/std/src/sys/solid/stdio.rs
deleted file mode 100644
index 50f0176967b..00000000000
--- a/library/std/src/sys/solid/stdio.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-use super::abi;
-use crate::io;
-
-pub struct Stdin;
-pub struct Stdout;
-pub struct Stderr;
-struct PanicOutput;
-
-impl Stdin {
-    pub const fn new() -> Stdin {
-        Stdin
-    }
-}
-
-impl io::Read for Stdin {
-    fn read(&mut self, _buf: &mut [u8]) -> io::Result<usize> {
-        Ok(0)
-    }
-}
-
-impl Stdout {
-    pub const fn new() -> Stdout {
-        Stdout
-    }
-}
-
-impl io::Write for Stdout {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        unsafe { abi::SOLID_LOG_write(buf.as_ptr(), buf.len()) };
-        Ok(buf.len())
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl Stderr {
-    pub const fn new() -> Stderr {
-        Stderr
-    }
-}
-
-impl io::Write for Stderr {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        unsafe { abi::SOLID_LOG_write(buf.as_ptr(), buf.len()) };
-        Ok(buf.len())
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl PanicOutput {
-    pub const fn new() -> PanicOutput {
-        PanicOutput
-    }
-}
-
-impl io::Write for PanicOutput {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        unsafe { abi::SOLID_LOG_write(buf.as_ptr(), buf.len()) };
-        Ok(buf.len())
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-pub const STDIN_BUF_SIZE: usize = 0;
-
-pub fn is_ebadf(_err: &io::Error) -> bool {
-    true
-}
-
-pub fn panic_output() -> Option<impl io::Write> {
-    Some(PanicOutput::new())
-}
diff --git a/library/std/src/sys/solid/thread_local_dtor.rs b/library/std/src/sys/solid/thread_local_dtor.rs
deleted file mode 100644
index 26918a4fcb0..00000000000
--- a/library/std/src/sys/solid/thread_local_dtor.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-#![cfg(target_thread_local)]
-#![unstable(feature = "thread_local_internals", issue = "none")]
-
-// Simplify dtor registration by using a list of destructors.
-
-use super::{abi, itron::task};
-use crate::cell::{Cell, RefCell};
-
-#[thread_local]
-static REGISTERED: Cell<bool> = Cell::new(false);
-
-#[thread_local]
-static DTORS: RefCell<Vec<(*mut u8, unsafe extern "C" fn(*mut u8))>> = RefCell::new(Vec::new());
-
-pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
-    if !REGISTERED.get() {
-        let tid = task::current_task_id_aborting();
-        // Register `tls_dtor` to make sure the TLS destructors are called
-        // for tasks created by other means than `std::thread`
-        unsafe { abi::SOLID_TLS_AddDestructor(tid as i32, tls_dtor) };
-        REGISTERED.set(true);
-    }
-
-    match DTORS.try_borrow_mut() {
-        Ok(mut dtors) => dtors.push((t, dtor)),
-        Err(_) => rtabort!("global allocator may not use TLS"),
-    }
-}
-
-pub unsafe fn run_dtors() {
-    let mut list = DTORS.take();
-    while !list.is_empty() {
-        for (ptr, dtor) in list {
-            unsafe { dtor(ptr) };
-        }
-
-        list = DTORS.take();
-    }
-}
-
-unsafe extern "C" fn tls_dtor(_unused: *mut u8) {
-    unsafe { run_dtors() };
-}
diff --git a/library/std/src/sys/solid/thread_local_key.rs b/library/std/src/sys/solid/thread_local_key.rs
deleted file mode 100644
index b37bf999698..00000000000
--- a/library/std/src/sys/solid/thread_local_key.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-pub type Key = usize;
-
-#[inline]
-pub unsafe fn create(_dtor: Option<unsafe extern "C" fn(*mut u8)>) -> Key {
-    panic!("should not be used on the solid target");
-}
-
-#[inline]
-pub unsafe fn set(_key: Key, _value: *mut u8) {
-    panic!("should not be used on the solid target");
-}
-
-#[inline]
-pub unsafe fn get(_key: Key) -> *mut u8 {
-    panic!("should not be used on the solid target");
-}
-
-#[inline]
-pub unsafe fn destroy(_key: Key) {
-    panic!("should not be used on the solid target");
-}
diff --git a/library/std/src/sys/solid/time.rs b/library/std/src/sys/solid/time.rs
deleted file mode 100644
index f83f1644fe8..00000000000
--- a/library/std/src/sys/solid/time.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-use super::{abi, error::expect_success};
-use crate::{mem::MaybeUninit, time::Duration};
-
-pub use super::itron::time::Instant;
-
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
-pub struct SystemTime(abi::time_t);
-
-pub const UNIX_EPOCH: SystemTime = SystemTime(0);
-
-impl SystemTime {
-    pub fn now() -> SystemTime {
-        let rtc = unsafe {
-            let mut out = MaybeUninit::zeroed();
-            expect_success(abi::SOLID_RTC_ReadTime(out.as_mut_ptr()), &"SOLID_RTC_ReadTime");
-            out.assume_init()
-        };
-        let t = unsafe {
-            libc::mktime(&mut libc::tm {
-                tm_sec: rtc.tm_sec,
-                tm_min: rtc.tm_min,
-                tm_hour: rtc.tm_hour,
-                tm_mday: rtc.tm_mday,
-                tm_mon: rtc.tm_mon - 1,
-                tm_year: rtc.tm_year,
-                tm_wday: rtc.tm_wday,
-                tm_yday: 0,
-                tm_isdst: 0,
-                tm_gmtoff: 0,
-                tm_zone: crate::ptr::null_mut(),
-            })
-        };
-        assert_ne!(t, -1, "mktime failed");
-        SystemTime(t)
-    }
-
-    pub(super) fn from_time_t(t: abi::time_t) -> Self {
-        Self(t)
-    }
-
-    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
-        if self.0 >= other.0 {
-            Ok(Duration::from_secs((self.0 as u64).wrapping_sub(other.0 as u64)))
-        } else {
-            Err(Duration::from_secs((other.0 as u64).wrapping_sub(self.0 as u64)))
-        }
-    }
-
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
-        Some(SystemTime(self.0.checked_add_unsigned(other.as_secs())?))
-    }
-
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
-        Some(SystemTime(self.0.checked_sub_unsigned(other.as_secs())?))
-    }
-}