Auto merge of #73265 - mark-i-m:mv-std, r=<try>tmp-nightly

mv std libs to library/

This is the first step in refactoring the directory layout of this repository, with further followup steps planned (but not done yet).

Background: currently, all crates are under src/, without nested src directories and with the unconventional `lib*` prefixes (e.g., `src/libcore/lib.rs`). This directory structures is not idiomatic and makes the `src/` directory rather overwhelming. To improve contributor experience and make things a bit more approachable, we are reorganizing the repo a bit.

In this PR, we move the standard libs (basically anything that is "runtime", as opposed to part of the compiler, build system, or one of the tools, etc). The new layout moves these libraries to a new `library/` directory in the root of the repo. Additionally, we remove the `lib*` prefixes and add nested `src/` directories.  The other crates/tools in this repo are not touched. So in summary:

```
library/<crate>/src/*.rs
src/<all the rest>     // unchanged
```

where `<crate>` is:
- core
- alloc
- std
- test
- proc_macro
- panic_abort
- panic_unwind
- profiler_builtins
- term
- unwind
- rtstartup
- backtrace
- rustc-std-workspace-*

There was a lot of discussion about this and a few rounds of compiler team approvals, FCPs, MCPs, and nominations. The original MCP is https://github.com/rust-lang/compiler-team/issues/298. The final approval of the compiler team was given here: https://github.com/rust-lang/rust/pull/73265#issuecomment-659498446.

