nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-10-31 22:41:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor[std]: do not use box syntax

Browse Source
This commit is contained in:
joboet 2023-01-17 14:08:35 +01:00
parent 159ba8a92c
commit 7f2cf19191
No known key found for this signature in database
GPG Key ID: 704E0149B0194B3C
9 changed files with 35 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
library/std/src/lib.rs
View File

@ -238,7 +238,6 @@
#![feature(allocator_internals)]
#![feature(allow_internal_unsafe)]
#![feature(allow_internal_unstable)]
#![feature(box_syntax)]
#![feature(c_unwind)]
#![feature(cfg_target_thread_local)]
#![feature(concat_idents)]

4
library/std/src/sys/hermit/thread.rs
View File

@ -27,10 +27,10 @@ impl Thread {
p: Box<dyn FnOnce()>,
core_id: isize,
) -> io::Result<Thread> {
let p = Box::into_raw(box p);
let p = Box::into_raw(Box::new(p));
let tid = abi::spawn2(
thread_start,
p as usize,
p.expose_addr(),
abi::Priority::into(abi::NORMAL_PRIO),
stack,
core_id,

23
library/std/src/sys/hermit/thread_local_dtor.rs
View File

@ -5,32 +5,23 @@
// The this solution works like the implementation of macOS and
// doesn't additional OS support
use crate::cell::Cell;
use crate::ptr;
use crate::mem;
#[thread_local]
static DTORS: Cell<*mut List> = Cell::new(ptr::null_mut());
type List = Vec<(*mut u8, unsafe extern "C" fn(*mut u8))>;
static mut DTORS: Vec<(*mut u8, unsafe extern "C" fn(*mut u8))> = Vec::new();
pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
if DTORS.get().is_null() {
let v: Box<List> = box Vec::new();
DTORS.set(Box::into_raw(v));
}
let list: &mut List = &mut *DTORS.get();
let list = &mut DTORS;
list.push((t, dtor));
}
// every thread call this function to run through all possible destructors
pub unsafe fn run_dtors() {
let mut ptr = DTORS.replace(ptr::null_mut());
while !ptr.is_null() {
let list = Box::from_raw(ptr);
for (ptr, dtor) in list.into_iter() {
let mut list = mem::take(&mut DTORS);
while !list.is_empty() {
for (ptr, dtor) in list {
dtor(ptr);
}
ptr = DTORS.replace(ptr::null_mut());
list = mem::take(&mut DTORS);
}
}

32
library/std/src/sys/solid/thread_local_dtor.rs
View File

@ -5,43 +5,35 @@
use super::{abi, itron::task};
use crate::cell::Cell;
use crate::ptr;
use crate::mem;
#[thread_local]
static DTORS: Cell<*mut List> = Cell::new(ptr::null_mut());
static REGISTERED: Cell<bool> = Cell::new(false);
type List = Vec<(*mut u8, unsafe extern "C" fn(*mut u8))>;
#[thread_local]
static mut DTORS: Vec<(*mut u8, unsafe extern "C" fn(*mut u8))> = Vec::new();
pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
if DTORS.get().is_null() {
if !REGISTERED.get() {
let tid = task::current_task_id_aborting();
let v: Box<List> = box Vec::new();
DTORS.set(Box::into_raw(v));
// 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);
}
let list: &mut List = unsafe { &mut *DTORS.get() };
let list = unsafe { &mut DTORS };
list.push((t, dtor));
}
pub unsafe fn run_dtors() {
let ptr = DTORS.get();
if !ptr.is_null() {
// Swap the destructor list, call all registered destructors,
// and repeat this until the list becomes permanently empty.
while let Some(list) = Some(crate::mem::replace(unsafe { &mut *ptr }, Vec::new()))
.filter(|list| !list.is_empty())
{
for (ptr, dtor) in list.into_iter() {
unsafe { dtor(ptr) };
}
let mut list = mem::take(unsafe { &mut DTORS });
while !list.is_empty() {
for (ptr, dtor) in list {
unsafe { dtor(ptr) };
}
// Drop the destructor list
unsafe { Box::from_raw(DTORS.replace(ptr::null_mut())) };
list = mem::take(unsafe { &mut DTORS });
}
}

2
library/std/src/sys/unix/thread.rs
View File

@ -49,7 +49,7 @@ unsafe impl Sync for Thread {}
impl Thread {
// unsafe: see thread::Builder::spawn_unchecked for safety requirements
pub unsafe fn new(stack: usize, p: Box<dyn FnOnce()>) -> io::Result<Thread> {
let p = Box::into_raw(box p);
let p = Box::into_raw(Box::new(p));
let mut native: libc::pthread_t = mem::zeroed();
let mut attr: libc::pthread_attr_t = mem::zeroed();
assert_eq!(libc::pthread_attr_init(&mut attr), 0);

25
library/std/src/sys/unix/thread_local_dtor.rs
View File

@ -57,39 +57,34 @@ pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
#[cfg(target_os = "macos")]
pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
use crate::cell::Cell;
use crate::mem;
use crate::ptr;
#[thread_local]
static REGISTERED: Cell<bool> = Cell::new(false);
#[thread_local]
static mut DTORS: Vec<(*mut u8, unsafe extern "C" fn(*mut u8))> = Vec::new();
if !REGISTERED.get() {
_tlv_atexit(run_dtors, ptr::null_mut());
REGISTERED.set(true);
}
type List = Vec<(*mut u8, unsafe extern "C" fn(*mut u8))>;
#[thread_local]
static DTORS: Cell<*mut List> = Cell::new(ptr::null_mut());
if DTORS.get().is_null() {
let v: Box<List> = box Vec::new();
DTORS.set(Box::into_raw(v));
}
extern "C" {
fn _tlv_atexit(dtor: unsafe extern "C" fn(*mut u8), arg: *mut u8);
}
let list: &mut List = &mut *DTORS.get();
let list = &mut DTORS;
list.push((t, dtor));
unsafe extern "C" fn run_dtors(_: *mut u8) {
let mut ptr = DTORS.replace(ptr::null_mut());
while !ptr.is_null() {
let list = Box::from_raw(ptr);
for (ptr, dtor) in list.into_iter() {
let mut list = mem::take(&mut DTORS);
while !list.is_empty() {
for (ptr, dtor) in list {
dtor(ptr);
}
ptr = DTORS.replace(ptr::null_mut());
list = mem::take(&mut DTORS);
}
}
}

2
library/std/src/sys/windows/thread.rs
View File

@ -22,7 +22,7 @@ pub struct Thread {
impl Thread {
// unsafe: see thread::Builder::spawn_unchecked for safety requirements
pub unsafe fn new(stack: usize, p: Box<dyn FnOnce()>) -> io::Result<Thread> {
let p = Box::into_raw(box p);
let p = Box::into_raw(Box::new(p));
// FIXME On UNIX, we guard against stack sizes that are too small but
// that's because pthreads enforces that stacks are at least

2
library/std/src/sys_common/thread_local_dtor.rs
View File

@ -30,7 +30,7 @@ pub unsafe fn register_dtor_fallback(t: *mut u8, dtor: unsafe extern "C" fn(*mut
static DTORS: StaticKey = StaticKey::new(Some(run_dtors));
type List = Vec<(*mut u8, unsafe extern "C" fn(*mut u8))>;
if DTORS.get().is_null() {
let v: Box<List> = box Vec::new();
let v: Box<List> = Box::new(Vec::new());
DTORS.set(Box::into_raw(v) as *mut u8);
}
let list: &mut List = &mut *(DTORS.get() as *mut List);

3
library/std/src/thread/local.rs
View File

@ -1110,8 +1110,7 @@ pub mod os {
let ptr = if ptr.is_null() {
// If the lookup returned null, we haven't initialized our own
// local copy, so do that now.
let ptr: Box<Value<T>> = box Value { inner: LazyKeyInner::new(), key: self };
let ptr = Box::into_raw(ptr);
let ptr = Box::into_raw(Box::new(Value { inner: LazyKeyInner::new(), key: self }));
// SAFETY: At this point we are sure there is no value inside
// ptr so setting it will not affect anyone else.
unsafe {