-#![deny(unsafe_op_in_unsafe_fn)]
-
use crate::alloc::{GlobalAlloc, Layout, System};
use crate::ptr;
use crate::sys::hermit::abi;
unsafe impl GlobalAlloc for System {
#[inline]
unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
- // SAFETY: The safety contract for `malloc` must be upheld by the caller.
- unsafe { abi::malloc(layout.size(), layout.align()) }
+ abi::malloc(layout.size(), layout.align())
}
unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
- // SAFETY: The safety contract for `malloc` must be upheld by the caller.
- // Also, `addr` must be valid for writes of `layout.size() * size_of::<u8>()` bytes.
- unsafe {
- let addr = abi::malloc(layout.size(), layout.align());
-
- if !addr.is_null() {
- ptr::write_bytes(addr, 0x00, layout.size());
- }
+ let addr = abi::malloc(layout.size(), layout.align());
- addr
+ if !addr.is_null() {
+ ptr::write_bytes(addr, 0x00, layout.size());
}
+
+ addr
}
#[inline]
unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
- // SAFETY: The safety contract for `free` must be upheld by the caller.
- unsafe { abi::free(ptr, layout.size(), layout.align()) }
+ abi::free(ptr, layout.size(), layout.align())
}
#[inline]
unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
- // SAFETY: The safety contract for `realloc` must be upheld by the caller.
- unsafe { abi::realloc(ptr, layout.size(), layout.align(), new_size) }
+ abi::realloc(ptr, layout.size(), layout.align(), new_size)
}
}
-#![deny(unsafe_op_in_unsafe_fn)]
-
use crate::ffi::OsString;
use crate::marker::PhantomData;
use crate::vec;
/// One-time global initialization.
pub unsafe fn init(argc: isize, argv: *const *const u8) {
- unsafe { imp::init(argc, argv) }
+ imp::init(argc, argv)
}
/// One-time global cleanup.
pub unsafe fn cleanup() {
- unsafe { imp::cleanup() }
+ imp::cleanup()
}
/// Returns the command line arguments
pub unsafe fn init(argc: isize, argv: *const *const u8) {
let _guard = LOCK.lock();
- unsafe {
- ARGC = argc;
- ARGV = argv;
- }
+ ARGC = argc;
+ ARGV = argv;
}
pub unsafe fn cleanup() {
let _guard = LOCK.lock();
ARGC = 0;
- unsafe {
- ARGV = ptr::null();
- }
+ ARGV = ptr::null();
}
pub fn args() -> Args {
-#![deny(unsafe_op_in_unsafe_fn)]
-
use crate::ffi::c_void;
use crate::ptr;
use crate::sync::atomic::{AtomicUsize, Ordering::SeqCst};
}
pub unsafe fn init(&mut self) {
- unsafe {
- let _ = abi::sem_init(&mut self.sem1 as *mut *const c_void, 0);
- let _ = abi::sem_init(&mut self.sem2 as *mut *const c_void, 0);
- }
+ let _ = abi::sem_init(&mut self.sem1 as *mut *const c_void, 0);
+ let _ = abi::sem_init(&mut self.sem2 as *mut *const c_void, 0);
}
pub unsafe fn notify_one(&self) {
if self.counter.load(SeqCst) > 0 {
self.counter.fetch_sub(1, SeqCst);
- unsafe {
- abi::sem_post(self.sem1);
- abi::sem_timedwait(self.sem2, 0);
- }
+ abi::sem_post(self.sem1);
+ abi::sem_timedwait(self.sem2, 0);
}
}
pub unsafe fn notify_all(&self) {
let counter = self.counter.swap(0, SeqCst);
for _ in 0..counter {
- unsafe {
- abi::sem_post(self.sem1);
- }
+ abi::sem_post(self.sem1);
}
for _ in 0..counter {
- unsafe {
- abi::sem_timedwait(self.sem2, 0);
- }
+ abi::sem_timedwait(self.sem2, 0);
}
}
pub unsafe fn wait(&self, mutex: &Mutex) {
self.counter.fetch_add(1, SeqCst);
mutex.unlock();
- unsafe {
- abi::sem_timedwait(self.sem1, 0);
- abi::sem_post(self.sem2);
- }
+ abi::sem_timedwait(self.sem1, 0);
+ abi::sem_post(self.sem2);
mutex.lock();
}
}
pub unsafe fn destroy(&self) {
- unsafe {
- let _ = abi::sem_destroy(self.sem1);
- let _ = abi::sem_destroy(self.sem2);
- }
+ let _ = abi::sem_destroy(self.sem1);
+ let _ = abi::sem_destroy(self.sem2);
}
}
-#![deny(unsafe_op_in_unsafe_fn)]
#![unstable(reason = "not public", issue = "none", feature = "fd")]
use crate::io::{self, ErrorKind, Read};
//! compiling for wasm. That way it's a compile time error for something that's
//! guaranteed to be a runtime error!
-#![deny(unsafe_op_in_unsafe_fn)]
-
use crate::intrinsics;
use crate::os::raw::c_char;
pub unsafe fn strlen(start: *const c_char) -> usize {
let mut str = start;
- // SAFETY: The safety contract for `*str != 0` must be upheld by the caller.
- // `start` must not be null.
- unsafe {
- while *str != 0 {
- str = str.offset(1);
- }
+ while *str != 0 {
+ str = str.offset(1);
}
(str as usize) - (start as usize)
fn main(argc: isize, argv: *const *const c_char) -> i32;
}
- unsafe {
- // initialize environment
- os::init_environment(env as *const *const i8);
+ // initialize environment
+ os::init_environment(env as *const *const i8);
- let result = main(argc as isize, argv);
+ let result = main(argc as isize, argv);
- run_dtors();
- abi::exit(result);
- }
+ run_dtors();
+ abi::exit(result);
}
pub fn decode_error_kind(errno: i32) -> ErrorKind {
-#![deny(unsafe_op_in_unsafe_fn)]
-
use crate::ffi::c_void;
use crate::ptr;
use crate::sys::hermit::abi;
#[inline]
pub unsafe fn init(&mut self) {
- unsafe {
- let _ = abi::sem_init(&mut self.inner as *mut *const c_void, 1);
- }
+ let _ = abi::sem_init(&mut self.inner as *mut *const c_void, 1);
}
#[inline]
pub unsafe fn lock(&self) {
- unsafe {
- let _ = abi::sem_timedwait(self.inner, 0);
- }
+ let _ = abi::sem_timedwait(self.inner, 0);
}
#[inline]
pub unsafe fn unlock(&self) {
- unsafe {
- let _ = abi::sem_post(self.inner);
- }
+ let _ = abi::sem_post(self.inner);
}
#[inline]
pub unsafe fn try_lock(&self) -> bool {
- let result = unsafe { abi::sem_trywait(self.inner) };
+ let result = abi::sem_trywait(self.inner);
result == 0
}
#[inline]
pub unsafe fn destroy(&self) {
- let _ = unsafe { abi::sem_destroy(self.inner) };
+ let _ = abi::sem_destroy(self.inner);
}
}
#[inline]
pub unsafe fn init(&self) {
- let _ = unsafe { abi::recmutex_init(&self.inner as *const *const c_void as *mut _) };
+ let _ = abi::recmutex_init(&self.inner as *const *const c_void as *mut _);
}
#[inline]
pub unsafe fn lock(&self) {
- let _ = unsafe { abi::recmutex_lock(self.inner) };
+ let _ = abi::recmutex_lock(self.inner);
}
#[inline]
#[inline]
pub unsafe fn unlock(&self) {
- let _ = unsafe { abi::recmutex_unlock(self.inner) };
+ let _ = abi::recmutex_unlock(self.inner);
}
#[inline]
pub unsafe fn destroy(&self) {
- let _ = unsafe { abi::recmutex_destroy(self.inner) };
+ let _ = abi::recmutex_destroy(self.inner);
}
}
-#![deny(unsafe_op_in_unsafe_fn)]
-
use crate::collections::HashMap;
use crate::error::Error as StdError;
use crate::ffi::{CStr, OsStr, OsString};
-#![deny(unsafe_op_in_unsafe_fn)]
-
use crate::cell::UnsafeCell;
use crate::sys::condvar::Condvar;
use crate::sys::mutex::Mutex;
#[inline]
pub unsafe fn read(&self) {
- unsafe {
- self.lock.lock();
- while !(*self.state.get()).inc_readers() {
- self.cond.wait(&self.lock);
- }
- self.lock.unlock();
+ self.lock.lock();
+ while !(*self.state.get()).inc_readers() {
+ self.cond.wait(&self.lock);
}
+ self.lock.unlock();
}
#[inline]
pub unsafe fn try_read(&self) -> bool {
- unsafe {
- self.lock.lock();
- let ok = (*self.state.get()).inc_readers();
- self.lock.unlock();
- }
+ self.lock.lock();
+ let ok = (*self.state.get()).inc_readers();
+ self.lock.unlock();
return ok;
}
#[inline]
pub unsafe fn write(&self) {
- unsafe {
- self.lock.lock();
- while !(*self.state.get()).inc_writers() {
- self.cond.wait(&self.lock);
- }
+ self.lock.lock();
+ while !(*self.state.get()).inc_writers() {
+ self.cond.wait(&self.lock);
}
self.lock.unlock();
}
#[inline]
pub unsafe fn try_write(&self) -> bool {
- unsafe {
- self.lock.lock();
- let ok = (*self.state.get()).inc_writers();
- self.lock.unlock();
- }
+ self.lock.lock();
+ let ok = (*self.state.get()).inc_writers();
+ self.lock.unlock();
return ok;
}
#[inline]
pub unsafe fn read_unlock(&self) {
- unsafe {
- self.lock.lock();
- let notify = (*self.state.get()).dec_readers();
- self.lock.unlock();
- if notify {
- // FIXME: should only wake up one of these some of the time
- self.cond.notify_all();
- }
+ self.lock.lock();
+ let notify = (*self.state.get()).dec_readers();
+ self.lock.unlock();
+ if notify {
+ // FIXME: should only wake up one of these some of the time
+ self.cond.notify_all();
}
}
#[inline]
pub unsafe fn write_unlock(&self) {
- unsafe {
- self.lock.lock();
- (*self.state.get()).dec_writers();
- self.lock.unlock();
- // FIXME: should only wake up one of these some of the time
- self.cond.notify_all();
- }
+ self.lock.lock();
+ (*self.state.get()).dec_writers();
+ self.lock.unlock();
+ // FIXME: should only wake up one of these some of the time
+ self.cond.notify_all();
}
#[inline]
pub unsafe fn destroy(&self) {
- unsafe {
- self.lock.destroy();
- self.cond.destroy();
- }
+ self.lock.destroy();
+ self.cond.destroy();
}
}
#![allow(dead_code)]
-#![deny(unsafe_op_in_unsafe_fn)]
use crate::ffi::CStr;
use crate::io;
core_id: isize,
) -> io::Result<Thread> {
let p = Box::into_raw(box p);
- let tid = unsafe {
- abi::spawn2(
- thread_start,
- p as usize,
- abi::Priority::into(abi::NORMAL_PRIO),
- stack,
- core_id,
- )
- };
+ let tid = abi::spawn2(
+ thread_start,
+ p as usize,
+ abi::Priority::into(abi::NORMAL_PRIO),
+ stack,
+ core_id,
+ );
return if tid == 0 {
// The thread failed to start and as a result p was not consumed. Therefore, it is
// safe to reconstruct the box so that it gets deallocated.
- unsafe {
- drop(Box::from_raw(p));
- }
+ drop(Box::from_raw(p));
Err(io::Error::new(io::ErrorKind::Other, "Unable to create thread!"))
} else {
Ok(Thread { tid: tid })
#![cfg(target_thread_local)]
#![unstable(feature = "thread_local_internals", issue = "none")]
-#![deny(unsafe_op_in_unsafe_fn)]
// Simplify dtor registration by using a list of destructors.
// The this solution works like the implementation of macOS and
DTORS.set(Box::into_raw(v));
}
- // SAFETY: `DTORS.get()` is not null.
- let list: &mut List = unsafe { &mut *DTORS.get() };
+ let list: &mut List = &mut *DTORS.get();
list.push((t, dtor));
}
pub unsafe fn run_dtors() {
let mut ptr = DTORS.replace(ptr::null_mut());
while !ptr.is_null() {
- // SAFETY: `ptr` is not null.
- let list = unsafe { Box::from_raw(ptr) };
+ let list = Box::from_raw(ptr);
for (ptr, dtor) in list.into_iter() {
dtor(ptr);
}