This is an automated email from the ASF dual-hosted git repository. dingyu pushed a commit to branch support-new-allocator in repository https://gitbox.apache.org/repos/asf/incubator-teaclave-sgx-sdk.git
commit c6fd975d5a511aca8c6b027a2351f4c67faaec7a Author: Yu Ding <[email protected]> AuthorDate: Mon Oct 26 21:37:08 2020 -0700 compiler: bump up to nightly-2020-10-25 for new AllocRef trait and AllocError --- rust-toolchain | 2 +- sgx_alloc/src/system.rs | 42 +++++++++++++++++++++--------------------- sgx_trts/src/oom.rs | 12 ++++++------ sgx_tstd/src/error.rs | 4 ++-- sgx_tstd/src/lib.rs | 1 + sgx_tstd/src/sync/condvar.rs | 6 +++--- sgx_tstd/src/sys/cmath.rs | 4 ++-- 7 files changed, 36 insertions(+), 35 deletions(-) diff --git a/rust-toolchain b/rust-toolchain index 641cabd..148ed93 100644 --- a/rust-toolchain +++ b/rust-toolchain @@ -1 +1 @@ -nightly-2020-09-10 +nightly-2020-10-25 diff --git a/sgx_alloc/src/system.rs b/sgx_alloc/src/system.rs index 47ac408..f6f2e7f 100644 --- a/sgx_alloc/src/system.rs +++ b/sgx_alloc/src/system.rs @@ -23,7 +23,7 @@ //! 2018-06-22 Add liballoc components here use core::alloc::{ - AllocErr, AllocRef, GlobalAlloc, Layout, + AllocError, AllocRef, GlobalAlloc, Layout, }; use core::intrinsics; use core::ptr::{self, NonNull}; @@ -43,7 +43,7 @@ pub struct System; impl System { #[inline] - fn alloc_impl(&mut self, layout: Layout, zeroed: bool) -> Result<NonNull<[u8]>, AllocErr> { + fn alloc_impl(&self, layout: Layout, zeroed: bool) -> Result<NonNull<[u8]>, AllocError> { match layout.size() { 0 => Ok(NonNull::slice_from_raw_parts(layout.dangling(), 0)), // SAFETY: `layout` is non-zero in size, @@ -53,7 +53,7 @@ impl System { } else { GlobalAlloc::alloc(self, layout) }; - let ptr = NonNull::new(raw_ptr).ok_or(AllocErr)?; + let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?; Ok(NonNull::slice_from_raw_parts(ptr, size)) }, } @@ -62,12 +62,12 @@ impl System { // Safety: Same as `AllocRef::grow` #[inline] unsafe fn grow_impl( - &mut self, + &self, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout, zeroed: bool, - ) -> Result<NonNull<[u8]>, AllocErr> { + ) -> Result<NonNull<[u8]>, AllocError> { debug_assert!( new_layout.size() >= old_layout.size(), "`new_layout.size()` must be greater than or equal to `old_layout.size()`" @@ -85,7 +85,7 @@ impl System { intrinsics::assume(new_size >= old_layout.size()); let raw_ptr = GlobalAlloc::realloc(self, ptr.as_ptr(), old_layout, new_size); - let ptr = NonNull::new(raw_ptr).ok_or(AllocErr)?; + let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?; if zeroed { raw_ptr.add(old_size).write_bytes(0, new_size - old_size); } @@ -100,7 +100,7 @@ impl System { old_size => { let new_ptr = self.alloc_impl(new_layout, zeroed)?; ptr::copy_nonoverlapping(ptr.as_ptr(), new_ptr.as_mut_ptr(), old_size); - self.dealloc(ptr, old_layout); + core::alloc::AllocRef::dealloc(self, ptr, old_layout); Ok(new_ptr) }, } @@ -109,17 +109,17 @@ impl System { unsafe impl AllocRef for System { #[inline] - fn alloc(&mut self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr> { + fn alloc(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> { self.alloc_impl(layout, false) } #[inline] - fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr> { + fn alloc_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> { self.alloc_impl(layout, true) } #[inline] - unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: Layout) { + unsafe fn dealloc(&self, ptr: NonNull<u8>, layout: Layout) { if layout.size() != 0 { GlobalAlloc::dealloc(self, ptr.as_ptr(), layout) } @@ -127,37 +127,37 @@ unsafe impl AllocRef for System { #[inline] unsafe fn grow( - &mut self, + &self, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout, - ) -> Result<NonNull<[u8]>, AllocErr> { + ) -> Result<NonNull<[u8]>, AllocError> { // SAFETY: all conditions must be upheld by the caller self.grow_impl(ptr, old_layout, new_layout, false) } #[inline] unsafe fn grow_zeroed( - &mut self, + &self, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout, - ) -> Result<NonNull<[u8]>, AllocErr> { + ) -> Result<NonNull<[u8]>, AllocError> { // SAFETY: all conditions must be upheld by the caller self.grow_impl(ptr, old_layout, new_layout, true) } #[inline] unsafe fn shrink( - &mut self, + &self, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout, - ) -> Result<NonNull<[u8]>, AllocErr> { + ) -> Result<NonNull<[u8]>, AllocError> { match new_layout.size() { // SAFETY: conditions must be upheld by the caller 0 => { - self.dealloc(ptr, old_layout); + core::alloc::AllocRef::dealloc(self, ptr, old_layout); Ok(NonNull::slice_from_raw_parts(new_layout.dangling(), 0)) }, // SAFETY: `new_size` is non-zero. Other conditions must be upheld by the caller @@ -166,7 +166,7 @@ unsafe impl AllocRef for System { intrinsics::assume(new_size <= old_layout.size()); let raw_ptr = GlobalAlloc::realloc(self, ptr.as_ptr(), old_layout, new_size); - let ptr = NonNull::new(raw_ptr).ok_or(AllocErr)?; + let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?; Ok(NonNull::slice_from_raw_parts(ptr, new_size)) }, @@ -176,9 +176,9 @@ unsafe impl AllocRef for System { // `new_ptr`. Thus, the call to `copy_nonoverlapping` is safe. The safety contract // for `dealloc` must be upheld by the caller. new_size => { - let new_ptr = self.alloc(new_layout)?; + let new_ptr = core::alloc::AllocRef::alloc(self, new_layout)?; ptr::copy_nonoverlapping(ptr.as_ptr(), new_ptr.as_mut_ptr(), new_size); - self.dealloc(ptr, old_layout); + core::alloc::AllocRef::dealloc(self, ptr, old_layout); Ok(new_ptr) }, } @@ -233,7 +233,7 @@ mod platform { if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() { libc::calloc(layout.size(), 1) as *mut u8 } else { - let ptr = self.alloc(layout); + let ptr = GlobalAlloc::alloc(self, layout); if !ptr.is_null() { ptr::write_bytes(ptr, 0, layout.size()); } diff --git a/sgx_trts/src/oom.rs b/sgx_trts/src/oom.rs index d14fd19..ad6530a 100644 --- a/sgx_trts/src/oom.rs +++ b/sgx_trts/src/oom.rs @@ -16,7 +16,7 @@ // under the License.. use crate::trts; -use core::alloc::AllocErr; +use core::alloc::AllocError; use core::mem; use core::ptr; use core::sync::atomic::{AtomicPtr, Ordering}; @@ -24,13 +24,13 @@ use core::sync::atomic::{AtomicPtr, Ordering}; static SGX_OOM_HANDLER: AtomicPtr<()> = AtomicPtr::new(ptr::null_mut()); #[allow(clippy::needless_pass_by_value)] -fn default_oom_handler(_err: AllocErr) -> ! { +fn default_oom_handler(_err: AllocError) -> ! { trts::rsgx_abort() } -pub fn rsgx_oom(err: AllocErr) -> ! { +pub fn rsgx_oom(err: AllocError) -> ! { let hook = SGX_OOM_HANDLER.load(Ordering::SeqCst); - let handler: fn(AllocErr) -> ! = if hook.is_null() { + let handler: fn(AllocError) -> ! = if hook.is_null() { default_oom_handler } else { unsafe { mem::transmute(hook) } @@ -42,13 +42,13 @@ pub fn rsgx_oom(err: AllocErr) -> ! { /// /// To avoid recursive OOM failures, it is critical that the OOM handler does /// not allocate any memory itself. -pub fn set_oom_handler(handler: fn(AllocErr) -> !) { +pub fn set_oom_handler(handler: fn(AllocError) -> !) { SGX_OOM_HANDLER.store(handler as *mut (), Ordering::SeqCst); } /// Unregisters the current custom handler, returning it. /// -pub fn take_oom_handler() -> fn(AllocErr) -> ! { +pub fn take_oom_handler() -> fn(AllocError) -> ! { let hook = SGX_OOM_HANDLER.swap(ptr::null_mut(), Ordering::SeqCst); if hook.is_null() { default_oom_handler diff --git a/sgx_tstd/src/error.rs b/sgx_tstd/src/error.rs index f01d8a0..7fd4d49 100644 --- a/sgx_tstd/src/error.rs +++ b/sgx_tstd/src/error.rs @@ -17,7 +17,7 @@ #[cfg(feature = "backtrace")] use crate::backtrace::Backtrace; -use core::alloc::{AllocErr, LayoutErr}; +use core::alloc::{AllocError, LayoutErr}; use core::array; use core::any::TypeId; use core::cell; @@ -203,7 +203,7 @@ impl Error for ! { } } -impl Error for AllocErr { +impl Error for AllocError { fn description(&self) -> &str { "memory allocation failed" } diff --git a/sgx_tstd/src/lib.rs b/sgx_tstd/src/lib.rs index 08b52e0..74d1ca7 100644 --- a/sgx_tstd/src/lib.rs +++ b/sgx_tstd/src/lib.rs @@ -56,6 +56,7 @@ #![feature(char_error_internals)] #![feature(concat_idents)] #![feature(const_fn)] +#![feature(const_fn_fn_ptr_basics)] #![feature(core_intrinsics)] #![feature(custom_test_frameworks)] #![feature(dropck_eyepatch)] diff --git a/sgx_tstd/src/sync/condvar.rs b/sgx_tstd/src/sync/condvar.rs index 71929c8..48aefbe 100644 --- a/sgx_tstd/src/sync/condvar.rs +++ b/sgx_tstd/src/sync/condvar.rs @@ -32,7 +32,7 @@ use sgx_trts::oom; use sgx_trts::libc; use core::sync::atomic::{AtomicUsize, Ordering}; use core::fmt; -use core::alloc::AllocErr; +use core::alloc::AllocError; use alloc_crate::boxed::Box; use crate::sync::{mutex, SgxThreadMutex, SgxMutexGuard}; use crate::sys_common::poison::{self, LockResult, PoisonError}; @@ -426,7 +426,7 @@ impl SgxCondvar { let ret = self.inner.broadcast(); match ret { Err(r) if r == libc::ENOMEM => { - oom::rsgx_oom(AllocErr) + oom::rsgx_oom(AllocError) }, _ => {}, } @@ -483,4 +483,4 @@ impl Drop for SgxCondvar { let result = unsafe { self.inner.destroy() }; debug_assert_eq!(result, Ok(()), "Error when destroy an SgxCondvar: {}", result.unwrap_err()); } -} \ No newline at end of file +} diff --git a/sgx_tstd/src/sys/cmath.rs b/sgx_tstd/src/sys/cmath.rs index a21825c..c5df605 100644 --- a/sgx_tstd/src/sys/cmath.rs +++ b/sgx_tstd/src/sys/cmath.rs @@ -17,7 +17,7 @@ use sgx_libc::{c_float, c_double}; -#[link_name = "sgx_tstdc"] +#[link(name = "sgx_tstdc")] extern "C" { pub fn acos(n: c_double) -> c_double; pub fn acosf(n: c_float) -> c_float; @@ -45,4 +45,4 @@ extern "C" { pub fn tanf(n: c_float) -> c_float; pub fn tanh(n: c_double) -> c_double; pub fn tanhf(n: c_float) -> c_float; -} \ No newline at end of file +} --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
