Merge remote-tracking branch 'upstream/master' into asm-compile-tests

20 files changed, 219 insertions, 178 deletions

diff --git a/src/libstd/sys/cloudabi/abi/bitflags.rs b/src/libstd/sys/cloudabi/abi/bitflags.rs
index f764cc1df5a..306936213ed 100644
--- a/src/libstd/sys/cloudabi/abi/bitflags.rs
+++ b/src/libstd/sys/cloudabi/abi/bitflags.rs
@@ -25,8 +25,7 @@
 // ignore-license
 
 #[cfg(feature = "bitflags")]
-#[macro_use]
-extern crate bitflags;
+use bitflags::bitflags;
 
 // Minimal implementation of bitflags! in case we can't depend on the bitflags
 // crate. Only implements `bits()` and a `from_bits_truncate()` that doesn't
diff --git a/src/libstd/sys/cloudabi/abi/cloudabi.rs b/src/libstd/sys/cloudabi/abi/cloudabi.rs
index 83d45b3547b..2307e2167c5 100644
--- a/src/libstd/sys/cloudabi/abi/cloudabi.rs
+++ b/src/libstd/sys/cloudabi/abi/cloudabi.rs
@@ -1090,10 +1090,10 @@ pub union auxv_union {
 #[test]
 #[cfg(target_pointer_width = "32")]
 fn auxv_layout_test_32() {
-  assert_eq!(::core::mem::size_of::<auxv>(), 8);
-  assert_eq!(::core::mem::align_of::<auxv>(), 4);
+  assert_eq!(core::mem::size_of::<auxv>(), 8);
+  assert_eq!(core::mem::align_of::<auxv>(), 4);
   unsafe {
-    let obj: auxv = ::core::mem::uninitialized();
+    let obj: auxv = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.a_type as *const _ as usize - base, 0);
     assert_eq!(&obj.union.a_val as *const _ as usize - base, 4);
@@ -1103,10 +1103,10 @@ fn auxv_layout_test_32() {
 #[test]
 #[cfg(target_pointer_width = "64")]
 fn auxv_layout_test_64() {
-  assert_eq!(::core::mem::size_of::<auxv>(), 16);
-  assert_eq!(::core::mem::align_of::<auxv>(), 8);
+  assert_eq!(core::mem::size_of::<auxv>(), 16);
+  assert_eq!(core::mem::align_of::<auxv>(), 8);
   unsafe {
-    let obj: auxv = ::core::mem::uninitialized();
+    let obj: auxv = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.a_type as *const _ as usize - base, 0);
     assert_eq!(&obj.union.a_val as *const _ as usize - base, 8);
@@ -1124,10 +1124,10 @@ pub struct ciovec {
 #[test]
 #[cfg(target_pointer_width = "32")]
 fn ciovec_layout_test_32() {
-  assert_eq!(::core::mem::size_of::<ciovec>(), 8);
-  assert_eq!(::core::mem::align_of::<ciovec>(), 4);
+  assert_eq!(core::mem::size_of::<ciovec>(), 8);
+  assert_eq!(core::mem::align_of::<ciovec>(), 4);
   unsafe {
-    let obj: ciovec = ::core::mem::uninitialized();
+    let obj: ciovec = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.buf.0 as *const _ as usize - base, 0);
     assert_eq!(&obj.buf.1 as *const _ as usize - base, 4);
@@ -1136,10 +1136,10 @@ fn ciovec_layout_test_32() {
 #[test]
 #[cfg(target_pointer_width = "64")]
 fn ciovec_layout_test_64() {
-  assert_eq!(::core::mem::size_of::<ciovec>(), 16);
-  assert_eq!(::core::mem::align_of::<ciovec>(), 8);
+  assert_eq!(core::mem::size_of::<ciovec>(), 16);
+  assert_eq!(core::mem::align_of::<ciovec>(), 8);
   unsafe {
-    let obj: ciovec = ::core::mem::uninitialized();
+    let obj: ciovec = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.buf.0 as *const _ as usize - base, 0);
     assert_eq!(&obj.buf.1 as *const _ as usize - base, 8);
@@ -1164,10 +1164,10 @@ pub struct dirent {
 }
 #[test]
 fn dirent_layout_test() {
-  assert_eq!(::core::mem::size_of::<dirent>(), 24);
-  assert_eq!(::core::mem::align_of::<dirent>(), 8);
+  assert_eq!(core::mem::size_of::<dirent>(), 24);
+  assert_eq!(core::mem::align_of::<dirent>(), 8);
   unsafe {
-    let obj: dirent = ::core::mem::uninitialized();
+    let obj: dirent = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.d_next as *const _ as usize - base, 0);
     assert_eq!(&obj.d_ino as *const _ as usize - base, 8);
@@ -1228,10 +1228,10 @@ pub struct event_proc_terminate {
 }
 #[test]
 fn event_layout_test() {
-  assert_eq!(::core::mem::size_of::<event>(), 32);
-  assert_eq!(::core::mem::align_of::<event>(), 8);
+  assert_eq!(core::mem::size_of::<event>(), 32);
+  assert_eq!(core::mem::align_of::<event>(), 8);
   unsafe {
-    let obj: event = ::core::mem::uninitialized();
+    let obj: event = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.userdata as *const _ as usize - base, 0);
     assert_eq!(&obj.error as *const _ as usize - base, 8);
@@ -1262,10 +1262,10 @@ pub struct fdstat {
 }
 #[test]
 fn fdstat_layout_test() {
-  assert_eq!(::core::mem::size_of::<fdstat>(), 24);
-  assert_eq!(::core::mem::align_of::<fdstat>(), 8);
+  assert_eq!(core::mem::size_of::<fdstat>(), 24);
+  assert_eq!(core::mem::align_of::<fdstat>(), 8);
   unsafe {
-    let obj: fdstat = ::core::mem::uninitialized();
+    let obj: fdstat = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.fs_filetype as *const _ as usize - base, 0);
     assert_eq!(&obj.fs_flags as *const _ as usize - base, 2);
@@ -1299,10 +1299,10 @@ pub struct filestat {
 }
 #[test]
 fn filestat_layout_test() {
-  assert_eq!(::core::mem::size_of::<filestat>(), 56);
-  assert_eq!(::core::mem::align_of::<filestat>(), 8);
+  assert_eq!(core::mem::size_of::<filestat>(), 56);
+  assert_eq!(core::mem::align_of::<filestat>(), 8);
   unsafe {
-    let obj: filestat = ::core::mem::uninitialized();
+    let obj: filestat = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.st_dev as *const _ as usize - base, 0);
     assert_eq!(&obj.st_ino as *const _ as usize - base, 8);
@@ -1325,10 +1325,10 @@ pub struct iovec {
 #[test]
 #[cfg(target_pointer_width = "32")]
 fn iovec_layout_test_32() {
-  assert_eq!(::core::mem::size_of::<iovec>(), 8);
-  assert_eq!(::core::mem::align_of::<iovec>(), 4);
+  assert_eq!(core::mem::size_of::<iovec>(), 8);
+  assert_eq!(core::mem::align_of::<iovec>(), 4);
   unsafe {
-    let obj: iovec = ::core::mem::uninitialized();
+    let obj: iovec = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.buf.0 as *const _ as usize - base, 0);
     assert_eq!(&obj.buf.1 as *const _ as usize - base, 4);
@@ -1337,10 +1337,10 @@ fn iovec_layout_test_32() {
 #[test]
 #[cfg(target_pointer_width = "64")]
 fn iovec_layout_test_64() {
-  assert_eq!(::core::mem::size_of::<iovec>(), 16);
-  assert_eq!(::core::mem::align_of::<iovec>(), 8);
+  assert_eq!(core::mem::size_of::<iovec>(), 16);
+  assert_eq!(core::mem::align_of::<iovec>(), 8);
   unsafe {
-    let obj: iovec = ::core::mem::uninitialized();
+    let obj: iovec = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.buf.0 as *const _ as usize - base, 0);
     assert_eq!(&obj.buf.1 as *const _ as usize - base, 8);
@@ -1360,10 +1360,10 @@ pub struct lookup {
 }
 #[test]
 fn lookup_layout_test() {
-  assert_eq!(::core::mem::size_of::<lookup>(), 8);
-  assert_eq!(::core::mem::align_of::<lookup>(), 4);
+  assert_eq!(core::mem::size_of::<lookup>(), 8);
+  assert_eq!(core::mem::align_of::<lookup>(), 4);
   unsafe {
-    let obj: lookup = ::core::mem::uninitialized();
+    let obj: lookup = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.fd as *const _ as usize - base, 0);
     assert_eq!(&obj.flags as *const _ as usize - base, 4);
@@ -1394,10 +1394,10 @@ pub struct recv_in {
 #[test]
 #[cfg(target_pointer_width = "32")]
 fn recv_in_layout_test_32() {
-  assert_eq!(::core::mem::size_of::<recv_in>(), 20);
-  assert_eq!(::core::mem::align_of::<recv_in>(), 4);
+  assert_eq!(core::mem::size_of::<recv_in>(), 20);
+  assert_eq!(core::mem::align_of::<recv_in>(), 4);
   unsafe {
-    let obj: recv_in = ::core::mem::uninitialized();
+    let obj: recv_in = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.ri_data.0 as *const _ as usize - base, 0);
     assert_eq!(&obj.ri_data.1 as *const _ as usize - base, 4);
@@ -1409,10 +1409,10 @@ fn recv_in_layout_test_32() {
 #[test]
 #[cfg(target_pointer_width = "64")]
 fn recv_in_layout_test_64() {
-  assert_eq!(::core::mem::size_of::<recv_in>(), 40);
-  assert_eq!(::core::mem::align_of::<recv_in>(), 8);
+  assert_eq!(core::mem::size_of::<recv_in>(), 40);
+  assert_eq!(core::mem::align_of::<recv_in>(), 8);
   unsafe {
-    let obj: recv_in = ::core::mem::uninitialized();
+    let obj: recv_in = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.ri_data.0 as *const _ as usize - base, 0);
     assert_eq!(&obj.ri_data.1 as *const _ as usize - base, 8);
@@ -1438,10 +1438,10 @@ pub struct recv_out {
 #[test]
 #[cfg(target_pointer_width = "32")]
 fn recv_out_layout_test_32() {
-  assert_eq!(::core::mem::size_of::<recv_out>(), 52);
-  assert_eq!(::core::mem::align_of::<recv_out>(), 4);
+  assert_eq!(core::mem::size_of::<recv_out>(), 52);
+  assert_eq!(core::mem::align_of::<recv_out>(), 4);
   unsafe {
-    let obj: recv_out = ::core::mem::uninitialized();
+    let obj: recv_out = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.ro_datalen as *const _ as usize - base, 0);
     assert_eq!(&obj.ro_fdslen as *const _ as usize - base, 4);
@@ -1452,10 +1452,10 @@ fn recv_out_layout_test_32() {
 #[test]
 #[cfg(target_pointer_width = "64")]
 fn recv_out_layout_test_64() {
-  assert_eq!(::core::mem::size_of::<recv_out>(), 64);
-  assert_eq!(::core::mem::align_of::<recv_out>(), 8);
+  assert_eq!(core::mem::size_of::<recv_out>(), 64);
+  assert_eq!(core::mem::align_of::<recv_out>(), 8);
   unsafe {
-    let obj: recv_out = ::core::mem::uninitialized();
+    let obj: recv_out = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.ro_datalen as *const _ as usize - base, 0);
     assert_eq!(&obj.ro_fdslen as *const _ as usize - base, 8);
@@ -1480,10 +1480,10 @@ pub struct send_in {
 #[test]
 #[cfg(target_pointer_width = "32")]
 fn send_in_layout_test_32() {
-  assert_eq!(::core::mem::size_of::<send_in>(), 20);
-  assert_eq!(::core::mem::align_of::<send_in>(), 4);
+  assert_eq!(core::mem::size_of::<send_in>(), 20);
+  assert_eq!(core::mem::align_of::<send_in>(), 4);
   unsafe {
-    let obj: send_in = ::core::mem::uninitialized();
+    let obj: send_in = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.si_data.0 as *const _ as usize - base, 0);
     assert_eq!(&obj.si_data.1 as *const _ as usize - base, 4);
@@ -1495,10 +1495,10 @@ fn send_in_layout_test_32() {
 #[test]
 #[cfg(target_pointer_width = "64")]
 fn send_in_layout_test_64() {
-  assert_eq!(::core::mem::size_of::<send_in>(), 40);
-  assert_eq!(::core::mem::align_of::<send_in>(), 8);
+  assert_eq!(core::mem::size_of::<send_in>(), 40);
+  assert_eq!(core::mem::align_of::<send_in>(), 8);
   unsafe {
-    let obj: send_in = ::core::mem::uninitialized();
+    let obj: send_in = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.si_data.0 as *const _ as usize - base, 0);
     assert_eq!(&obj.si_data.1 as *const _ as usize - base, 8);
@@ -1518,10 +1518,10 @@ pub struct send_out {
 #[test]
 #[cfg(target_pointer_width = "32")]
 fn send_out_layout_test_32() {
-  assert_eq!(::core::mem::size_of::<send_out>(), 4);
-  assert_eq!(::core::mem::align_of::<send_out>(), 4);
+  assert_eq!(core::mem::size_of::<send_out>(), 4);
+  assert_eq!(core::mem::align_of::<send_out>(), 4);
   unsafe {
-    let obj: send_out = ::core::mem::uninitialized();
+    let obj: send_out = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.so_datalen as *const _ as usize - base, 0);
   }
@@ -1529,10 +1529,10 @@ fn send_out_layout_test_32() {
 #[test]
 #[cfg(target_pointer_width = "64")]
 fn send_out_layout_test_64() {
-  assert_eq!(::core::mem::size_of::<send_out>(), 8);
-  assert_eq!(::core::mem::align_of::<send_out>(), 8);
+  assert_eq!(core::mem::size_of::<send_out>(), 8);
+  assert_eq!(core::mem::align_of::<send_out>(), 8);
   unsafe {
-    let obj: send_out = ::core::mem::uninitialized();
+    let obj: send_out = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.so_datalen as *const _ as usize - base, 0);
   }
@@ -1647,10 +1647,10 @@ pub struct subscription_proc_terminate {
 #[test]
 #[cfg(target_pointer_width = "32")]
 fn subscription_layout_test_32() {
-  assert_eq!(::core::mem::size_of::<subscription>(), 56);
-  assert_eq!(::core::mem::align_of::<subscription>(), 8);
+  assert_eq!(core::mem::size_of::<subscription>(), 56);
+  assert_eq!(core::mem::align_of::<subscription>(), 8);
   unsafe {
-    let obj: subscription = ::core::mem::uninitialized();
+    let obj: subscription = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.userdata as *const _ as usize - base, 0);
     assert_eq!(&obj.unused as *const _ as usize - base, 8);
@@ -1674,10 +1674,10 @@ fn subscription_layout_test_32() {
 #[test]
 #[cfg(target_pointer_width = "64")]
 fn subscription_layout_test_64() {
-  assert_eq!(::core::mem::size_of::<subscription>(), 56);
-  assert_eq!(::core::mem::align_of::<subscription>(), 8);
+  assert_eq!(core::mem::size_of::<subscription>(), 56);
+  assert_eq!(core::mem::align_of::<subscription>(), 8);
   unsafe {
-    let obj: subscription = ::core::mem::uninitialized();
+    let obj: subscription = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.userdata as *const _ as usize - base, 0);
     assert_eq!(&obj.unused as *const _ as usize - base, 8);
@@ -1728,10 +1728,10 @@ pub struct tcb {
 #[test]
 #[cfg(target_pointer_width = "32")]
 fn tcb_layout_test_32() {
-  assert_eq!(::core::mem::size_of::<tcb>(), 4);
-  assert_eq!(::core::mem::align_of::<tcb>(), 4);
+  assert_eq!(core::mem::size_of::<tcb>(), 4);
+  assert_eq!(core::mem::align_of::<tcb>(), 4);
   unsafe {
-    let obj: tcb = ::core::mem::uninitialized();
+    let obj: tcb = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.parent as *const _ as usize - base, 0);
   }
@@ -1739,10 +1739,10 @@ fn tcb_layout_test_32() {
 #[test]
 #[cfg(target_pointer_width = "64")]
 fn tcb_layout_test_64() {
-  assert_eq!(::core::mem::size_of::<tcb>(), 8);
-  assert_eq!(::core::mem::align_of::<tcb>(), 8);
+  assert_eq!(core::mem::size_of::<tcb>(), 8);
+  assert_eq!(core::mem::align_of::<tcb>(), 8);
   unsafe {
-    let obj: tcb = ::core::mem::uninitialized();
+    let obj: tcb = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.parent as *const _ as usize - base, 0);
   }
@@ -1773,10 +1773,10 @@ pub struct threadattr {
 #[test]
 #[cfg(target_pointer_width = "32")]
 fn threadattr_layout_test_32() {
-  assert_eq!(::core::mem::size_of::<threadattr>(), 16);
-  assert_eq!(::core::mem::align_of::<threadattr>(), 4);
+  assert_eq!(core::mem::size_of::<threadattr>(), 16);
+  assert_eq!(core::mem::align_of::<threadattr>(), 4);
   unsafe {
-    let obj: threadattr = ::core::mem::uninitialized();
+    let obj: threadattr = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.entry_point as *const _ as usize - base, 0);
     assert_eq!(&obj.stack.0 as *const _ as usize - base, 4);
@@ -1787,10 +1787,10 @@ fn threadattr_layout_test_32() {
 #[test]
 #[cfg(target_pointer_width = "64")]
 fn threadattr_layout_test_64() {
-  assert_eq!(::core::mem::size_of::<threadattr>(), 32);
-  assert_eq!(::core::mem::align_of::<threadattr>(), 8);
+  assert_eq!(core::mem::size_of::<threadattr>(), 32);
+  assert_eq!(core::mem::align_of::<threadattr>(), 8);
   unsafe {
-    let obj: threadattr = ::core::mem::uninitialized();
+    let obj: threadattr = core::mem::uninitialized();
     let base = &obj as *const _ as usize;
     assert_eq!(&obj.entry_point as *const _ as usize - base, 0);
     assert_eq!(&obj.stack.0 as *const _ as usize - base, 8);
diff --git a/src/libstd/sys/cloudabi/args.rs b/src/libstd/sys/cloudabi/args.rs
index 4147ffff871..dea562abad3 100644
--- a/src/libstd/sys/cloudabi/args.rs
+++ b/src/libstd/sys/cloudabi/args.rs
@@ -1,4 +1,4 @@
-pub use sys::cloudabi::shims::args::*;
+pub use crate::sys::cloudabi::shims::args::*;
 
 #[allow(dead_code)]
 pub fn init(_: isize, _: *const *const u8) {}
diff --git a/src/libstd/sys/cloudabi/backtrace.rs b/src/libstd/sys/cloudabi/backtrace.rs
index 72f28550435..a15d2238e55 100644
--- a/src/libstd/sys/cloudabi/backtrace.rs
+++ b/src/libstd/sys/cloudabi/backtrace.rs
@@ -1,9 +1,10 @@
-use error::Error;
-use ffi::CStr;
-use intrinsics;
-use io;
-use libc;
-use sys_common::backtrace::Frame;
+use crate::error::Error;
+use crate::ffi::CStr;
+use crate::fmt;
+use crate::intrinsics;
+use crate::io;
+use crate::sys_common::backtrace::Frame;
+
 use unwind as uw;
 
 pub struct BacktraceContext;
@@ -22,8 +23,8 @@ impl Error for UnwindError {
     }
 }
 
-impl ::fmt::Display for UnwindError {
-    fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
+impl fmt::Display for UnwindError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}: {:?}", self.description(), self.0)
     }
 }
diff --git a/src/libstd/sys/cloudabi/condvar.rs b/src/libstd/sys/cloudabi/condvar.rs
index 758f29653ae..7aa0b0b6f49 100644
--- a/src/libstd/sys/cloudabi/condvar.rs
+++ b/src/libstd/sys/cloudabi/condvar.rs
@@ -1,10 +1,10 @@
-use cell::UnsafeCell;
-use mem;
-use sync::atomic::{AtomicU32, Ordering};
-use sys::cloudabi::abi;
-use sys::mutex::{self, Mutex};
-use sys::time::checked_dur2intervals;
-use time::Duration;
+use crate::cell::UnsafeCell;
+use crate::mem;
+use crate::sync::atomic::{AtomicU32, Ordering};
+use crate::sys::cloudabi::abi;
+use crate::sys::mutex::{self, Mutex};
+use crate::sys::time::checked_dur2intervals;
+use crate::time::Duration;
 
 extern "C" {
     #[thread_local]
diff --git a/src/libstd/sys/cloudabi/io.rs b/src/libstd/sys/cloudabi/io.rs
new file mode 100644
index 00000000000..8b02d3fd19d
--- /dev/null
+++ b/src/libstd/sys/cloudabi/io.rs
@@ -0,0 +1,32 @@
+pub struct IoVec<'a>(&'a [u8]);
+
+impl<'a> IoVec<'a> {
+    #[inline]
+    pub fn new(buf: &'a [u8]) -> IoVec<'a> {
+        IoVec(buf)
+    }
+
+    #[inline]
+    pub fn as_slice(&self) -> &[u8] {
+        self.0
+    }
+}
+
+pub struct IoVecMut<'a>(&'a mut [u8]);
+
+impl<'a> IoVecMut<'a> {
+    #[inline]
+    pub fn new(buf: &'a mut [u8]) -> IoVecMut<'a> {
+        IoVecMut(buf)
+    }
+
+    #[inline]
+    pub fn as_slice(&self) -> &[u8] {
+        self.0
+    }
+
+    #[inline]
+    pub fn as_mut_slice(&mut self) -> &mut [u8] {
+        self.0
+    }
+}
diff --git a/src/libstd/sys/cloudabi/mod.rs b/src/libstd/sys/cloudabi/mod.rs
index cd621b76945..47c90fddd86 100644
--- a/src/libstd/sys/cloudabi/mod.rs
+++ b/src/libstd/sys/cloudabi/mod.rs
@@ -1,6 +1,5 @@
-use io;
-use libc;
-use mem;
+use crate::io::ErrorKind;
+use crate::mem;
 
 #[path = "../unix/alloc.rs"]
 pub mod alloc;
@@ -10,6 +9,7 @@ pub mod backtrace;
 #[path = "../unix/cmath.rs"]
 pub mod cmath;
 pub mod condvar;
+pub mod io;
 #[path = "../unix/memchr.rs"]
 pub mod memchr;
 pub mod mutex;
@@ -32,29 +32,29 @@ pub use self::shims::*;
 #[allow(dead_code)]
 pub fn init() {}
 
-pub fn decode_error_kind(errno: i32) -> io::ErrorKind {
+pub fn decode_error_kind(errno: i32) -> ErrorKind {
     match errno {
-        x if x == abi::errno::ACCES as i32 => io::ErrorKind::PermissionDenied,
-        x if x == abi::errno::ADDRINUSE as i32 => io::ErrorKind::AddrInUse,
-        x if x == abi::errno::ADDRNOTAVAIL as i32 => io::ErrorKind::AddrNotAvailable,
-        x if x == abi::errno::AGAIN as i32 => io::ErrorKind::WouldBlock,
-        x if x == abi::errno::CONNABORTED as i32 => io::ErrorKind::ConnectionAborted,
-        x if x == abi::errno::CONNREFUSED as i32 => io::ErrorKind::ConnectionRefused,
-        x if x == abi::errno::CONNRESET as i32 => io::ErrorKind::ConnectionReset,
-        x if x == abi::errno::EXIST as i32 => io::ErrorKind::AlreadyExists,
-        x if x == abi::errno::INTR as i32 => io::ErrorKind::Interrupted,
-        x if x == abi::errno::INVAL as i32 => io::ErrorKind::InvalidInput,
-        x if x == abi::errno::NOENT as i32 => io::ErrorKind::NotFound,
-        x if x == abi::errno::NOTCONN as i32 => io::ErrorKind::NotConnected,
-        x if x == abi::errno::PERM as i32 => io::ErrorKind::PermissionDenied,
-        x if x == abi::errno::PIPE as i32 => io::ErrorKind::BrokenPipe,
-        x if x == abi::errno::TIMEDOUT as i32 => io::ErrorKind::TimedOut,
-        _ => io::ErrorKind::Other,
+        x if x == abi::errno::ACCES as i32 => ErrorKind::PermissionDenied,
+        x if x == abi::errno::ADDRINUSE as i32 => ErrorKind::AddrInUse,
+        x if x == abi::errno::ADDRNOTAVAIL as i32 => ErrorKind::AddrNotAvailable,
+        x if x == abi::errno::AGAIN as i32 => ErrorKind::WouldBlock,
+        x if x == abi::errno::CONNABORTED as i32 => ErrorKind::ConnectionAborted,
+        x if x == abi::errno::CONNREFUSED as i32 => ErrorKind::ConnectionRefused,
+        x if x == abi::errno::CONNRESET as i32 => ErrorKind::ConnectionReset,
+        x if x == abi::errno::EXIST as i32 => ErrorKind::AlreadyExists,
+        x if x == abi::errno::INTR as i32 => ErrorKind::Interrupted,
+        x if x == abi::errno::INVAL as i32 => ErrorKind::InvalidInput,
+        x if x == abi::errno::NOENT as i32 => ErrorKind::NotFound,
+        x if x == abi::errno::NOTCONN as i32 => ErrorKind::NotConnected,
+        x if x == abi::errno::PERM as i32 => ErrorKind::PermissionDenied,
+        x if x == abi::errno::PIPE as i32 => ErrorKind::BrokenPipe,
+        x if x == abi::errno::TIMEDOUT as i32 => ErrorKind::TimedOut,
+        _ => ErrorKind::Other,
     }
 }
 
 pub unsafe fn abort_internal() -> ! {
-    ::core::intrinsics::abort();
+    core::intrinsics::abort();
 }
 
 pub use libc::strlen;
diff --git a/src/libstd/sys/cloudabi/mutex.rs b/src/libstd/sys/cloudabi/mutex.rs
index ae62d8bfdb0..5e191e31d5f 100644
--- a/src/libstd/sys/cloudabi/mutex.rs
+++ b/src/libstd/sys/cloudabi/mutex.rs
@@ -1,8 +1,8 @@
-use cell::UnsafeCell;
-use mem;
-use sync::atomic::{AtomicU32, Ordering};
-use sys::cloudabi::abi;
-use sys::rwlock::{self, RWLock};
+use crate::cell::UnsafeCell;
+use crate::mem;
+use crate::sync::atomic::{AtomicU32, Ordering};
+use crate::sys::cloudabi::abi;
+use crate::sys::rwlock::{self, RWLock};
 
 extern "C" {
     #[thread_local]
diff --git a/src/libstd/sys/cloudabi/os.rs b/src/libstd/sys/cloudabi/os.rs
index 8a6464125de..7db7808a087 100644
--- a/src/libstd/sys/cloudabi/os.rs
+++ b/src/libstd/sys/cloudabi/os.rs
@@ -1,8 +1,9 @@
-use ffi::CStr;
-use libc::{self, c_int};
-use str;
+use crate::ffi::CStr;
+use crate::str;
 
-pub use sys::cloudabi::shims::os::*;
+use libc::c_int;
+
+pub use crate::sys::cloudabi::shims::os::*;
 
 pub fn errno() -> i32 {
     extern "C" {
diff --git a/src/libstd/sys/cloudabi/rwlock.rs b/src/libstd/sys/cloudabi/rwlock.rs
index 7f08c2c7869..6da3f3841b6 100644
--- a/src/libstd/sys/cloudabi/rwlock.rs
+++ b/src/libstd/sys/cloudabi/rwlock.rs
@@ -1,7 +1,7 @@
-use cell::UnsafeCell;
-use mem;
-use sync::atomic::{AtomicU32, Ordering};
-use sys::cloudabi::abi;
+use crate::cell::UnsafeCell;
+use crate::mem;
+use crate::sync::atomic::{AtomicU32, Ordering};
+use crate::sys::cloudabi::abi;
 
 extern "C" {
     #[thread_local]
diff --git a/src/libstd/sys/cloudabi/shims/args.rs b/src/libstd/sys/cloudabi/shims/args.rs
index f924a434263..f5cf71caf6c 100644
--- a/src/libstd/sys/cloudabi/shims/args.rs
+++ b/src/libstd/sys/cloudabi/shims/args.rs
@@ -1,4 +1,4 @@
-use ffi::OsString;
+use crate::ffi::OsString;
 
 pub struct Args(());
 
diff --git a/src/libstd/sys/cloudabi/shims/fs.rs b/src/libstd/sys/cloudabi/shims/fs.rs
index 3af10a74c7d..56667bef007 100644
--- a/src/libstd/sys/cloudabi/shims/fs.rs
+++ b/src/libstd/sys/cloudabi/shims/fs.rs
@@ -1,10 +1,10 @@
-use ffi::OsString;
-use fmt;
-use hash::{Hash, Hasher};
-use io::{self, SeekFrom};
-use path::{Path, PathBuf};
-use sys::time::SystemTime;
-use sys::{unsupported, Void};
+use crate::ffi::OsString;
+use crate::fmt;
+use crate::hash::{Hash, Hasher};
+use crate::io::{self, SeekFrom};
+use crate::path::{Path, PathBuf};
+use crate::sys::time::SystemTime;
+use crate::sys::{unsupported, Void};
 
 pub struct File(Void);
 
diff --git a/src/libstd/sys/cloudabi/shims/mod.rs b/src/libstd/sys/cloudabi/shims/mod.rs
index 080eac19ceb..fbb5ff55f22 100644
--- a/src/libstd/sys/cloudabi/shims/mod.rs
+++ b/src/libstd/sys/cloudabi/shims/mod.rs
@@ -1,4 +1,4 @@
-use io;
+use crate::io;
 
 pub mod args;
 pub mod env;
diff --git a/src/libstd/sys/cloudabi/shims/net.rs b/src/libstd/sys/cloudabi/shims/net.rs
index b4caa899a75..6d2a4962ab4 100644
--- a/src/libstd/sys/cloudabi/shims/net.rs
+++ b/src/libstd/sys/cloudabi/shims/net.rs
@@ -1,10 +1,11 @@
-use fmt;
-use io;
-use net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr};
-use time::Duration;
-use sys::{unsupported, Void};
-use convert::TryFrom;
-
+use crate::fmt;
+use crate::io::{self, IoVec, IoVecMut};
+use crate::net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr};
+use crate::time::Duration;
+use crate::sys::{unsupported, Void};
+use crate::convert::TryFrom;
+
+#[allow(unused_extern_crates)]
 pub extern crate libc as netc;
 
 pub struct TcpStream(Void);
@@ -42,10 +43,18 @@ impl TcpStream {
         match self.0 {}
     }
 
+    pub fn read_vectored(&self, _: &mut [IoVecMut<'_>]) -> io::Result<usize> {
+        match self.0 {}
+    }
+
     pub fn write(&self, _: &[u8]) -> io::Result<usize> {
         match self.0 {}
     }
 
+    pub fn write_vectored(&self, _: &[IoVec<'_>]) -> io::Result<usize> {
+        match self.0 {}
+    }
+
     pub fn peer_addr(&self) -> io::Result<SocketAddr> {
         match self.0 {}
     }
@@ -288,10 +297,10 @@ impl Iterator for LookupHost {
     }
 }
 
-impl<'a> TryFrom<&'a str> for LookupHost {
+impl TryFrom<&str> for LookupHost {
     type Error = io::Error;
 
-    fn try_from(_v: &'a str) -> io::Result<LookupHost> {
+    fn try_from(_v: &str) -> io::Result<LookupHost> {
         unsupported()
     }
 }
diff --git a/src/libstd/sys/cloudabi/shims/os.rs b/src/libstd/sys/cloudabi/shims/os.rs
index 31cb18ea526..0c4690e12b0 100644
--- a/src/libstd/sys/cloudabi/shims/os.rs
+++ b/src/libstd/sys/cloudabi/shims/os.rs
@@ -1,10 +1,10 @@
-use error::Error as StdError;
-use ffi::{OsStr, OsString};
-use fmt;
-use io;
-use iter;
-use path::{self, PathBuf};
-use sys::{unsupported, Void};
+use crate::error::Error as StdError;
+use crate::ffi::{OsStr, OsString};
+use crate::fmt;
+use crate::io;
+use crate::iter;
+use crate::path::{self, PathBuf};
+use crate::sys::{unsupported, Void};
 
 pub fn getcwd() -> io::Result<PathBuf> {
     unsupported()
diff --git a/src/libstd/sys/cloudabi/shims/pipe.rs b/src/libstd/sys/cloudabi/shims/pipe.rs
index 30ef79dd769..f3debb95047 100644
--- a/src/libstd/sys/cloudabi/shims/pipe.rs
+++ b/src/libstd/sys/cloudabi/shims/pipe.rs
@@ -1,5 +1,5 @@
-use io;
-use sys::Void;
+use crate::io;
+use crate::sys::Void;
 
 pub struct AnonPipe(Void);
 
diff --git a/src/libstd/sys/cloudabi/shims/process.rs b/src/libstd/sys/cloudabi/shims/process.rs
index 49b9d5e266e..710c42c1149 100644
--- a/src/libstd/sys/cloudabi/shims/process.rs
+++ b/src/libstd/sys/cloudabi/shims/process.rs
@@ -1,10 +1,10 @@
-use ffi::OsStr;
-use fmt;
-use io;
-use sys::fs::File;
-use sys::pipe::AnonPipe;
-use sys::{unsupported, Void};
-use sys_common::process::{CommandEnv, DefaultEnvKey};
+use crate::ffi::OsStr;
+use crate::fmt;
+use crate::io;
+use crate::sys::fs::File;
+use crate::sys::pipe::AnonPipe;
+use crate::sys::{unsupported, Void};
+use crate::sys_common::process::{CommandEnv, DefaultEnvKey};
 
 ////////////////////////////////////////////////////////////////////////////////
 // Command
diff --git a/src/libstd/sys/cloudabi/stdio.rs b/src/libstd/sys/cloudabi/stdio.rs
index 81d79213f61..601563c5b1f 100644
--- a/src/libstd/sys/cloudabi/stdio.rs
+++ b/src/libstd/sys/cloudabi/stdio.rs
@@ -1,5 +1,5 @@
-use io;
-use sys::cloudabi::abi;
+use crate::io;
+use crate::sys::cloudabi::abi;
 
 pub struct Stdin(());
 pub struct Stdout(());
@@ -59,7 +59,7 @@ pub fn is_ebadf(err: &io::Error) -> bool {
     err.raw_os_error() == Some(abi::errno::BADF as i32)
 }
 
-pub const STDIN_BUF_SIZE: usize = ::sys_common::io::DEFAULT_BUF_SIZE;
+pub const STDIN_BUF_SIZE: usize = crate::sys_common::io::DEFAULT_BUF_SIZE;
 
 pub fn panic_output() -> Option<impl io::Write> {
     Stderr::new().ok()
diff --git a/src/libstd/sys/cloudabi/thread.rs b/src/libstd/sys/cloudabi/thread.rs
index 950420420f0..f853346e0e6 100644
--- a/src/libstd/sys/cloudabi/thread.rs
+++ b/src/libstd/sys/cloudabi/thread.rs
@@ -1,14 +1,13 @@
-use boxed::FnBox;
-use cmp;
-use ffi::CStr;
-use io;
-use libc;
-use mem;
-use ptr;
-use sys::cloudabi::abi;
-use sys::time::checked_dur2intervals;
-use sys_common::thread::*;
-use time::Duration;
+use crate::boxed::FnBox;
+use crate::cmp;
+use crate::ffi::CStr;
+use crate::io;
+use crate::mem;
+use crate::ptr;
+use crate::sys::cloudabi::abi;
+use crate::sys::time::checked_dur2intervals;
+use crate::sys_common::thread::*;
+use crate::time::Duration;
 
 pub const DEFAULT_MIN_STACK_SIZE: usize = 2 * 1024 * 1024;
 
diff --git a/src/libstd/sys/cloudabi/time.rs b/src/libstd/sys/cloudabi/time.rs
index 545e3c0ce84..d7502c61eff 100644
--- a/src/libstd/sys/cloudabi/time.rs
+++ b/src/libstd/sys/cloudabi/time.rs
@@ -1,6 +1,6 @@
-use mem;
-use sys::cloudabi::abi;
-use time::Duration;
+use crate::mem;
+use crate::sys::cloudabi::abi;
+use crate::time::Duration;
 
 const NSEC_PER_SEC: abi::timestamp = 1_000_000_000;