Edition 2018 cleanups

cynecx · cynecx · commit e55d24c14b51 · 2020-10-13T00:47:36.000+02:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -7,6 +7,7 @@ license = "Apache-2.0/MIT"
 homepage = "https://github.com/edef1c/libfringe"
 repository = "https://github.com/edef1c/libfringe"
 documentation = "https://edef1c.github.io/libfringe"
+edition = "2018"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.14"
@@ -16,10 +17,11 @@ optional = true
 version = "1.0.0"
 
 [target.'cfg(unix)'.dev-dependencies]
-packed_simd = "0.3.3"
+packed_simd = { version = "0.3.4", package = "packed_simd_2" }
 
 [features]
-default = ["alloc", "valgrind"]
+default = [ "std" ]
+std = [ "alloc" ]
 alloc = []
 valgrind = ["valgrind_request"]
 
diff --git a/benches/generator.rs b/benches/generator.rs
@@ -5,8 +5,6 @@
 // http://opensource.org/licenses/MIT>, at your option. This file may not be
 // copied, modified, or distributed except according to those terms.
 #![feature(test)]
-extern crate fringe;
-extern crate test;
 
 use fringe::{Generator, OsStack};
 
diff --git a/benches/syscall.rs b/benches/syscall.rs
@@ -5,14 +5,13 @@
 // http://opensource.org/licenses/MIT>, at your option. This file may not be
 // copied, modified, or distributed except according to those terms.
 #![cfg(target_os = "linux")]
