deleted file mode 100644
--- a/third_party/rust/coco/.cargo-checksum.json
+++ /dev/null
@@ -1,1 +0,0 @@
-{"files":{".travis.yml":"b4ea42f2ade2f287c4b0b6eee0e34437ec7cad7462832c18c397372b2a18aef1","CHANGELOG.md":"255242d56d5ce66921e03665a7b4b87be94c4b2ca7c4333f6569abe45321f992","Cargo.toml":"3aeb19f8e670699b19d0627c2466e8a859a02d3b8697c2054ac1ce8f82876c3e","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"0621878e61f0d0fda054bcbe02df75192c28bde1ecc8289cbd86aeba2dd72720","README.md":"7c3ce82aaba8e7bb81a62e1c99eb4c62c0116cd0832e343be5a52ec5e20942cb","benches/bench.rs":"ab1b7a1db73425735405fc214606c9ec783b350001f1be376ebf43cd4a540b67","ci/script.sh":"878f8b0a1d77d51834c152b299e6ef7b9c7d24a7ca2fbefe5070e9d2a72532c9","src/deque.rs":"5eaa6bec7c61435abebb35d52e9e02a6bb164c92d6c078f634e2b941f03e033d","src/epoch/atomic.rs":"1b7ed6f5abc0860a71a2d07f9099a4c0c7f274f7fe2a09733b64bf9f1a72fcd1","src/epoch/garbage.rs":"b1b35659796008001a8cb4a9edad7c101091f5ba45515cc5d64ef1ec862d36af","src/epoch/mod.rs":"0c83566f179b125ce37d40d5ba1c8731b3baa29fc0c46f966eeb44d1cb41502c","src/epoch/thread.rs":"cb8d17c75763004f4d3b227a7b710b1c8cbf3c5adc87d8346db57b2f8af59b27","src/lib.rs":"4b01d1e4bea889496b8c22713caaf34c65339aa8582e8b903fd3e0395c830a4a","src/stack.rs":"c1186eadfce0b83c3df2211cf15e0d2426b3a8fc3cd7726eca4e73851a502b60"},"package":"c06169f5beb7e31c7c67ebf5540b8b472d23e3eade3b2ec7d1f5b504a85f91bd"}
\ No newline at end of file

deleted file mode 100644
--- a/third_party/rust/coco/.travis.yml
+++ /dev/null
@@ -1,27 +0,0 @@
-language: rust
-
-rust:
-  - stable
-  - beta
-  - nightly
-
-env:
-    global:
-      - RUST_MIN_STACK=33554432
-
-matrix:
-
-addons:
-  apt:
-    sources:
-      - ubuntu-toolchain-r-test
-      - llvm-toolchain-precise
-      - llvm-toolchain-precise-3.8
-    packages:
-      - llvm-3.8
-      - llvm-3.8-dev
-      - clang-3.8
-      - clang-3.8-dev
-
-script:
-  - ./ci/script.sh

deleted file mode 100644
--- a/third_party/rust/coco/CHANGELOG.md
+++ /dev/null
@@ -1,4 +0,0 @@
-# Release 0.1.0
-
-* Implemented a lock-free stack.
-* Implemented a lock-free work-stealing deque.

deleted file mode 100644
--- a/third_party/rust/coco/Cargo.toml
+++ /dev/null
@@ -1,32 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g. crates.io) dependencies
-#
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
-
-[package]
-name = "coco"
-version = "0.1.1"
-authors = ["Stjepan Glavina <stjepang@gmail.com>"]
-description = "Concurrent collections"
-documentation = "https://docs.rs/coco"
-readme = "README.md"
-license = "Apache-2.0/MIT"
-repository = "https://github.com/stjepang/coco"
-[dependencies.scopeguard]
-version = "0.3"
-
-[dependencies.either]
-version = "1.0"
-[dev-dependencies.rand]
-version = "0.3"
-
-[features]
-internals = []
-strict_gc = []

deleted file mode 100644
--- a/third_party/rust/coco/README.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# Concurrent collections
-
-[![Build Status](https://travis-ci.org/stjepang/coco.svg?branch=master)](https://travis-ci.org/stjepang/coco)
-[![License](https://img.shields.io/badge/license-Apache--2.0%2FMIT-blue.svg)](https://github.com/stjepang/coco)
-[![Cargo](https://img.shields.io/crates/v/coco.svg)](https://crates.io/crates/coco)
-[![Documentation](https://docs.rs/coco/badge.svg)](https://docs.rs/coco)
-
-This crate offers several collections that are designed for performance in multithreaded
-contexts. They can be freely shared among multiple threads running in parallel, and concurrently
-modified without the overhead of locking.
-
-<!-- Some of these data structures are lock-free. Others are not strictly speaking lock-free, but -->
-<!-- still scale well with respect to the number of threads accessing them. -->
-
-The following collections are available:
-
-* `Stack`: A lock-free stack.
-* `deque`: A lock-free work-stealing deque.

deleted file mode 100755
--- a/third_party/rust/coco/benches/bench.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![feature(test)]
-
-extern crate coco;
-extern crate test;
-
-use coco::epoch;
-use test::Bencher;
-
-#[bench]
-fn pin_empty(b: &mut Bencher) {
-    b.iter(|| epoch::pin(|_| ()))
-}

deleted file mode 100755
--- a/third_party/rust/coco/ci/script.sh
+++ /dev/null
@@ -1,20 +0,0 @@
-#!/bin/bash
-
-set -ex
-
-cargo test
-cargo test --features strict_gc
-
-if [[ "$TRAVIS_RUST_VERSION" == "nightly" ]]; then
-    cd sanitize
-
-    cargo test
-    cargo test --features coco/strict_gc
-
-    for _ in {1..10}; do
-        cargo test --release
-    done
-    for _ in {1..10}; do
-        cargo test --release --features coco/strict_gc
-    done
-fi

deleted file mode 100644
--- a/third_party/rust/coco/src/deque.rs
+++ /dev/null
@@ -1,813 +0,0 @@
-//! A lock-free work-stealing deque.
-//!
-//! There is one worker and possibly multiple stealers per deque. The worker has exclusive access
-//! to one side of the deque and may push and pop elements. Stealers can only steal (i.e. pop)
-//! elements from the other side.
-//!
-//! The implementation is based on the following papers:
-//!
-//! 1. Dynamic Circular Work-Stealing Deque
-//!    <sup>[pdf][chase-lev]</sup>
-//! 2. Correct and Efficient Work-Stealing for Weak Memory Models
-//!    <sup>[pdf][weak-mem]</sup>
-//! 3. CDSChecker: Checking Concurrent Data Structures Written with C/C++ Atomics
-//!    <sup>[pdf][checker] [code][code]</sup>
-//!
-//! [chase-lev]: https://pdfs.semanticscholar.org/3771/77bb82105c35e6e26ebad1698a20688473bd.pdf
-//! [weak-mem]: http://www.di.ens.fr/~zappa/readings/ppopp13.pdf
-//! [checker]: http://plrg.eecs.uci.edu/publications/c11modelcheck.pdf
-//! [code]: https://github.com/computersforpeace/model-checker-benchmarks/tree/master/chase-lev-deque-bugfix
-//!
-//! # Examples
-//!
-//! ```
-//! use coco::deque;
-//!
-//! let (w, s) = deque::new();
-//!
-//! // Create some work.
-//! for i in 0..1000 {
-//!     w.push(i);
-//! }
-//!
-//! let threads = (0..4).map(|_| {
-//!     let s = s.clone();
-//!     std::thread::spawn(move || {
-//!         while let Some(x) = s.steal() {
-//!             // Do something with `x`...
-//!         }
-//!     })
-//! }).collect::<Vec<_>>();
-//!
-//! while let Some(x) = w.pop() {
-//!     // Do something with `x`...
-//!     // Or create even more work...
-//!     if x > 1 {
-//!         w.push(x / 2);
-//!         w.push(x / 2);
-//!     }
-//! }
-//!
-//! for t in threads {
-//!     t.join().unwrap();
-//! }
-//! ```
-
-use std::cmp;
-use std::fmt;
-use std::marker::PhantomData;
-use std::mem;
-use std::ptr;
-use std::sync::Arc;
-use std::sync::atomic::{AtomicIsize, fence};
-use std::sync::atomic::Ordering::{Acquire, Release, Relaxed, SeqCst};
-
-use epoch::{self, Atomic};
-
-/// Minimum buffer capacity for a deque.
-const MIN_CAP: usize = 16;
-
-/// A buffer where deque elements are stored.
-struct Buffer<T> {
-    /// Pointer to the allocated memory.
-    ptr: *mut T,
-    /// Capacity of the buffer. Always a power of two.
-    cap: usize,
-}
-
-impl<T> Buffer<T> {
-    /// Returns a new buffe with the specified capacity.
-    fn new(cap: usize) -> Self {
-        let mut v = Vec::with_capacity(cap);
-        let ptr = v.as_mut_ptr();
-        mem::forget(v);
-        Buffer {
-            ptr: ptr,
-            cap: cap,
-        }
-    }
-
-    /// Returns a pointer to the element at the specified `index`.
-    unsafe fn at(&self, index: isize) -> *mut T {
-        // `self.len` is always a power of two.
-        self.ptr.offset(index & (self.cap - 1) as isize)
-    }
-
-    /// Writes `value` into the specified `index`.
-    unsafe fn write(&self, index: isize, value: T) {
-        ptr::write(self.at(index), value)
-    }
-
-    /// Reads the value from the specified `index`.
-    unsafe fn read(&self, index: isize) -> T {
-        ptr::read(self.at(index))
-    }
-}
-
-struct Deque<T> {
-    bottom: AtomicIsize,
-    top: AtomicIsize,
-    buffer: Atomic<Buffer<T>>,
-}
-
-/// A work-stealing deque.
-impl<T> Deque<T> {
-    /// Returns a new, empty deque.
-    fn new() -> Self {
-        Deque {
-            bottom: AtomicIsize::new(0),
-            top: AtomicIsize::new(0),
-            buffer: Atomic::new(Buffer::new(MIN_CAP), 0),
-        }
-    }
-
-    /// Returns the number of elements in the deque.
-    ///
-    /// If used concurrently with other operations, the returned number is just an estimate.
-    fn len(&self) -> usize {
-        let b = self.bottom.load(Relaxed);
-        let t = self.top.load(Relaxed);
-        // The length can be negative because `b` and `t` were loaded without synchronization.
-        cmp::max(b.wrapping_sub(t), 0) as usize
-    }
-
-    /// Resizes the buffer with new capacity of `new_cap`.
-    #[cold]
-    unsafe fn resize(&self, new_cap: usize) {
-        // Load the bottom, top, and buffer.
-        let b = self.bottom.load(Relaxed);
-        let t = self.top.load(Relaxed);
-        let buffer = self.buffer.load_raw(Relaxed).0;
-
-        // Allocate a new buffer.
-        let new = Buffer::new(new_cap);
-
-        // Copy data from the old buffer to the new one.
-        let mut i = t;
-        while i != b {
-            ptr::copy_nonoverlapping((*buffer).at(i), new.at(i), 1);
-            i = i.wrapping_add(1);
-        }
-
-        epoch::pin(|pin| {
-            // Replace the old buffer with the new one.
-            self.buffer.store_box(Box::new(new), 0, pin).as_raw();
-
-            let ptr = (*buffer).ptr;
-            let cap = (*buffer).cap;
-
-            // Destroy the old buffer later.
-            epoch::defer_free(ptr, cap, pin);
-            epoch::defer_free(buffer, 1, pin);
-
-            // If the size of the buffer at least than 1KB, then flush the thread-local garbage in
-            // order to destroy it sooner.
-            if mem::size_of::<T>() * cap >= 1 << 10 {
-                epoch::flush(pin);
-            }
-        })
-    }
-
-    /// Pushes an element onto the bottom of the deque.
-    fn push(&self, value: T) {
-        unsafe {
-            // Load the bottom, top, and buffer. The buffer doesn't have to be epoch-protected
-            // because the current thread (the worker) is the only one that grows and shrinks it.
-            let b = self.bottom.load(Relaxed);
-            let t = self.top.load(Acquire);
-            let mut buffer = self.buffer.load_raw(Relaxed).0;
-
-            // Calculate the length of the deque.
-            let len = b.wrapping_sub(t);
-
-            // Is the deque full?
-            let cap = (*buffer).cap;
-            if len >= cap as isize {
-                // Yes. Grow the underlying buffer.
-                self.resize(2 * cap);
-                buffer = self.buffer.load_raw(Relaxed).0;
-            }
-
-            // Write `value` into the right slot and increment `b`.
-            (*buffer).write(b, value);
-            fence(Release);
-            self.bottom.store(b.wrapping_add(1), Relaxed);
-        }
-    }
-
-    /// Pops an element from the bottom of the deque.
-    fn pop(&self) -> Option<T> {
-        // Load the bottom.
-        let b = self.bottom.load(Relaxed);
-
-        // If the deque is empty, return early without incurring the cost of a SeqCst fence.
-        let t = self.top.load(Relaxed);
-        if b.wrapping_sub(t) <= 0 {
-            return None;
-        }
-
-        // Decrement the bottom.
-        let b = b.wrapping_sub(1);
-        self.bottom.store(b, Relaxed);
-
-        // Load the buffer. The buffer doesn't have to be epoch-protected because the current
-        // thread (the worker) is the only one that grows and shrinks it.
-        let buffer = self.buffer.load_raw(Relaxed).0;
-
-        fence(SeqCst);
-
-        // Load the top.
-        let t = self.top.load(Relaxed);
-
-        // Compute the length after the bottom was decremented.
-        let len = b.wrapping_sub(t);
-
-        if len < 0 {
-            // The deque is empty. Restore the bottom back to the original value.
-            self.bottom.store(b.wrapping_add(1), Relaxed);
-            None
-        } else {
-            // Read the value to be popped.
-            let mut value = unsafe { Some((*buffer).read(b)) };
-
-            // Are we popping the last element from the deque?
-            if len == 0 {
-                // Try incrementing the top.
-                if self.top.compare_exchange(t, t.wrapping_add(1), SeqCst, Relaxed).is_err() {
-                    // Failed. We didn't pop anything.
-                    mem::forget(value.take());
-                }
-
-                // Restore the bottom back to the original value.
-                self.bottom.store(b.wrapping_add(1), Relaxed);
-            } else {
-                // Shrink the buffer if `len` is less than one fourth of `cap`.
-                unsafe {
-                    let cap = (*buffer).cap;
-                    if cap > MIN_CAP && len < cap as isize / 4 {
-                        self.resize(cap / 2);
-                    }
-                }
-            }
-
-            value
-        }
-    }
-
-    /// Steals an element from the top of the deque.
-    fn steal(&self) -> Option<T> {
-        // Load the top.
-        let mut t = self.top.load(Acquire);
-
-        // A SeqCst fence is needed here.
-        // If the current thread is already pinned (reentrantly), we must manually issue the fence.
-        // Otherwise, the following pinning will issue the fence anyway, so we don't have to.
-        if epoch::is_pinned() {
-            fence(SeqCst);
-        }
-
-        epoch::pin(|pin| {
-            // Loop until we successfully steal an element or find the deque empty.
-            loop {
-                // Load the bottom.
-                let b = self.bottom.load(Acquire);
-
-                // Is the deque empty?
-                if b.wrapping_sub(t) <= 0 {
-                    return None;
-                }
-
-                // Load the buffer and read the value at the top.
-                let a = self.buffer.load(pin).unwrap();
-                let value = unsafe { a.read(t) };
-
-                // Try incrementing the top to steal the value.
-                if self.top.compare_exchange(t, t.wrapping_add(1), SeqCst, Relaxed).is_ok() {
-                    return Some(value);
-                }
-
-                // We didn't steal this value, forget it.
-                mem::forget(value);
-
-                // Before every iteration of the loop we must load the top, issue a SeqCst fence,
-                // and then load the bottom. Now reload the top and issue the fence.
-                t = self.top.load(Acquire);
-                fence(SeqCst);
-            }
-        })
-    }
-
-    /// Steals an element from the top of the deque, but only the worker may call this method.
-    fn steal_as_worker(&self) -> Option<T> {
-        let b = self.bottom.load(Relaxed);
-        let a = self.buffer.load_raw(Relaxed).0;
-
-        // Loop until we successfully steal an element or find the deque empty.
-        loop {
-            let t = self.top.load(Relaxed);
-
-            // Is the deque empty?
-            if b.wrapping_sub(t) <= 0 {
-                return None;
-            }
-
-            // Try incrementing the top to steal the value.
-            if self.top.compare_exchange(t, t.wrapping_add(1), SeqCst, Relaxed).is_ok() {
-                return unsafe { Some((*a).read(t)) };
-            }
-        }
-    }
-}
-
-impl<T> Drop for Deque<T> {
-    fn drop(&mut self) {
-        // Load the bottom, top, and buffer.
-        let b = self.bottom.load(Relaxed);
-        let t = self.top.load(Relaxed);
-        let buffer = self.buffer.load_raw(Relaxed).0;
-
-        unsafe {
-            // Go through the buffer from top to bottom and drop all elements in the deque.
-            let mut i = t;
-            while i != b {
-                ptr::drop_in_place((*buffer).at(i));
-                i = i.wrapping_add(1);
-            }
-
-            // Free the memory allocated by the buffer.
-            drop(Vec::from_raw_parts((*buffer).ptr, 0, (*buffer).cap));
-            drop(Vec::from_raw_parts(buffer, 0, 1));
-        }
-    }
-}
-
-/// Worker side of a work-stealing deque.
-///
-/// There is only one worker per deque.
-pub struct Worker<T> {
-    deque: Arc<Deque<T>>,
-    _marker: PhantomData<*mut ()>, // !Send + !Sync
-}
-
-unsafe impl<T: Send> Send for Worker<T> {}
-
-impl<T> Worker<T> {
-    /// Returns the number of elements in the deque.
-    ///
-    /// If used concurrently with other operations, the returned number is just an estimate.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use coco::deque;
-    ///
-    /// let (w, _) = deque::new();
-    /// for i in 0..30 {
-    ///     w.push(i);
-    /// }
-    /// assert_eq!(w.len(), 30);
-    /// ```
-    pub fn len(&self) -> usize {
-        self.deque.len()
-    }
-
-    /// Pushes an element onto the bottom of the deque.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use coco::deque;
-    ///
-    /// let (w, _) = deque::new();
-    /// w.push(1);
-    /// w.push(2);
-    /// ```
-    pub fn push(&self, value: T) {
-        self.deque.push(value);
-    }
-
-    /// Pops an element from the bottom of the deque.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use coco::deque;
-    ///
-    /// let (w, _) = deque::new();
-    /// w.push(1);
-    /// w.push(2);
-    ///
-    /// assert_eq!(w.pop(), Some(2));
-    /// assert_eq!(w.pop(), Some(1));
-    /// assert_eq!(w.pop(), None);
-    /// ```
-    pub fn pop(&self) -> Option<T> {
-        self.deque.pop()
-    }
-
-    /// Steals an element from the top of the deque.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use coco::deque;
-    ///
-    /// let (w, _) = deque::new();
-    /// w.push(1);
-    /// w.push(2);
-    ///
-    /// assert_eq!(w.steal(), Some(1));
-    /// assert_eq!(w.steal(), Some(2));
-    /// assert_eq!(w.steal(), None);
-    /// ```
-    pub fn steal(&self) -> Option<T> {
-        self.deque.steal_as_worker()
-    }
-}
-
-impl<T> fmt::Debug for Worker<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Worker {{ ... }}")
-    }
-}
-
-/// Stealer side of a work-stealing deque.
-///
-/// Stealers may be cloned in order to create more stealers for the same deque.
-pub struct Stealer<T> {
-    deque: Arc<Deque<T>>,
-    _marker: PhantomData<*mut ()>, // !Send + !Sync
-}
-
-unsafe impl<T: Send> Send for Stealer<T> {}
-unsafe impl<T: Send> Sync for Stealer<T> {}
-
-impl<T> Stealer<T> {
-    /// Returns the number of elements in the deque.
-    ///
-    /// If used concurrently with other operations, the returned number is just an estimate.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use coco::deque;
-    ///
-    /// let (w, _) = deque::new();
-    /// for i in 0..30 {
-    ///     w.push(i);
-    /// }
-    /// assert_eq!(w.len(), 30);
-    /// ```
-    pub fn len(&self) -> usize {
-        self.deque.len()
-    }
-
-    /// Steals an element from the top of the deque.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use coco::deque;
-    ///
-    /// let (w, s) = deque::new();
-    /// w.push(1);
-    /// w.push(2);
-    ///
-    /// assert_eq!(s.steal(), Some(1));
-    /// assert_eq!(s.steal(), Some(2));
-    /// assert_eq!(s.steal(), None);
-    /// ```
-    pub fn steal(&self) -> Option<T> {
-        self.deque.steal()
-    }
-}
-
-impl<T> Clone for Stealer<T> {
-    fn clone(&self) -> Self {
-        Stealer {
-            deque: self.deque.clone(),
-            _marker: PhantomData,
-        }
-    }
-}
-
-impl<T> fmt::Debug for Stealer<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Stealer {{ ... }}")
-    }
-}
-
-/// Returns a new work-stealing deque.
-///
-/// The worker is unique, while stealers can be cloned and distributed among multiple threads.
-///
-/// The deque will be destructed as soon as it's worker and all it's stealers get dropped.
-///
-/// # Examples
-///
-/// ```
-/// use coco::deque;
-///
-/// let (w, s1) = deque::new();
-/// let s2 = s1.clone();
-///
-/// w.push('a');
-/// w.push('b');
-/// w.push('c');
-///
-/// assert_eq!(w.pop(), Some('c'));
-/// assert_eq!(s1.steal(), Some('a'));
-/// assert_eq!(s2.steal(), Some('b'));
-/// ```
-pub fn new<T>() -> (Worker<T>, Stealer<T>) {
-    let d = Arc::new(Deque::new());
-    let worker = Worker {
-        deque: d.clone(),
-        _marker: PhantomData,
-    };
-    let stealer = Stealer {
-        deque: d,
-        _marker: PhantomData,
-    };
-    (worker, stealer)
-}
-
-#[cfg(test)]
-mod tests {
-    extern crate rand;
-
-    use std::sync::{Arc, Mutex};
-    use std::sync::atomic::{AtomicBool, AtomicUsize};
-    use std::sync::atomic::Ordering::SeqCst;
-    use std::thread;
-
-    use epoch;
-    use self::rand::Rng;
-
-    #[test]
-    fn smoke() {
-        let (w, s) = super::new();
-        assert_eq!(w.pop(), None);
-        assert_eq!(s.steal(), None);
-        assert_eq!(w.len(), 0);
-        assert_eq!(s.len(), 0);
-
-        w.push(1);
-        assert_eq!(w.len(), 1);
-        assert_eq!(s.len(), 1);
-        assert_eq!(w.pop(), Some(1));
-        assert_eq!(w.pop(), None);
-        assert_eq!(s.steal(), None);
-        assert_eq!(w.len(), 0);
-        assert_eq!(s.len(), 0);
-
-        w.push(2);
-        assert_eq!(s.steal(), Some(2));
-        assert_eq!(s.steal(), None);
-        assert_eq!(w.pop(), None);
-
-        w.push(3);
-        w.push(4);
-        w.push(5);
-        assert_eq!(w.steal(), Some(3));
-        assert_eq!(s.steal(), Some(4));
-        assert_eq!(w.steal(), Some(5));
-        assert_eq!(w.steal(), None);
-    }
-
-    #[test]
-    fn steal_push() {
-        const STEPS: usize = 50_000;
-
-        let (w, s) = super::new();
-        let t = thread::spawn(move || {
-            for i in 0..STEPS {
-                loop {
-                    if let Some(v) = s.steal() {
-                        assert_eq!(i, v);
-                        break;
-                    }
-                }
-            }
-        });
-
-        for i in 0..STEPS {
-            w.push(i);
-        }
-        t.join().unwrap();
-    }
-
-    #[test]
-    fn stampede() {
-        const COUNT: usize = 50_000;
-
-        let (w, s) = super::new();
-
-        for i in 0..COUNT {
-            w.push(Box::new(i + 1));
-        }
-        let remaining = Arc::new(AtomicUsize::new(COUNT));
-
-        let threads = (0..8).map(|_| {
-            let s = s.clone();
-            let remaining = remaining.clone();
-
-            thread::spawn(move || {
-                let mut last = 0;
-                while remaining.load(SeqCst) > 0 {
-                    if let Some(x) = s.steal() {
-                        assert!(last < *x);
-                        last = *x;
-                        remaining.fetch_sub(1, SeqCst);
-                    }
-                }
-            })
-        }).collect::<Vec<_>>();
-
-        let mut last = COUNT + 1;
-        while remaining.load(SeqCst) > 0 {
-            if let Some(x) = w.pop() {
-                assert!(last > *x);
-                last = *x;
-                remaining.fetch_sub(1, SeqCst);
-            }
-        }
-
-        for t in threads {
-            t.join().unwrap();
-        }
-    }
-
-    fn run_stress() {
-        const COUNT: usize = 50_000;
-
-        let (w, s) = super::new();
-        let done = Arc::new(AtomicBool::new(false));
-        let hits = Arc::new(AtomicUsize::new(0));
-
-        let threads = (0..8).map(|_| {
-            let s = s.clone();
-            let done = done.clone();
-            let hits = hits.clone();
-
-            thread::spawn(move || {
-                while !done.load(SeqCst) {
-                    if let Some(_) = s.steal() {
-                        hits.fetch_add(1, SeqCst);
-                    }
-                }
-            })
-        }).collect::<Vec<_>>();
-
-        let mut rng = rand::thread_rng();
-        let mut expected = 0;
-        while expected < COUNT {
-            if rng.gen_range(0, 3) == 0 {
-                if w.pop().is_some() {
-                    hits.fetch_add(1, SeqCst);
-                }
-            } else {
-                w.push(expected);
-                expected += 1;
-            }
-        }
-
-        while hits.load(SeqCst) < COUNT {
-            if w.pop().is_some() {
-                hits.fetch_add(1, SeqCst);
-            }
-        }
-        done.store(true, SeqCst);
-
-        for t in threads {
-            t.join().unwrap();
-        }
-    }
-
-    #[test]
-    fn stress() {
-        run_stress();
-    }
-
-    #[test]
-    fn stress_pinned() {
-        epoch::pin(|_| run_stress());
-    }
-
-    #[test]
-    fn no_starvation() {
-        const COUNT: usize = 50_000;
-
-        let (w, s) = super::new();
-        let done = Arc::new(AtomicBool::new(false));
-
-        let (threads, hits): (Vec<_>, Vec<_>) = (0..8).map(|_| {
-            let s = s.clone();
-            let done = done.clone();
-            let hits = Arc::new(AtomicUsize::new(0));
-
-            let t = {
-                let hits = hits.clone();
-                thread::spawn(move || {
-                    while !done.load(SeqCst) {
-                        if let Some(_) = s.steal() {
-                            hits.fetch_add(1, SeqCst);
-                        }
-                    }
-                })
-            };
-
-            (t, hits)
-        }).unzip();
-
-        let mut rng = rand::thread_rng();
-        let mut my_hits = 0;
-        loop {
-            for i in 0..rng.gen_range(0, COUNT) {
-                if rng.gen_range(0, 3) == 0 && my_hits == 0 {
-                    if w.pop().is_some() {
-                        my_hits += 1;
-                    }
-                } else {
-                    w.push(i);
-                }
-            }
-
-            if my_hits > 0 && hits.iter().all(|h| h.load(SeqCst) > 0) {
-                break;
-            }
-        }
-        done.store(true, SeqCst);
-
-        for t in threads {
-            t.join().unwrap();
-        }
-    }
-
-    #[test]
-    fn destructors() {
-        const COUNT: usize = 50_000;
-
-        struct Elem(usize, Arc<Mutex<Vec<usize>>>);
-
-        impl Drop for Elem {
-            fn drop(&mut self) {
-                self.1.lock().unwrap().push(self.0);
-            }
-        }
-
-        let (w, s) = super::new();
-
-        let dropped = Arc::new(Mutex::new(Vec::new()));
-        let remaining = Arc::new(AtomicUsize::new(COUNT));
-        for i in 0..COUNT {
-            w.push(Elem(i, dropped.clone()));
-        }
-
-        let threads = (0..8).map(|_| {
-            let s = s.clone();
-            let remaining = remaining.clone();
-
-            thread::spawn(move || {
-                for _ in 0..1000 {
-                    if s.steal().is_some() {
-                        remaining.fetch_sub(1, SeqCst);
-                    }
-                }
-            })
-        }).collect::<Vec<_>>();
-
-        for _ in 0..1000 {
-            if w.pop().is_some() {
-                remaining.fetch_sub(1, SeqCst);
-            }
-        }
-
-        for t in threads {
-            t.join().unwrap();
-        }
-
-        let rem = remaining.load(SeqCst);
-        assert!(rem > 0);
-        assert_eq!(w.len(), rem);
-        assert_eq!(s.len(), rem);
-
-        {
-            let mut v = dropped.lock().unwrap();
-            assert_eq!(v.len(), COUNT - rem);
-            v.clear();
-        }
-
-        drop(w);
-        drop(s);
-
-        {
-            let mut v = dropped.lock().unwrap();
-            assert_eq!(v.len(), rem);
-            v.sort();
-            for w in v.windows(2) {
-                assert_eq!(w[0] + 1, w[1]);
-            }
-        }
-    }
-}

deleted file mode 100644
--- a/third_party/rust/coco/src/epoch/atomic.rs
+++ /dev/null
@@ -1,532 +0,0 @@
-use std::mem;
-use std::ptr;
-use std::marker::PhantomData;
-use std::sync::atomic::AtomicUsize;
-use std::sync::atomic::Ordering::{self, AcqRel, Acquire, Release, SeqCst};
-
-use epoch::Pin;
-
-/// Returns a mask containing unused least significant bits of an aligned pointer to `T`.
-fn low_bits<T>() -> usize {
-    (1 << mem::align_of::<T>().trailing_zeros()) - 1
-}
-
-/// Tags the unused least significant bits of `raw` with `tag`.
-///
-/// # Panics
-///
-/// Panics if the tag doesn't fit into the unused bits of the pointer, or if the pointer is
-/// unaligned.
-fn raw_and_tag<T>(raw: *mut T, tag: usize) -> usize {
-    let mask = low_bits::<T>();
-    assert!(raw as usize & mask == 0, "unaligned pointer");
-    assert!(tag <= mask, "tag too large to fit into the unused bits: {} > {}", tag, mask);
-    raw as usize | tag
-}
-
-/// A tagged atomic nullable pointer.
-///
-/// The tag is stored into the unused least significant bits of the pointer. The pointer must be
-/// properly aligned.
-#[derive(Debug)]
-pub struct Atomic<T> {
-    data: AtomicUsize,
-    _marker: PhantomData<*mut T>, // !Send + !Sync
-}
-
-unsafe impl<T: Send + Sync> Send for Atomic<T> {}
-unsafe impl<T: Send + Sync> Sync for Atomic<T> {}
-
-impl<T> Atomic<T> {
-    /// Constructs a tagged atomic pointer from raw data.
-    unsafe fn from_data(data: usize) -> Self {
-        Atomic {
-            data: AtomicUsize::new(data),
-            _marker: PhantomData,
-        }
-    }
-
-    /// Returns a new, null atomic pointer tagged with `tag`.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the tag doesn't fit into the unused bits of an aligned pointer.
-    pub fn null(tag: usize) -> Self {
-        unsafe { Self::from_raw(ptr::null_mut(), tag) }
-    }
-
-    /// Allocates `data` on the heap and returns a new atomic pointer that points to it and is
-    /// tagged with `tag`.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the tag doesn't fit into the unused bits of the pointer, or if the allocated
-    /// pointer is unaligned.
-    pub fn new(data: T, tag: usize) -> Self {
-        unsafe { Self::from_raw(Box::into_raw(Box::new(data)), tag) }
-    }
-
-    /// Returns a new atomic pointer initialized with `ptr`.
-    pub fn from_ptr(ptr: Ptr<T>) -> Self {
-        unsafe { Self::from_data(ptr.data) }
-    }
-
-    /// Returns a new atomic pointer initialized with `b` and `tag`.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the tag doesn't fit into the unused bits of the pointer, or if the pointer is
-    /// unaligned.
-    pub fn from_box(b: Box<T>, tag: usize) -> Self {
-        unsafe { Self::from_raw(Box::into_raw(b), tag) }
-    }
-
-    /// Returns a new atomic pointer initialized with `raw` and `tag`.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the tag doesn't fit into the unused bits of the pointer, or if the pointer is
-    /// unaligned.
-    pub unsafe fn from_raw(raw: *mut T, tag: usize) -> Self {
-        Self::from_data(raw_and_tag(raw, tag))
-    }
-
-    /// Loads the tagged atomic pointer.
-    ///
-    /// This operation uses the `Acquire` ordering.
-    pub fn load<'p>(&self, _: &'p Pin) -> Ptr<'p, T> {
-        unsafe { Ptr::from_data(self.data.load(Acquire)) }
-    }
-
-    /// Loads the tagged atomic pointer as a raw pointer and a tag.
-    ///
-    /// Argument `order` describes the memory ordering of this operation.
-    pub fn load_raw(&self, order: Ordering) -> (*mut T, usize) {
-        let p = unsafe { Ptr::<T>::from_data(self.data.load(order)) };
-        (p.as_raw(), p.tag())
-    }
-
-    /// Stores `new` tagged with `tag` into the atomic.
-    ///
-    /// This operation uses the `Release` ordering.
-    pub fn store<'p>(&self, new: Ptr<'p, T>) {
-        self.data.store(new.data, Release);
-    }
-
-    /// Stores `new` tagged with `tag` into the atomic and returns it.
-    ///
-    /// This operation uses the `Release` ordering.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the tag doesn't fit into the unused bits of the pointer, or if the pointer is
-    /// unaligned.
-    pub fn store_box<'p>(&self, new: Box<T>, tag: usize, _: &'p Pin) -> Ptr<'p, T> {
-        let ptr = unsafe { Ptr::from_raw(Box::into_raw(new), tag) };
-        self.data.store(ptr.data, Release);
-        ptr
-    }
-
-    /// Stores `new` tagged with `tag` into the atomic.
-    ///
-    /// Argument `order` describes the memory ordering of this operation.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the tag doesn't fit into the unused bits of the pointer, or if the pointer is
-    /// unaligned.
-    pub unsafe fn store_raw<'p>(
-        &self,
-        new: *mut T,
-        tag: usize,
-        order: Ordering,
-        _: &'p Pin,
-    ) -> Ptr<'p, T> {
-        let ptr = Ptr::from_raw(new, tag);
-        self.data.store(ptr.data, order);
-        ptr
-    }
-
-    /// Stores `new` into the atomic, returning the old tagged pointer.
-    ///
-    /// This operation uses the `AcqRel` ordering.
-    pub fn swap<'p>(&self, new: Ptr<'p, T>) -> Ptr<'p, T> {
-        unsafe { Ptr::from_data(self.data.swap(new.data, AcqRel)) }
-    }
-
-    /// Stores `new` tagged with `tag` into the atomic, returning the old tagged pointer.
-    ///
-    /// This operation uses the `AcqRel` ordering.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the tag doesn't fit into the unused bits of the pointer, or if the pointer is
-    /// unaligned.
-    pub fn swap_box<'p>(&self, new: Box<T>, tag: usize, _: &'p Pin) -> Ptr<'p, T> {
-        let data = unsafe { Ptr::from_raw(Box::into_raw(new), tag).data };
-        unsafe { Ptr::from_data(self.data.swap(data, AcqRel)) }
-    }
-
-    /// Stores `new` tagged with `tag` into the atomic, returning the old tagged pointer.
-    ///
-    /// Argument `order` describes the memory ordering of this operation.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the tag doesn't fit into the unused bits of the pointer, or if the pointer is
-    /// unaligned.
-    pub unsafe fn swap_raw<'p>(&self, new: *mut T, tag: usize, order: Ordering) -> Ptr<'p, T> {
-        let data = Ptr::from_raw(new, tag).data;
-        Ptr::from_data(self.data.swap(data, order))
-    }
-
-    /// If the tagged atomic pointer is equal to `current`, stores `new`.
-    ///
-    /// The return value is a result indicating whether the new pointer was stored. On failure the
-    /// current value of the tagged atomic pointer is returned.
-    ///
-    /// This operation uses the `AcqRel` ordering.
-    pub fn cas<'p>(
-        &self,
-        current: Ptr<'p, T>,
-        new: Ptr<'p, T>,
-    ) -> Result<(), Ptr<'p, T>> {
-        let previous = self.data.compare_and_swap(current.data, new.data, AcqRel);
-        if previous == current.data {
-            Ok(())
-        } else {
-            unsafe { Err(Ptr::from_data(previous)) }
-        }
-    }
-
-    /// If the tagged atomic pointer is equal to `current`, stores `new`.
-    ///
-    /// The return value is a result indicating whether the new pointer was stored. On failure the
-    /// current value of the tagged atomic pointer is returned.
-    ///
-    /// This operation uses the `SeqCst` ordering.
-    pub fn cas_sc<'p>(&self, current: Ptr<'p, T>, new: Ptr<'p, T>) -> Result<(), Ptr<'p, T>> {
-        let previous = self.data.compare_and_swap(current.data, new.data, SeqCst);
-        if previous == current.data {
-            Ok(())
-        } else {
-            unsafe { Err(Ptr::from_data(previous)) }
-        }
-    }
-
-    /// If the tagged atomic pointer is equal to `current`, stores `new`.
-    ///
-    /// The return value is a result indicating whether the new pointer was stored. On failure the
-    /// current value of the tagged atomic pointer is returned.
-    ///
-    /// This method can sometimes spuriously fail even when comparison succeeds, which can result
-    /// in more efficient code on some platforms.
-    ///
-    /// This operation uses the `AcqRel` ordering.
-    pub fn cas_weak<'p>(&self, current: Ptr<'p, T>, new: Ptr<'p, T>) -> Result<(), Ptr<'p, T>> {
-        match self.data.compare_exchange_weak(current.data, new.data, AcqRel, Acquire) {
-            Ok(_) => Ok(()),
-            Err(previous) => unsafe { Err(Ptr::from_data(previous)) },
-        }
-    }
-
-    /// If the tagged atomic pointer is equal to `current`, stores `new`.
-    ///
-    /// The return value is a result indicating whether the new pointer was stored. On failure the
-    /// current value of the tagged atomic pointer is returned.
-    ///
-    /// This method can sometimes spuriously fail even when comparison succeeds, which can result
-    /// in more efficient code on some platforms.
-    ///
-    /// This operation uses the `SeqCst` ordering.
-    pub fn cas_weak_sc<'p>(
-        &self,
-        current: Ptr<'p, T>,
-        new: Ptr<'p, T>,
-    ) -> Result<(), Ptr<'p, T>> {
-        match self.data.compare_exchange_weak(current.data, new.data, SeqCst, SeqCst) {
-            Ok(_) => Ok(()),
-            Err(previous) => unsafe { Err(Ptr::from_data(previous)) },
-        }
-    }
-
-    /// If the tagged atomic pointer is equal to `current`, stores `new` tagged with `tag`.
-    ///
-    /// The return value is a result indicating whether the new pointer was stored. On success the
-    /// new pointer is returned. On failure the current value of the tagged atomic pointer and
-    /// `new` are returned.
-    ///
-    /// This operation uses the `AcqRel` ordering.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the tag doesn't fit into the unused bits of the pointer, or if the pointer is
-    /// unaligned.
-    pub fn cas_box<'p>(
-        &self,
-        current: Ptr<'p, T>,
-        mut new: Box<T>,
-        tag: usize,
-    ) -> Result<Ptr<'p, T>, (Ptr<'p, T>, Box<T>)> {
-        let new_data = raw_and_tag(new.as_mut(), tag);
-        let previous = self.data.compare_and_swap(current.data, new_data, AcqRel);
-        if previous == current.data {
-            mem::forget(new);
-            unsafe { Ok(Ptr::from_data(new_data)) }
-        } else {
-            unsafe { Err((Ptr::from_data(previous), new)) }
-        }
-    }
-
-    /// If the tagged atomic pointer is equal to `current`, stores `new` tagged with `tag`.
-    ///
-    /// The return value is a result indicating whether the new pointer was stored. On success the
-    /// new pointer is returned. On failure the current value of the tagged atomic pointer and
-    /// `new` are returned.
-    ///
-    /// This operation uses the `SeqCst` ordering.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the tag doesn't fit into the unused bits of the pointer, or if the pointer is
-    /// unaligned.
-    pub fn cas_box_sc<'p>(
-        &self,
-        current: Ptr<'p, T>,
-        mut new: Box<T>,
-        tag: usize,
-    ) -> Result<Ptr<'p, T>, (Ptr<'p, T>, Box<T>)> {
-        let new_data = raw_and_tag(new.as_mut(), tag);
-        let previous = self.data.compare_and_swap(current.data, new_data, SeqCst);
-        if previous == current.data {
-            mem::forget(new);
-            unsafe { Ok(Ptr::from_data(new_data)) }
-        } else {
-            unsafe { Err((Ptr::from_data(previous), new)) }
-        }
-    }
-
-    /// If the tagged atomic pointer is equal to `current`, stores `new` tagged with `tag`.
-    ///
-    /// The return value is a result indicating whether the new pointer was stored. On success the
-    /// new pointer is returned. On failure the current value of the tagged atomic pointer and
-    /// `new` are returned.
-    ///
-    /// This method can sometimes spuriously fail even when comparison succeeds, which can result
-    /// in more efficient code on some platforms.
-    ///
-    /// This operation uses the `AcqRel` ordering.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the tag doesn't fit into the unused bits of the pointer, or if the pointer is
-    /// unaligned.
-    pub fn cas_box_weak<'p>(
-        &self,
-        current: Ptr<'p, T>,
-        mut new: Box<T>,
-        tag: usize
-    ) -> Result<Ptr<'p, T>, (Ptr<'p, T>, Box<T>)> {
-        let new_data = raw_and_tag(new.as_mut(), tag);
-        match self.data.compare_exchange_weak(current.data, new_data, AcqRel, Acquire) {
-            Ok(_) => {
-                mem::forget(new);
-                unsafe { Ok(Ptr::from_data(new_data)) }
-            }
-            Err(previous) => unsafe { Err((Ptr::from_data(previous), new)) },
-        }
-    }
-
-    /// If the tagged atomic pointer is equal to `current`, stores `new` tagged with `tag`.
-    ///
-    /// The return value is a result indicating whether the new pointer was stored. On success the
-    /// new pointer is returned. On failure the current value of the tagged atomic pointer and
-    /// `new` are returned.
-    ///
-    /// This method can sometimes spuriously fail even when comparison succeeds, which can result
-    /// in more efficient code on some platforms.
-    ///
-    /// This operation uses the `AcqRel` ordering.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the tag doesn't fit into the unused bits of the pointer, or if the pointer is
-    /// unaligned.
-    pub fn cas_box_weak_sc<'p>(
-        &self,
-        current: Ptr<'p, T>,
-        mut new: Box<T>,
-        tag: usize,
-    ) -> Result<Ptr<'p, T>, (Ptr<'p, T>, Box<T>)> {
-        let new_data = raw_and_tag(new.as_mut(), tag);
-        match self.data.compare_exchange_weak(current.data, new_data, SeqCst, SeqCst) {
-            Ok(_) => {
-                mem::forget(new);
-                unsafe { Ok(Ptr::from_data(new_data)) }
-            }
-            Err(previous) => unsafe { Err((Ptr::from_data(previous), new)) },
-        }
-    }
-
-    /// If the tagged atomic pointer is equal to `current`, stores `new`.
-    ///
-    /// The return value is a result indicating whether the new pointer was stored. On failure the
-    /// current value of the tagged atomic pointer is returned.
-    ///
-    /// Argument `order` describes the memory ordering of this operation.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the tag doesn't fit into the unused bits of the pointer, or if the pointer is
-    /// unaligned.
-    pub unsafe fn cas_raw(
-        &self,
-        current: (*mut T, usize),
-        new: (*mut T, usize),
-        order: Ordering,
-    ) -> Result<(), (*mut T, usize)> {
-        let current_data = raw_and_tag(current.0, current.1);
-        let new_data = raw_and_tag(new.0, new.1);
-        let previous = self.data.compare_and_swap(current_data, new_data, order);
-        if previous == current_data {
-            Ok(())
-        } else {
-            let ptr = Ptr::from_data(previous);
-            Err((ptr.as_raw(), ptr.tag()))
-        }
-    }
-
-    /// If the tagged atomic pointer is equal to `current`, stores `new`.
-    ///
-    /// The return value is a result indicating whether the new pointer was stored. On failure the
-    /// current value of the tagged atomic pointer is returned.
-    ///
-    /// This method can sometimes spuriously fail even when comparison succeeds, which can result
-    /// in more efficient code on some platforms.
-    ///
-    /// Argument `order` describes the memory ordering of this operation.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the tag doesn't fit into the unused bits of the pointer, or if the pointer is
-    /// unaligned.
-    pub unsafe fn cas_raw_weak(
-        &self,
-        current: (*mut T, usize),
-        new: (*mut T, usize),
-        order: Ordering,
-    ) -> Result<(), (*mut T, usize)> {
-        let current_data = raw_and_tag(current.0, current.1);
-        let new_data = raw_and_tag(new.0, new.1);
-        let previous = self.data.compare_and_swap(current_data, new_data, order);
-        if previous == current_data {
-            Ok(())
-        } else {
-            let ptr = Ptr::from_data(previous);
-            Err((ptr.as_raw(), ptr.tag()))
-        }
-    }
-}
-
-impl<T> Default for Atomic<T> {
-    fn default() -> Self {
-        Atomic {
-            data: AtomicUsize::new(0),
-            _marker: PhantomData,
-        }
-    }
-}
-
-/// A tagged nullable pointer.
-#[derive(Debug)]
-pub struct Ptr<'p, T: 'p> {
-    data: usize,
-    _marker: PhantomData<(*mut T, &'p T)>, // !Send + !Sync
-}
-
-impl<'a, T> Clone for Ptr<'a, T> {
-    fn clone(&self) -> Self {
-        Ptr {
-            data: self.data,
-            _marker: PhantomData,
-        }
-    }
-}
-
-impl<'a, T> Copy for Ptr<'a, T> {}
-
-impl<'p, T: 'p> Ptr<'p, T> {
-    /// Constructs a nullable pointer from raw data.
-    unsafe fn from_data(data: usize) -> Self {
-        Ptr {
-            data: data,
-            _marker: PhantomData,
-        }
-    }
-
-    /// Returns a null pointer with a tag.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the tag doesn't fit into the unused bits of an aligned pointer.
-    pub fn null(tag: usize) -> Self {
-        unsafe { Self::from_data(raw_and_tag::<T>(ptr::null_mut(), tag)) }
-    }
-
-    /// Constructs a tagged pointer from a raw pointer and tag.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the tag doesn't fit into the unused bits of the pointer, or if the pointer is
-    /// unaligned.
-    pub unsafe fn from_raw(raw: *mut T, tag: usize) -> Self {
-        Self::from_data(raw_and_tag(raw, tag))
-    }
-
-    /// Returns `true` if the pointer is null.
-    pub fn is_null(&self) -> bool {
-        self.as_raw().is_null()
-    }
-
-    /// Converts the pointer to a reference.
-    pub fn as_ref(&self) -> Option<&'p T> {
-        unsafe { self.as_raw().as_ref() }
-    }
-
-    /// Converts the pointer to a raw pointer.
-    pub fn as_raw(&self) -> *mut T {
-        (self.data & !low_bits::<T>()) as *mut T
-    }
-
-    /// Returns a reference to the pointing object.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the pointer is null.
-    pub fn unwrap(&self) -> &'p T {
-        self.as_ref().unwrap()
-    }
-
-    /// Returns the tag.
-    pub fn tag(&self) -> usize {
-        self.data & low_bits::<T>()
-    }
-
-    /// Constructs a new tagged pointer with a different tag.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the tag doesn't fit into the unused bits of the pointer.
-    pub fn with_tag(&self, tag: usize) -> Self {
-        unsafe { Self::from_raw(self.as_raw(), tag) }
-    }
-}
-
-impl<'p, T> Default for Ptr<'p, T> {
-    fn default() -> Self {
-        Ptr {
-            data: 0,
-            _marker: PhantomData,
-        }
-    }
-}

