From 002ead57fe5752700627ad7f4efd510d4eaf9525 Mon Sep 17 00:00:00 2001 From: Dmitry Kashitsyn Date: Wed, 13 Jun 2018 22:27:08 +0700 Subject: [PATCH 1/5] Fixes allocator to reflect recent changes in API --- wee_alloc/src/imp_static_array.rs | 6 +++--- wee_alloc/src/imp_unix.rs | 6 +++--- wee_alloc/src/imp_wasm32.rs | 6 +++--- wee_alloc/src/imp_windows.rs | 6 +++--- wee_alloc/src/lib.rs | 26 +++++++++++++------------- 5 files changed, 25 insertions(+), 25 deletions(-) diff --git a/wee_alloc/src/imp_static_array.rs b/wee_alloc/src/imp_static_array.rs index 851d23e..97edf5a 100644 --- a/wee_alloc/src/imp_static_array.rs +++ b/wee_alloc/src/imp_static_array.rs @@ -1,5 +1,5 @@ use const_init::ConstInit; -use core::alloc::{AllocErr, Opaque}; +use core::alloc::{AllocErr, u8}; #[cfg(feature = "extra_assertions")] use core::cell::Cell; use core::ptr::NonNull; @@ -10,12 +10,12 @@ const SCRATCH_LEN_BYTES: usize = include!(concat!(env!("OUT_DIR"), "/wee_alloc_s static mut SCRATCH_HEAP: [u8; SCRATCH_LEN_BYTES] = [0; SCRATCH_LEN_BYTES]; static mut OFFSET: Mutex = Mutex::new(0); -pub(crate) unsafe fn alloc_pages(pages: Pages) -> Result, AllocErr> { +pub(crate) unsafe fn alloc_pages(pages: Pages) -> Result, AllocErr> { let bytes: Bytes = pages.into(); let mut offset = OFFSET.lock(); let end = bytes.0 + *offset; if end < SCRATCH_LEN_BYTES { - let ptr = SCRATCH_HEAP[*offset..end].as_mut_ptr() as *mut u8 as *mut Opaque; + let ptr = SCRATCH_HEAP[*offset..end].as_mut_ptr() as *mut u8; *offset = end; NonNull::new(ptr).ok_or_else(|| AllocErr) } else { diff --git a/wee_alloc/src/imp_unix.rs b/wee_alloc/src/imp_unix.rs index b8f603e..5debea2 100644 --- a/wee_alloc/src/imp_unix.rs +++ b/wee_alloc/src/imp_unix.rs @@ -1,11 +1,11 @@ use const_init::ConstInit; -use core::alloc::{AllocErr, Opaque}; +use core::alloc::AllocErr; use core::cell::UnsafeCell; use core::ptr::NonNull; use libc; use memory_units::{Bytes, Pages}; -pub(crate) fn alloc_pages(pages: Pages) -> Result, AllocErr> { +pub(crate) fn alloc_pages(pages: Pages) -> Result, AllocErr> { unsafe { let bytes: Bytes = pages.into(); let addr = libc::mmap( @@ -19,7 +19,7 @@ pub(crate) fn alloc_pages(pages: Pages) -> Result, AllocErr> { if addr == libc::MAP_FAILED { Err(AllocErr) } else { - NonNull::new(addr as *mut Opaque).ok_or(AllocErr) + NonNull::new(addr as *mut u8).ok_or(AllocErr) } } } diff --git a/wee_alloc/src/imp_wasm32.rs b/wee_alloc/src/imp_wasm32.rs index 9165948..cf61153 100644 --- a/wee_alloc/src/imp_wasm32.rs +++ b/wee_alloc/src/imp_wasm32.rs @@ -1,6 +1,6 @@ use super::{assert_is_word_aligned, PAGE_SIZE, unchecked_unwrap}; use const_init::ConstInit; -use core::alloc::{AllocErr, Opaque}; +use core::alloc::{AllocErr, u8}; use core::cell::UnsafeCell; use core::ptr::NonNull; use memory_units::Pages; @@ -10,10 +10,10 @@ extern "C" { fn grow_memory(pages: usize) -> i32; } -pub(crate) unsafe fn alloc_pages(n: Pages) -> Result, AllocErr> { +pub(crate) unsafe fn alloc_pages(n: Pages) -> Result, AllocErr> { let ptr = grow_memory(n.0); if -1 != ptr { - let ptr = (ptr as usize * PAGE_SIZE.0) as *mut Opaque; + let ptr = (ptr as usize * PAGE_SIZE.0) as *mut u8; assert_is_word_aligned(ptr as *mut u8); Ok(unchecked_unwrap(NonNull::new(ptr))) } else { diff --git a/wee_alloc/src/imp_windows.rs b/wee_alloc/src/imp_windows.rs index 2894c41..cb0b6c8 100644 --- a/wee_alloc/src/imp_windows.rs +++ b/wee_alloc/src/imp_windows.rs @@ -1,5 +1,5 @@ use const_init::ConstInit; -use core::alloc::{AllocErr, Opaque}; +use core::alloc::{AllocErr, u8}; use core::cell::UnsafeCell; use core::ptr::NonNull; use memory_units::{Bytes, Pages}; @@ -12,10 +12,10 @@ use winapi::um::synchapi::{CreateMutexW, ReleaseMutex, WaitForSingleObject}; use winapi::um::winbase::{WAIT_OBJECT_0, INFINITE}; use winapi::um::winnt::{HANDLE, MEM_COMMIT, PAGE_READWRITE}; -pub(crate) fn alloc_pages(pages: Pages) -> Result, AllocErr> { +pub(crate) fn alloc_pages(pages: Pages) -> Result, AllocErr> { let bytes: Bytes = pages.into(); let ptr = unsafe { VirtualAlloc(NULL, bytes.0, MEM_COMMIT, PAGE_READWRITE) }; - NonNull::new(ptr as *mut Opaque).ok_or(AllocErr) + NonNull::new(ptr as *mut u8).ok_or(AllocErr) } // Align to the cache line size on an i7 to avoid false sharing. diff --git a/wee_alloc/src/lib.rs b/wee_alloc/src/lib.rs index 0f5db6e..fdfd251 100644 --- a/wee_alloc/src/lib.rs +++ b/wee_alloc/src/lib.rs @@ -222,7 +222,7 @@ for hacking! #![deny(missing_docs)] #![cfg_attr(not(feature = "use_std_for_test_debugging"), no_std)] -#![feature(alloc, allocator_api, core_intrinsics, global_allocator)] +#![feature(alloc, allocator_api, core_intrinsics)] #![cfg_attr(target_arch = "wasm32", feature(link_llvm_intrinsics))] #[macro_use] @@ -269,7 +269,7 @@ mod neighbors; mod size_classes; use const_init::ConstInit; -use core::alloc::{Alloc, AllocErr, GlobalAlloc, Layout, Opaque}; +use core::alloc::{Alloc, AllocErr, GlobalAlloc, Layout}; use core::cell::Cell; use core::cmp; use core::marker::Sync; @@ -520,7 +520,7 @@ impl<'a> FreeCell<'a> { } unsafe fn from_uninitialized( - raw: NonNull, + raw: NonNull, size: Bytes, next_free: Option<*const FreeCell<'a>>, policy: &AllocPolicy<'a>, @@ -586,7 +586,7 @@ impl<'a> FreeCell<'a> { let split_cell_head = split_and_aligned - size_of::().0; let split_cell = unsafe { &*FreeCell::from_uninitialized( - unchecked_unwrap(NonNull::new(split_cell_head as *mut Opaque)), + unchecked_unwrap(NonNull::new(split_cell_head as *mut u8)), Bytes(next - split_cell_head) - size_of::(), None, policy, @@ -951,7 +951,7 @@ unsafe fn alloc_first_fit<'a>( align: Bytes, head: &Cell<*const FreeCell<'a>>, policy: &AllocPolicy<'a>, -) -> Result, AllocErr> { +) -> Result, AllocErr> { extra_assert!(size.0 > 0); walk_free_list(head, policy, |previous, current| { @@ -960,7 +960,7 @@ unsafe fn alloc_first_fit<'a>( if let Some(allocated) = current.try_alloc(previous, size, align, policy) { assert_aligned_to(allocated.data(), align); return Some(unchecked_unwrap( - NonNull::new(allocated.data() as *mut Opaque), + NonNull::new(allocated.data() as *mut u8), )); } @@ -973,7 +973,7 @@ unsafe fn alloc_with_refill<'a, 'b>( align: Bytes, head: &'b Cell<*const FreeCell<'a>>, policy: &AllocPolicy<'a>, -) -> Result, AllocErr> { +) -> Result, AllocErr> { if let Ok(result) = alloc_first_fit(size, align, head, policy) { return Ok(result); } @@ -1072,7 +1072,7 @@ unsafe impl<'a, 'b> Alloc for &'b WeeAlloc<'a> where 'a: 'b, { - unsafe fn alloc(&mut self, layout: Layout) -> Result, AllocErr> { + unsafe fn alloc(&mut self, layout: Layout) -> Result, AllocErr> { let size = Bytes(layout.size()); let align = if layout.align() == 0 { Bytes(1) @@ -1084,7 +1084,7 @@ where // Ensure that our made up pointer is properly aligned by using the // alignment as the pointer. extra_assert!(align.0 > 0); - return Ok(NonNull::new_unchecked(align.0 as *mut Opaque)); + return Ok(NonNull::new_unchecked(align.0 as *mut u8)); } let size: Words = size.round_up_to(); @@ -1095,7 +1095,7 @@ where }) } - unsafe fn dealloc(&mut self, ptr: NonNull, layout: Layout) { + unsafe fn dealloc(&mut self, ptr: NonNull, layout: Layout) { let size = Bytes(layout.size()); if size.0 == 0 { return; @@ -1185,15 +1185,15 @@ where } unsafe impl GlobalAlloc for WeeAlloc<'static> { - unsafe fn alloc(&self, layout: Layout) -> *mut Opaque { + unsafe fn alloc(&self, layout: Layout) -> *mut u8 { let mut me = self; match Alloc::alloc(&mut me, layout) { Ok(ptr) => ptr.as_ptr(), - Err(AllocErr) => 0 as *mut Opaque, + Err(AllocErr) => 0 as *mut u8, } } - unsafe fn dealloc(&self, ptr: *mut Opaque, layout: Layout) { + unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) { if let Some(ptr) = NonNull::new(ptr) { let mut me = self; Alloc::dealloc(&mut me, ptr, layout); From bb410407cff8cdff86c4938b998194e8c599a336 Mon Sep 17 00:00:00 2001 From: Dmitry Kashitsyn Date: Wed, 13 Jun 2018 22:38:38 +0700 Subject: [PATCH 2/5] Fixes imports --- wee_alloc/src/imp_static_array.rs | 2 +- wee_alloc/src/imp_wasm32.rs | 2 +- wee_alloc/src/imp_windows.rs | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/wee_alloc/src/imp_static_array.rs b/wee_alloc/src/imp_static_array.rs index 97edf5a..07c7778 100644 --- a/wee_alloc/src/imp_static_array.rs +++ b/wee_alloc/src/imp_static_array.rs @@ -1,5 +1,5 @@ use const_init::ConstInit; -use core::alloc::{AllocErr, u8}; +use core::alloc::AllocErr; #[cfg(feature = "extra_assertions")] use core::cell::Cell; use core::ptr::NonNull; diff --git a/wee_alloc/src/imp_wasm32.rs b/wee_alloc/src/imp_wasm32.rs index cf61153..b226fdb 100644 --- a/wee_alloc/src/imp_wasm32.rs +++ b/wee_alloc/src/imp_wasm32.rs @@ -1,6 +1,6 @@ use super::{assert_is_word_aligned, PAGE_SIZE, unchecked_unwrap}; use const_init::ConstInit; -use core::alloc::{AllocErr, u8}; +use core::alloc::AllocErr; use core::cell::UnsafeCell; use core::ptr::NonNull; use memory_units::Pages; diff --git a/wee_alloc/src/imp_windows.rs b/wee_alloc/src/imp_windows.rs index cb0b6c8..d3030c1 100644 --- a/wee_alloc/src/imp_windows.rs +++ b/wee_alloc/src/imp_windows.rs @@ -1,5 +1,5 @@ use const_init::ConstInit; -use core::alloc::{AllocErr, u8}; +use core::alloc::AllocErr; use core::cell::UnsafeCell; use core::ptr::NonNull; use memory_units::{Bytes, Pages}; From 121c5bebb56d117122e0961ca2069fc12faaa2c7 Mon Sep 17 00:00:00 2001 From: Dmitry Kashitsyn Date: Wed, 13 Jun 2018 23:01:18 +0700 Subject: [PATCH 3/5] Fixes examples and tests --- example/src/lib.rs | 14 ++++++-------- test/src/lib.rs | 2 +- 2 files changed, 7 insertions(+), 9 deletions(-) diff --git a/example/src/lib.rs b/example/src/lib.rs index 8fc0b06..cc451fd 100755 --- a/example/src/lib.rs +++ b/example/src/lib.rs @@ -6,7 +6,7 @@ // We aren't using the standard library. #![no_std] // Replacing the allocator and using the `alloc` crate are still unstable. -#![feature(alloc, core_intrinsics, global_allocator, lang_items)] +#![feature(alloc, core_intrinsics, panic_implementation, lang_items)] extern crate alloc; extern crate wee_alloc; @@ -15,14 +15,12 @@ extern crate wee_alloc; #[global_allocator] static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT; -// Need to provide a tiny `panic_fmt` lang-item implementation for -// `#![no_std]`. This translates into an `unreachable` instruction that will +// Need to provide a tiny `panic` implementation for `#![no_std]`. +// This translates into an `unreachable` instruction that will // raise a `trap` the WebAssembly execution if we panic at runtime. -#[lang = "panic_fmt"] -extern "C" fn panic_fmt(_args: ::core::fmt::Arguments, _file: &'static str, _line: u32) -> ! { - unsafe { - ::core::intrinsics::abort(); - } +#[panic_implementation] +fn panic(_info: &::core::panic::PanicInfo) -> ! { + unsafe { ::core::intrinsics::abort() } } // Need to provide a tiny `oom` lang-item implementation for diff --git a/test/src/lib.rs b/test/src/lib.rs index cf6f97e..0c34a5e 100755 --- a/test/src/lib.rs +++ b/test/src/lib.rs @@ -9,7 +9,7 @@ extern crate cfg_if; extern crate rand; extern crate wee_alloc; -use alloc::heap::{Alloc, Layout}; +use std::alloc::{Alloc, Layout}; use quickcheck::{Arbitrary, Gen}; use std::f64; use std::fs; From 8c6dbcd9dfc53f6e5592e7d25de490e8fffe5e00 Mon Sep 17 00:00:00 2001 From: Dmitry Kashitsyn Date: Wed, 13 Jun 2018 23:11:09 +0700 Subject: [PATCH 4/5] Fixes tests --- test/src/lib.rs | 2 +- test/tests/global.rs | 2 -- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/test/src/lib.rs b/test/src/lib.rs index 0c34a5e..eac075b 100755 --- a/test/src/lib.rs +++ b/test/src/lib.rs @@ -374,7 +374,7 @@ quickcheck! { let align = ALIGNS[align % ALIGNS.len()]; let mut w = &wee_alloc::WeeAlloc::INIT; - let layout = alloc::heap::Layout::from_size_align(size, align).unwrap(); + let layout = Layout::from_size_align(size, align).unwrap(); let _ = unsafe { w.alloc(layout) }; } } diff --git a/test/tests/global.rs b/test/tests/global.rs index 9b35585..0bb82fe 100755 --- a/test/tests/global.rs +++ b/test/tests/global.rs @@ -1,8 +1,6 @@ // Adopted from // https://github.com/alexcrichton/dlmalloc-rs/blob/master/tests/global.rs -#![feature(global_allocator)] - extern crate wee_alloc; use std::collections::HashMap; From 4102b6c81ebc24a5cab63a94368d6e3a3a6c8a5e Mon Sep 17 00:00:00 2001 From: Dmitry Kashitsyn Date: Wed, 13 Jun 2018 23:58:23 +0700 Subject: [PATCH 5/5] Fixes example and readme --- README.md | 31 ++++++++++++++++--------------- example/src/lib.rs | 4 +++- test/src/lib.rs | 1 - wee_alloc/src/lib.rs | 31 ++++++++++++++++--------------- 4 files changed, 35 insertions(+), 32 deletions(-) diff --git a/README.md b/README.md index 2573349..0d4687b 100644 --- a/README.md +++ b/README.md @@ -50,12 +50,9 @@ infrastructure. Nevertheless, `wee_alloc` is also usable with `std`. // We aren't using the standard library. #![no_std] -// Required to replace the global allocator. -#![feature(global_allocator)] - // Required to use the `alloc` crate and its types, the `abort` intrinsic, and a // custom panic handler. -#![feature(alloc, core_intrinsics, lang_items)] +#![feature(alloc, core_intrinsics, panic_implementation, lang_items)] extern crate alloc; extern crate wee_alloc; @@ -64,18 +61,22 @@ extern crate wee_alloc; #[global_allocator] static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT; -// Need to provide a tiny `panic_fmt` lang-item implementation for `#![no_std]`. -// This implementation will translate panics into traps in the resulting -// WebAssembly. -#[lang = "panic_fmt"] -extern "C" fn panic_fmt( - _args: ::core::fmt::Arguments, - _file: &'static str, - _line: u32 -) -> ! { - use core::intrinsics; +// Need to provide a tiny `panic` implementation for `#![no_std]`. +// This translates into an `unreachable` instruction that will +// raise a `trap` the WebAssembly execution if we panic at runtime. +#[panic_implementation] +fn panic(_info: &::core::panic::PanicInfo) -> ! { + unsafe { + ::core::intrinsics::abort(); + } +} + +// Need to provide a tiny `oom` lang-item implementation for +// `#![no_std]`. +#[lang = "oom"] +extern "C" fn oom() -> ! { unsafe { - intrinsics::abort(); + ::core::intrinsics::abort(); } } diff --git a/example/src/lib.rs b/example/src/lib.rs index cc451fd..943e7c4 100755 --- a/example/src/lib.rs +++ b/example/src/lib.rs @@ -20,7 +20,9 @@ static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT; // raise a `trap` the WebAssembly execution if we panic at runtime. #[panic_implementation] fn panic(_info: &::core::panic::PanicInfo) -> ! { - unsafe { ::core::intrinsics::abort() } + unsafe { + ::core::intrinsics::abort(); + } } // Need to provide a tiny `oom` lang-item implementation for diff --git a/test/src/lib.rs b/test/src/lib.rs index eac075b..5799464 100755 --- a/test/src/lib.rs +++ b/test/src/lib.rs @@ -1,6 +1,5 @@ #![feature(alloc, allocator_api)] -extern crate alloc; extern crate histo; #[macro_use] extern crate quickcheck; diff --git a/wee_alloc/src/lib.rs b/wee_alloc/src/lib.rs index fdfd251..8199e72 100644 --- a/wee_alloc/src/lib.rs +++ b/wee_alloc/src/lib.rs @@ -50,12 +50,9 @@ infrastructure. Nevertheless, `wee_alloc` is also usable with `std`. // We aren't using the standard library. #![no_std] -// Required to replace the global allocator. -#![feature(global_allocator)] - // Required to use the `alloc` crate and its types, the `abort` intrinsic, and a // custom panic handler. -#![feature(alloc, core_intrinsics, lang_items)] +#![feature(alloc, core_intrinsics, panic_implementation, lang_items)] extern crate alloc; extern crate wee_alloc; @@ -64,18 +61,22 @@ extern crate wee_alloc; #[global_allocator] static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT; -// Need to provide a tiny `panic_fmt` lang-item implementation for `#![no_std]`. -// This implementation will translate panics into traps in the resulting -// WebAssembly. -#[lang = "panic_fmt"] -extern "C" fn panic_fmt( - _args: ::core::fmt::Arguments, - _file: &'static str, - _line: u32 -) -> ! { - use core::intrinsics; +// Need to provide a tiny `panic` implementation for `#![no_std]`. +// This translates into an `unreachable` instruction that will +// raise a `trap` the WebAssembly execution if we panic at runtime. +#[panic_implementation] +fn panic(_info: &::core::panic::PanicInfo) -> ! { + unsafe { + ::core::intrinsics::abort(); + } +} + +// Need to provide a tiny `oom` lang-item implementation for +// `#![no_std]`. +#[lang = "oom"] +extern "C" fn oom() -> ! { unsafe { - intrinsics::abort(); + ::core::intrinsics::abort(); } }