-#![feature(asm, test)]
-extern crate test;
+#![feature(llvm_asm, test)]
 
 #[cfg(target_arch = "x86_64")]
 #[bench]
 fn syscall(b: &mut test::Bencher) {
   b.iter(|| unsafe {
-    asm!("movq $$102, %rax\n\
+    llvm_asm!("movq $$102, %rax\n\
           syscall"
          :
          :
@@ -25,7 +24,7 @@ fn syscall(b: &mut test::Bencher) {
 #[bench]
 fn syscall(b: &mut test::Bencher) {
   b.iter(|| unsafe {
-    asm!("mov $$24, %eax\n\
+    llvm_asm!("mov $$24, %eax\n\
           int $$0x80"
          :
          :
diff --git a/rustfmt.toml b/rustfmt.toml
@@ -1,2 +1,3 @@
+merge_imports = true
 newline_style = "Unix"
-tab_spaces = 2
+tab_spaces = 2
diff --git a/src/arch/aarch64.rs b/src/arch/aarch64.rs
@@ -46,6 +46,7 @@
 // * The 1st init trampoline tells the unwinder to restore x29 and x30
 //   from the stack frame at x29 (in the parent stack), thus continuing
 //   unwinding at the swap call site instead of falling off the end of context stack.
+
 use core::mem;
 use stack::Stack;
 
diff --git a/src/arch/mod.rs b/src/arch/mod.rs
@@ -8,7 +8,6 @@
 
 pub use self::imp::*;
 
-#[allow(unused_attributes)] // rust-lang/rust#35584
 #[cfg_attr(target_arch = "x86", path = "x86.rs")]
 #[cfg_attr(target_arch = "x86_64", path = "x86_64.rs")]
 #[cfg_attr(target_arch = "aarch64", path = "aarch64.rs")]
@@ -17,11 +16,12 @@ mod imp;
 
 #[cfg(test)]
 mod tests {
-  extern crate packed_simd;
   extern crate test;
 
-  use arch::{self, StackPointer};
-  use OsStack;
+  use crate::{
+    arch::{self, StackPointer},
+    OsStack,
+  };
 
   #[test]
   fn context() {
diff --git a/src/arch/or1k.rs b/src/arch/or1k.rs
@@ -41,8 +41,9 @@
 // * The 1st init trampoline tells the unwinder to restore r2 and r9
 //   from the stack frame at r2 (in the parent stack), thus continuing
 //   unwinding at the swap call site instead of falling off the end of context stack.
+
+use crate::stack::Stack;
 use core::mem;
-use stack::Stack;
 
 pub const STACK_ALIGNMENT: usize = 4;
 
diff --git a/src/arch/x86.rs b/src/arch/x86.rs
@@ -41,8 +41,9 @@
 // * The 1st init trampoline tells the unwinder to restore %ebp and its return
 //   address from the stack frame at %ebp (in the parent stack), thus continuing
 //   unwinding at the swap call site instead of falling off the end of context stack.
+
+use crate::stack::Stack;
 use core::mem;
-use stack::Stack;
 
 pub const STACK_ALIGNMENT: usize = 16;
 
diff --git a/src/arch/x86_64.rs b/src/arch/x86_64.rs
@@ -46,8 +46,9 @@
 // * The 1st init trampoline tells the unwinder to restore %rbp and its return
 //   address from the stack frame at %rbp (in the parent stack), thus continuing
 //   unwinding at the swap call site instead of falling off the end of context stack.
-use core::mem;
-use stack::Stack;
+
+use crate::stack::Stack;
+use core::mem::MaybeUninit;
 
 pub const STACK_ALIGNMENT: usize = 16;
 
@@ -56,13 +57,13 @@ pub const STACK_ALIGNMENT: usize = 16;
 pub struct StackPointer(*mut usize);
 
 pub unsafe fn init(
-  stack: &Stack,
+  stack: &dyn Stack,
   f: unsafe extern "C" fn(usize, StackPointer) -> !,
 ) -> StackPointer {
   #[cfg(not(target_vendor = "apple"))]
   #[naked]
   unsafe extern "C" fn trampoline_1() {
-    asm!(
+    llvm_asm!(
       r#"
         # gdb has a hardcoded check that rejects backtraces where frame addresses
         # do not monotonically decrease. It is turned off if the function is called
@@ -102,7 +103,7 @@ pub unsafe fn init(
   #[cfg(target_vendor = "apple")]
   #[naked]
   unsafe extern "C" fn trampoline_1() {
-    asm!(
+    llvm_asm!(
       r#"
       # Identical to the above, except avoids .local/.size that aren't available on Mach-O.
       __morestack:
@@ -117,7 +118,7 @@ pub unsafe fn init(
 
   #[naked]
   unsafe extern "C" fn trampoline_2() {
-    asm!(
+    llvm_asm!(
       r#"
         # Set up the second part of our DWARF CFI.
         # When unwinding the frame corresponding to this function, a DWARF unwinder
@@ -175,20 +176,20 @@ pub unsafe fn init(
 pub unsafe fn swap(
   arg: usize,
   new_sp: StackPointer,
-  new_stack: Option<&Stack>,
+  new_stack: Option<&dyn Stack>,
 ) -> (usize, StackPointer) {
   // Address of the topmost CFA stack slot.
-  let mut dummy: usize = mem::uninitialized();
+  let mut dummy: MaybeUninit<usize> = MaybeUninit::uninit();
   let new_cfa = if let Some(new_stack) = new_stack {
     (new_stack.base() as *mut usize).offset(-4)
   } else {
     // Just pass a dummy pointer if we aren't linking the stack
-    &mut dummy
+    dummy.as_mut_ptr()
   };
 
-  let ret: usize;
-  let ret_sp: *mut usize;
-  asm!(
+  let mut ret: usize;
+  let mut ret_sp: *mut usize;
+  llvm_asm!(
     r#"
         # Push the return address
         leaq    0f(%rip), %rax
diff --git a/src/debug/mod.rs b/src/debug/mod.rs
@@ -4,6 +4,7 @@
 // http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
 // http://opensource.org/licenses/MIT>, at your option. This file may not be
 // copied, modified, or distributed except according to those terms.
+
 pub use self::imp::*;
 
 #[cfg(feature = "valgrind")]
@@ -12,12 +13,14 @@ mod imp;
 
 #[cfg(not(feature = "valgrind"))]
 mod imp {
-  use stack;
+  use crate::stack::Stack;
+
   #[derive(Debug)]
   pub struct StackId;
+
   /// No-op since no valgrind
   impl StackId {
-    pub fn register<Stack: stack::Stack>(_stack: &Stack) -> StackId {
+    pub fn register<S: Stack>(_stack: &S) -> StackId {
       StackId
     }
   }
diff --git a/src/debug/valgrind.rs b/src/debug/valgrind.rs
@@ -4,10 +4,9 @@
 // http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
 // http://opensource.org/licenses/MIT>, at your option. This file may not be
 // copied, modified, or distributed except according to those terms.
-extern crate valgrind_request;
 
-use self::valgrind_request::{stack_deregister, stack_register};
-use stack;
+use crate::stack;
+use valgrind_request::{stack_deregister, stack_register};
 
 #[derive(Debug)]
 pub struct StackId(self::valgrind_request::Value);
diff --git a/src/generator.rs b/src/generator.rs
@@ -11,14 +11,12 @@
 //! returning a value to the caller, and resuming the suspended function
 //! afterwards.
 
-use core::cell::Cell;
-use core::marker::PhantomData;
-use core::mem::ManuallyDrop;
-use core::{mem, ptr};
+use core::{cell::Cell, marker::PhantomData, mem, mem::ManuallyDrop, ptr};
 
-use arch::{self, StackPointer};
-use debug;
-use stack;
+use crate::{
+  arch::{self, StackPointer},
+  debug, stack,
+};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum State {
@@ -152,7 +150,7 @@ where
       state: State::Runnable,
       stack: ManuallyDrop::new(stack),
       stack_id: ManuallyDrop::new(stack_id),
-      stack_ptr: stack_ptr,
+      stack_ptr,
       phantom: PhantomData,
     }
   }
@@ -215,7 +213,7 @@ where
   /// This will leave any pointers into the generator stack dangling, and won't run destructors.
   pub unsafe fn unsafe_unwrap(mut self) -> Stack {
     ManuallyDrop::drop(&mut self.stack_id);
-    let stack = ptr::read(&mut *self.stack);
+    let stack = ptr::read(&*self.stack);
     mem::forget(self);
     stack
   }
diff --git a/src/lib.rs b/src/lib.rs
@@ -4,10 +4,6 @@
 // http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
 // http://opensource.org/licenses/MIT>, at your option. This file may not be
 // copied, modified, or distributed except according to those terms.
-#![feature(asm, naked_functions, untagged_unions)]
-#![cfg_attr(feature = "alloc", feature(alloc, allocator_api))]
-#![cfg_attr(test, feature(test))]
-#![no_std]
 
 //! libfringe is a library implementing safe, lightweight context switches,
 //! without relying on kernel services. It can be used in hosted environments
@@ -29,23 +25,24 @@
 //!   * a stack allocator based on anonymous memory mappings with guard pages,
 //!     [OsStack](struct.OsStack.html).
 
-#[cfg(test)]
+#![feature(asm, naked_functions, untagged_unions)]
+#![cfg_attr(test, feature(test))]
+#![no_std]
+
+#[cfg(any(feature = "std", test))]
 #[macro_use]
 extern crate std;
 
 #[cfg(feature = "alloc")]
 extern crate alloc;
 
+mod arch;
+mod debug;
+pub mod generator;
+mod stack;
+
 pub use generator::Generator;
 pub use stack::*;
 
-mod arch;
-
 /// Minimum alignment of a stack base address on the target platform.
 pub const STACK_ALIGNMENT: usize = arch::STACK_ALIGNMENT;
-
-mod debug;
-
-pub mod generator;
-
-mod stack;
diff --git a/src/stack/mod.rs b/src/stack/mod.rs
@@ -7,17 +7,17 @@
 //! Traits for stacks.
 
 mod slice_stack;
-pub use stack::slice_stack::SliceStack;
+pub use crate::stack::slice_stack::SliceStack;
 
 #[cfg(feature = "alloc")]
 mod owned_stack;
 #[cfg(feature = "alloc")]
-pub use stack::owned_stack::OwnedStack;
+pub use crate::stack::owned_stack::OwnedStack;
 
-#[cfg(unix)]
+#[cfg(all(unix, feature = "std"))]
 mod os;
-#[cfg(unix)]
-pub use stack::os::OsStack;
+#[cfg(all(unix, feature = "std"))]
+pub use crate::stack::os::OsStack;
 
 /// A trait for objects that hold ownership of a stack.
 ///
diff --git a/src/stack/os/mod.rs b/src/stack/os/mod.rs
@@ -4,10 +4,9 @@
 // http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
 // http://opensource.org/licenses/MIT>, at your option. This file may not be
 // copied, modified, or distributed except according to those terms.
-extern crate std;
 
-use self::std::io::Error as IoError;
-use stack::{GuardedStack, Stack};
+use crate::stack::{GuardedStack, Stack};
+use std::io::Error as IoError;
 
 mod sys;
 
@@ -40,12 +39,12 @@ impl OsStack {
     let len = len + page_size;
 
     // Allocate a stack.
-    let ptr = try!(unsafe { sys::map_stack(len) });
-    let stack = OsStack { ptr: ptr, len: len };
+    let ptr = unsafe { sys::map_stack(len)? };
+    let stack = OsStack { ptr, len };
 
     // Mark the guard page. If this fails, `stack` will be dropped,
     // unmapping it.
-    try!(unsafe { sys::protect_stack(stack.ptr) });
+    unsafe { sys::protect_stack(stack.ptr)? };
 
     Ok(stack)
   }
@@ -54,12 +53,12 @@ impl OsStack {
 unsafe impl Stack for OsStack {
   #[inline(always)]
   fn base(&self) -> *mut u8 {
-    unsafe { self.ptr.offset(self.len as isize) }
+    unsafe { self.ptr.add(self.len) }
   }
 
   #[inline(always)]
   fn limit(&self) -> *mut u8 {
-    unsafe { self.ptr.offset(sys::page_size() as isize) }
+    unsafe { self.ptr.add(sys::page_size()) }
   }
 }
 
diff --git a/src/stack/os/sys.rs b/src/stack/os/sys.rs
diff --git a/src/stack/owned_stack.rs b/src/stack/owned_stack.rs
diff --git a/src/stack/slice_stack.rs b/src/stack/slice_stack.rs
diff --git a/tests/fpe.rs b/tests/fpe.rs
diff --git a/tests/generator.rs b/tests/generator.rs
diff --git a/tests/iterator.rs b/tests/iterator.rs
diff --git a/tests/stack.rs b/tests/stack.rs

Original file line number	Diff line number	Diff line change
`@@ -5,14 +5,13 @@`
`5`	`5`	`// http://opensource.org/licenses/MIT>, at your option. This file may not be`
`6`	`6`	`// copied, modified, or distributed except according to those terms.`
`7`	`7`	`#![cfg(target_os = "linux")]`
`8`		`-#![feature(asm, test)]`
`9`		`-extern crate test;`
	`8`	`+#![feature(llvm_asm, test)]`
`10`	`9`
`11`	`10`	`#[cfg(target_arch = "x86_64")]`
`12`	`11`	`#[bench]`
`13`	`12`	`fn syscall(b: &mut test::Bencher) {`
`14`	`13`	`b.iter(\|\| unsafe {`
`15`		`- asm!("movq $$102, %rax\n\`
	`14`	`+ llvm_asm!("movq $$102, %rax\n\`
`16`	`15`	`syscall"`
`17`	`16`	`:`
`18`	`17`	`:`
`@@ -25,7 +24,7 @@ fn syscall(b: &mut test::Bencher) {`
`25`	`24`	`#[bench]`
`26`	`25`	`fn syscall(b: &mut test::Bencher) {`
`27`	`26`	`b.iter(\|\| unsafe {`
`28`		`- asm!("mov $$24, %eax\n\`
	`27`	`+ llvm_asm!("mov $$24, %eax\n\`
`29`	`28`	`int $$0x80"`
`30`	`29`	`:`
`31`	`30`	`:`