The name `library` was chosen to complement a later move of the compiler crates to a `compiler/` directory. There was a lot of discussion around adding the nested `src/` directories. Note that this does increase the nesting depth (plausibly important for manual traversal of the tree, e.g., through GitHub's UI or `cd`), but this is deemed to be better as it fits the standard layout of Rust crates throughout most of the ecosystem, though there is some debate about how much this should apply to multi-crate projects. Overall, there seem to be more people in favor of nested `src/` than against.

After this PR, there are no dependencies out of the `library/` directory except on the `build_helper` (or crates.io crates).

11 files changed, 0 insertions, 2011 deletions

diff --git a/src/liballoc/benches/btree/map.rs b/src/liballoc/benches/btree/map.rs
deleted file mode 100644
index 38d19c59ad1..00000000000
--- a/src/liballoc/benches/btree/map.rs
+++ /dev/null
@@ -1,284 +0,0 @@
-use std::collections::BTreeMap;
-use std::iter::Iterator;
-use std::ops::RangeBounds;
-use std::vec::Vec;
-
-use rand::{seq::SliceRandom, thread_rng, Rng};
-use test::{black_box, Bencher};
-
-macro_rules! map_insert_rand_bench {
-    ($name: ident, $n: expr, $map: ident) => {
-        #[bench]
-        pub fn $name(b: &mut Bencher) {
-            let n: usize = $n;
-            let mut map = $map::new();
-            // setup
-            let mut rng = thread_rng();
-
-            for _ in 0..n {
-                let i = rng.gen::<usize>() % n;
-                map.insert(i, i);
-            }
-
-            // measure
-            b.iter(|| {
-                let k = rng.gen::<usize>() % n;
-                map.insert(k, k);
-                map.remove(&k);
-            });
-            black_box(map);
-        }
-    };
-}
-
-macro_rules! map_insert_seq_bench {
-    ($name: ident, $n: expr, $map: ident) => {
-        #[bench]
-        pub fn $name(b: &mut Bencher) {
-            let mut map = $map::new();
-            let n: usize = $n;
-            // setup
-            for i in 0..n {
-                map.insert(i * 2, i * 2);
-            }
-
-            // measure
-            let mut i = 1;
-            b.iter(|| {
-                map.insert(i, i);
-                map.remove(&i);
-                i = (i + 2) % n;
-            });
-            black_box(map);
-        }
-    };
-}
-
-macro_rules! map_find_rand_bench {
-    ($name: ident, $n: expr, $map: ident) => {
-        #[bench]
-        pub fn $name(b: &mut Bencher) {
-            let mut map = $map::new();
-            let n: usize = $n;
-
-            // setup
-            let mut rng = thread_rng();
-            let mut keys: Vec<_> = (0..n).map(|_| rng.gen::<usize>() % n).collect();
-
-            for &k in &keys {
-                map.insert(k, k);
-            }
-
-            keys.shuffle(&mut rng);
-
-            // measure
-            let mut i = 0;
-            b.iter(|| {
-                let t = map.get(&keys[i]);
-                i = (i + 1) % n;
-                black_box(t);
-            })
-        }
-    };
-}
-
-macro_rules! map_find_seq_bench {
-    ($name: ident, $n: expr, $map: ident) => {
-        #[bench]
-        pub fn $name(b: &mut Bencher) {
-            let mut map = $map::new();
-            let n: usize = $n;
-
-            // setup
-            for i in 0..n {
-                map.insert(i, i);
-            }
-
-            // measure
-            let mut i = 0;
-            b.iter(|| {
-                let x = map.get(&i);
-                i = (i + 1) % n;
-                black_box(x);
-            })
-        }
-    };
-}
-
-map_insert_rand_bench! {insert_rand_100,    100,    BTreeMap}
-map_insert_rand_bench! {insert_rand_10_000, 10_000, BTreeMap}
-
-map_insert_seq_bench! {insert_seq_100,    100,    BTreeMap}
-map_insert_seq_bench! {insert_seq_10_000, 10_000, BTreeMap}
-
-map_find_rand_bench! {find_rand_100,    100,    BTreeMap}
-map_find_rand_bench! {find_rand_10_000, 10_000, BTreeMap}
-
-map_find_seq_bench! {find_seq_100,    100,    BTreeMap}
-map_find_seq_bench! {find_seq_10_000, 10_000, BTreeMap}
-
-fn bench_iteration(b: &mut Bencher, size: i32) {
-    let mut map = BTreeMap::<i32, i32>::new();
-    let mut rng = thread_rng();
-
-    for _ in 0..size {
-        map.insert(rng.gen(), rng.gen());
-    }
-
-    b.iter(|| {
-        for entry in &map {
-            black_box(entry);
-        }
-    });
-}
-
-#[bench]
-pub fn iteration_20(b: &mut Bencher) {
-    bench_iteration(b, 20);
-}
-
-#[bench]
-pub fn iteration_1000(b: &mut Bencher) {
-    bench_iteration(b, 1000);
-}
-
-#[bench]
-pub fn iteration_100000(b: &mut Bencher) {
-    bench_iteration(b, 100000);
-}
-
-fn bench_iteration_mut(b: &mut Bencher, size: i32) {
-    let mut map = BTreeMap::<i32, i32>::new();
-    let mut rng = thread_rng();
-
-    for _ in 0..size {
-        map.insert(rng.gen(), rng.gen());
-    }
-
-    b.iter(|| {
-        for kv in map.iter_mut() {
-            black_box(kv);
-        }
-    });
-}
-
-#[bench]
-pub fn iteration_mut_20(b: &mut Bencher) {
-    bench_iteration_mut(b, 20);
-}
-
-#[bench]
-pub fn iteration_mut_1000(b: &mut Bencher) {
-    bench_iteration_mut(b, 1000);
-}
-
-#[bench]
-pub fn iteration_mut_100000(b: &mut Bencher) {
-    bench_iteration_mut(b, 100000);
-}
-
-fn bench_first_and_last(b: &mut Bencher, size: i32) {
-    let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
-    b.iter(|| {
-        for _ in 0..10 {
-            black_box(map.first_key_value());
-            black_box(map.last_key_value());
-        }
-    });
-}
-
-#[bench]
-pub fn first_and_last_0(b: &mut Bencher) {
-    bench_first_and_last(b, 0);
-}
-
-#[bench]
-pub fn first_and_last_100(b: &mut Bencher) {
-    bench_first_and_last(b, 100);
-}
-
-#[bench]
-pub fn first_and_last_10k(b: &mut Bencher) {
-    bench_first_and_last(b, 10_000);
-}
-
-const BENCH_RANGE_SIZE: i32 = 145;
-const BENCH_RANGE_COUNT: i32 = BENCH_RANGE_SIZE * (BENCH_RANGE_SIZE - 1) / 2;
-
-fn bench_range<F, R>(b: &mut Bencher, f: F)
-where
-    F: Fn(i32, i32) -> R,
-    R: RangeBounds<i32>,
-{
-    let map: BTreeMap<_, _> = (0..BENCH_RANGE_SIZE).map(|i| (i, i)).collect();
-    b.iter(|| {
-        let mut c = 0;
-        for i in 0..BENCH_RANGE_SIZE {
-            for j in i + 1..BENCH_RANGE_SIZE {
-                black_box(map.range(f(i, j)));
-                c += 1;
-            }
-        }
-        debug_assert_eq!(c, BENCH_RANGE_COUNT);
-    });
-}
-
-#[bench]
-pub fn range_included_excluded(b: &mut Bencher) {
-    bench_range(b, |i, j| i..j);
-}
-
-#[bench]
-pub fn range_included_included(b: &mut Bencher) {
-    bench_range(b, |i, j| i..=j);
-}
-
-#[bench]
-pub fn range_included_unbounded(b: &mut Bencher) {
-    bench_range(b, |i, _| i..);
-}
-
-#[bench]
-pub fn range_unbounded_unbounded(b: &mut Bencher) {
-    bench_range(b, |_, _| ..);
-}
-
-fn bench_iter(b: &mut Bencher, repeats: i32, size: i32) {
-    let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
-    b.iter(|| {
-        for _ in 0..repeats {
-            black_box(map.iter());
-        }
-    });
-}
-
-/// Contrast range_unbounded_unbounded with `iter()`.
-#[bench]
-pub fn range_unbounded_vs_iter(b: &mut Bencher) {
-    bench_iter(b, BENCH_RANGE_COUNT, BENCH_RANGE_SIZE);
-}
-
-#[bench]
-pub fn iter_0(b: &mut Bencher) {
-    bench_iter(b, 1_000, 0);
-}
-
-#[bench]
-pub fn iter_1(b: &mut Bencher) {
-    bench_iter(b, 1_000, 1);
-}
-
-#[bench]
-pub fn iter_100(b: &mut Bencher) {
-    bench_iter(b, 1_000, 100);
-}
-
-#[bench]
-pub fn iter_10k(b: &mut Bencher) {
-    bench_iter(b, 1_000, 10_000);
-}
-
-#[bench]
-pub fn iter_1m(b: &mut Bencher) {
-    bench_iter(b, 1_000, 1_000_000);
-}
diff --git a/src/liballoc/benches/btree/mod.rs b/src/liballoc/benches/btree/mod.rs
deleted file mode 100644
index 095ca5dd2e2..00000000000
--- a/src/liballoc/benches/btree/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-mod map;
-mod set;
diff --git a/src/liballoc/benches/btree/set.rs b/src/liballoc/benches/btree/set.rs
deleted file mode 100644
index 2518506b9b5..00000000000
--- a/src/liballoc/benches/btree/set.rs
+++ /dev/null
@@ -1,216 +0,0 @@
-use std::collections::BTreeSet;
-
-use rand::{thread_rng, Rng};
-use test::Bencher;
-
-fn random(n: usize) -> BTreeSet<usize> {
-    let mut rng = thread_rng();
-    let mut set = BTreeSet::new();
-    while set.len() < n {
-        set.insert(rng.gen());
-    }
-    assert_eq!(set.len(), n);
-    set
-}
-
-fn neg(n: usize) -> BTreeSet<i32> {
-    let set: BTreeSet<i32> = (-(n as i32)..=-1).collect();
-    assert_eq!(set.len(), n);
-    set
-}
-
-fn pos(n: usize) -> BTreeSet<i32> {
-    let set: BTreeSet<i32> = (1..=(n as i32)).collect();
-    assert_eq!(set.len(), n);
-    set
-}
-
-fn stagger(n1: usize, factor: usize) -> [BTreeSet<u32>; 2] {
-    let n2 = n1 * factor;
-    let mut sets = [BTreeSet::new(), BTreeSet::new()];
-    for i in 0..(n1 + n2) {
-        let b = i % (factor + 1) != 0;
-        sets[b as usize].insert(i as u32);
-    }
-    assert_eq!(sets[0].len(), n1);
-    assert_eq!(sets[1].len(), n2);
-    sets
-}
-
-macro_rules! set_bench {
-    ($name: ident, $set_func: ident, $result_func: ident, $sets: expr) => {
-        #[bench]
-        pub fn $name(b: &mut Bencher) {
-            // setup
-            let sets = $sets;
-
-            // measure
-            b.iter(|| sets[0].$set_func(&sets[1]).$result_func())
-        }
-    };
-}
-
-#[bench]
-pub fn clone_100(b: &mut Bencher) {
-    let src = pos(100);
-    b.iter(|| src.clone())
-}
-
-#[bench]
-pub fn clone_100_and_clear(b: &mut Bencher) {
-    let src = pos(100);
-    b.iter(|| src.clone().clear())
-}
-
-#[bench]
-pub fn clone_100_and_drain_all(b: &mut Bencher) {
-    let src = pos(100);
-    b.iter(|| src.clone().drain_filter(|_| true).count())
-}
-
-#[bench]
-pub fn clone_100_and_drain_half(b: &mut Bencher) {
-    let src = pos(100);
-    b.iter(|| {
-        let mut set = src.clone();
-        assert_eq!(set.drain_filter(|i| i % 2 == 0).count(), 100 / 2);
-        assert_eq!(set.len(), 100 / 2);
-    })
-}
-
-#[bench]
-pub fn clone_100_and_into_iter(b: &mut Bencher) {
-    let src = pos(100);
-    b.iter(|| src.clone().into_iter().count())
-}
-
-#[bench]
-pub fn clone_100_and_pop_all(b: &mut Bencher) {
-    let src = pos(100);
-    b.iter(|| {
-        let mut set = src.clone();
-        while set.pop_first().is_some() {}
-        set
-    });
-}
-
-#[bench]
-pub fn clone_100_and_remove_all(b: &mut Bencher) {
-    let src = pos(100);
-    b.iter(|| {
-        let mut set = src.clone();
-        while let Some(elt) = set.iter().copied().next() {
-            set.remove(&elt);
-        }
-        set
-    });
-}
-
-#[bench]
-pub fn clone_100_and_remove_half(b: &mut Bencher) {
-    let src = pos(100);
-    b.iter(|| {
-        let mut set = src.clone();
-        for i in (2..=100 as i32).step_by(2) {
-            set.remove(&i);
-        }
-        assert_eq!(set.len(), 100 / 2);
-        set
-    })
-}
-
-#[bench]
-pub fn clone_10k(b: &mut Bencher) {
-    let src = pos(10_000);
-    b.iter(|| src.clone())
-}
-
-#[bench]
-pub fn clone_10k_and_clear(b: &mut Bencher) {
-    let src = pos(10_000);
-    b.iter(|| src.clone().clear())
-}
-
-#[bench]
-pub fn clone_10k_and_drain_all(b: &mut Bencher) {
-    let src = pos(10_000);
-    b.iter(|| src.clone().drain_filter(|_| true).count())
-}
-
-#[bench]
-pub fn clone_10k_and_drain_half(b: &mut Bencher) {
-    let src = pos(10_000);
-    b.iter(|| {
-        let mut set = src.clone();
-        assert_eq!(set.drain_filter(|i| i % 2 == 0).count(), 10_000 / 2);
-        assert_eq!(set.len(), 10_000 / 2);
-    })
-}
-
-#[bench]
-pub fn clone_10k_and_into_iter(b: &mut Bencher) {
-    let src = pos(10_000);
-    b.iter(|| src.clone().into_iter().count())
-}
-
-#[bench]
-pub fn clone_10k_and_pop_all(b: &mut Bencher) {
-    let src = pos(10_000);
-    b.iter(|| {
-        let mut set = src.clone();
-        while set.pop_first().is_some() {}
-        set
-    });
-}
-
-#[bench]
-pub fn clone_10k_and_remove_all(b: &mut Bencher) {
-    let src = pos(10_000);
-    b.iter(|| {
-        let mut set = src.clone();
-        while let Some(elt) = set.iter().copied().next() {
-            set.remove(&elt);
-        }
-        set
-    });
-}
-
-#[bench]
-pub fn clone_10k_and_remove_half(b: &mut Bencher) {
-    let src = pos(10_000);
-    b.iter(|| {
-        let mut set = src.clone();
-        for i in (2..=10_000 as i32).step_by(2) {
-            set.remove(&i);
-        }
-        assert_eq!(set.len(), 10_000 / 2);
-        set
-    })
-}
-
-set_bench! {intersection_100_neg_vs_100_pos, intersection, count, [neg(100), pos(100)]}
-set_bench! {intersection_100_neg_vs_10k_pos, intersection, count, [neg(100), pos(10_000)]}
-set_bench! {intersection_100_pos_vs_100_neg, intersection, count, [pos(100), neg(100)]}
-set_bench! {intersection_100_pos_vs_10k_neg, intersection, count, [pos(100), neg(10_000)]}
-set_bench! {intersection_10k_neg_vs_100_pos, intersection, count, [neg(10_000), pos(100)]}
-set_bench! {intersection_10k_neg_vs_10k_pos, intersection, count, [neg(10_000), pos(10_000)]}
-set_bench! {intersection_10k_pos_vs_100_neg, intersection, count, [pos(10_000), neg(100)]}
-set_bench! {intersection_10k_pos_vs_10k_neg, intersection, count, [pos(10_000), neg(10_000)]}
-set_bench! {intersection_random_100_vs_100, intersection, count, [random(100), random(100)]}
-set_bench! {intersection_random_100_vs_10k, intersection, count, [random(100), random(10_000)]}
-set_bench! {intersection_random_10k_vs_100, intersection, count, [random(10_000), random(100)]}
-set_bench! {intersection_random_10k_vs_10k, intersection, count, [random(10_000), random(10_000)]}
-set_bench! {intersection_staggered_100_vs_100, intersection, count, stagger(100, 1)}
-set_bench! {intersection_staggered_10k_vs_10k, intersection, count, stagger(10_000, 1)}
-set_bench! {intersection_staggered_100_vs_10k, intersection, count, stagger(100, 100)}
-set_bench! {difference_random_100_vs_100, difference, count, [random(100), random(100)]}
-set_bench! {difference_random_100_vs_10k, difference, count, [random(100), random(10_000)]}
-set_bench! {difference_random_10k_vs_100, difference, count, [random(10_000), random(100)]}
-set_bench! {difference_random_10k_vs_10k, difference, count, [random(10_000), random(10_000)]}
-set_bench! {difference_staggered_100_vs_100, difference, count, stagger(100, 1)}
-set_bench! {difference_staggered_10k_vs_10k, difference, count, stagger(10_000, 1)}
-set_bench! {difference_staggered_100_vs_10k, difference, count, stagger(100, 100)}
-set_bench! {is_subset_100_vs_100, is_subset, clone, [pos(100), pos(100)]}
-set_bench! {is_subset_100_vs_10k, is_subset, clone, [pos(100), pos(10_000)]}
-set_bench! {is_subset_10k_vs_100, is_subset, clone, [pos(10_000), pos(100)]}
-set_bench! {is_subset_10k_vs_10k, is_subset, clone, [pos(10_000), pos(10_000)]}
diff --git a/src/liballoc/benches/lib.rs b/src/liballoc/benches/lib.rs
deleted file mode 100644
index 608eafc88d2..00000000000
--- a/src/liballoc/benches/lib.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Disabling on android for the time being
-// See https://github.com/rust-lang/rust/issues/73535#event-3477699747
-#![cfg(not(target_os = "android"))]
-#![feature(btree_drain_filter)]
-#![feature(map_first_last)]
-#![feature(repr_simd)]
-#![feature(test)]
-
-extern crate test;
-
-mod btree;
-mod linked_list;
-mod slice;
-mod str;
-mod string;
-mod vec;
-mod vec_deque;
diff --git a/src/liballoc/benches/linked_list.rs b/src/liballoc/benches/linked_list.rs
deleted file mode 100644
index 29c5ad2bc6e..00000000000
--- a/src/liballoc/benches/linked_list.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-use std::collections::LinkedList;
-use test::Bencher;
-
-#[bench]
-fn bench_collect_into(b: &mut Bencher) {
-    let v = &[0; 64];
-    b.iter(|| {
-        let _: LinkedList<_> = v.iter().cloned().collect();
-    })
-}
-
-#[bench]
-fn bench_push_front(b: &mut Bencher) {
-    let mut m: LinkedList<_> = LinkedList::new();
-    b.iter(|| {
-        m.push_front(0);
-    })
-}
-
-#[bench]
-fn bench_push_back(b: &mut Bencher) {
-    let mut m: LinkedList<_> = LinkedList::new();
-    b.iter(|| {
-        m.push_back(0);
-    })
-}
-
-#[bench]
-fn bench_push_back_pop_back(b: &mut Bencher) {
-    let mut m: LinkedList<_> = LinkedList::new();
-    b.iter(|| {
-        m.push_back(0);
-        m.pop_back();
-    })
-}
-
-#[bench]
-fn bench_push_front_pop_front(b: &mut Bencher) {
-    let mut m: LinkedList<_> = LinkedList::new();
-    b.iter(|| {
-        m.push_front(0);
-        m.pop_front();
-    })
-}
-
-#[bench]
-fn bench_iter(b: &mut Bencher) {
-    let v = &[0; 128];
-    let m: LinkedList<_> = v.iter().cloned().collect();
-    b.iter(|| {
-        assert!(m.iter().count() == 128);
-    })
-}
-#[bench]
-fn bench_iter_mut(b: &mut Bencher) {
-    let v = &[0; 128];
-    let mut m: LinkedList<_> = v.iter().cloned().collect();
-    b.iter(|| {
-        assert!(m.iter_mut().count() == 128);
-    })
-}
-#[bench]
-fn bench_iter_rev(b: &mut Bencher) {
-    let v = &[0; 128];
-    let m: LinkedList<_> = v.iter().cloned().collect();
-    b.iter(|| {
-        assert!(m.iter().rev().count() == 128);
-    })
-}
-#[bench]
-fn bench_iter_mut_rev(b: &mut Bencher) {
-    let v = &[0; 128];
-    let mut m: LinkedList<_> = v.iter().cloned().collect();
-    b.iter(|| {
-        assert!(m.iter_mut().rev().count() == 128);
-    })
-}
diff --git a/src/liballoc/benches/slice.rs b/src/liballoc/benches/slice.rs
deleted file mode 100644
index e20c043286e..00000000000
--- a/src/liballoc/benches/slice.rs
+++ /dev/null
@@ -1,382 +0,0 @@
-use std::{mem, ptr};
-
-use rand::distributions::{Alphanumeric, Standard};
-use rand::{thread_rng, Rng, SeedableRng};
-use rand_xorshift::XorShiftRng;
-use test::{black_box, Bencher};
-
-#[bench]
-fn iterator(b: &mut Bencher) {
-    // peculiar numbers to stop LLVM from optimising the summation
-    // out.
-    let v: Vec<_> = (0..100).map(|i| i ^ (i << 1) ^ (i >> 1)).collect();
-
-    b.iter(|| {
-        let mut sum = 0;
-        for x in &v {
-            sum += *x;
-        }
-        // sum == 11806, to stop dead code elimination.
-        if sum == 0 {
-            panic!()
-        }
-    })
-}
-
-#[bench]
-fn mut_iterator(b: &mut Bencher) {
-    let mut v = vec![0; 100];
-
-    b.iter(|| {
-        let mut i = 0;
-        for x in &mut v {
-            *x = i;
-            i += 1;
-        }
-    })
-}
-
-#[bench]
-fn concat(b: &mut Bencher) {
-    let xss: Vec<Vec<i32>> = (0..100).map(|i| (0..i).collect()).collect();
-    b.iter(|| {
-        xss.concat();
-    });
-}
-
-#[bench]
-fn join(b: &mut Bencher) {
-    let xss: Vec<Vec<i32>> = (0..100).map(|i| (0..i).collect()).collect();
-    b.iter(|| xss.join(&0));
-}
-
-#[bench]
-fn push(b: &mut Bencher) {
-    let mut vec = Vec::<i32>::new();
-    b.iter(|| {
-        vec.push(0);
-        black_box(&vec);
-    });
-}
-
-#[bench]
-fn starts_with_same_vector(b: &mut Bencher) {
-    let vec: Vec<_> = (0..100).collect();
-    b.iter(|| vec.starts_with(&vec))
-}
-
-#[bench]
-fn starts_with_single_element(b: &mut Bencher) {
-    let vec: Vec<_> = vec![0];
-    b.iter(|| vec.starts_with(&vec))
-}
-
-#[bench]
-fn starts_with_diff_one_element_at_end(b: &mut Bencher) {
-    let vec: Vec<_> = (0..100).collect();
-    let mut match_vec: Vec<_> = (0..99).collect();
-    match_vec.push(0);
-    b.iter(|| vec.starts_with(&match_vec))
-}
-
-#[bench]
-fn ends_with_same_vector(b: &mut Bencher) {
-    let vec: Vec<_> = (0..100).collect();
-    b.iter(|| vec.ends_with(&vec))
-}
-
-#[bench]
-fn ends_with_single_element(b: &mut Bencher) {
-    let vec: Vec<_> = vec![0];
-    b.iter(|| vec.ends_with(&vec))
-}
-
-#[bench]
-fn ends_with_diff_one_element_at_beginning(b: &mut Bencher) {
-    let vec: Vec<_> = (0..100).collect();
-    let mut match_vec: Vec<_> = (0..100).collect();
-    match_vec[0] = 200;
-    b.iter(|| vec.starts_with(&match_vec))
-}
-
-#[bench]
-fn contains_last_element(b: &mut Bencher) {
-    let vec: Vec<_> = (0..100).collect();
-    b.iter(|| vec.contains(&99))
-}
-
-#[bench]
-fn zero_1kb_from_elem(b: &mut Bencher) {
-    b.iter(|| vec![0u8; 1024]);
-}
-
-#[bench]
-fn zero_1kb_set_memory(b: &mut Bencher) {
-    b.iter(|| {
-        let mut v = Vec::<u8>::with_capacity(1024);
-        unsafe {
-            let vp = v.as_mut_ptr();
-            ptr::write_bytes(vp, 0, 1024);
-            v.set_len(1024);
-        }
-        v
-    });
-}
-
-#[bench]
-fn zero_1kb_loop_set(b: &mut Bencher) {
-    b.iter(|| {
-        let mut v = Vec::<u8>::with_capacity(1024);
-        unsafe {
-            v.set_len(1024);
-        }
-        for i in 0..1024 {
-            v[i] = 0;
-        }
-    });
-}
-
-#[bench]
-fn zero_1kb_mut_iter(b: &mut Bencher) {
-    b.iter(|| {
-        let mut v = Vec::<u8>::with_capacity(1024);
-        unsafe {
-            v.set_len(1024);
-        }
-        for x in &mut v {
-            *x = 0;
-        }
-        v
-    });
-}
-
-#[bench]
-fn random_inserts(b: &mut Bencher) {
-    let mut rng = thread_rng();
-    b.iter(|| {
-        let mut v = vec![(0, 0); 30];
-        for _ in 0..100 {
-            let l = v.len();
-            v.insert(rng.gen::<usize>() % (l + 1), (1, 1));
-        }
-    })
-}
-
-#[bench]
-fn random_removes(b: &mut Bencher) {
-    let mut rng = thread_rng();
-    b.iter(|| {
-        let mut v = vec![(0, 0); 130];
-        for _ in 0..100 {
-            let l = v.len();
-            v.remove(rng.gen::<usize>() % l);
-        }
-    })
-}
-
-fn gen_ascending(len: usize) -> Vec<u64> {
-    (0..len as u64).collect()
-}
-
-fn gen_descending(len: usize) -> Vec<u64> {
-    (0..len as u64).rev().collect()
-}
-
-const SEED: [u8; 16] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
-
-fn gen_random(len: usize) -> Vec<u64> {
-    let mut rng = XorShiftRng::from_seed(SEED);
-    (&mut rng).sample_iter(&Standard).take(len).collect()
-}
-
-fn gen_random_bytes(len: usize) -> Vec<u8> {
-    let mut rng = XorShiftRng::from_seed(SEED);
-    (&mut rng).sample_iter(&Standard).take(len).collect()
-}
-
-fn gen_mostly_ascending(len: usize) -> Vec<u64> {
-    let mut rng = XorShiftRng::from_seed(SEED);
-    let mut v = gen_ascending(len);
-    for _ in (0usize..).take_while(|x| x * x <= len) {
-        let x = rng.gen::<usize>() % len;
-        let y = rng.gen::<usize>() % len;
-        v.swap(x, y);
-    }
-    v
-}
-
-fn gen_mostly_descending(len: usize) -> Vec<u64> {
-    let mut rng = XorShiftRng::from_seed(SEED);
-    let mut v = gen_descending(len);
-    for _ in (0usize..).take_while(|x| x * x <= len) {
-        let x = rng.gen::<usize>() % len;
-        let y = rng.gen::<usize>() % len;
-        v.swap(x, y);
-    }
-    v
-}
-
-fn gen_strings(len: usize) -> Vec<String> {
-    let mut rng = XorShiftRng::from_seed(SEED);
-    let mut v = vec![];
-    for _ in 0..len {
-        let n = rng.gen::<usize>() % 20 + 1;
-        v.push((&mut rng).sample_iter(&Alphanumeric).take(n).collect());
-    }
-    v
-}
-
-fn gen_big_random(len: usize) -> Vec<[u64; 16]> {
-    let mut rng = XorShiftRng::from_seed(SEED);
-    (&mut rng).sample_iter(&Standard).map(|x| [x; 16]).take(len).collect()
-}
-
-macro_rules! sort {
-    ($f:ident, $name:ident, $gen:expr, $len:expr) => {
-        #[bench]
-        fn $name(b: &mut Bencher) {
-            let v = $gen($len);
-            b.iter(|| v.clone().$f());
-            b.bytes = $len * mem::size_of_val(&$gen(1)[0]) as u64;
-        }
-    };
-}
-
-macro_rules! sort_strings {
-    ($f:ident, $name:ident, $gen:expr, $len:expr) => {
-        #[bench]
-        fn $name(b: &mut Bencher) {
-            let v = $gen($len);
-            let v = v.iter().map(|s| &**s).collect::<Vec<&str>>();
-            b.iter(|| v.clone().$f());
-            b.bytes = $len * mem::size_of::<&str>() as u64;
-        }
-    };
-}
-
-macro_rules! sort_expensive {
-    ($f:ident, $name:ident, $gen:expr, $len:expr) => {
-        #[bench]
-        fn $name(b: &mut Bencher) {
-            let v = $gen($len);
-            b.iter(|| {
-                let mut v = v.clone();
-                let mut count = 0;
-                v.$f(|a: &u64, b: &u64| {
-                    count += 1;
-                    if count % 1_000_000_000 == 0 {
-                        panic!("should not happen");
-                    }
-                    (*a as f64).cos().partial_cmp(&(*b as f64).cos()).unwrap()
-                });
-                black_box(count);
-            });
-            b.bytes = $len * mem::size_of_val(&$gen(1)[0]) as u64;
-        }
-    };
-}
-
-macro_rules! sort_lexicographic {
-    ($f:ident, $name:ident, $gen:expr, $len:expr) => {
-        #[bench]
-        fn $name(b: &mut Bencher) {
-            let v = $gen($len);
-            b.iter(|| v.clone().$f(|x| x.to_string()));
-            b.bytes = $len * mem::size_of_val(&$gen(1)[0]) as u64;
-        }
-    };
-}
-
-sort!(sort, sort_small_ascending, gen_ascending, 10);
-sort!(sort, sort_small_descending, gen_descending, 10);
-sort!(sort, sort_small_random, gen_random, 10);
-sort!(sort, sort_small_big, gen_big_random, 10);
-sort!(sort, sort_medium_random, gen_random, 100);
-sort!(sort, sort_large_ascending, gen_ascending, 10000);
-sort!(sort, sort_large_descending, gen_descending, 10000);
-sort!(sort, sort_large_mostly_ascending, gen_mostly_ascending, 10000);
-sort!(sort, sort_large_mostly_descending, gen_mostly_descending, 10000);
-sort!(sort, sort_large_random, gen_random, 10000);
-sort!(sort, sort_large_big, gen_big_random, 10000);
-sort_strings!(sort, sort_large_strings, gen_strings, 10000);
-sort_expensive!(sort_by, sort_large_expensive, gen_random, 10000);
-
-sort!(sort_unstable, sort_unstable_small_ascending, gen_ascending, 10);
-sort!(sort_unstable, sort_unstable_small_descending, gen_descending, 10);
-sort!(sort_unstable, sort_unstable_small_random, gen_random, 10);
-sort!(sort_unstable, sort_unstable_small_big, gen_big_random, 10);
-sort!(sort_unstable, sort_unstable_medium_random, gen_random, 100);
-sort!(sort_unstable, sort_unstable_large_ascending, gen_ascending, 10000);
-sort!(sort_unstable, sort_unstable_large_descending, gen_descending, 10000);
-sort!(sort_unstable, sort_unstable_large_mostly_ascending, gen_mostly_ascending, 10000);
-sort!(sort_unstable, sort_unstable_large_mostly_descending, gen_mostly_descending, 10000);
-sort!(sort_unstable, sort_unstable_large_random, gen_random, 10000);
-sort!(sort_unstable, sort_unstable_large_big, gen_big_random, 10000);
-sort_strings!(sort_unstable, sort_unstable_large_strings, gen_strings, 10000);
-sort_expensive!(sort_unstable_by, sort_unstable_large_expensive, gen_random, 10000);
-
-sort_lexicographic!(sort_by_key, sort_by_key_lexicographic, gen_random, 10000);
-sort_lexicographic!(sort_unstable_by_key, sort_unstable_by_key_lexicographic, gen_random, 10000);
-sort_lexicographic!(sort_by_cached_key, sort_by_cached_key_lexicographic, gen_random, 10000);
-
-macro_rules! reverse {
-    ($name:ident, $ty:ty, $f:expr) => {
-        #[bench]
-        fn $name(b: &mut Bencher) {
-            // odd length and offset by 1 to be as unaligned as possible
-            let n = 0xFFFFF;
-            let mut v: Vec<_> = (0..1 + (n / mem::size_of::<$ty>() as u64)).map($f).collect();
-            b.iter(|| black_box(&mut v[1..]).reverse());
-            b.bytes = n;
-        }
-    };
-}
-
-reverse!(reverse_u8, u8, |x| x as u8);
-reverse!(reverse_u16, u16, |x| x as u16);
-reverse!(reverse_u8x3, [u8; 3], |x| [x as u8, (x >> 8) as u8, (x >> 16) as u8]);
-reverse!(reverse_u32, u32, |x| x as u32);
-reverse!(reverse_u64, u64, |x| x as u64);
-reverse!(reverse_u128, u128, |x| x as u128);
-#[repr(simd)]
-struct F64x4(f64, f64, f64, f64);
-reverse!(reverse_simd_f64x4, F64x4, |x| {
-    let x = x as f64;
-    F64x4(x, x, x, x)
-});
-
-macro_rules! rotate {
-    ($name:ident, $gen:expr, $len:expr, $mid:expr) => {
-        #[bench]
-        fn $name(b: &mut Bencher) {
-            let size = mem::size_of_val(&$gen(1)[0]);
-            let mut v = $gen($len * 8 / size);
-            b.iter(|| black_box(&mut v).rotate_left(($mid * 8 + size - 1) / size));
-            b.bytes = (v.len() * size) as u64;
-        }
-    };
-}
-
-rotate!(rotate_tiny_by1, gen_random, 16, 1);
-rotate!(rotate_tiny_half, gen_random, 16, 16 / 2);
-rotate!(rotate_tiny_half_plus_one, gen_random, 16, 16 / 2 + 1);
-
-rotate!(rotate_medium_by1, gen_random, 9158, 1);
-rotate!(rotate_medium_by727_u64, gen_random, 9158, 727);
-rotate!(rotate_medium_by727_bytes, gen_random_bytes, 9158, 727);
-rotate!(rotate_medium_by727_strings, gen_strings, 9158, 727);
-rotate!(rotate_medium_half, gen_random, 9158, 9158 / 2);
-rotate!(rotate_medium_half_plus_one, gen_random, 9158, 9158 / 2 + 1);
-
-// Intended to use more RAM than the machine has cache
-rotate!(rotate_huge_by1, gen_random, 5 * 1024 * 1024, 1);
-rotate!(rotate_huge_by9199_u64, gen_random, 5 * 1024 * 1024, 9199);
-rotate!(rotate_huge_by9199_bytes, gen_random_bytes, 5 * 1024 * 1024, 9199);
-rotate!(rotate_huge_by9199_strings, gen_strings, 5 * 1024 * 1024, 9199);
-rotate!(rotate_huge_by9199_big, gen_big_random, 5 * 1024 * 1024, 9199);
-rotate!(rotate_huge_by1234577_u64, gen_random, 5 * 1024 * 1024, 1234577);
-rotate!(rotate_huge_by1234577_bytes, gen_random_bytes, 5 * 1024 * 1024, 1234577);
-rotate!(rotate_huge_by1234577_strings, gen_strings, 5 * 1024 * 1024, 1234577);
-rotate!(rotate_huge_by1234577_big, gen_big_random, 5 * 1024 * 1024, 1234577);
-rotate!(rotate_huge_half, gen_random, 5 * 1024 * 1024, 5 * 1024 * 1024 / 2);
-rotate!(rotate_huge_half_plus_one, gen_random, 5 * 1024 * 1024, 5 * 1024 * 1024 / 2 + 1);
diff --git a/src/liballoc/benches/str.rs b/src/liballoc/benches/str.rs
deleted file mode 100644
index 391475bc0c7..00000000000
--- a/src/liballoc/benches/str.rs
+++ /dev/null
@@ -1,299 +0,0 @@
-use test::{black_box, Bencher};
-
-#[bench]
-fn char_iterator(b: &mut Bencher) {
-    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-
-    b.iter(|| s.chars().count());
-}
-
-#[bench]
-fn char_iterator_for(b: &mut Bencher) {
-    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-
-    b.iter(|| {
-        for ch in s.chars() {
-            black_box(ch);
-        }
-    });
-}
-
-#[bench]
-fn char_iterator_ascii(b: &mut Bencher) {
-    let s = "Mary had a little lamb, Little lamb
-    Mary had a little lamb, Little lamb
-    Mary had a little lamb, Little lamb
-    Mary had a little lamb, Little lamb
-    Mary had a little lamb, Little lamb
-    Mary had a little lamb, Little lamb";
-
-    b.iter(|| s.chars().count());
-}
-
-#[bench]
-fn char_iterator_rev(b: &mut Bencher) {
-    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-
-    b.iter(|| s.chars().rev().count());
-}
-
-#[bench]
-fn char_iterator_rev_for(b: &mut Bencher) {
-    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-
-    b.iter(|| {
-        for ch in s.chars().rev() {
-            black_box(ch);
-        }
-    });
-}
-
-#[bench]
-fn char_indicesator(b: &mut Bencher) {
-    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-    let len = s.chars().count();
-
-    b.iter(|| assert_eq!(s.char_indices().count(), len));
-}
-
-#[bench]
-fn char_indicesator_rev(b: &mut Bencher) {
-    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-    let len = s.chars().count();
-
-    b.iter(|| assert_eq!(s.char_indices().rev().count(), len));
-}
-
-#[bench]
-fn split_unicode_ascii(b: &mut Bencher) {
-    let s = "ประเทศไทย中华Việt Namประเทศไทย中华Việt Nam";
-
-    b.iter(|| assert_eq!(s.split('V').count(), 3));
-}
-
-#[bench]
-fn split_ascii(b: &mut Bencher) {
-    let s = "Mary had a little lamb, Little lamb, little-lamb.";
-    let len = s.split(' ').count();
-
-    b.iter(|| assert_eq!(s.split(' ').count(), len));
-}
-
-#[bench]
-fn split_extern_fn(b: &mut Bencher) {
-    let s = "Mary had a little lamb, Little lamb, little-lamb.";
-    let len = s.split(' ').count();
-    fn pred(c: char) -> bool {
-        c == ' '
-    }
-
-    b.iter(|| assert_eq!(s.split(pred).count(), len));
-}
-
-#[bench]
-fn split_closure(b: &mut Bencher) {
-    let s = "Mary had a little lamb, Little lamb, little-lamb.";
-    let len = s.split(' ').count();
-
-    b.iter(|| assert_eq!(s.split(|c: char| c == ' ').count(), len));
-}
-
-#[bench]
-fn split_slice(b: &mut Bencher) {
-    let s = "Mary had a little lamb, Little lamb, little-lamb.";
-    let len = s.split(' ').count();
-
-    let c: &[char] = &[' '];
-    b.iter(|| assert_eq!(s.split(c).count(), len));
-}
-
-#[bench]
-fn bench_join(b: &mut Bencher) {
-    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-    let sep = "→";
-    let v = vec![s, s, s, s, s, s, s, s, s, s];
-    b.iter(|| {
-        assert_eq!(v.join(sep).len(), s.len() * 10 + sep.len() * 9);
-    })
-}
-
-#[bench]
-fn bench_contains_short_short(b: &mut Bencher) {
-    let haystack = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
-    let needle = "sit";
-
-    b.iter(|| {
-        assert!(haystack.contains(needle));
-    })
-}
-
-#[bench]
-fn bench_contains_short_long(b: &mut Bencher) {
-    let haystack = "\
-Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse quis lorem sit amet dolor \
-ultricies condimentum. Praesent iaculis purus elit, ac malesuada quam malesuada in. Duis sed orci \
-eros. Suspendisse sit amet magna mollis, mollis nunc luctus, imperdiet mi. Integer fringilla non \
-sem ut lacinia. Fusce varius tortor a risus porttitor hendrerit. Morbi mauris dui, ultricies nec \
-tempus vel, gravida nec quam.
-
-In est dui, tincidunt sed tempus interdum, adipiscing laoreet ante. Etiam tempor, tellus quis \
-sagittis interdum, nulla purus mattis sem, quis auctor erat odio ac tellus. In nec nunc sit amet \
-diam volutpat molestie at sed ipsum. Vestibulum laoreet consequat vulputate. Integer accumsan \
-lorem ac dignissim placerat. Suspendisse convallis faucibus lorem. Aliquam erat volutpat. In vel \
-eleifend felis. Sed suscipit nulla lorem, sed mollis est sollicitudin et. Nam fermentum egestas \
-interdum. Curabitur ut nisi justo.
-
-Sed sollicitudin ipsum tellus, ut condimentum leo eleifend nec. Cras ut velit ante. Phasellus nec \
-mollis odio. Mauris molestie erat in arcu mattis, at aliquet dolor vehicula. Quisque malesuada \
-lectus sit amet nisi pretium, a condimentum ipsum porta. Morbi at dapibus diam. Praesent egestas \
-est sed risus elementum, eu rutrum metus ultrices. Etiam fermentum consectetur magna, id rutrum \
-felis accumsan a. Aliquam ut pellentesque libero. Sed mi nulla, lobortis eu tortor id, suscipit \
-ultricies neque. Morbi iaculis sit amet risus at iaculis. Praesent eget ligula quis turpis \
-feugiat suscipit vel non arcu. Interdum et malesuada fames ac ante ipsum primis in faucibus. \
-Aliquam sit amet placerat lorem.
-
-Cras a lacus vel ante posuere elementum. Nunc est leo, bibendum ut facilisis vel, bibendum at \
-mauris. Nullam adipiscing diam vel odio ornare, luctus adipiscing mi luctus. Nulla facilisi. \
-Mauris adipiscing bibendum neque, quis adipiscing lectus tempus et. Sed feugiat erat et nisl \
-lobortis pharetra. Donec vitae erat enim. Nullam sit amet felis et quam lacinia tincidunt. Aliquam \
-suscipit dapibus urna. Sed volutpat urna in magna pulvinar volutpat. Phasellus nec tellus ac diam \
-cursus accumsan.
-
-Nam lectus enim, dapibus non nisi tempor, consectetur convallis massa. Maecenas eleifend dictum \
-feugiat. Etiam quis mauris vel risus luctus mattis a a nunc. Nullam orci quam, imperdiet id \
-vehicula in, porttitor ut nibh. Duis sagittis adipiscing nisl vitae congue. Donec mollis risus eu \
-leo suscipit, varius porttitor nulla porta. Pellentesque ut sem nec nisi euismod vehicula. Nulla \
-malesuada sollicitudin quam eu fermentum.";
-    let needle = "english";
-
-    b.iter(|| {
-        assert!(!haystack.contains(needle));
-    })
-}
-
-#[bench]
-fn bench_contains_bad_naive(b: &mut Bencher) {
-    let haystack = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
-    let needle = "aaaaaaaab";
-
-    b.iter(|| {
-        assert!(!haystack.contains(needle));
-    })
-}
-
-#[bench]
-fn bench_contains_equal(b: &mut Bencher) {
-    let haystack = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
-    let needle = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
-
-    b.iter(|| {
-        assert!(haystack.contains(needle));
-    })
-}
-
-macro_rules! make_test_inner {
-    ($s:ident, $code:expr, $name:ident, $str:expr, $iters:expr) => {
-        #[bench]
-        fn $name(bencher: &mut Bencher) {
-            let mut $s = $str;
-            black_box(&mut $s);
-            bencher.iter(|| {
-                for _ in 0..$iters {
-                    black_box($code);
-                }
-            });
-        }
-    };
-}
-
-macro_rules! make_test {
-    ($name:ident, $s:ident, $code:expr) => {
-        make_test!($name, $s, $code, 1);
-    };
-    ($name:ident, $s:ident, $code:expr, $iters:expr) => {
-        mod $name {
-            use test::Bencher;
-            use test::black_box;
-
-            // Short strings: 65 bytes each
-            make_test_inner!($s, $code, short_ascii,
-                "Mary had a little lamb, Little lamb Mary had a littl lamb, lamb!", $iters);
-            make_test_inner!($s, $code, short_mixed,
-                "ศไทย中华Việt Nam; Mary had a little lamb, Little lam!", $iters);
-            make_test_inner!($s, $code, short_pile_of_poo,
-                "💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩!", $iters);
-            make_test_inner!($s, $code, long_lorem_ipsum,"\
-Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse quis lorem sit amet dolor \
-ultricies condimentum. Praesent iaculis purus elit, ac malesuada quam malesuada in. Duis sed orci \
-eros. Suspendisse sit amet magna mollis, mollis nunc luctus, imperdiet mi. Integer fringilla non \
-sem ut lacinia. Fusce varius tortor a risus porttitor hendrerit. Morbi mauris dui, ultricies nec \
-tempus vel, gravida nec quam.
-
-In est dui, tincidunt sed tempus interdum, adipiscing laoreet ante. Etiam tempor, tellus quis \
-sagittis interdum, nulla purus mattis sem, quis auctor erat odio ac tellus. In nec nunc sit amet \
-diam volutpat molestie at sed ipsum. Vestibulum laoreet consequat vulputate. Integer accumsan \
-lorem ac dignissim placerat. Suspendisse convallis faucibus lorem. Aliquam erat volutpat. In vel \
-eleifend felis. Sed suscipit nulla lorem, sed mollis est sollicitudin et. Nam fermentum egestas \
-interdum. Curabitur ut nisi justo.
-
-Sed sollicitudin ipsum tellus, ut condimentum leo eleifend nec. Cras ut velit ante. Phasellus nec \
-mollis odio. Mauris molestie erat in arcu mattis, at aliquet dolor vehicula. Quisque malesuada \
-lectus sit amet nisi pretium, a condimentum ipsum porta. Morbi at dapibus diam. Praesent egestas \
-est sed risus elementum, eu rutrum metus ultrices. Etiam fermentum consectetur magna, id rutrum \
-felis accumsan a. Aliquam ut pellentesque libero. Sed mi nulla, lobortis eu tortor id, suscipit \
-ultricies neque. Morbi iaculis sit amet risus at iaculis. Praesent eget ligula quis turpis \
-feugiat suscipit vel non arcu. Interdum et malesuada fames ac ante ipsum primis in faucibus. \
-Aliquam sit amet placerat lorem.
-
-Cras a lacus vel ante posuere elementum. Nunc est leo, bibendum ut facilisis vel, bibendum at \
-mauris. Nullam adipiscing diam vel odio ornare, luctus adipiscing mi luctus. Nulla facilisi. \
-Mauris adipiscing bibendum neque, quis adipiscing lectus tempus et. Sed feugiat erat et nisl \
-lobortis pharetra. Donec vitae erat enim. Nullam sit amet felis et quam lacinia tincidunt. Aliquam \
-suscipit dapibus urna. Sed volutpat urna in magna pulvinar volutpat. Phasellus nec tellus ac diam \
-cursus accumsan.
-
-Nam lectus enim, dapibus non nisi tempor, consectetur convallis massa. Maecenas eleifend dictum \
-feugiat. Etiam quis mauris vel risus luctus mattis a a nunc. Nullam orci quam, imperdiet id \
-vehicula in, porttitor ut nibh. Duis sagittis adipiscing nisl vitae congue. Donec mollis risus eu \
-leo suscipit, varius porttitor nulla porta. Pellentesque ut sem nec nisi euismod vehicula. Nulla \
-malesuada sollicitudin quam eu fermentum!", $iters);
-        }
-    }
-}
-
-make_test!(chars_count, s, s.chars().count());
-
-make_test!(contains_bang_str, s, s.contains("!"));
-make_test!(contains_bang_char, s, s.contains('!'));
-
-make_test!(match_indices_a_str, s, s.match_indices("a").count());
-
-make_test!(split_a_str, s, s.split("a").count());
-
-make_test!(trim_ascii_char, s, { s.trim_matches(|c: char| c.is_ascii()) });
-make_test!(trim_start_ascii_char, s, { s.trim_start_matches(|c: char| c.is_ascii()) });
-make_test!(trim_end_ascii_char, s, { s.trim_end_matches(|c: char| c.is_ascii()) });
-
-make_test!(find_underscore_char, s, s.find('_'));
-make_test!(rfind_underscore_char, s, s.rfind('_'));
-make_test!(find_underscore_str, s, s.find("_"));
-
-make_test!(find_zzz_char, s, s.find('\u{1F4A4}'));
-make_test!(rfind_zzz_char, s, s.rfind('\u{1F4A4}'));
-make_test!(find_zzz_str, s, s.find("\u{1F4A4}"));
-
-make_test!(starts_with_ascii_char, s, s.starts_with('/'), 1024);
-make_test!(ends_with_ascii_char, s, s.ends_with('/'), 1024);
-make_test!(starts_with_unichar, s, s.starts_with('\u{1F4A4}'), 1024);
-make_test!(ends_with_unichar, s, s.ends_with('\u{1F4A4}'), 1024);
-make_test!(starts_with_str, s, s.starts_with("💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩"), 1024);
-make_test!(ends_with_str, s, s.ends_with("💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩"), 1024);
-
-make_test!(split_space_char, s, s.split(' ').count());
-make_test!(split_terminator_space_char, s, s.split_terminator(' ').count());
-
-make_test!(splitn_space_char, s, s.splitn(10, ' ').count());
-make_test!(rsplitn_space_char, s, s.rsplitn(10, ' ').count());
-
-make_test!(split_space_str, s, s.split(" ").count());
-make_test!(split_ad_str, s, s.split("ad").count());
diff --git a/src/liballoc/benches/string.rs b/src/liballoc/benches/string.rs
deleted file mode 100644
index 5c95160ba2d..00000000000
--- a/src/liballoc/benches/string.rs
+++ /dev/null
@@ -1,164 +0,0 @@
-use std::iter::repeat;
-use test::{black_box, Bencher};
-
-#[bench]
-fn bench_with_capacity(b: &mut Bencher) {
-    b.iter(|| String::with_capacity(100));
-}
-
-#[bench]
-fn bench_push_str(b: &mut Bencher) {
-    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-    b.iter(|| {
-        let mut r = String::new();
-        r.push_str(s);
-    });
-}
-
-const REPETITIONS: u64 = 10_000;
-
-#[bench]
-fn bench_push_str_one_byte(b: &mut Bencher) {
-    b.bytes = REPETITIONS;
-    b.iter(|| {
-        let mut r = String::new();
-        for _ in 0..REPETITIONS {
-            r.push_str("a")
-        }
-    });
-}
-
-#[bench]
-fn bench_push_char_one_byte(b: &mut Bencher) {
-    b.bytes = REPETITIONS;
-    b.iter(|| {
-        let mut r = String::new();
-        for _ in 0..REPETITIONS {
-            r.push('a')
-        }
-    });
-}
-
-#[bench]
-fn bench_push_char_two_bytes(b: &mut Bencher) {
-    b.bytes = REPETITIONS * 2;
-    b.iter(|| {
-        let mut r = String::new();
-        for _ in 0..REPETITIONS {
-            r.push('â')
-        }
-    });
-}
-
-#[bench]
-fn from_utf8_lossy_100_ascii(b: &mut Bencher) {
-    let s = b"Hello there, the quick brown fox jumped over the lazy dog! \
-              Lorem ipsum dolor sit amet, consectetur. ";
-
-    assert_eq!(100, s.len());
-    b.iter(|| {
-        let _ = String::from_utf8_lossy(s);
-    });
-}
-
-#[bench]
-fn from_utf8_lossy_100_multibyte(b: &mut Bencher) {
-    let s = "𐌀𐌖𐌋𐌄𐌑𐌉ปรدولة الكويتทศไทย中华𐍅𐌿𐌻𐍆𐌹𐌻𐌰".as_bytes();
-    assert_eq!(100, s.len());
-    b.iter(|| {
-        let _ = String::from_utf8_lossy(s);
-    });
-}
-
-#[bench]
-fn from_utf8_lossy_invalid(b: &mut Bencher) {
-    let s = b"Hello\xC0\x80 There\xE6\x83 Goodbye";
-    b.iter(|| {
-        let _ = String::from_utf8_lossy(s);
-    });
-}
-
-#[bench]
-fn from_utf8_lossy_100_invalid(b: &mut Bencher) {
-    let s = repeat(0xf5).take(100).collect::<Vec<_>>();
-    b.iter(|| {
-        let _ = String::from_utf8_lossy(&s);
-    });
-}
-
-#[bench]
-fn bench_exact_size_shrink_to_fit(b: &mut Bencher) {
-    let s = "Hello there, the quick brown fox jumped over the lazy dog! \
-             Lorem ipsum dolor sit amet, consectetur. ";
-    // ensure our operation produces an exact-size string before we benchmark it
-    let mut r = String::with_capacity(s.len());
-    r.push_str(s);
-    assert_eq!(r.len(), r.capacity());
-    b.iter(|| {
-        let mut r = String::with_capacity(s.len());
-        r.push_str(s);
-        r.shrink_to_fit();
-        r
-    });
-}
-
-#[bench]
-fn bench_from_str(b: &mut Bencher) {
-    let s = "Hello there, the quick brown fox jumped over the lazy dog! \
-             Lorem ipsum dolor sit amet, consectetur. ";
-    b.iter(|| String::from(s))
-}
-
-#[bench]
-fn bench_from(b: &mut Bencher) {
-    let s = "Hello there, the quick brown fox jumped over the lazy dog! \
-             Lorem ipsum dolor sit amet, consectetur. ";
-    b.iter(|| String::from(s))
-}
-
-#[bench]
-fn bench_to_string(b: &mut Bencher) {
-    let s = "Hello there, the quick brown fox jumped over the lazy dog! \
-             Lorem ipsum dolor sit amet, consectetur. ";
-    b.iter(|| s.to_string())
-}
-
-#[bench]
-fn bench_insert_char_short(b: &mut Bencher) {
-    let s = "Hello, World!";
-    b.iter(|| {
-        let mut x = String::from(s);
-        black_box(&mut x).insert(6, black_box(' '));
-        x
-    })
-}
-
-#[bench]
-fn bench_insert_char_long(b: &mut Bencher) {
-    let s = "Hello, World!";
-    b.iter(|| {
-        let mut x = String::from(s);
-        black_box(&mut x).insert(6, black_box('❤'));
-        x
-    })
-}
-
-#[bench]
-fn bench_insert_str_short(b: &mut Bencher) {
-    let s = "Hello, World!";
-    b.iter(|| {
-        let mut x = String::from(s);
-        black_box(&mut x).insert_str(6, black_box(" "));
-        x
-    })
-}
-
-#[bench]
-fn bench_insert_str_long(b: &mut Bencher) {
-    let s = "Hello, World!";
-    b.iter(|| {
-        let mut x = String::from(s);
-        black_box(&mut x).insert_str(6, black_box(" rustic "));
-        x
-    })
-}
diff --git a/src/liballoc/benches/vec.rs b/src/liballoc/benches/vec.rs
deleted file mode 100644
index a3da9e80cd0..00000000000
--- a/src/liballoc/benches/vec.rs
+++ /dev/null
@@ -1,482 +0,0 @@
-use std::iter::{repeat, FromIterator};
-use test::Bencher;
-
-#[bench]
-fn bench_new(b: &mut Bencher) {
-    b.iter(|| {
-        let v: Vec<u32> = Vec::new();
-        assert_eq!(v.len(), 0);
-        assert_eq!(v.capacity(), 0);
-    })
-}
-
-fn do_bench_with_capacity(b: &mut Bencher, src_len: usize) {
-    b.bytes = src_len as u64;
-
-    b.iter(|| {
-        let v: Vec<u32> = Vec::with_capacity(src_len);
-        assert_eq!(v.len(), 0);
-        assert_eq!(v.capacity(), src_len);
-    })
-}
-
-#[bench]
-fn bench_with_capacity_0000(b: &mut Bencher) {
-    do_bench_with_capacity(b, 0)
-}
-
-#[bench]
-fn bench_with_capacity_0010(b: &mut Bencher) {
-    do_bench_with_capacity(b, 10)
-}
-
-#[bench]
-fn bench_with_capacity_0100(b: &mut Bencher) {
-    do_bench_with_capacity(b, 100)
-}
-
-#[bench]
-fn bench_with_capacity_1000(b: &mut Bencher) {
-    do_bench_with_capacity(b, 1000)
-}
-
-fn do_bench_from_fn(b: &mut Bencher, src_len: usize) {
-    b.bytes = src_len as u64;
-
-    b.iter(|| {
-        let dst = (0..src_len).collect::<Vec<_>>();
-        assert_eq!(dst.len(), src_len);
-        assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
-    })
-}
-
-#[bench]
-fn bench_from_fn_0000(b: &mut Bencher) {
-    do_bench_from_fn(b, 0)
-}
-
-#[bench]
-fn bench_from_fn_0010(b: &mut Bencher) {
-    do_bench_from_fn(b, 10)
-}
-
-#[bench]
-fn bench_from_fn_0100(b: &mut Bencher) {
-    do_bench_from_fn(b, 100)
-}
-
-#[bench]
-fn bench_from_fn_1000(b: &mut Bencher) {
-    do_bench_from_fn(b, 1000)
-}
-
-fn do_bench_from_elem(b: &mut Bencher, src_len: usize) {
-    b.bytes = src_len as u64;
-
-    b.iter(|| {
-        let dst: Vec<usize> = repeat(5).take(src_len).collect();
-        assert_eq!(dst.len(), src_len);
-        assert!(dst.iter().all(|x| *x == 5));
-    })
-}
-
-#[bench]
-fn bench_from_elem_0000(b: &mut Bencher) {
-    do_bench_from_elem(b, 0)
-}
-
-#[bench]
-fn bench_from_elem_0010(b: &mut Bencher) {
-    do_bench_from_elem(b, 10)
-}
-
-#[bench]
-fn bench_from_elem_0100(b: &mut Bencher) {
-    do_bench_from_elem(b, 100)
-}
-
-#[bench]
-fn bench_from_elem_1000(b: &mut Bencher) {
-    do_bench_from_elem(b, 1000)
-}
-
-fn do_bench_from_slice(b: &mut Bencher, src_len: usize) {
-    let src: Vec<_> = FromIterator::from_iter(0..src_len);
-
-    b.bytes = src_len as u64;
-
-    b.iter(|| {
-        let dst = src.clone()[..].to_vec();
-        assert_eq!(dst.len(), src_len);
-        assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
-    });
-}
-
-#[bench]
-fn bench_from_slice_0000(b: &mut Bencher) {
-    do_bench_from_slice(b, 0)
-}
-
-#[bench]
-fn bench_from_slice_0010(b: &mut Bencher) {
-    do_bench_from_slice(b, 10)
-}
-
-#[bench]
-fn bench_from_slice_0100(b: &mut Bencher) {
-    do_bench_from_slice(b, 100)
-}
-
-#[bench]
-fn bench_from_slice_1000(b: &mut Bencher) {
-    do_bench_from_slice(b, 1000)
-}
-
-fn do_bench_from_iter(b: &mut Bencher, src_len: usize) {
-    let src: Vec<_> = FromIterator::from_iter(0..src_len);
-
-    b.bytes = src_len as u64;
-
-    b.iter(|| {
-        let dst: Vec<_> = FromIterator::from_iter(src.clone());
-        assert_eq!(dst.len(), src_len);
-        assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
-    });
-}
-
-#[bench]
-fn bench_from_iter_0000(b: &mut Bencher) {
-    do_bench_from_iter(b, 0)
-}
-
-#[bench]
-fn bench_from_iter_0010(b: &mut Bencher) {
-    do_bench_from_iter(b, 10)
-}
-
-#[bench]
-fn bench_from_iter_0100(b: &mut Bencher) {
-    do_bench_from_iter(b, 100)
-}
-
-#[bench]
-fn bench_from_iter_1000(b: &mut Bencher) {
-    do_bench_from_iter(b, 1000)
-}
-
-fn do_bench_extend(b: &mut Bencher, dst_len: usize, src_len: usize) {
-    let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
-    let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
-
-    b.bytes = src_len as u64;
-
-    b.iter(|| {
-        let mut dst = dst.clone();
-        dst.extend(src.clone());
-        assert_eq!(dst.len(), dst_len + src_len);
-        assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
-    });
-}
-
-#[bench]
-fn bench_extend_0000_0000(b: &mut Bencher) {
-    do_bench_extend(b, 0, 0)
-}
-
-#[bench]
-fn bench_extend_0000_0010(b: &mut Bencher) {
-    do_bench_extend(b, 0, 10)
-}
-
-#[bench]
-fn bench_extend_0000_0100(b: &mut Bencher) {
-    do_bench_extend(b, 0, 100)
-}
-
-#[bench]
-fn bench_extend_0000_1000(b: &mut Bencher) {
-    do_bench_extend(b, 0, 1000)
-}
-
-#[bench]
-fn bench_extend_0010_0010(b: &mut Bencher) {
-    do_bench_extend(b, 10, 10)
-}
-
-#[bench]
-fn bench_extend_0100_0100(b: &mut Bencher) {
-    do_bench_extend(b, 100, 100)
-}
-
-#[bench]
-fn bench_extend_1000_1000(b: &mut Bencher) {
-    do_bench_extend(b, 1000, 1000)
-}
-
-fn do_bench_push_all(b: &mut Bencher, dst_len: usize, src_len: usize) {
-    let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
-    let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
-
-    b.bytes = src_len as u64;
-
-    b.iter(|| {
-        let mut dst = dst.clone();
-        dst.extend_from_slice(&src);
-        assert_eq!(dst.len(), dst_len + src_len);
-        assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
-    });
-}
-
-#[bench]
-fn bench_push_all_0000_0000(b: &mut Bencher) {
-    do_bench_push_all(b, 0, 0)
-}
-
-#[bench]
-fn bench_push_all_0000_0010(b: &mut Bencher) {
-    do_bench_push_all(b, 0, 10)
-}
-
-#[bench]
-fn bench_push_all_0000_0100(b: &mut Bencher) {
-    do_bench_push_all(b, 0, 100)
-}
-
-#[bench]
-fn bench_push_all_0000_1000(b: &mut Bencher) {
-    do_bench_push_all(b, 0, 1000)
-}
-
-#[bench]
-fn bench_push_all_0010_0010(b: &mut Bencher) {
-    do_bench_push_all(b, 10, 10)
-}
-
-#[bench]
-fn bench_push_all_0100_0100(b: &mut Bencher) {
-    do_bench_push_all(b, 100, 100)
-}
-
-#[bench]
-fn bench_push_all_1000_1000(b: &mut Bencher) {
-    do_bench_push_all(b, 1000, 1000)
-}
-
-fn do_bench_push_all_move(b: &mut Bencher, dst_len: usize, src_len: usize) {
-    let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
-    let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
-
-    b.bytes = src_len as u64;
-
-    b.iter(|| {
-        let mut dst = dst.clone();
-        dst.extend(src.clone());
-        assert_eq!(dst.len(), dst_len + src_len);
-        assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
-    });
-}
-
-#[bench]
-fn bench_push_all_move_0000_0000(b: &mut Bencher) {
-    do_bench_push_all_move(b, 0, 0)
-}
-
-#[bench]
-fn bench_push_all_move_0000_0010(b: &mut Bencher) {
-    do_bench_push_all_move(b, 0, 10)
-}
-
-#[bench]
-fn bench_push_all_move_0000_0100(b: &mut Bencher) {
-    do_bench_push_all_move(b, 0, 100)
-}
-
-#[bench]
-fn bench_push_all_move_0000_1000(b: &mut Bencher) {
-    do_bench_push_all_move(b, 0, 1000)
-}
-
-#[bench]
-fn bench_push_all_move_0010_0010(b: &mut Bencher) {
-    do_bench_push_all_move(b, 10, 10)
-}
-
-#[bench]
-fn bench_push_all_move_0100_0100(b: &mut Bencher) {
-    do_bench_push_all_move(b, 100, 100)
-}
-
-#[bench]
-fn bench_push_all_move_1000_1000(b: &mut Bencher) {
-    do_bench_push_all_move(b, 1000, 1000)
-}
-
-fn do_bench_clone(b: &mut Bencher, src_len: usize) {
-    let src: Vec<usize> = FromIterator::from_iter(0..src_len);
-
-    b.bytes = src_len as u64;
-
-    b.iter(|| {
-        let dst = src.clone();
-        assert_eq!(dst.len(), src_len);
-        assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
-    });
-}
-
-#[bench]
-fn bench_clone_0000(b: &mut Bencher) {
-    do_bench_clone(b, 0)
-}
-
-#[bench]
-fn bench_clone_0010(b: &mut Bencher) {
-    do_bench_clone(b, 10)
-}
-
-#[bench]
-fn bench_clone_0100(b: &mut Bencher) {
-    do_bench_clone(b, 100)
-}
-
-#[bench]
-fn bench_clone_1000(b: &mut Bencher) {
-    do_bench_clone(b, 1000)
-}
-
-fn do_bench_clone_from(b: &mut Bencher, times: usize, dst_len: usize, src_len: usize) {
-    let dst: Vec<_> = FromIterator::from_iter(0..src_len);
-    let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
-
-    b.bytes = (times * src_len) as u64;
-
-    b.iter(|| {
-        let mut dst = dst.clone();
-
-        for _ in 0..times {
-            dst.clone_from(&src);
-
-            assert_eq!(dst.len(), src_len);
-            assert!(dst.iter().enumerate().all(|(i, x)| dst_len + i == *x));
-        }
-    });
-}
-
-#[bench]
-fn bench_clone_from_01_0000_0000(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 0, 0)
-}
-
-#[bench]
-fn bench_clone_from_01_0000_0010(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 0, 10)
-}
-
-#[bench]
-fn bench_clone_from_01_0000_0100(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 0, 100)
-}
-
-#[bench]
-fn bench_clone_from_01_0000_1000(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 0, 1000)
-}
-
-#[bench]
-fn bench_clone_from_01_0010_0010(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 10, 10)
-}
-
-#[bench]
-fn bench_clone_from_01_0100_0100(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 100, 100)
-}
-
-#[bench]
-fn bench_clone_from_01_1000_1000(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 1000, 1000)
-}
-
-#[bench]
-fn bench_clone_from_01_0010_0100(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 10, 100)
-}
-
-#[bench]
-fn bench_clone_from_01_0100_1000(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 100, 1000)
-}
-
-#[bench]
-fn bench_clone_from_01_0010_0000(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 10, 0)
-}
-
-#[bench]
-fn bench_clone_from_01_0100_0010(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 100, 10)
-}
-
-#[bench]
-fn bench_clone_from_01_1000_0100(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 1000, 100)
-}
-
-#[bench]
-fn bench_clone_from_10_0000_0000(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 0, 0)
-}
-
-#[bench]
-fn bench_clone_from_10_0000_0010(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 0, 10)
-}
-
-#[bench]
-fn bench_clone_from_10_0000_0100(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 0, 100)
-}
-
-#[bench]
-fn bench_clone_from_10_0000_1000(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 0, 1000)
-}
-
-#[bench]
-fn bench_clone_from_10_0010_0010(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 10, 10)
-}
-
-#[bench]
-fn bench_clone_from_10_0100_0100(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 100, 100)
-}
-
-#[bench]
-fn bench_clone_from_10_1000_1000(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 1000, 1000)
-}
-
-#[bench]
-fn bench_clone_from_10_0010_0100(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 10, 100)
-}
-
-#[bench]
-fn bench_clone_from_10_0100_1000(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 100, 1000)
-}
-
-#[bench]
-fn bench_clone_from_10_0010_0000(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 10, 0)
-}
-
-#[bench]
-fn bench_clone_from_10_0100_0010(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 100, 10)
-}
-
-#[bench]
-fn bench_clone_from_10_1000_0100(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 1000, 100)
-}
diff --git a/src/liballoc/benches/vec_deque.rs b/src/liballoc/benches/vec_deque.rs
deleted file mode 100644
index bf2dffd1e93..00000000000
--- a/src/liballoc/benches/vec_deque.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-use std::collections::VecDeque;
-use test::{black_box, Bencher};
-
-#[bench]
-fn bench_new(b: &mut Bencher) {
-    b.iter(|| {
-        let ring: VecDeque<i32> = VecDeque::new();
-        black_box(ring);
-    })
-}
-
-#[bench]
-fn bench_grow_1025(b: &mut Bencher) {
-    b.iter(|| {
-        let mut deq = VecDeque::new();
-        for i in 0..1025 {
-            deq.push_front(i);
-        }
-        black_box(deq);
-    })
-}
-
-#[bench]
-fn bench_iter_1000(b: &mut Bencher) {
-    let ring: VecDeque<_> = (0..1000).collect();
-
-    b.iter(|| {
-        let mut sum = 0;
-        for &i in &ring {
-            sum += i;
-        }
-        black_box(sum);
-    })
-}
-
-#[bench]
-fn bench_mut_iter_1000(b: &mut Bencher) {
-    let mut ring: VecDeque<_> = (0..1000).collect();
-
-    b.iter(|| {
-        let mut sum = 0;
-        for i in &mut ring {
-            sum += *i;
-        }
-        black_box(sum);
-    })
-}
-
-#[bench]
-fn bench_try_fold(b: &mut Bencher) {
-    let ring: VecDeque<_> = (0..1000).collect();
-
-    b.iter(|| black_box(ring.iter().try_fold(0, |a, b| Some(a + b))))
-}
diff --git a/src/liballoc/benches/vec_deque_append.rs b/src/liballoc/benches/vec_deque_append.rs
deleted file mode 100644
index 5825bdc355f..00000000000
--- a/src/liballoc/benches/vec_deque_append.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-use std::{collections::VecDeque, time::Instant};
-
-const VECDEQUE_LEN: i32 = 100000;
-const WARMUP_N: usize = 100;
-const BENCH_N: usize = 1000;
-
-fn main() {
-    let a: VecDeque<i32> = (0..VECDEQUE_LEN).collect();
-    let b: VecDeque<i32> = (0..VECDEQUE_LEN).collect();
-
-    for _ in 0..WARMUP_N {
-        let mut c = a.clone();
-        let mut d = b.clone();
-        c.append(&mut d);
-    }
-
-    let mut durations = Vec::with_capacity(BENCH_N);
-
-    for _ in 0..BENCH_N {
-        let mut c = a.clone();
-        let mut d = b.clone();
-        let before = Instant::now();
-        c.append(&mut d);
-        let after = Instant::now();
-        durations.push(after.duration_since(before));
-    }
-
-    let l = durations.len();
-    durations.sort();
-
-    assert!(BENCH_N % 2 == 0);
-    let median = (durations[(l / 2) - 1] + durations[l / 2]) / 2;
-    println!("\ncustom-bench vec_deque_append {:?} ns/iter\n", median.as_nanos());
-}