deleted file mode 100644
--- a/third_party/rust/coco/src/epoch/garbage.rs
+++ /dev/null
@@ -1,736 +0,0 @@
-//! Garbage collection.
-//!
-//! # Bags and garbage queues
-//!
-//! Objects that get removed from concurrent data structures must be stashed away until the global
-//! epoch sufficiently advances so that they become safe for destruction. Pointers to such garbage
-//! objects are kept in bags.
-//!
-//! When a bag becomes full, it is marked with the current global epoch pushed into a `Garbage`
-//! queue. Usually each instance of concurrent data structure has it's own `Garbage` queue that
-//! gets fully destroyed as soon as the data structure gets dropped.
-//!
-//! Whenever a bag is pushed into the queue, some garbage is collected and destroyed along the way.
-//! Garbage collection can also be manually triggered by calling method `collect`.
-//!
-//! # The global garbage queue
-//!
-//! Some data structures don't own objects but merely transfer them between threads, e.g. queues.
-//! As such, queues don't execute destructors - they only allocate and free some memory. it would
-//! be costly for each queue to handle it's own `Garbage`, so there is a special global queue all
-//! data structures can share.
-//!
-//! The global garbage queue is very efficient. Each thread has a thread-local bag that is
-//! populated with garbage, and when it becomes full, it is finally pushed into queue. This design
-//! reduces contention on data structures. The global queue cannot be explicitly accessed - the
-//! only way to interact with it is by calling function `defer_free`.
-
-use std::cell::UnsafeCell;
-use std::cmp;
-use std::fmt;
-use std::mem;
-use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT};
-use std::sync::atomic::Ordering::{AcqRel, Acquire, Relaxed, SeqCst};
-
-use epoch::{self, Atomic, Pin, Ptr};
-
-/// Maximum number of objects a bag can contain.
-#[cfg(not(feature = "strict_gc"))]
-const MAX_OBJECTS: usize = 64;
-#[cfg(feature = "strict_gc")]
-const MAX_OBJECTS: usize = 4;
-
-/// The global epoch.
-///
-/// The last bit in this number is unused and is always zero. Every so often the global epoch is
-/// incremented, i.e. we say it "advances". A pinned thread may advance the global epoch only if
-/// all currently pinned threads have been pinned in the current epoch.
-///
-/// If an object became garbage in some epoch, then we can be sure that after two advancements no
-/// thread will hold a reference to it. That is the crux of safe memory reclamation.
-pub static EPOCH: AtomicUsize = ATOMIC_USIZE_INIT;
-
-/// Holds removed objects that will be eventually destroyed.
-pub struct Bag {
-    /// Number of objects in the bag.
-    len: AtomicUsize,
-    /// Removed objects.
-    objects: [UnsafeCell<(unsafe fn(*mut u8, usize), *mut u8, usize)>; MAX_OBJECTS],
-    /// The global epoch at the moment when this bag got pushed into the queue.
-    epoch: usize,
-    /// The next bag in the queue.
-    next: Atomic<Bag>,
-}
-
-impl Bag {
-    /// Returns a new, empty bag.
-    pub fn new() -> Self {
-        Bag {
-            len: AtomicUsize::new(0),
-            objects: unsafe { mem::zeroed() },
-            epoch: unsafe { mem::uninitialized() },
-            next: Atomic::null(0),
-        }
-    }
-
-    /// Returns `true` if the bag is empty.
-    pub fn is_empty(&self) -> bool {
-        self.len.load(Relaxed) == 0
-    }
-
-    /// Attempts to insert a garbage object into the bag and returns `true` if succeeded.
-    pub fn try_insert<T>(&self, destroy: unsafe fn(*mut T, usize), object: *mut T, count: usize)
-                         -> bool {
-        // Erase type `*mut T` and use `*mut u8` instead.
-        let destroy: unsafe fn(*mut u8, usize) = unsafe { mem::transmute(destroy) };
-        let object = object as *mut u8;
-
-        let mut len = self.len.load(Acquire);
-        loop {
-            // Is the bag full?
-            if len == self.objects.len() {
-                return false;
-            }
-
-            // Try incrementing `len`.
-            match self.len.compare_exchange(len, len + 1, AcqRel, Acquire) {
-                Ok(_) => {
-                    // Success! Now store the garbage object into the array. The current thread
-                    // will synchronize with the thread that destroys it through epoch advancement.
-                    unsafe { *self.objects[len].get() = (destroy, object, count) }
-                    return true;
-                }
-                Err(l) => len = l,
-            }
-        }
-    }
-
-    /// Destroys all objects in the bag.
-    ///
-    /// Note: can be called only once!
-    unsafe fn destroy_all_objects(&self) {
-        for cell in self.objects.iter().take(self.len.load(Relaxed)) {
-            let (destroy, object, count) = *cell.get();
-            destroy(object, count);
-        }
-    }
-}
-
-/// A garbage queue.
-///
-/// This is where a concurrent data structure can store removed objects for deferred destruction.
-///
-/// Stored garbage objects are first kept in the garbage buffer. When the buffer becomes full, it's
-/// objects are flushed into the garbage queue. Flushing can be manually triggered by calling
-/// [`flush`].
-///
-/// Some garbage in the queue can be manually collected by calling [`collect`].
-///
-/// [`flush`]: method.flush.html
-/// [`collect`]: method.collect.html
-pub struct Garbage {
-    /// Head of the queue.
-    head: Atomic<Bag>,
-    /// Tail of the queue.
-    tail: Atomic<Bag>,
-    /// The next bag that will be pushed into the queue as soon as it gets full.
-    pending: Atomic<Bag>,
-}
-
-unsafe impl Send for Garbage {}
-unsafe impl Sync for Garbage {}
-
-impl Garbage {
-    /// Returns a new, empty garbage queue.
-    pub fn new() -> Self {
-        let garbage = Garbage {
-            head: Atomic::null(0),
-            tail: Atomic::null(0),
-            pending: Atomic::null(0),
-        };
-
-        // This code may be executing while a thread harness is initializing, so normal pinning
-        // would try to access it while it is being initialized. Such accesses fail with a panic.
-        // We must therefore cheat by creating a fake pin.
-        let pin = unsafe { &mem::zeroed::<Pin>() };
-
-        // The head of the queue is always a sentinel entry.
-        let sentinel = garbage.head.store_box(Box::new(Bag::new()), 0, pin);
-        garbage.tail.store(sentinel);
-
-        garbage
-    }
-
-    /// Attempts to compare-and-swap the pending bag `old` with a new, empty one.
-    ///
-    /// The return value is a result indicating whether the compare-and-swap successfully installed
-    /// a new bag. On success the new bag is returned. On failure the current more up-to-date
-    /// pending bag is returned.
-    fn replace_pending<'p>(&self, old: Ptr<'p, Bag>, pin: &'p Pin)
-                           -> Result<Ptr<'p, Bag>, Ptr<'p, Bag>> {
-        match self.pending.cas_box(old, Box::new(Bag::new()), 0) {
-            Ok(new) => {
-                if !old.is_null() {
-                    // Push the old bag into the queue.
-                    let bag = unsafe { Box::from_raw(old.as_raw()) };
-                    self.push(bag, pin);
-                }
-
-                // Spare some cycles on garbage collection.
-                // Note: This may itself produce garbage and allocate new bags.
-                epoch::thread::try_advance(pin);
-                self.collect(pin);
-
-                Ok(new)
-            }
-            Err((pending, _)) => Err(pending),
-        }
-    }
-
-    /// Adds an object that will later be freed.
-    ///
-    /// The specified object is an array allocated at address `object` and consists of `count`
-    /// elements of type `T`.
-    ///
-    /// This method inserts the object into the garbage buffer. When the buffers becomes full, it's
-    /// objects are flushed into the garbage queue.
-    pub unsafe fn defer_free<T>(&self, object: *mut T, count: usize, pin: &Pin) {
-        unsafe fn free<T>(ptr: *mut T, count: usize) {
-            // Free the memory, but don't run the destructors.
-            drop(Vec::from_raw_parts(ptr, 0, count));
-        }
-        self.defer_destroy(free, object, count, pin);
-    }
-
-    /// Adds an object that will later be dropped and freed.
-    ///
-    /// The specified object is an array allocated at address `object` and consists of `count`
-    /// elements of type `T`.
-    ///
-    /// This method inserts the object into the garbage buffer. When the buffers becomes full, it's
-    /// objects are flushed into the garbage queue.
-    ///
-    /// Note: The object must be `Send + 'self`.
-    pub unsafe fn defer_drop<T>(&self, object: *mut T, count: usize, pin: &Pin) {
-        unsafe fn destruct<T>(ptr: *mut T, count: usize) {
-            // Run the destructors and free the memory.
-            drop(Vec::from_raw_parts(ptr, count, count));
-        }
-        self.defer_destroy(destruct, object, count, pin);
-    }
-
-    /// Adds an object that will later be destroyed using `destroy`.
-    ///
-    /// The specified object is an array allocated at address `object` and consists of `count`
-    /// elements of type `T`.
-    ///
-    /// This method inserts the object into the garbage buffer. When the buffers becomes full, it's
-    /// objects are flushed into the garbage queue.
-    ///
-    /// Note: The object must be `Send + 'self`.
-    pub unsafe fn defer_destroy<T>(
-        &self,
-        destroy: unsafe fn(*mut T, usize),
-        object: *mut T,
-        count: usize,
-        pin: &Pin
-    ) {
-        let mut pending = self.pending.load(pin);
-        loop {
-            match pending.as_ref() {
-                Some(p) if p.try_insert(destroy, object, count) => break,
-                _ => {
-                    match self.replace_pending(pending, pin) {
-                        Ok(p) => pending = p,
-                        Err(p) => pending = p,
-                    }
-                }
-            }
-        }
-    }
-
-    /// Flushes the buffered garbage.
-    ///
-    /// It is wise to flush the garbage just after passing a very large object to one of the
-    /// `defer_*` methods, so that it isn't sitting in the buffer for a long time.
-    pub fn flush(&self, pin: &Pin) {
-        let mut pending = self.pending.load(pin);
-        loop {
-            match pending.as_ref() {
-                None => break,
-                Some(p) => {
-                    if p.is_empty() {
-                        // The bag is already empty.
-                        break;
-                    } else {
-                        match self.replace_pending(pending, pin) {
-                            Ok(_) => break,
-                            Err(p) => pending = p,
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    /// Collects some garbage from the queue and destroys it.
-    ///
-    /// Generally speaking, it's not necessary to call this method because garbage production
-    /// already triggers garbage destruction. However, if there are long periods without garbage
-    /// production, it might be a good idea to call this method from time to time.
-    ///
-    /// This method collects several buffers worth of garbage objects.
-    pub fn collect(&self, pin: &Pin) {
-        /// Number of bags to destroy.
-        const COLLECT_STEPS: usize = 8;
-
-        let epoch = EPOCH.load(SeqCst);
-        let condition = |bag: &Bag| {
-            // A pinned thread can witness at most one epoch advancement. Therefore, any bag that
-            // is within one epoch of the current one cannot be destroyed yet.
-            let diff = epoch.wrapping_sub(bag.epoch);
-            cmp::min(diff, 0usize.wrapping_sub(diff)) > 2
-        };
-
-        for _ in 0..COLLECT_STEPS {
-            match self.try_pop_if(&condition, pin) {
-                None => break,
-                Some(bag) => unsafe { bag.destroy_all_objects() },
-            }
-        }
-    }
-
-    /// Pushes a bag into the queue.
-    fn push(&self, mut bag: Box<Bag>, pin: &Pin) {
-        // Mark the bag with the current epoch.
-        bag.epoch = EPOCH.load(SeqCst);
-
-        let mut tail = self.tail.load(pin);
-        loop {
-            let next = tail.unwrap().next.load(pin);
-            if next.is_null() {
-                // Try installing the new bag.
-                match tail.unwrap().next.cas_box(next, bag, 0) {
-                    Ok(bag) => {
-                        // Tail pointer shouldn't fall behind. Let's move it forward.
-                        let _ = self.tail.cas(tail, bag);
-                        break;
-                    }
-                    Err((t, b)) => {
-                        tail = t;
-                        bag = b;
-                    }
-                }
-            } else {
-                // This is not the actual tail. Move the tail pointer forward.
-                match self.tail.cas(tail, next) {
-                    Ok(()) => tail = next,
-                    Err(t) => tail = t,
-                }
-            }
-        }
-    }
-
-    /// Attempts to pop a bag from the front of the queue and returns it if `condition` is met.
-    ///
-    /// If the bag in the front doesn't meet it or if the queue is empty, `None` is returned.
-    fn try_pop_if<'p, F>(&self, condition: F, pin: &'p Pin) -> Option<&'p Bag>
-        where F: Fn(&Bag) -> bool
-    {
-        let mut head = self.head.load(pin);
-        loop {
-            let next = head.unwrap().next.load(pin);
-            match next.as_ref() {
-                Some(n) if condition(n) => {
-                    // Try moving the head forward.
-                    match self.head.cas(head, next) {
-                        Ok(()) => {
-                            // The old head may be later freed.
-                            unsafe { epoch::defer_free(head.as_raw(), 1, pin) }
-                            // The new head holds the popped value (heads are sentinels!).
-                            return Some(n);
-                        }
-                        Err(h) => head = h,
-                    }
-                }
-                None | Some(_) => return None,
-            }
-        }
-    }
-}
-
-impl Drop for Garbage {
-    fn drop(&mut self) {
-        unsafe {
-            // Load the pending bag, then destroy it and all it's objects.
-            let pending = self.pending.load_raw(Relaxed).0;
-            if !pending.is_null() {
-                (*pending).destroy_all_objects();
-                drop(Vec::from_raw_parts(pending, 0, 1));
-            }
-
-            // Destroy all bags and objects in the queue.
-            let mut head = self.head.load_raw(Relaxed).0;
-            loop {
-                // Load the next bag and destroy the current head.
-                let next = (*head).next.load_raw(Relaxed).0;
-                drop(Vec::from_raw_parts(head, 0, 1));
-
-                // If the next node is null, we've reached the end of the queue.
-                if next.is_null() {
-                    break;
-                }
-
-                // Move one step forward.
-                head = next;
-
-                // Destroy all objects in this bag.
-                // The bag itself will be destroyed in the next iteration of the loop.
-                (*head).destroy_all_objects();
-            }
-        }
-    }
-}
-
-impl fmt::Debug for Garbage {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Garbage {{ ... }}")
-    }
-}
-
-/// Returns a reference to a global garbage, which is lazily initialized.
-fn global() -> &'static Garbage {
-    static GLOBAL: AtomicUsize = ATOMIC_USIZE_INIT;
-
-    let current = GLOBAL.load(Acquire);
-
-    let garbage = if current == 0 {
-        // Initialize the singleton.
-        let raw = Box::into_raw(Box::new(Garbage::new()));
-        let new = raw as usize;
-        let previous = GLOBAL.compare_and_swap(0, new, AcqRel);
-
-        if previous == 0 {
-            // Ok, we initialized it.
-            new
-        } else {
-            // Another thread has already initialized it.
-            unsafe { drop(Box::from_raw(raw)); }
-            previous
-        }
-    } else {
-        current
-    };
-
-    unsafe { &*(garbage as *const Garbage) }
-}
-
-/// Pushes a bag into the global garbage.
-pub fn push(bag: Box<Bag>, pin: &Pin) {
-    global().push(bag, pin);
-}
-
-/// Collects several bags from the global queue and destroys their objects.
-pub fn collect(pin: &Pin) {
-    global().collect(pin);
-}
-
-/// Destroys the global garbage.
-///
-/// # Safety
-///
-/// This function may only be called at the very end of the main thread, and only if the main
-/// thread has never been pinned.
-#[cfg(feature = "internals")]
-pub unsafe fn destroy_global() {
-    let global = global() as *const Garbage as *mut Garbage;
-    drop(Box::from_raw(global));
-}
-
-#[cfg(test)]
-mod tests {
-    extern crate rand;
-
-    use std::mem;
-    use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT};
-    use std::sync::atomic::Ordering::SeqCst;
-    use std::sync::Arc;
-    use std::thread;
-
-    use self::rand::{Rng, thread_rng};
-
-    use super::Garbage;
-    use ::epoch;
-
-    #[test]
-    fn smoke() {
-        let g = Garbage::new();
-        epoch::pin(|pin| {
-            let a = Box::into_raw(Box::new(7));
-            unsafe { g.defer_free(a, 1, pin) }
-            assert!(!g.pending.load(pin).unwrap().is_empty());
-        });
-    }
-
-    #[test]
-    fn flush_pending() {
-        let g = Garbage::new();
-        let mut rng = thread_rng();
-
-        for _ in 0..100_000 {
-            epoch::pin(|pin| unsafe {
-                let a = Box::into_raw(Box::new(7));
-                g.defer_drop(a, 1, pin);
-
-                if rng.gen_range(0, 100) == 0 {
-                    g.flush(pin);
-                    assert!(g.pending.load(pin).unwrap().is_empty());
-                }
-            });
-        }
-    }
-
-    #[test]
-    fn incremental() {
-        const COUNT: usize = 100_000;
-        static DESTROYS: AtomicUsize = ATOMIC_USIZE_INIT;
-
-        let g = Garbage::new();
-
-        epoch::pin(|pin| unsafe {
-            for _ in 0..COUNT {
-                let a = Box::into_raw(Box::new(7i32));
-                unsafe fn destroy(ptr: *mut i32, count: usize) {
-                    drop(Box::from_raw(ptr));
-                    DESTROYS.fetch_add(count, SeqCst);
-                }
-                g.defer_destroy(destroy, a, 1, pin);
-            }
-            g.flush(pin);
-        });
-
-        let mut last = 0;
-
-        while last < COUNT {
-            let curr = DESTROYS.load(SeqCst);
-            assert!(curr - last < 1000);
-            last = curr;
-
-            epoch::pin(|pin| g.collect(pin));
-        }
-        assert!(DESTROYS.load(SeqCst) == COUNT);
-    }
-
-    #[test]
-    fn buffering() {
-        const COUNT: usize = 10;
-        static DESTROYS: AtomicUsize = ATOMIC_USIZE_INIT;
-
-        let g = Garbage::new();
-
-        epoch::pin(|pin| unsafe {
-            for _ in 0..COUNT {
-                let a = Box::into_raw(Box::new(7i32));
-                unsafe fn destroy(ptr: *mut i32, count: usize) {
-                    drop(Box::from_raw(ptr));
-                    DESTROYS.fetch_add(count, SeqCst);
-                }
-                g.defer_destroy(destroy, a, 1, pin);
-            }
-        });
-
-        for _ in 0..100_000 {
-            epoch::pin(|pin| {
-                g.collect(pin);
-                assert!(DESTROYS.load(SeqCst) < COUNT);
-            });
-        }
-        epoch::pin(|pin| g.flush(pin));
-
-        while DESTROYS.load(SeqCst) < COUNT {
-            epoch::pin(|pin| g.collect(pin));
-        }
-        assert_eq!(DESTROYS.load(SeqCst), COUNT);
-    }
-
-    #[test]
-    fn count_drops() {
-        const COUNT: usize = 100_000;
-        static DROPS: AtomicUsize = ATOMIC_USIZE_INIT;
-
-        struct Elem(i32);
-
-        impl Drop for Elem {
-            fn drop(&mut self) {
-                DROPS.fetch_add(1, SeqCst);
-            }
-        }
-
-        let g = Garbage::new();
-
-        epoch::pin(|pin| unsafe {
-            for _ in 0..COUNT {
-                let a = Box::into_raw(Box::new(Elem(7i32)));
-                g.defer_drop(a, 1, pin);
-            }
-            g.flush(pin);
-        });
-
-        while DROPS.load(SeqCst) < COUNT {
-            epoch::pin(|pin| g.collect(pin));
-        }
-        assert_eq!(DROPS.load(SeqCst), COUNT);
-    }
-
-    #[test]
-    fn count_destroy() {
-        const COUNT: usize = 100_000;
-        static DESTROYS: AtomicUsize = ATOMIC_USIZE_INIT;
-
-        let g = Garbage::new();
-
-        epoch::pin(|pin| unsafe {
-            for _ in 0..COUNT {
-                let a = Box::into_raw(Box::new(7i32));
-                unsafe fn destroy(ptr: *mut i32, count: usize) {
-                    drop(Box::from_raw(ptr));
-                    DESTROYS.fetch_add(count, SeqCst);
-                }
-                g.defer_destroy(destroy, a, 1, pin);
-            }
-            g.flush(pin);
-        });
-
-        while DESTROYS.load(SeqCst) < COUNT {
-            epoch::pin(|pin| g.collect(pin));
-        }
-        assert_eq!(DESTROYS.load(SeqCst), COUNT);
-    }
-
-    #[test]
-    fn drop_array() {
-        const COUNT: usize = 700;
-        static DROPS: AtomicUsize = ATOMIC_USIZE_INIT;
-
-        struct Elem(i32);
-
-        impl Drop for Elem {
-            fn drop(&mut self) {
-                DROPS.fetch_add(1, SeqCst);
-            }
-        }
-
-        let g = Garbage::new();
-
-        epoch::pin(|pin| unsafe {
-            let mut v = Vec::with_capacity(COUNT);
-            for i in 0..COUNT {
-                v.push(Elem(i as i32));
-            }
-
-            g.defer_drop(v.as_mut_ptr(), v.len(), pin);
-            g.flush(pin);
-
-            mem::forget(v);
-        });
-
-        while DROPS.load(SeqCst) < COUNT {
-            epoch::pin(|pin| g.collect(pin));
-        }
-        assert_eq!(DROPS.load(SeqCst), COUNT);
-    }
-
-    #[test]
-    fn destroy_array() {
-        const COUNT: usize = 100_000;
-        static DESTROYS: AtomicUsize = ATOMIC_USIZE_INIT;
-
-        let g = Garbage::new();
-
-        epoch::pin(|pin| unsafe {
-            let mut v = Vec::with_capacity(COUNT);
-            for i in 0..COUNT {
-                v.push(i as i32);
-            }
-
-            unsafe fn destroy(ptr: *mut i32, count: usize) {
-                assert!(count == COUNT);
-                drop(Vec::from_raw_parts(ptr, count, count));
-                DESTROYS.fetch_add(count, SeqCst);
-            }
-            g.defer_destroy(destroy, v.as_mut_ptr(), v.len(), pin);
-            g.flush(pin);
-
-            mem::forget(v);
-        });
-
-        while DESTROYS.load(SeqCst) < COUNT {
-            epoch::pin(|pin| g.collect(pin));
-        }
-        assert_eq!(DESTROYS.load(SeqCst), COUNT);
-    }
-
-    #[test]
-    fn drop_garbage() {
-        const COUNT: usize = 100_000;
-        static DROPS: AtomicUsize = ATOMIC_USIZE_INIT;
-
-        struct Elem(i32);
-
-        impl Drop for Elem {
-            fn drop(&mut self) {
-                DROPS.fetch_add(1, SeqCst);
-            }
-        }
-
-        let g = Garbage::new();
-
-        epoch::pin(|pin| unsafe {
-            for _ in 0..COUNT {
-                let a = Box::into_raw(Box::new(Elem(7i32)));
-                g.defer_drop(a, 1, pin);
-            }
-            g.flush(pin);
-        });
-
-        drop(g);
-        assert_eq!(DROPS.load(SeqCst), COUNT);
-    }
-
-    #[test]
-    fn stress() {
-        const THREADS: usize = 8;
-        const COUNT: usize = 100_000;
-        static DROPS: AtomicUsize = ATOMIC_USIZE_INIT;
-
-        struct Elem(i32);
-
-        impl Drop for Elem {
-            fn drop(&mut self) {
-                DROPS.fetch_add(1, SeqCst);
-            }
-        }
-
-        let g = Arc::new(Garbage::new());
-
-        let threads = (0..THREADS).map(|_| {
-            let g = g.clone();
-
-            thread::spawn(move || {
-                for _ in 0..COUNT {
-                    epoch::pin(|pin| unsafe {
-                        let a = Box::into_raw(Box::new(Elem(7i32)));
-                        g.defer_drop(a, 1, pin);
-                    });
-                }
-            })
-        }).collect::<Vec<_>>();
-
-        for t in threads {
-            t.join().unwrap();
-        }
-
-        drop(g);
-        assert_eq!(DROPS.load(SeqCst), COUNT * THREADS);
-    }
-}

deleted file mode 100644
--- a/third_party/rust/coco/src/epoch/mod.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-//! Epoch-based garbage collection.
-//!
-//! # Pointers
-//!
-//! Concurrent collections are built using atomic pointers. This module provides [`Atomic`], which
-//! is just a shared atomic pointer to a heap-allocated object. Loading an [`Atomic`] yields a
-//! [`Ptr`], which is an epoch-protected pointer through which the loaded object can be safely
-//! read.
-//!
-//! # Pinning
-//!
-//! Before an [`Atomic`] can be loaded, the current thread must be pinned. By pinning a thread we
-//! declare that any object that gets removed from now on must not be destructed just yet. Garbage
-//! collection of newly removed objects is suspended until the thread gets unpinned.
-//!
-//! # Garbage
-//!
-//! Objects that get removed from concurrent collections must be stashed away until all currently
-//! pinned threads get unpinned. Such objects can be stored into a [`Garbage`], where they are kept
-//! until the right time for their destruction comes.
-//!
-//! There is a global shared instance of [`Garbage`], which can only deallocate memory. It cannot
-//! drop objects or run arbitrary destruction procedures. Removed objects can be stored into it by
-//! calling [`defer_free`].
-//!
-//! [`Atomic`]: struct.Atomic.html
-//! [`Garbage`]: struct.Garbage.html
-//! [`Ptr`]: struct.Ptr.html
-//! [`defer_free`]: fn.defer_free.html
-
-mod atomic;
-mod garbage;
-mod thread;
-
-pub use self::atomic::{Atomic, Ptr};
-pub use self::garbage::Garbage;
-pub use self::thread::{Pin, defer_free, flush, is_pinned, pin};
-
-#[cfg(feature = "internals")]
-pub use self::garbage::destroy_global;

deleted file mode 100644
--- a/third_party/rust/coco/src/epoch/thread.rs
+++ /dev/null
@@ -1,462 +0,0 @@
-//! Thread synchronization and pinning.
-//!
-//! # Registration
-//!
-//! In order to track all threads in one place, we need some form of thread registration. Every
-//! thread has a thread-local so-called "harness" that registers it the first time it is pinned,
-//! and unregisters when it exits.
-//!
-//! Registered threads are tracked in a global lock-free singly-linked list of thread entries. The
-//! head of this list is accessed by calling the `participants` function.
-//!
-//! # Thread entries
-//!
-//! Thread entries are implemented as the `Thread` data type. Every entry contains an integer that
-//! tells whether the thread is pinned and if so, what was the global epoch at the time it was
-//! pinned. Entries also hold a pin counter that aids in periodic global epoch advancement.
-
-use std::cell::Cell;
-use std::mem;
-use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT};
-use std::sync::atomic::Ordering::{Relaxed, Release, SeqCst};
-
-use epoch::Atomic;
-use epoch::garbage::{self, Bag, EPOCH};
-
-thread_local! {
-    /// The thread registration harness.
-    ///
-    /// The harness is lazily initialized on it's first use. Initialization performs registration.
-    /// If initialized, the harness will get destructed on thread exit, which in turn unregisters
-    /// the thread.
-    static HARNESS: Harness = Harness {
-        thread: Thread::register(),
-        is_pinned: Cell::new(false),
-        pin_count: Cell::new(0),
-        bag: Cell::new(Box::into_raw(Box::new(Bag::new()))),
-    };
-}
-
-/// Holds thread-local data and unregisters the thread when dropped.
-struct Harness {
-    /// This thread's entry in the participants list.
-    thread: *const Thread,
-    /// Whether the thread is currently pinned.
-    is_pinned: Cell<bool>,
-    /// Total number of pinnings performed.
-    pin_count: Cell<usize>,
-    /// The local bag of objects that will be later freed.
-    bag: Cell<*mut Bag>,
-}
-
-impl Drop for Harness {
-    fn drop(&mut self) {
-        // Now that the thread is exiting, we must move the local bag into the global garbage
-        // queue. Also, let's try advancing the epoch and help free some garbage.
-        let thread = unsafe { &*self.thread };
-
-        // If we called `pin()` here, it would try to access `HARNESS` and then panic.
-        // To work around the problem, we manually pin the thread.
-        let pin = &Pin { bag: &self.bag };
-        thread.set_pinned(pin);
-
-        // Spare some cycles on garbage collection.
-        // Note: This may itself produce garbage and in turn allocate new bags.
-        try_advance(pin);
-        garbage::collect(pin);
-
-        // Push the local bag into the global garbage queue.
-        let bag = unsafe { Box::from_raw(self.bag.get()) };
-        garbage::push(bag, pin);
-
-        // Manually unpin the thread.
-        thread.set_unpinned();
-
-        // Mark the thread entry as deleted.
-        thread.unregister();
-    }
-}
-
-/// An entry in the linked list of participating threads.
-struct Thread {
-    /// The least significant bit is set if the thread is currently pinned. The rest of the bits
-    /// encode the current epoch.
-    state: AtomicUsize,
-    /// The next thread in the linked list of participants. If the tag is 1, this entry is deleted
-    /// and can be unlinked from the list.
-    next: Atomic<Thread>,
-}
-
-impl Thread {
-    /// Marks the thread as pinned.
-    ///
-    /// Must not be called if the thread is already pinned!
-    #[inline]
-    fn set_pinned(&self, _pin: &Pin) {
-        let epoch = EPOCH.load(Relaxed);
-        let state = epoch | 1;
-
-        // Now we must store `state` into `self.state`. It's important that any succeeding loads
-        // don't get reordered with this store. In order words, this thread's epoch must be fully
-        // announced to other threads. Only then it becomes safe to load from the shared memory.
-        if cfg!(any(target_arch = "x86", target_arch = "x86_64")) {
-            // On x86 architectures we have a choice:
-            // 1. `atomic::fence(SeqCst)`, which compiles to a `mfence` instruction.
-            // 2. `compare_and_swap(_, _, SeqCst)`, which compiles to a `lock cmpxchg` instruction.
-            //
-            // Both instructions have the effect of a full barrier, but the second one seems to be
-            // faster in this particular case.
-            let previous = self.state.load(Relaxed);
-            self.state.compare_and_swap(previous, state, SeqCst);
-        } else {
-            self.state.store(state, Relaxed);
-            ::std::sync::atomic::fence(SeqCst);
-        }
-    }
-
-    /// Marks the thread as unpinned.
-    #[inline]
-    fn set_unpinned(&self) {
-        // Clear the last bit.
-        // We don't need to preserve the epoch, so just store the number zero.
-        self.state.store(0, Release);
-    }
-
-    /// Registers a thread by adding a new entry to the list of participanting threads.
-    ///
-    /// Returns a pointer to the newly allocated entry.
-    fn register() -> *mut Thread {
-        let list = participants();
-
-        let mut new = Box::new(Thread {
-            state: AtomicUsize::new(0),
-            next: Atomic::null(0),
-        });
-
-        // This code is executing while the thread harness is initializing, so normal pinning would
-        // try to access it while it is being initialized. Such accesses fail with a panic. We must
-        // therefore cheat by creating a fake pin.
-        let pin = unsafe { &mem::zeroed::<Pin>() };
-
-        let mut head = list.load(pin);
-        loop {
-            new.next.store(head);
-
-            // Try installing this thread's entry as the new head.
-            match list.cas_box(head, new, 0) {
-                Ok(n) => return n.as_raw(),
-                Err((h, n)) => {
-                    head = h;
-                    new = n;
-                }
-            }
-        }
-    }
-
-    /// Unregisters the thread by marking it's entry as deleted.
-    ///
-    /// This function doesn't physically remove the entry from the linked list, though. That will
-    /// do a future call to `try_advance`.
-    fn unregister(&self) {
-        // This code is executing while the thread harness is initializing, so normal pinning would
-        // try to access it while it is being initialized. Such accesses fail with a panic. We must
-        // therefore cheat by creating a fake pin.
-        let pin = unsafe { &mem::zeroed::<Pin>() };
-
-        // Simply mark the next-pointer in this thread's entry.
-        let mut next = self.next.load(pin);
-        while next.tag() == 0 {
-            match self.next.cas(next, next.with_tag(1)) {
-                Ok(()) => break,
-                Err(n) => next = n,
-            }
-        }
-    }
-}
-
-/// Returns a reference to the head pointer of the list of participating threads.
-fn participants() -> &'static Atomic<Thread> {
-    static PARTICIPANTS: AtomicUsize = ATOMIC_USIZE_INIT;
-    unsafe { &*(&PARTICIPANTS as *const _ as *const _) }
-}
-
-/// Attempts to advance the global epoch.
-///
-/// The global epoch can advance only if all currently pinned threads have been pinned in the
-/// current epoch.
-#[cold]
-pub fn try_advance(pin: &Pin) {
-    let epoch = EPOCH.load(SeqCst);
-
-    // Traverse the linked list of participating threads.
-    let mut pred = participants();
-    let mut curr = pred.load(pin);
-
-    while let Some(c) = curr.as_ref() {
-        let succ = c.next.load(pin);
-
-        if succ.tag() == 1 {
-            // This thread has exited. Try unlinking it from the list.
-            let succ = succ.with_tag(0);
-
-            if pred.cas(curr, succ).is_err() {
-                // We lost the race to unlink the thread. Usually that means we should traverse the
-                // list again from the beginning, but since another thread trying to advance the
-                // epoch has won the race, we leave the job to that one.
-                return;
-            }
-
-            // The unlinked entry can later be freed.
-            unsafe { defer_free(c as *const _ as *mut Thread, 1, pin) }
-
-            // Move forward, but don't change the predecessor.
-            curr = succ;
-        } else {
-            let thread_state = c.state.load(SeqCst);
-            let thread_is_pinned = thread_state & 1 == 1;
-            let thread_epoch = thread_state & !1;
-
-            // If the thread was pinned in a different epoch, we cannot advance the global epoch
-            // just yet.
-            if thread_is_pinned && thread_epoch != epoch {
-                return;
-            }
-
-            // Move one step forward.
-            pred = &c.next;
-            curr = succ;
-        }
-    }
-
-    // All pinned threads were pinned in the current global epoch.
-    // Finally, try advancing the epoch. We increment by 2 and simply wrap around on overflow.
-    EPOCH.compare_and_swap(epoch, epoch.wrapping_add(2), SeqCst);
-}
-
-/// A witness that the current thread is pinned.
-///
-/// A reference to `Pin` is proof that the current thread is pinned. Lots of methods that interact
-/// with [`Atomic`]s can safely be called only while the thread is pinned so they often require a
-/// reference to `Pin`.
-///
-/// This data type is inherently bound to the thread that created it, therefore it does not
-/// implement `Send` nor `Sync`.
-///
-/// [`Atomic`]: struct.Atomic.html
-#[derive(Debug)]
-pub struct Pin {
-    /// A pointer to the cell within the harness, which holds a pointer to the local bag.
-    ///
-    /// This pointer is kept within `Pin` as a matter of convenience. It could also be reached
-    /// through the harness itself, but that doesn't work if we're in the process of it's
-    /// destruction.
-    bag: *const Cell<*mut Bag>, // !Send + !Sync
-}
-
-/// Pins the current thread.
-///
-/// The provided function takes a reference to a `Pin`, which can be used to interact with
-/// [`Atomic`]s. The pin serves as a proof that whatever data you load from an [`Atomic`] will not
-/// be concurrently deleted by another thread while the pin is alive.
-///
-/// Note that keeping a thread pinned for a long time prevents memory reclamation of any newly
-/// deleted objects protected by [`Atomic`]s. The provided function should be very quick -
-/// generally speaking, it shouldn't take more than 100 ms.
-///
-/// Pinning is reentrant. There is no harm in pinning a thread while it's already pinned (repinning
-/// is essentially a noop).
-///
-/// Pinning itself comes with a price: it begins with a `SeqCst` fence and performs a few other
-/// atomic operations. However, this mechanism is designed to be as performant as possible, so it
-/// can be used pretty liberally. On a modern machine pinning takes 10 to 15 nanoseconds.
-///
-/// [`Atomic`]: struct.Atomic.html
-pub fn pin<F, T>(f: F) -> T
-    where F: FnOnce(&Pin) -> T
-{
-    /// Number of pinnings after which a thread will collect some global garbage.
-    const PINS_BETWEEN_COLLECT: usize = 128;
-
-    HARNESS.with(|harness| {
-        let thread = unsafe { &*harness.thread };
-        let pin = &Pin { bag: &harness.bag };
-
-        let was_pinned = harness.is_pinned.get();
-        if !was_pinned {
-            // Pin the thread.
-            harness.is_pinned.set(true);
-            thread.set_pinned(pin);
-
-            // Increment the pin counter.
-            let count = harness.pin_count.get();
-            harness.pin_count.set(count.wrapping_add(1));
-
-            // If the counter progressed enough, try advancing the epoch and collecting garbage.
-            if count % PINS_BETWEEN_COLLECT == 0 {
-                try_advance(pin);
-                garbage::collect(pin);
-            }
-        }
-
-        // This will unpin the thread even if `f` panics.
-        defer! {
-            if !was_pinned {
-                // Unpin the thread.
-                thread.set_unpinned();
-                harness.is_pinned.set(false);
-            }
-        }
-
-        f(pin)
-    })
-}
-
-/// Returns `true` if the current thread is pinned.
-#[inline]
-pub fn is_pinned() -> bool {
-    HARNESS.with(|harness| harness.is_pinned.get())
-}
-
-/// Stashes away an object that will later be freed.
-///
-/// The specified object is an array allocated at address `object` and consists of `count` elements
-/// of type `T`.
-///
-/// This function inserts the object into a thread-local buffer. When the buffers becomes full,
-/// it's objects are flushed into the globally shared [`Garbage`] instance.
-///
-/// If the object is unusually large, it is wise to follow up with a call to [`flush`] so that it
-/// doesn't get stuck waiting in the buffer for a long time.
-///
-/// [`Garbage`]: struct.Garbage.html
-/// [`flush`]: fn.flush.html
-pub unsafe fn defer_free<T>(object: *mut T, count: usize, pin: &Pin) {
-    unsafe fn free<T>(ptr: *mut T, count: usize) {
-        // Free the memory, but don't run the destructors.
-        drop(Vec::from_raw_parts(ptr, 0, count));
-    }
-
-    loop {
-        // Get the thread-local bag.
-        let cell = &*pin.bag;
-        let bag = cell.get();
-
-        // Try inserting the object into the bag.
-        if (*bag).try_insert(free::<T>, object, count) {
-            // Success! We're done.
-            break;
-        }
-
-        // Flush the garbage and create a new bag.
-        flush(pin);
-    }
-}
-
-/// Flushes the buffered thread-local garbage.
-///
-/// It is wise to flush the garbage just after passing a very large object to [`defer_free`], so
-/// that it isn't sitting in the buffer for a long time.
-///
-/// [`defer_free`]: fn.defer_free.html
-pub fn flush(pin: &Pin) {
-    unsafe {
-        // Get the thread-local bag.
-        let cell = &*pin.bag;
-        let bag = cell.get();
-
-        if !(*bag).is_empty() {
-            // The bag is full. We must replace it with a fresh one.
-            cell.set(Box::into_raw(Box::new(Bag::new())));
-
-            // Push the old bag into the garbage queue.
-            let bag = Box::from_raw(bag);
-            garbage::push(bag, pin);
-
-            // Spare some cycles on garbage collection.
-            // Note: This may itself produce garbage and allocate new bags.
-            try_advance(pin);
-            garbage::collect(pin);
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::thread;
-    use std::sync::atomic::Ordering::SeqCst;
-
-    use epoch;
-    use epoch::garbage::EPOCH;
-    use epoch::thread::{HARNESS, try_advance};
-
-    #[test]
-    fn pin_reentrant() {
-        assert!(!epoch::is_pinned());
-        epoch::pin(|_| {
-            assert!(epoch::is_pinned());
-            epoch::pin(|_| {
-                assert!(epoch::is_pinned());
-            });
-            assert!(epoch::is_pinned());
-        });
-        assert!(!epoch::is_pinned());
-    }
-
-    #[test]
-    fn flush_local_garbage() {
-        for _ in 0..100 {
-            epoch::pin(|pin| {
-                unsafe {
-                    let a = Box::into_raw(Box::new(7));
-                    epoch::defer_free(a, 1, pin);
-
-                    HARNESS.with(|h| {
-                        assert!(!(*h.bag.get()).is_empty());
-
-                        while !(*h.bag.get()).is_empty() {
-                            epoch::flush(pin);
-                        }
-                    });
-                }
-            });
-        }
-    }
-
-    #[test]
-    fn garbage_buffering() {
-        HARNESS.with(|h| unsafe {
-            while !(*h.bag.get()).is_empty() {
-                epoch::pin(|pin| epoch::flush(pin));
-            }
-
-            epoch::pin(|pin| {
-                for _ in 0..10 {
-                    let a = Box::into_raw(Box::new(7));
-                    epoch::defer_free(a, 1, pin);
-                }
-                assert!(!(*h.bag.get()).is_empty());
-            });
-        });
-    }
-
-    #[test]
-    fn pin_holds_advance() {
-        let threads = (0..8).map(|_| {
-            thread::spawn(|| {
-                for _ in 0..500_000 {
-                    epoch::pin(|pin| {
-                        let before = EPOCH.load(SeqCst);
-                        try_advance(pin);
-                        let after = EPOCH.load(SeqCst);
-
-                        assert!(after.wrapping_sub(before) <= 2);
-                    });
-                }
-            })
-        }).collect::<Vec<_>>();
-
-        for t in threads {
-            t.join().unwrap();
-        }
-    }
-}