deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/.cargo-checksum.json
+++ /dev/null
@@ -1,1 +0,0 @@
-{"files":{".travis.yml":"6f11d19317924088c90d605e1d13e4af230b10e289c5df6139c40a62409eabd9","Cargo.toml":"f893b7b701611e48ab80db25670342084b11d8d4ed3f3471b68842c490d247b8","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397","README.md":"11061a4c1e27fde148b5b1fb6df553f8eb464e279be0f5e278d262bf35d7b0f8","appveyor.yml":"29d9f44137560479a75b02a7953cfa0c378c2577ed1925f579b400295c7937e3","examples/backtrace.rs":"fd6e1cc6c3378ec7d41cd03b2bef187051298dceb01147e71f207dbb8a0c4867","examples/raw.rs":"f07be26d1f97cd7ac79290ac99d19c4eec5d27031fe270ab5364c25d9c2ad9e0","src/backtrace/dbghelp.rs":"45c5052763857d4a3727c3082be1b2f6c28f7973afd66706657defda5d97c6ec","src/backtrace/libunwind.rs":"cc9cdc1d389571cdedf43dfc2d39b8c3af85531a3965ed700c724f436afb213e","src/backtrace/mod.rs":"d00f4a574fae44df81b1d40bf44acea84addb70b4c76c85bfaa1f3ab0bcd7f0d","src/backtrace/noop.rs":"dc4a6602e9852b945c382194402314d3d68c8ca90199af9a8159419fb91a3c99","src/backtrace/unix_backtrace.rs":"1bb4a4a2f1e56f8ac04002dd77411116d8b4920f905d1ddfcb289e242f939a86","src/capture.rs":"de3250fcb9ff941391dea24decc8166d058f17abe77d25ff82b766ac384f00ea","src/dylib.rs":"09f3d7f32849cf0daa4de9df48f8e4a4d5ba62e20723c79578201bd271dc4777","src/lib.rs":"7ccd8cc3679435f0e39efd26f23d9d7a01094ab09ba6d411c6587b2420c6886b","src/symbolize/coresymbolication.rs":"99280684791694f560824b39291ee7ad78a2b53f82e5972ff3d9b77b43671f60","src/symbolize/dbghelp.rs":"d743545bb3e64eafc4903e3e7aec115b64da2174e75afd7b465bc0b89573b88a","src/symbolize/dladdr.rs":"8287cbca440a9e92e74d88c5a7b920f6b4cf6d8f50bc8b0f61aca5ba42d5b5ec","src/symbolize/libbacktrace.rs":"0cdad7de2501baef9da193ee6aab21c453d26348a2071c805a133efe1209eaa1","src/symbolize/mod.rs":"7f2efe54ce40f42ba38673614cff2a510632123cb6d1bc3da88566f12bcba588","src/symbolize/noop.rs":"b622fcecb4e22b42c3d3e2ef5dc5a6ab14601fec83c7797ee1fbbacc12fe6ca1","tests/smoke.rs":"fc882d7db0f4842e4415e3319774a33ba27c4d6412a62f8ee194a5dafd8a6128"},"package":"72f9b4182546f4b04ebc4ab7f84948953a118bd6021a1b6a6c909e3e94f6be76"}
\ No newline at end of file

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/.travis.yml
+++ /dev/null
@@ -1,40 +0,0 @@
-language: rust
-rust:
-  - stable
-  - beta
-  - nightly
-sudo: false
-before_script:
-  - pip install 'travis-cargo<0.2' --user && export PATH=$HOME/.local/bin:$PATH
-script:
-  - cargo test
-  - cargo test --no-default-features
-  - cargo test --no-default-features --features 'libunwind'
-  - cargo test --no-default-features --features 'libunwind dladdr'
-  - cargo test --no-default-features --features 'libunwind libbacktrace'
-  - cargo test --no-default-features --features 'unix-backtrace'
-  - cargo test --no-default-features --features 'unix-backtrace dladdr'
-  - cargo test --no-default-features --features 'unix-backtrace libbacktrace'
-  - cargo test --no-default-features --features 'serialize-serde'
-  - cargo test --no-default-features --features 'serialize-rustc'
-  - cargo test --no-default-features --features 'serialize-rustc serialize-serde'
-  - cargo test --no-default-features --features 'cpp_demangle'
-  - cd ./cpp_smoke_test && cargo test && cd ..
-  - cargo clean && cargo build
-  - rustdoc --test README.md -L target/debug/deps -L target/debug
-  - cargo doc --no-deps
-notifications:
-  email:
-    on_success: never
-after_success:
-  - travis-cargo --only nightly doc-upload
-env:
-  global:
-    # serde-codegen has historically needed a large stack to expand
-    - RUST_MIN_STACK=16777216
-    - secure: "Kuf3j6gC3MhR+F7g8/5J4+3tu+FXJP/SqKjsUVVjs/qjniIVX3MwZPhtP/pVtdRvYjW0NzLw5Nufb4o1cyY4uKwR8BHHNuEUE/h3mPShjWHqzLyn5QiBumPozsFCa32H4gconRmp3+s0YrBT7nLoGvUZZS0dkldMkpvvrPL/yUKXLS8HEP4L1GO5iMQQYG6i3sbWTbHikE6ZQogW/iZommyqUkVB/s/SQvdH9SXu89ttNXlm/F+EIsgsgyzpbULp5sD34GRDPJe+H1m+sgA1kTRrzmuBGNmz9mx6GyIKaqACTm1gRcb06nFjTPVTQioJBNnoV7TEqZCvjuSsUjcGmP4Aeissafo93ADzV+bd0uoWIScE9ltSVS+RgCDV+sd0GHz5U6FjhgZp0amaVl3d6hPp8lbTfK/gfj1i9ktQfKZbG7rB4tfIU1KeQRkyE9vb/TaKp8nwBbc4SVQ4EKFOlRbE1S1FooaKZweW8w57d2u+sMMMVJbO28/Ap8tk9xDSOl4shPaT0iM0U9/heF8FmCZB1OKXLKn6TAaNFnaMTvdTHl+Tjrf6Vzd/oPXJ7GuaB6eLxXYjXvZHuKiLkSZriOzhL7PbijNILbSgZt7+Fa0vcnXP8zgD4dmupx/CoIHLN9NP4o9cGXuBcaJ/iFryJ4i5LKGFNEUHtXkavDrcgcA="
-
-
-os:
-  - linux
-  - osx

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/Cargo.toml
+++ /dev/null
@@ -1,87 +0,0 @@
-[package]
-name = "backtrace"
-version = "0.3.2"
-authors = ["Alex Crichton <alex@alexcrichton.com>",
-           "The Rust Project Developers"]
-license = "MIT/Apache-2.0"
-readme = "README.md"
-repository = "https://github.com/alexcrichton/backtrace-rs"
-homepage = "https://github.com/alexcrichton/backtrace-rs"
-documentation = "http://alexcrichton.com/backtrace-rs"
-description = """
-A library to acquire a stack trace (backtrace) at runtime in a Rust program.
-"""
-[dependencies]
-libc = "0.2"
-cfg-if = "0.1"
-rustc-demangle = "0.1.4"
-
-# Optionally enable the ability to serialize a `Backtrace`
-serde = { version = "1.0", optional = true }
-serde_derive = { version = "1.0", optional = true }
-rustc-serialize = { version = "0.3", optional = true }
-
-# Optionally demangle C++ frames' symbols in backtraces.
-cpp_demangle = { default-features = false, version = "0.2.3", optional = true }
-
-[target.'cfg(windows)'.dependencies]
-dbghelp-sys = { version = "0.2", optional = true }
-kernel32-sys = { version = "0.2", optional = true }
-winapi = { version = "0.2.5", optional = true }
-
-[target.'cfg(all(unix, not(target_os = "emscripten"), not(target_os = "macos"), not(target_os = "ios")))'.dependencies]
-backtrace-sys = { path = "backtrace-sys", version = "0.1.3", optional = true }
-
-# Each feature controls the two phases of finding a backtrace: getting a
-# backtrace and then resolving instruction pointers to symbols. The default
-# feature enables all the necessary features for each platform this library
-# supports, but it can be disabled to have finer grained control over the
-# dependencies.
-#
-# Note that not all features are available on all platforms, so even though a
-# feature is enabled some other feature may be used instead.
-[features]
-default = ["libunwind", "libbacktrace", "coresymbolication", "dladdr", "dbghelp"]
-
-    #=======================================
-    # Methods of acquiring a backtrace
-    #
-    # - libunwind: when using this the libgcc library is linked against to get
-    #   the unwinding support. This is generally the most reliable method to get
-    #   a backtrace on unix.
-    # - unix-backtrace: this uses the backtrace(3) function to acquire a
-    #   backtrace, but is not as reliable as libunwind. It is, however,
-    #   generally found in more locations.
-    # - dbghelp: on windows this enables usage of dbghelp.dll to find a
-    #   backtrace at runtime
-    # - kernel32: on windows this enables using RtlCaptureStackBackTrace as the
-    #   function to acquire a backtrace
-    libunwind = []
-    unix-backtrace = []
-    dbghelp = ["kernel32-sys", "winapi", "dbghelp-sys"]
-    kernel32 = []
-
-    #=======================================
-    # Methods of resolving symbols
-    #
-    # - libbacktrace: this feature activates the `backtrace-sys` dependency,
-    #   building the libbacktrace library found in gcc repos. This library
-    #   parses the DWARF info of ELF executables to find symbol names, and it
-    #   can also provide filename/line number information if debuginfo is
-    #   compiled in. This library currently only primarily works on unixes that
-    #   are not OSX, however.
-    # - dladdr: this feature uses the dladdr(3) function (a glibc extension) to
-    #   resolve symbol names. This is fairly unreliable on linux, but works well
-    #   enough on OSX.
-    # - coresymbolication: this feature uses the undocumented core symbolication
-    #   framework on OS X to symbolize.
-    libbacktrace = ["backtrace-sys"]
-    dladdr = []
-    coresymbolication = []
-
-    #=======================================
-    # Methods of serialization
-    #
-    # Various features used for enabling rustc-serialize or syntex codegen.
-    serialize-rustc = ["rustc-serialize"]
-    serialize-serde = ["serde", "serde_derive"]

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/LICENSE-APACHE
+++ /dev/null
@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/LICENSE-MIT
+++ /dev/null
@@ -1,25 +0,0 @@
-Copyright (c) 2014 Alex Crichton
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/README.md
+++ /dev/null
@@ -1,82 +0,0 @@
-# backtrace-rs
-
-[![Build Status](https://travis-ci.org/alexcrichton/backtrace-rs.svg?branch=master)](https://travis-ci.org/alexcrichton/backtrace-rs)
-[![Build status](https://ci.appveyor.com/api/projects/status/v4l9oj4aqbbgyx44?svg=true)](https://ci.appveyor.com/project/alexcrichton/backtrace-rs)
-
-[Documentation](http://alexcrichton.com/backtrace-rs)
-
-A library for acquiring backtraces at runtime for Rust. This library aims to
-enhance the support given by the standard library at `std::rt` by providing a
-more stable and programmatic interface.
-
-## Install
-
-```toml
-[dependencies]
-backtrace = "0.3"
-```
-
-```rust
-extern crate backtrace;
-```
-
-Note that this crate requires `make`, `objcopy`, and `ar` to be present on Linux
-systems.
-
-## Usage
-
-To simply capture a backtrace and defer dealing with it until a later time,
-you can use the top-level `Backtrace` type.
-
-```rust
-extern crate backtrace;
-
-use backtrace::Backtrace;
-
-fn main() {
-    let bt = Backtrace::new();
-
-    // do_some_work();
-
-    println!("{:?}", bt);
-}
-```
-
-If, however, you'd like more raw access to the actual tracing functionality, you
-can use the `trace` and `resolve` functions directly.
-
-```rust
-extern crate backtrace;
-
-fn main() {
-    backtrace::trace(|frame| {
-        let ip = frame.ip();
-        let symbol_address = frame.symbol_address();
-
-        // Resolve this instruction pointer to a symbol name
-        backtrace::resolve(ip, |symbol| {
-            if let Some(name) = symbol.name() {
-                // ...
-            }
-            if let Some(filename) = symbol.filename() {
-                // ...
-            }
-        });
-
-        true // keep going to the next frame
-    });
-}
-```
-
-## Platform Support
-
-This library currently supports OSX, Linux, and Windows. Support for other
-platforms is always welcome!
-
-## License
-
-`backtrace-rs` is primarily distributed under the terms of both the MIT license
-and the Apache License (Version 2.0), with portions covered by various BSD-like
-licenses.
-
-See LICENSE-APACHE, and LICENSE-MIT for details.

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/appveyor.yml
+++ /dev/null
@@ -1,20 +0,0 @@
-environment:
-  matrix:
-  - TARGET: x86_64-pc-windows-gnu
-    MSYS_BITS: 64
-  - TARGET: i686-pc-windows-gnu
-    MSYS_BITS: 32
-  - TARGET: x86_64-pc-windows-msvc
-  - TARGET: i686-pc-windows-msvc
-install:
-  - ps: Start-FileDownload "https://static.rust-lang.org/dist/rust-nightly-${env:TARGET}.exe"
-  - rust-nightly-%TARGET%.exe /VERYSILENT /NORESTART /DIR="C:\Program Files (x86)\Rust"
-  - set PATH=%PATH%;C:\Program Files (x86)\Rust\bin
-  - if defined MSYS_BITS set PATH=%PATH%;C:\msys64\mingw%MSYS_BITS%\bin
-  - rustc -V
-  - cargo -V
-
-build: false
-
-test_script:
-  - cargo test --target %TARGET%

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/examples/backtrace.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-extern crate backtrace;
-
-use backtrace::Backtrace;
-
-fn main() {
-    println!("{:?}", Backtrace::new());
-}

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/examples/raw.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-extern crate backtrace;
-
-fn main() {
-    foo();
-}
-
-fn foo() { bar() }
-fn bar() { baz() }
-fn baz() { print() }
-
-#[cfg(target_pointer_width = "32")] const HEX_WIDTH: usize = 10;
-#[cfg(target_pointer_width = "64")] const HEX_WIDTH: usize = 20;
-
-fn print() {
-    let mut cnt = 0;
-    backtrace::trace(|frame| {
-        let ip = frame.ip();
-        print!("frame #{:<2} - {:#02$x}", cnt, ip as usize, HEX_WIDTH);
-        cnt += 1;
-
-        let mut resolved = false;
-        backtrace::resolve(frame.ip(), |symbol| {
-            if !resolved {
-                resolved = true;
-            } else {
-                print!("{}", vec![" "; 7 + 2 + 3 + HEX_WIDTH].join(""));
-            }
-
-            if let Some(name) = symbol.name() {
-                print!(" - {}", name);
-            } else {
-                print!(" - <unknown>");
-            }
-            if let Some(file) = symbol.filename() {
-                if let Some(l) = symbol.lineno() {
-                    print!("\n{:13}{:4$}@ {}:{}", "", "", file.display(), l,
-                           HEX_WIDTH);
-                }
-            }
-            println!("");
-
-        });
-        if !resolved {
-            println!(" - <no info>");
-        }
-        true // keep going
-    });
-}

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/src/backtrace/dbghelp.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![allow(bad_style)]
-
-use std::mem;
-use winapi::*;
-use kernel32;
-
-pub struct Frame {
-    inner: STACKFRAME64,
-}
-
-impl Frame {
-    pub fn ip(&self) -> *mut c_void {
-        self.inner.AddrPC.Offset as *mut _
-    }
-
-    pub fn symbol_address(&self) -> *mut c_void {
-        self.ip()
-    }
-}
-
-#[inline(always)]
-pub fn trace(cb: &mut FnMut(&super::Frame) -> bool) {
-    // According to windows documentation, all dbghelp functions are
-    // single-threaded.
-    let _g = ::lock::lock();
-
-    unsafe {
-        // Allocate necessary structures for doing the stack walk
-        let process = kernel32::GetCurrentProcess();
-        let thread = kernel32::GetCurrentThread();
-
-        // The CONTEXT structure needs to be aligned on a 16-byte boundary for
-        // 64-bit Windows, but currently we don't have a way to express that in
-        // Rust. Allocations are generally aligned to 16-bytes, though, so we
-        // box this up.
-        let mut context = Box::new(mem::zeroed::<CONTEXT>());
-        kernel32::RtlCaptureContext(&mut *context);
-        let mut frame = super::Frame {
-            inner: Frame { inner: mem::zeroed() },
-        };
-        let image = init_frame(&mut frame.inner.inner, &context);
-
-        // Initialize this process's symbols
-        let _c = ::dbghelp_init();
-
-        // And now that we're done with all the setup, do the stack walking!
-        while ::dbghelp::StackWalk64(image as DWORD,
-                                     process,
-                                     thread,
-                                     &mut frame.inner.inner,
-                                     &mut *context as *mut _ as *mut _,
-                                     None,
-                                     Some(::dbghelp::SymFunctionTableAccess64),
-                                     Some(::dbghelp::SymGetModuleBase64),
-                                     None) == TRUE {
-            if frame.inner.inner.AddrPC.Offset == frame.inner.inner.AddrReturn.Offset ||
-               frame.inner.inner.AddrPC.Offset == 0 ||
-               frame.inner.inner.AddrReturn.Offset == 0 {
-                break
-            }
-
-            if !cb(&frame) {
-                break
-            }
-        }
-    }
-}
-
-#[cfg(target_arch = "x86_64")]
-fn init_frame(frame: &mut STACKFRAME64, ctx: &CONTEXT) -> WORD {
-    frame.AddrPC.Offset = ctx.Rip as u64;
-    frame.AddrPC.Mode = AddrModeFlat;
-    frame.AddrStack.Offset = ctx.Rsp as u64;
-    frame.AddrStack.Mode = AddrModeFlat;
-    frame.AddrFrame.Offset = ctx.Rbp as u64;
-    frame.AddrFrame.Mode = AddrModeFlat;
-    IMAGE_FILE_MACHINE_AMD64
-}
-
-#[cfg(target_arch = "x86")]
-fn init_frame(frame: &mut STACKFRAME64, ctx: &CONTEXT) -> WORD {
-    frame.AddrPC.Offset = ctx.Eip as u64;
-    frame.AddrPC.Mode = AddrModeFlat;
-    frame.AddrStack.Offset = ctx.Esp as u64;
-    frame.AddrStack.Mode = AddrModeFlat;
-    frame.AddrFrame.Offset = ctx.Ebp as u64;
-    frame.AddrFrame.Mode = AddrModeFlat;
-    IMAGE_FILE_MACHINE_I386
-}

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/src/backtrace/libunwind.rs
+++ /dev/null
@@ -1,200 +0,0 @@
-// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::os::raw::c_void;
-
-pub struct Frame {
-    ctx: *mut uw::_Unwind_Context,
-}
-
-impl Frame {
-    pub fn ip(&self) -> *mut c_void {
-        let mut ip_before_insn = 0;
-        let mut ip = unsafe {
-            uw::_Unwind_GetIPInfo(self.ctx, &mut ip_before_insn) as *mut c_void
-        };
-        if !ip.is_null() && ip_before_insn == 0 {
-            // this is a non-signaling frame, so `ip` refers to the address
-            // after the calling instruction. account for that.
-            ip = (ip as usize - 1) as *mut _;
-        }
-        return ip
-    }
-
-    pub fn symbol_address(&self) -> *mut c_void {
-        // dladdr() on osx gets whiny when we use FindEnclosingFunction, and
-        // it appears to work fine without it, so we only use
-        // FindEnclosingFunction on non-osx platforms. In doing so, we get a
-        // slightly more accurate stack trace in the process.
-        //
-        // This is often because panic involves the last instruction of a
-        // function being "call std::rt::begin_unwind", with no ret
-        // instructions after it. This means that the return instruction
-        // pointer points *outside* of the calling function, and by
-        // unwinding it we go back to the original function.
-        if cfg!(target_os = "macos") || cfg!(target_os = "ios") {
-            self.ip()
-        } else {
-            unsafe { uw::_Unwind_FindEnclosingFunction(self.ip()) }
-        }
-    }
-}
-
-#[inline(always)]
-pub fn trace(mut cb: &mut FnMut(&super::Frame) -> bool) {
-    unsafe {
-        uw::_Unwind_Backtrace(trace_fn, &mut cb as *mut _ as *mut _);
-    }
-
-    extern fn trace_fn(ctx: *mut uw::_Unwind_Context,
-                       arg: *mut c_void) -> uw::_Unwind_Reason_Code {
-        let cb = unsafe { &mut *(arg as *mut &mut FnMut(&super::Frame) -> bool) };
-        let cx = super::Frame {
-            inner: Frame { ctx: ctx },
-        };
-
-        let mut bomb = ::Bomb { enabled: true };
-        let keep_going = cb(&cx);
-        bomb.enabled = false;
-
-        if keep_going {
-            uw::_URC_NO_REASON
-        } else {
-            uw::_URC_FAILURE
-        }
-    }
-}
-
-/// Unwind library interface used for backtraces
-///
-/// Note that dead code is allowed as here are just bindings
-/// iOS doesn't use all of them it but adding more
-/// platform-specific configs pollutes the code too much
-#[allow(non_camel_case_types)]
-#[allow(non_snake_case)]
-#[allow(dead_code)]
-mod uw {
-    pub use self::_Unwind_Reason_Code::*;
-
-    use libc;
-    use std::os::raw::{c_int, c_void};
-
-    #[repr(C)]
-    pub enum _Unwind_Reason_Code {
-        _URC_NO_REASON = 0,
-        _URC_FOREIGN_EXCEPTION_CAUGHT = 1,
-        _URC_FATAL_PHASE2_ERROR = 2,
-        _URC_FATAL_PHASE1_ERROR = 3,
-        _URC_NORMAL_STOP = 4,
-        _URC_END_OF_STACK = 5,
-        _URC_HANDLER_FOUND = 6,
-        _URC_INSTALL_CONTEXT = 7,
-        _URC_CONTINUE_UNWIND = 8,
-        _URC_FAILURE = 9, // used only by ARM EABI
-    }
-
-    pub enum _Unwind_Context {}
-
-    pub type _Unwind_Trace_Fn =
-            extern fn(ctx: *mut _Unwind_Context,
-                      arg: *mut c_void) -> _Unwind_Reason_Code;
-
-    extern {
-        // No native _Unwind_Backtrace on iOS
-        #[cfg(not(all(target_os = "ios", target_arch = "arm")))]
-        pub fn _Unwind_Backtrace(trace: _Unwind_Trace_Fn,
-                                 trace_argument: *mut c_void)
-                    -> _Unwind_Reason_Code;
-
-        // available since GCC 4.2.0, should be fine for our purpose
-        #[cfg(all(not(all(target_os = "android", target_arch = "arm")),
-                  not(all(target_os = "linux", target_arch = "arm"))))]
-        pub fn _Unwind_GetIPInfo(ctx: *mut _Unwind_Context,
-                                 ip_before_insn: *mut c_int)
-                    -> libc::uintptr_t;
-
-        #[cfg(all(not(target_os = "android"),
-                  not(all(target_os = "linux", target_arch = "arm"))))]
-        pub fn _Unwind_FindEnclosingFunction(pc: *mut c_void)
-            -> *mut c_void;
-    }
-
-    // On android, the function _Unwind_GetIP is a macro, and this is the
-    // expansion of the macro. This is all copy/pasted directly from the
-    // header file with the definition of _Unwind_GetIP.
-    #[cfg(any(all(target_os = "android", target_arch = "arm"),
-              all(target_os = "linux", target_arch = "arm")))]
-    pub unsafe fn _Unwind_GetIP(ctx: *mut _Unwind_Context) -> libc::uintptr_t {
-        #[repr(C)]
-        enum _Unwind_VRS_Result {
-            _UVRSR_OK = 0,
-            _UVRSR_NOT_IMPLEMENTED = 1,
-            _UVRSR_FAILED = 2,
-        }
-        #[repr(C)]
-        enum _Unwind_VRS_RegClass {
-            _UVRSC_CORE = 0,
-            _UVRSC_VFP = 1,
-            _UVRSC_FPA = 2,
-            _UVRSC_WMMXD = 3,
-            _UVRSC_WMMXC = 4,
-        }
-        #[repr(C)]
-        enum _Unwind_VRS_DataRepresentation {
-            _UVRSD_UINT32 = 0,
-            _UVRSD_VFPX = 1,
-            _UVRSD_FPAX = 2,
-            _UVRSD_UINT64 = 3,
-            _UVRSD_FLOAT = 4,
-            _UVRSD_DOUBLE = 5,
-        }
-
-        type _Unwind_Word = libc::c_uint;
-        extern {
-            fn _Unwind_VRS_Get(ctx: *mut _Unwind_Context,
-                               klass: _Unwind_VRS_RegClass,
-                               word: _Unwind_Word,
-                               repr: _Unwind_VRS_DataRepresentation,
-                               data: *mut c_void)
-                -> _Unwind_VRS_Result;
-        }
-
-        let mut val: _Unwind_Word = 0;
-        let ptr = &mut val as *mut _Unwind_Word;
-        let _ = _Unwind_VRS_Get(ctx, _Unwind_VRS_RegClass::_UVRSC_CORE, 15,
-                                _Unwind_VRS_DataRepresentation::_UVRSD_UINT32,
-                                ptr as *mut c_void);
-        (val & !1) as libc::uintptr_t
-    }
-
-    // This function doesn't exist on Android or ARM/Linux, so make it same
-    // to _Unwind_GetIP
-    #[cfg(any(all(target_os = "android", target_arch = "arm"),
-              all(target_os = "linux", target_arch = "arm")))]
-    pub unsafe fn _Unwind_GetIPInfo(ctx: *mut _Unwind_Context,
-                                    ip_before_insn: *mut c_int)
-        -> libc::uintptr_t
-    {
-        *ip_before_insn = 0;
-        _Unwind_GetIP(ctx)
-    }
-
-    // This function also doesn't exist on Android or ARM/Linux, so make it
-    // a no-op
-    #[cfg(any(target_os = "android",
-              all(target_os = "linux", target_arch = "arm")))]
-    pub unsafe fn _Unwind_FindEnclosingFunction(pc: *mut c_void)
-        -> *mut c_void
-    {
-        pc
-    }
-}
-
-

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/src/backtrace/mod.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-use std::fmt;
-
-use std::os::raw::c_void;
-
-/// Inspects the current call-stack, passing all active frames into the closure
-/// provided to calculate a stack trace.
-///
-/// This function is the workhorse of this library in calculating the stack
-/// traces for a program. The given closure `cb` is yielded instances of a
-/// `Frame` which represent information about that call frame on the stack. The
-/// closure is yielded frames in a top-down fashion (most recently called
-/// functions first).
-///
-/// The closure's return value is an indication of whether the backtrace should
-/// continue. A return value of `false` will terminate the backtrace and return
-/// immediately.
-///
-/// Once a `Frame` is acquired you will likely want to call `backtrace::resolve`
-/// to convert the `ip` (instruction pointer) or symbol address to a `Symbol`
-/// through which the name and/or filename/line number can be learned.
-///
-/// Note that this is a relatively low-level function and if you'd like to, for
-/// example, capture a backtrace to be inspected later, then the `Backtrace`
-/// type may be more appropriate.
-///
-/// # Example
-///
-/// ```
-/// extern crate backtrace;
-///
-/// fn main() {
-///     backtrace::trace(|frame| {
-///         // ...
-///
-///         true // continue the backtrace
-///     });
-/// }
-/// ```
-#[inline(never)] // if this is never inlined then the first frame can be konwn
-                 // to be skipped
-pub fn trace<F: FnMut(&Frame) -> bool>(mut cb: F) {
-    trace_imp(&mut cb)
-}
-
-/// A trait representing one frame of a backtrace, yielded to the `trace`
-/// function of this crate.
-///
-/// The tracing function's closure will be yielded frames, and the frame is
-/// virtually dispatched as the underlying implementation is not always known
-/// until runtime.
-pub struct Frame {
-    inner: FrameImp,
-}
-
-impl Frame {
-    /// Returns the current instruction pointer of this frame.
-    ///
-    /// This is normally the next instruction to execute in the frame, but not
-    /// all implementations list this with 100% accuracy (but it's generally
-    /// pretty close).
-    ///
-    /// It is recommended to pass this value to `backtrace::resolve` to turn it
-    /// into a symbol name.
-    pub fn ip(&self) -> *mut c_void {
-        self.inner.ip()
-    }
-
-    /// Returns the starting symbol address of the frame of this function.
-    ///
-    /// This will attempt to rewind the instruction pointer returned by `ip` to
-    /// the start of the function, returning that value. In some cases, however,
-    /// backends will just return `ip` from this function.
-    ///
-    /// The returned value can sometimes be used if `backtrace::resolve` failed
-    /// on the `ip` given above.
-    pub fn symbol_address(&self) -> *mut c_void {
-        self.inner.symbol_address()
-    }
-}
-
-impl fmt::Debug for Frame {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("Frame")
-            .field("ip", &self.ip())
-            .field("symbol_address", &self.symbol_address())
-            .finish()
-    }
-}
-
-cfg_if! {
-    if #[cfg(all(unix,
-                 not(target_os = "emscripten"),
-                 feature = "libunwind"))] {
-        mod libunwind;
-        use self::libunwind::trace as trace_imp;
-        use self::libunwind::Frame as FrameImp;
-    } else if #[cfg(all(unix,
-                        not(target_os = "emscripten"),
-                        feature = "unix-backtrace"))] {
-        mod unix_backtrace;
-        use self::unix_backtrace::trace as trace_imp;
-        use self::unix_backtrace::Frame as FrameImp;
-    } else if #[cfg(all(windows, feature = "dbghelp"))] {
-        mod dbghelp;
-        use self::dbghelp::trace as trace_imp;
-        use self::dbghelp::Frame as FrameImp;
-    } else {
-        mod noop;
-        use self::noop::trace as trace_imp;
-        use self::noop::Frame as FrameImp;
-    }
-}

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/src/backtrace/noop.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-use std::os::raw::c_void;
-
-#[inline(always)]
-pub fn trace(_cb: &mut FnMut(&super::Frame) -> bool) {}
-
-pub struct Frame;
-
-impl Frame {
-    pub fn ip(&self) -> *mut c_void {
-        0 as *mut _
-    }
-
-    pub fn symbol_address(&self) -> *mut c_void {
-        0 as *mut _
-    }
-}

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/src/backtrace/unix_backtrace.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::mem;
-use std::os::raw::{c_void, c_int};
-
-pub struct Frame {
-    addr: *mut c_void,
-}
-
-impl Frame {
-    pub fn ip(&self) -> *mut c_void { self.addr }
-    pub fn symbol_address(&self) -> *mut c_void { self.addr }
-}
-
-extern {
-    fn backtrace(buf: *mut *mut c_void, sz: c_int) -> c_int;
-}
-
-#[inline(always)]
-pub fn trace(mut cb: &mut FnMut(&super::Frame) -> bool) {
-    const SIZE: usize = 100;
-
-    let mut buf: [*mut c_void; SIZE];
-    let cnt;
-    unsafe {
-        buf = mem::zeroed();
-        cnt = backtrace(buf.as_mut_ptr(), SIZE as c_int);
-    }
-
-    for addr in buf[..cnt as usize].iter() {
-        let cx = super::Frame {
-            inner: Frame { addr: *addr },
-        };
-        if !cb(&cx) {
-            return
-        }
-    }
-}

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/src/capture.rs
+++ /dev/null
@@ -1,194 +0,0 @@
-use std::fmt;
-use std::mem;
-use std::os::raw::c_void;
-use std::path::{Path, PathBuf};
-
-use {trace, resolve, SymbolName};
-
-/// Representation of an owned and self-contained backtrace.
-///
-/// This structure can be used to capture a backtrace at various points in a
-/// program and later used to inspect what the backtrace was at that time.
-#[derive(Clone)]
-#[cfg_attr(feature = "serialize-rustc", derive(RustcDecodable, RustcEncodable))]
-#[cfg_attr(feature = "serialize-serde", derive(Deserialize, Serialize))]
-pub struct Backtrace {
-    frames: Vec<BacktraceFrame>,
-}
-
-/// Captured version of a frame in a backtrace.
-///
-/// This type is returned as a list from `Backtrace::frames` and represents one
-/// stack frame in a captured backtrace.
-#[derive(Clone)]
-#[cfg_attr(feature = "serialize-rustc", derive(RustcDecodable, RustcEncodable))]
-#[cfg_attr(feature = "serialize-serde", derive(Deserialize, Serialize))]
-pub struct BacktraceFrame {
-    ip: usize,
-    symbol_address: usize,
-    symbols: Vec<BacktraceSymbol>,
-}
-
-/// Captured version of a symbol in a backtrace.
-///
-/// This type is returned as a list from `BacktraceFrame::symbols` and
-/// represents the metadata for a symbol in a backtrace.
-#[derive(Clone)]
-#[cfg_attr(feature = "serialize-rustc", derive(RustcDecodable, RustcEncodable))]
-#[cfg_attr(feature = "serialize-serde", derive(Deserialize, Serialize))]
-pub struct BacktraceSymbol {
-    name: Option<Vec<u8>>,
-    addr: Option<usize>,
-    filename: Option<PathBuf>,
-    lineno: Option<u32>,
-}
-
-impl Backtrace {
-    /// Captures a backtrace at the callsite of this function, returning an
-    /// owned representation.
-    ///
-    /// This function is useful for representing a backtrace as an object in
-    /// Rust. This returned value can be sent across threads and printed
-    /// elsewhere, and thie purpose of this value is to be entirely self
-    /// contained.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use backtrace::Backtrace;
-    ///
-    /// let current_backtrace = Backtrace::new();
-    /// ```
-    pub fn new() -> Backtrace {
-        let mut frames = Vec::new();
-        trace(|frame| {
-            let mut symbols = Vec::new();
-            resolve(frame.ip(), |symbol| {
-                symbols.push(BacktraceSymbol {
-                    name: symbol.name().map(|m| m.as_bytes().to_vec()),
-                    addr: symbol.addr().map(|a| a as usize),
-                    filename: symbol.filename().map(|m| m.to_path_buf()),
-                    lineno: symbol.lineno(),
-                });
-            });
-            frames.push(BacktraceFrame {
-                ip: frame.ip() as usize,
-                symbol_address: frame.symbol_address() as usize,
-                symbols: symbols,
-            });
-            true
-        });
-
-        Backtrace { frames: frames }
-    }
-
-    /// Returns the frames from when this backtrace was captured.
-    ///
-    /// The first entry of this slice is likely the function `Backtrace::new`,
-    /// and the last frame is likely something about how this thread or the main
-    /// function started.
-    pub fn frames(&self) -> &[BacktraceFrame] {
-        &self.frames
-    }
-}
-
-impl From<Vec<BacktraceFrame>> for Backtrace {
-    fn from(frames: Vec<BacktraceFrame>) -> Self {
-        Backtrace {
-            frames: frames
-        }
-    }
-}
-
-impl Into<Vec<BacktraceFrame>> for Backtrace {
-    fn into(self) -> Vec<BacktraceFrame> {
-        self.frames
-    }
-}
-
-impl BacktraceFrame {
-    /// Same as `Frame::ip`
-    pub fn ip(&self) -> *mut c_void {
-        self.ip as *mut c_void
-    }
-
-    /// Same as `Frame::symbol_address`
-    pub fn symbol_address(&self) -> *mut c_void {
-        self.symbol_address as *mut c_void
-    }
-}
-
-impl BacktraceFrame {
-    /// Returns the list of symbols that this frame corresponds to.
-    ///
-    /// Normally there is only one symbol per frame, but sometimes if a number
-    /// of functions are inlined into one frame then multiple symbols will be
-    /// returned. The first symbol listed is the "innermost function", whereas
-    /// the last symbol is the outermost (last caller).
-    pub fn symbols(&self) -> &[BacktraceSymbol] {
-        &self.symbols
-    }
-}
-
-impl BacktraceSymbol {
-    /// Same as `Symbol::name`
-    pub fn name(&self) -> Option<SymbolName> {
-        self.name.as_ref().map(|s| SymbolName::new(s))
-    }
-
-    /// Same as `Symbol::addr`
-    pub fn addr(&self) -> Option<*mut c_void> {
-        self.addr.map(|s| s as *mut c_void)
-    }
-
-    /// Same as `Symbol::filename`
-    pub fn filename(&self) -> Option<&Path> {
-        self.filename.as_ref().map(|p| &**p)
-    }
-
-    /// Same as `Symbol::lineno`
-    pub fn lineno(&self) -> Option<u32> {
-        self.lineno
-    }
-}
-
-impl fmt::Debug for Backtrace {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        let hex_width = mem::size_of::<usize>() * 2 + 2;
-
-        try!(write!(fmt, "stack backtrace:"));
-
-        for (idx, frame) in self.frames().iter().enumerate() {
-            let ip = frame.ip();
-            try!(write!(fmt, "\n{:4}: {:2$?}", idx, ip, hex_width));
-
-            if frame.symbols.len() == 0 {
-                try!(write!(fmt, " - <no info>"));
-            }
-
-            for (idx, symbol) in frame.symbols().iter().enumerate() {
-                if idx != 0 {
-                    try!(write!(fmt, "\n      {:1$}", "", hex_width));
-                }
-
-                if let Some(name) = symbol.name() {
-                    try!(write!(fmt, " - {}", name));
-                } else {
-                    try!(write!(fmt, " - <unknown>"));
-                }
-
-                if let (Some(file), Some(line)) = (symbol.filename(), symbol.lineno()) {
-                    try!(write!(fmt, "\n      {:3$}at {}:{}", "", file.display(), line, hex_width));
-                }
-            }
-        }
-
-        Ok(())
-    }
-}
-
-impl Default for Backtrace {
-    fn default() -> Backtrace {
-        Backtrace::new()
-    }
-}

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/src/dylib.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use std::ffi::CString;
-use std::marker;
-use std::mem;
-use std::sync::atomic::{AtomicUsize, Ordering};
-
-use libc::{self, c_char, c_void};
-
-pub struct Dylib {
-    pub init: AtomicUsize,
-}
-
-pub struct Symbol<T> {
-    pub name: &'static str,
-    pub addr: AtomicUsize,
-    pub _marker: marker::PhantomData<T>,
-}
-
-impl Dylib {
-    pub unsafe fn get<'a, T>(&self, sym: &'a Symbol<T>) -> Option<&'a T> {
-        self.load().and_then(|handle| {
-            sym.get(handle)
-        })
-    }
-
-    pub unsafe fn init(&self, path: &str) -> bool {
-        if self.init.load(Ordering::SeqCst) != 0 {
-            return true
-        }
-        let name = CString::new(path).unwrap();
-        let ptr = libc::dlopen(name.as_ptr() as *const c_char, libc::RTLD_LAZY);
-        if ptr.is_null() {
-            return false
-        }
-        match self.init.compare_and_swap(0, ptr as usize, Ordering::SeqCst) {
-            0 => {}
-            _ => { libc::dlclose(ptr); }
-        }
-        return true
-    }
-
-    unsafe fn load(&self) -> Option<*mut c_void> {
-        match self.init.load(Ordering::SeqCst) {
-            0 => None,
-            n => Some(n as *mut c_void),
-        }
-    }
-}
-
-impl<T> Symbol<T> {
-    unsafe fn get(&self, handle: *mut c_void) -> Option<&T> {
-        assert_eq!(mem::size_of::<T>(), mem::size_of_val(&self.addr));
-        if self.addr.load(Ordering::SeqCst) == 0 {
-            self.addr.store(fetch(handle, self.name.as_ptr()), Ordering::SeqCst)
-        }
-        if self.addr.load(Ordering::SeqCst) == 1 {
-            None
-        } else {
-            mem::transmute::<&AtomicUsize, Option<&T>>(&self.addr)
-        }
-    }
-}
-
-unsafe fn fetch(handle: *mut c_void, name: *const u8) -> usize {
-    let ptr = libc::dlsym(handle, name as *const _);
-    if ptr.is_null() {
-        1
-    } else {
-        ptr as usize
-    }
-}

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/src/lib.rs
+++ /dev/null
@@ -1,169 +0,0 @@
-//! A library for acquiring a backtrace at runtime
-//!
-//! This library is meant to supplement the `RUST_BACKTRACE=1` support of the
-//! standard library by allowing an acquisition of a backtrace at runtime
-//! programmatically. The backtraces generated by this library do not need to be
-//! parsed, for example, and expose the functionality of multiple backend
-//! implementations.
-//!
-//! # Implementation
-//!
-//! This library makes use of a number of strategies for actually acquiring a
-//! backtrace. For example unix uses libgcc's libunwind bindings by default to
-//! acquire a backtrace, but coresymbolication or dladdr is used on OSX to
-//! acquire symbol names while linux uses gcc's libbacktrace.
-//!
-//! When using the default feature set of this library the "most reasonable" set
-//! of defaults is chosen for the current platform, but the features activated
-//! can also be controlled at a finer granularity.
-//!
-//! # Platform Support
-//!
-//! Currently this library is verified to work on Linux, OSX, and Windows, but
-//! it may work on other platforms as well. Note that the quality of the
-//! backtrace may vary across platforms.
-//!
-//! # API Principles
-//!
-//! This library attempts to be as flexible as possible to accomodate different
-//! backend implementations of acquiring a backtrace. Consequently the currently
-//! exported functions are closure-based as opposed to the likely expected
-//! iterator-based versions. This is done due to limitations of the underlying
-//! APIs used from the system.
-//!
-//! # Usage
-//!
-//! First, add this to your Cargo.toml
-//!
-//! ```toml
-//! [dependencies]
-//! backtrace = "0.2"
-//! ```
-//!
-//! Next:
-//!
-//! ```
-//! extern crate backtrace;
-//!
-//! fn main() {
-//!     backtrace::trace(|frame| {
-//!         let ip = frame.ip();
-//!         let symbol_address = frame.symbol_address();
-//!
-//!         // Resolve this instruction pointer to a symbol name
-//!         backtrace::resolve(ip, |symbol| {
-//!             if let Some(name) = symbol.name() {
-//!                 // ...
-//!             }
-//!             if let Some(filename) = symbol.filename() {
-//!                 // ...
-//!             }
-//!         });
-//!
-//!         true // keep going to the next frame
-//!     });
-//! }
-//! ```
-
-#![doc(html_root_url = "http://alexcrichton.com/backtrace-rs")]
-#![deny(missing_docs)]
-#![deny(warnings)]
-
-extern crate libc;
-#[cfg(all(windows, feature = "kernel32-sys"))] extern crate kernel32;
-#[cfg(all(windows, feature = "winapi"))] extern crate winapi;
-#[cfg(all(windows, feature = "dbghelp"))] extern crate dbghelp;
-
-#[cfg(feature = "serde")]
-extern crate serde;
-
-#[cfg(feature = "serde_derive")]
-#[cfg_attr(feature = "serde_derive", macro_use)]
-extern crate serde_derive;
-
-#[cfg(feature = "rustc-serialize")]
-extern crate rustc_serialize;
-
-#[macro_use]
-extern crate cfg_if;
-
-extern crate rustc_demangle;
-
-#[cfg(feature = "cpp_demangle")]
-extern crate cpp_demangle;
-
-#[allow(dead_code)] // not used everywhere
-#[cfg(unix)]
-#[macro_use]
-mod dylib;
-
-pub use backtrace::{trace, Frame};
-mod backtrace;
-
-pub use symbolize::{resolve, Symbol, SymbolName};
-mod symbolize;
-
-pub use capture::{Backtrace, BacktraceFrame, BacktraceSymbol};
-mod capture;
-
-#[allow(dead_code)]
-struct Bomb {
-    enabled: bool,
-}
-
-#[allow(dead_code)]
-impl Drop for Bomb {
-    fn drop(&mut self) {
-        if self.enabled {
-            panic!("cannot panic during the backtrace function");
-        }
-    }
-}
-
-#[allow(dead_code)]
-mod lock {
-    use std::cell::Cell;
-    use std::mem;
-    use std::sync::{Once, Mutex, MutexGuard, ONCE_INIT};
-
-    pub struct LockGuard(MutexGuard<'static, ()>);
-
-    static mut LOCK: *mut Mutex<()> = 0 as *mut _;
-    static INIT: Once = ONCE_INIT;
-    thread_local!(static LOCK_HELD: Cell<bool> = Cell::new(false));
-
-    impl Drop for LockGuard {
-        fn drop(&mut self) {
-            LOCK_HELD.with(|slot| {
-                assert!(slot.get());
-                slot.set(false);
-            });
-        }
-    }
-
-    pub fn lock() -> Option<LockGuard> {
-        if LOCK_HELD.with(|l| l.get()) {
-            return None
-        }
-        LOCK_HELD.with(|s| s.set(true));
-        unsafe {
-            INIT.call_once(|| {
-                LOCK = mem::transmute(Box::new(Mutex::new(())));
-            });
-            Some(LockGuard((*LOCK).lock().unwrap()))
-        }
-    }
-}
-
-// requires external synchronization
-#[cfg(all(windows, feature = "dbghelp"))]
-unsafe fn dbghelp_init() {
-    static mut INITIALIZED: bool = false;
-
-    if !INITIALIZED {
-        dbghelp::SymInitializeW(kernel32::GetCurrentProcess(),
-                                0 as *mut _,
-                                winapi::TRUE);
-        INITIALIZED = true;
-    }
-}

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/src/symbolize/coresymbolication.rs
+++ /dev/null
@@ -1,192 +0,0 @@
-// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![allow(bad_style)]
-
-use std::ffi::{CStr, OsStr};
-use std::mem;
-use std::os::raw::{c_void, c_char, c_int};
-use std::os::unix::prelude::*;
-use std::path::Path;
-use std::ptr;
-use std::sync::atomic::ATOMIC_USIZE_INIT;
-
-use libc::{self, Dl_info};
-
-use SymbolName;
-use dylib::Dylib;
-use dylib::Symbol as DylibSymbol;
-
-#[repr(C)]
-#[derive(Copy, Clone, PartialEq)]
-pub struct CSTypeRef {
-    cpp_data: *const c_void,
-    cpp_obj: *const c_void
-}
-
-const CS_NOW: u64 = 0x80000000;
-const CSREF_NULL: CSTypeRef = CSTypeRef {
-    cpp_data: 0 as *const c_void,
-    cpp_obj: 0 as *const c_void,
-};
-
-pub enum Symbol {
-    Core {
-        path: *const c_char,
-        lineno: u32,
-        name: *const c_char,
-        addr: *mut c_void,
-    },
-    Dladdr(Dl_info),
-}
-
-impl Symbol {
-    pub fn name(&self) -> Option<SymbolName> {
-        let name = match *self {
-            Symbol::Core { name, .. } => name,
-            Symbol::Dladdr(ref info) => info.dli_sname,
-        };
-        if name.is_null() {
-            None
-        } else {
-            Some(SymbolName::new(unsafe {
-                CStr::from_ptr(name).to_bytes()
-            }))
-        }
-    }
-
-    pub fn addr(&self) -> Option<*mut c_void> {
-        match *self {
-            Symbol::Core { addr, .. } => Some(addr),
-            Symbol::Dladdr(ref info) => Some(info.dli_saddr as *mut _),
-        }
-    }
-
-    pub fn filename(&self) -> Option<&Path> {
-        match *self {
-            Symbol::Core { path, .. } => {
-                if path.is_null() {
-                    None
-                } else {
-                    Some(Path::new(OsStr::from_bytes(unsafe {
-                        CStr::from_ptr(path).to_bytes()
-                    })))
-                }
-            }
-            Symbol::Dladdr(_) => None,
-        }
-    }
-
-    pub fn lineno(&self) -> Option<u32> {
-        match *self {
-            Symbol::Core { lineno: 0, .. } => None,
-            Symbol::Core { lineno, .. } => Some(lineno),
-            Symbol::Dladdr(_) => None,
-        }
-    }
-}
-
-static CORESYMBOLICATION: Dylib = Dylib { init: ATOMIC_USIZE_INIT };
-
-macro_rules! dlsym {
-    (extern {
-        $(fn $name:ident($($arg:ident: $t:ty),*) -> $ret:ty;)*
-    }) => ($(
-        static $name: ::dylib::Symbol<unsafe extern fn($($t),*) -> $ret> =
-            ::dylib::Symbol {
-                name: concat!(stringify!($name), "\0"),
-                addr: ::std::sync::atomic::ATOMIC_USIZE_INIT,
-                _marker: ::std::marker::PhantomData,
-            };
-    )*)
-}
-
-dlsym! {
-    extern {
-        fn CSSymbolicatorCreateWithPid(pid: c_int) -> CSTypeRef;
-        fn CSRelease(rf: CSTypeRef) -> c_void;
-        fn CSSymbolicatorGetSymbolWithAddressAtTime(
-            cs: CSTypeRef, addr: *const c_void, time: u64) -> CSTypeRef;
-        fn CSSymbolicatorGetSourceInfoWithAddressAtTime(
-            cs: CSTypeRef, addr: *const c_void, time: u64) -> CSTypeRef;
-        fn CSSourceInfoGetLineNumber(info: CSTypeRef) -> c_int;
-        fn CSSourceInfoGetPath(info: CSTypeRef) -> *const c_char;
-        fn CSSourceInfoGetSymbol(info: CSTypeRef) -> CSTypeRef;
-        fn CSSymbolGetName(sym: CSTypeRef) -> *const c_char;
-        fn CSSymbolGetSymbolOwner(sym: CSTypeRef) -> CSTypeRef;
-        fn CSSymbolOwnerGetBaseAddress(symowner: CSTypeRef) -> *mut c_void;
-    }
-}
-
-unsafe fn get<T>(sym: &DylibSymbol<T>) -> &T {
-    CORESYMBOLICATION.get(sym).unwrap()
-}
-
-unsafe fn try_resolve(addr: *mut c_void, cb: &mut FnMut(&super::Symbol)) -> bool {
-    let path = "/System/Library/PrivateFrameworks/CoreSymbolication.framework\
-                /Versions/A/CoreSymbolication";
-    if !CORESYMBOLICATION.init(path) {
-        return false;
-    }
-
-    let cs = get(&CSSymbolicatorCreateWithPid)(libc::getpid());
-    if cs == CSREF_NULL {
-        return false
-    }
-
-    let info = get(&CSSymbolicatorGetSourceInfoWithAddressAtTime)(
-        cs, addr, CS_NOW);
-    let sym = if info == CSREF_NULL {
-        get(&CSSymbolicatorGetSymbolWithAddressAtTime)(cs, addr, CS_NOW)
-    } else {
-        get(&CSSourceInfoGetSymbol)(info)
-    };
-
-    let mut rv = false;
-    if sym != CSREF_NULL {
-        let owner = get(&CSSymbolGetSymbolOwner)(sym);
-        if owner != CSREF_NULL {
-            cb(&super::Symbol {
-                inner: Symbol::Core {
-                    path: if info != CSREF_NULL {
-                        get(&CSSourceInfoGetPath)(info)
-                    } else {
-                        ptr::null()
-                    },
-                    lineno: if info != CSREF_NULL {
-                        get(&CSSourceInfoGetLineNumber)(info) as u32
-                    } else {
-                        0
-                    },
-                    name: get(&CSSymbolGetName)(sym),
-                    addr: get(&CSSymbolOwnerGetBaseAddress)(owner),
-                },
-            });
-            rv = true;
-        }
-    }
-    get(&CSRelease)(cs);
-
-    rv
-}
-
-pub fn resolve(addr: *mut c_void, cb: &mut FnMut(&super::Symbol)) {
-    unsafe {
-        if try_resolve(addr, cb) {
-            return
-        }
-        let mut info: Dl_info = mem::zeroed();
-        if libc::dladdr(addr as *mut _, &mut info) != 0 {
-            cb(&super::Symbol {
-                inner: Symbol::Dladdr(info),
-            });
-        }
-    }
-}

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/src/symbolize/dbghelp.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![allow(bad_style)]
-
-use std::ffi::OsString;
-use std::mem;
-use std::path::Path;
-use std::os::windows::prelude::*;
-use std::slice;
-use kernel32;
-use winapi::*;
-
-use SymbolName;
-
-pub struct Symbol {
-    name: OsString,
-    addr: *mut c_void,
-    line: Option<u32>,
-    filename: Option<OsString>,
-}
-
-impl Symbol {
-    pub fn name(&self) -> Option<SymbolName> {
-        self.name.to_str().map(|s| SymbolName::new(s.as_bytes()))
-    }
-
-    pub fn addr(&self) -> Option<*mut c_void> {
-        Some(self.addr as *mut _)
-    }
-
-    pub fn filename(&self) -> Option<&Path> {
-        self.filename.as_ref().map(Path::new)
-    }
-
-    pub fn lineno(&self) -> Option<u32> {
-        self.line
-    }
-}
-
-pub fn resolve(addr: *mut c_void, cb: &mut FnMut(&super::Symbol)) {
-    // According to windows documentation, all dbghelp functions are
-    // single-threaded.
-    let _g = ::lock::lock();
-
-    unsafe {
-        let size = 2 * MAX_SYM_NAME + mem::size_of::<SYMBOL_INFOW>();
-        let mut data = vec![0u8; size];
-        let info = &mut *(data.as_mut_ptr() as *mut SYMBOL_INFOW);
-        info.MaxNameLen = MAX_SYM_NAME as ULONG;
-        // the struct size in C.  the value is different to
-        // `size_of::<SYMBOL_INFOW>() - MAX_SYM_NAME + 1` (== 81)
-        // due to struct alignment.
-        info.SizeOfStruct = 88;
-
-        let _c = ::dbghelp_init();
-
-        let mut displacement = 0u64;
-        let ret = ::dbghelp::SymFromAddrW(kernel32::GetCurrentProcess(),
-                                          addr as DWORD64,
-                                          &mut displacement,
-                                          info);
-        if ret != TRUE {
-            return
-        }
-        let name = slice::from_raw_parts(info.Name.as_ptr() as *const u16,
-                                         info.NameLen as usize);
-        let name = OsString::from_wide(name);
-
-        let mut line = mem::zeroed::<IMAGEHLP_LINEW64>();
-        line.SizeOfStruct = mem::size_of::<IMAGEHLP_LINEW64>() as DWORD;
-        let mut displacement = 0;
-        let ret = ::dbghelp::SymGetLineFromAddrW64(kernel32::GetCurrentProcess(),
-                                                   addr as DWORD64,
-                                                   &mut displacement,
-                                                   &mut line);
-        let mut filename = None;
-        let mut lineno = None;
-        if ret == TRUE {
-            lineno = Some(line.LineNumber as u32);
-
-            let base = line.FileName;
-            let mut len = 0;
-            while *base.offset(len) != 0 {
-                len += 1;
-            }
-            let name = slice::from_raw_parts(base, len as usize);
-            filename = Some(OsString::from_wide(name));
-        }
-
-        cb(&super::Symbol {
-            inner: Symbol {
-                name: name,
-                addr: info.Address as *mut _,
-                line: lineno,
-                filename: filename,
-            },
-        })
-    }
-}

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/src/symbolize/dladdr.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::ffi::CStr;
-use std::mem;
-use std::os::raw::c_void;
-use std::path::Path;
-
-use libc::{self, Dl_info};
-
-use SymbolName;
-
-pub struct Symbol {
-    inner: Dl_info,
-}
-
-impl Symbol {
-    pub fn name(&self) -> Option<SymbolName> {
-        if self.inner.dli_sname.is_null() {
-            None
-        } else {
-            Some(SymbolName::new(unsafe {
-                CStr::from_ptr(self.inner.dli_sname).to_bytes()
-            }))
-        }
-    }
-
-    pub fn addr(&self) -> Option<*mut c_void> {
-        Some(self.inner.dli_saddr as *mut _)
-    }
-
-    pub fn filename(&self) -> Option<&Path> {
-        None
-    }
-
-    pub fn lineno(&self) -> Option<u32> {
-        None
-    }
-}
-
-pub fn resolve(addr: *mut c_void, cb: &mut FnMut(&super::Symbol)) {
-    unsafe {
-        let mut info: super::Symbol = super::Symbol {
-            inner: Symbol {
-                inner: mem::zeroed(),
-            },
-        };
-        if libc::dladdr(addr as *mut _, &mut info.inner.inner) != 0 {
-            cb(&info)
-        }
-    }
-}

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/src/symbolize/libbacktrace.rs
+++ /dev/null
@@ -1,180 +0,0 @@
-// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![allow(bad_style)]
-
-extern crate backtrace_sys as bt;
-
-use libc::uintptr_t;
-use std::ffi::{CStr, OsStr};
-use std::os::raw::{c_void, c_char, c_int};
-use std::os::unix::prelude::*;
-use std::path::Path;
-use std::ptr;
-use std::sync::{ONCE_INIT, Once};
-
-use SymbolName;
-
-pub enum Symbol {
-    Syminfo {
-        pc: uintptr_t,
-        symname: *const c_char,
-    },
-    Pcinfo {
-        pc: uintptr_t,
-        filename: *const c_char,
-        lineno: c_int,
-        function: *const c_char,
-    },
-}
-
-impl Symbol {
-    pub fn name(&self) -> Option<SymbolName> {
-        let ptr = match *self {
-            Symbol::Syminfo { symname, .. } => symname,
-            Symbol::Pcinfo { function, .. } => function,
-        };
-        if ptr.is_null() {
-            None
-        } else {
-            Some(SymbolName::new(unsafe { CStr::from_ptr(ptr).to_bytes() }))
-        }
-    }
-
-    pub fn addr(&self) -> Option<*mut c_void> {
-        let pc = match *self {
-            Symbol::Syminfo { pc, .. } => pc,
-            Symbol::Pcinfo { pc, .. } => pc,
-        };
-        if pc == 0 {None} else {Some(pc as *mut _)}
-    }
-
-    pub fn filename(&self) -> Option<&Path> {
-        match *self {
-            Symbol::Syminfo { .. } => None,
-            Symbol::Pcinfo { filename, .. } => {
-                Some(Path::new(OsStr::from_bytes(unsafe {
-                    CStr::from_ptr(filename).to_bytes()
-                })))
-            }
-        }
-    }
-
-    pub fn lineno(&self) -> Option<u32> {
-        match *self {
-            Symbol::Syminfo { .. } => None,
-            Symbol::Pcinfo { lineno, .. } => Some(lineno as u32),
-        }
-    }
-}
-
-extern fn error_cb(_data: *mut c_void, _msg: *const c_char,
-                   _errnum: c_int) {
-    // do nothing for now
-}
-
-extern fn syminfo_cb(data: *mut c_void,
-                     pc: uintptr_t,
-                     symname: *const c_char,
-                     _symval: uintptr_t,
-                     _symsize: uintptr_t) {
-    unsafe {
-        call(data, &super::Symbol {
-            inner: Symbol::Syminfo {
-                pc: pc,
-                symname: symname,
-            },
-        });
-    }
-}
-
-extern fn pcinfo_cb(data: *mut c_void,
-                    pc: uintptr_t,
-                    filename: *const c_char,
-                    lineno: c_int,
-                    function: *const c_char) -> c_int {
-    unsafe {
-        if filename.is_null() || function.is_null() {
-            return -1
-        }
-        call(data, &super::Symbol {
-            inner: Symbol::Pcinfo {
-                pc: pc,
-                filename: filename,
-                lineno: lineno,
-                function: function,
-            },
-        });
-        return 0
-    }
-}
-
-unsafe fn call(data: *mut c_void, sym: &super::Symbol) {
-    let cb = data as *mut &mut FnMut(&super::Symbol);
-    let mut bomb = ::Bomb { enabled: true };
-    (*cb)(sym);
-    bomb.enabled = false;
-}
-
-// The libbacktrace API supports creating a state, but it does not
-// support destroying a state. I personally take this to mean that a
-// state is meant to be created and then live forever.
-//
-// I would love to register an at_exit() handler which cleans up this
-// state, but libbacktrace provides no way to do so.
-//
-// With these constraints, this function has a statically cached state
-// that is calculated the first time this is requested. Remember that
-// backtracing all happens serially (one global lock).
-//
-// Things don't work so well on not-Linux since libbacktrace can't track down
-// that executable this is. We at one point used env::current_exe but it turns
-// out that there are some serious security issues with that approach.
-//
-// Specifically, on certain platforms like BSDs, a malicious actor can cause an
-// arbitrary file to be placed at the path returned by current_exe. libbacktrace
-// does not behave defensively in the presence of ill-formed DWARF information,
-// and has been demonstrated to segfault in at least one case. There is no
-// evidence at the moment to suggest that a more carefully constructed file
-// can't cause arbitrary code execution. As a result of all of this, we don't
-// hint libbacktrace with the path to the current process.
-unsafe fn init_state() -> *mut bt::backtrace_state {
-    static mut STATE: *mut bt::backtrace_state = 0 as *mut _;
-    static INIT: Once = ONCE_INIT;
-    INIT.call_once(|| {
-        // Our libbacktrace may not have multithreading support, so
-        // set `threaded = 0` and synchronize ourselves.
-        STATE = bt::backtrace_create_state(ptr::null(), 0, error_cb,
-                                           ptr::null_mut());
-    });
-
-    STATE
-}
-
-pub fn resolve(symaddr: *mut c_void, mut cb: &mut FnMut(&super::Symbol)) {
-    let _guard = ::lock::lock();
-
-    // backtrace errors are currently swept under the rug
-    unsafe {
-        let state = init_state();
-        if state.is_null() {
-            return
-        }
-
-        let ret = bt::backtrace_pcinfo(state, symaddr as uintptr_t,
-                                       pcinfo_cb, error_cb,
-                                       &mut cb as *mut _ as *mut _);
-        if ret != 0 {
-            bt::backtrace_syminfo(state, symaddr as uintptr_t,
-                                  syminfo_cb, error_cb,
-                                  &mut cb as *mut _ as *mut _);
-        }
-    }
-}

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/src/symbolize/mod.rs
+++ /dev/null
@@ -1,283 +0,0 @@
-use std::fmt;
-#[cfg(not(feature = "cpp_demangle"))]
-use std::marker::PhantomData;
-use std::os::raw::c_void;
-use std::path::Path;
-use std::str;
-use rustc_demangle::{try_demangle, Demangle};
-
-/// Resolve an address to a symbol, passing the symbol to the specified
-/// closure.
-///
-/// This function will look up the given address in areas such as the local
-/// symbol table, dynamic symbol table, or DWARF debug info (depending on the
-/// activated implementation) to find symbols to yield.
-///
-/// The closure may not be called if resolution could not be performed, and it
-/// also may be called more than once in the case of inlined functions.
-///
-/// Symbols yielded represent the execution at the specified `addr`, returning
-/// file/line pairs for that addres (if available).
-///
-/// # Example
-///
-/// ```
-/// extern crate backtrace;
-///
-/// fn main() {
-///     backtrace::trace(|frame| {
-///         let ip = frame.ip();
-///
-///         backtrace::resolve(ip, |symbol| {
-///             // ...
-///         });
-///
-///         false // only look at the top frame
-///     });
-/// }
-/// ```
-pub fn resolve<F: FnMut(&Symbol)>(addr: *mut c_void, mut cb: F) {
-    resolve_imp(addr, &mut cb)
-}
-
-/// A trait representing the resolution of a symbol in a file.
-///
-/// This trait is yielded as a trait object to the closure given to the
-/// `backtrace::resolve` function, and it is virtually dispatched as it's
-/// unknown which implementation is behind it.
-///
-/// A symbol can give contextual information about a funciton, for example the
-/// name, filename, line number, precise address, etc. Not all information is
-/// always available in a symbol, however, so all methods return an `Option`.
-pub struct Symbol {
-    inner: SymbolImp,
-}
-
-impl Symbol {
-    /// Returns the name of this function.
-    ///
-    /// The returned structure can be used to query various properties about the
-    /// symbol name:
-    ///
-    /// * The `Display` implementation will print out the demangled symbol.
-    /// * The raw `str` value of the symbol can be accessed (if it's valid
-    ///   utf-8).
-    /// * The raw bytes for the symbol name can be accessed.
-    pub fn name(&self) -> Option<SymbolName> {
-        self.inner.name()
-    }
-
-    /// Returns the starting address of this function.
-    pub fn addr(&self) -> Option<*mut c_void> {
-        self.inner.addr()
-    }
-
-    /// Returns the file name where this function was defined.
-    ///
-    /// This is currently only available when libbacktrace is being used (e.g.
-    /// unix platforms other than OSX) and when a binary is compiled with
-    /// debuginfo. If neither of these conditions is met then this will likely
-    /// return `None`.
-    pub fn filename(&self) -> Option<&Path> {
-        self.inner.filename()
-    }
-
-    /// Returns the line number for where this symbol is currently executing.
-    ///
-    /// This return value is typically `Some` if `filename` returns `Some`, and
-    /// is consequently subject to similar caveats.
-    pub fn lineno(&self) -> Option<u32> {
-        self.inner.lineno()
-    }
-}
-
-impl fmt::Debug for Symbol {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut d = f.debug_struct("Symbol");
-        if let Some(name) = self.name() {
-            d.field("name", &name);
-        }
-        if let Some(addr) = self.addr() {
-            d.field("addr", &addr);
-        }
-        if let Some(filename) = self.filename() {
-            d.field("filename", &filename);
-        }
-        if let Some(lineno) = self.lineno() {
-            d.field("lineno", &lineno);
-        }
-        d.finish()
-    }
-}
-
-
-cfg_if! {
-    if #[cfg(feature = "cpp_demangle")] {
-        // Maybe a parsed C++ symbol, if parsing the mangled symbol as Rust
-        // failed.
-        struct OptionCppSymbol<'a>(Option<::cpp_demangle::BorrowedSymbol<'a>>);
-
-        impl<'a> OptionCppSymbol<'a> {
-            fn parse(input: &'a [u8]) -> OptionCppSymbol<'a> {
-                OptionCppSymbol(::cpp_demangle::BorrowedSymbol::new(input).ok())
-            }
-
-            fn none() -> OptionCppSymbol<'a> {
-                OptionCppSymbol(None)
-            }
-        }
-    } else {
-        // Make sure to keep this zero-sized, so that the `cpp_demangle` feature
-        // has no cost when disabled.
-        struct OptionCppSymbol<'a>(PhantomData<&'a ()>);
-
-        impl<'a> OptionCppSymbol<'a> {
-            fn parse(_: &'a [u8]) -> OptionCppSymbol<'a> {
-                OptionCppSymbol(PhantomData)
-            }
-
-            fn none() -> OptionCppSymbol<'a> {
-                OptionCppSymbol(PhantomData)
-            }
-        }
-    }
-}
-
-/// A wrapper around a symbol name to provide ergonomic accessors to the
-/// demangled name, the raw bytes, the raw string, etc.
-// Allow dead code for when the `cpp_demangle` feature is not enabled.
-#[allow(dead_code)]
-pub struct SymbolName<'a> {
-    bytes: &'a [u8],
-    demangled: Option<Demangle<'a>>,
-    cpp_demangled: OptionCppSymbol<'a>,
-}
-
-impl<'a> SymbolName<'a> {
-    /// Creates a new symbol name from the raw underlying bytes.
-    pub fn new(bytes: &'a [u8]) -> SymbolName<'a> {
-        let str_bytes = str::from_utf8(bytes).ok();
-        let demangled = str_bytes.and_then(|s| try_demangle(s).ok());
-
-        let cpp = if demangled.is_none() {
-            OptionCppSymbol::parse(bytes)
-        } else {
-            OptionCppSymbol::none()
-        };
-
-        SymbolName {
-            bytes: bytes,
-            demangled: demangled,
-            cpp_demangled: cpp,
-        }
-    }
-
-    /// Returns the raw symbol name as a `str` if the symbols is valid utf-8.
-    pub fn as_str(&self) -> Option<&'a str> {
-        self.demangled
-            .as_ref()
-            .map(|s| s.as_str())
-            .or_else(|| {
-                str::from_utf8(self.bytes).ok()
-            })
-    }
-
-    /// Returns the raw symbol name as a list of bytes
-    pub fn as_bytes(&self) -> &'a [u8] {
-        self.bytes
-    }
-}
-
-cfg_if! {
-    if #[cfg(feature = "cpp_demangle")] {
-        impl<'a> fmt::Display for SymbolName<'a> {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                if let Some(ref s) = self.demangled {
-                    s.fmt(f)
-                } else if let Some(ref cpp) = self.cpp_demangled.0 {
-                    cpp.fmt(f)
-                } else {
-                    String::from_utf8_lossy(self.bytes).fmt(f)
-                }
-            }
-        }
-    } else {
-        impl<'a> fmt::Display for SymbolName<'a> {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                if let Some(ref s) = self.demangled {
-                    s.fmt(f)
-                } else {
-                    String::from_utf8_lossy(self.bytes).fmt(f)
-                }
-            }
-        }
-    }
-}
-
-cfg_if! {
-    if #[cfg(feature = "cpp_demangle")] {
-        impl<'a> fmt::Debug for SymbolName<'a> {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                use std::fmt::Write;
-
-                if let Some(ref s) = self.demangled {
-                    return s.fmt(f)
-                }
-
-                // This may to print if the demangled symbol isn't actually
-                // valid, so handle the error here gracefully by not propagating
-                // it outwards.
-                if let Some(ref cpp) = self.cpp_demangled.0 {
-                    let mut s = String::new();
-                    if write!(s, "{}", cpp).is_ok() {
-                        return s.fmt(f)
-                    }
-                }
-
-                String::from_utf8_lossy(self.bytes).fmt(f)
-            }
-        }
-    } else {
-        impl<'a> fmt::Debug for SymbolName<'a> {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                if let Some(ref s) = self.demangled {
-                    s.fmt(f)
-                } else {
-                    String::from_utf8_lossy(self.bytes).fmt(f)
-                }
-            }
-        }
-    }
-}
-
-cfg_if! {
-    if #[cfg(all(windows, feature = "dbghelp"))] {
-        mod dbghelp;
-        use self::dbghelp::resolve as resolve_imp;
-        use self::dbghelp::Symbol as SymbolImp;
-    } else if #[cfg(all(feature = "libbacktrace",
-                        unix,
-                        not(target_os = "emscripten"),
-                        not(target_os = "macos"),
-                        not(target_os = "ios")))] {
-        mod libbacktrace;
-        use self::libbacktrace::resolve as resolve_imp;
-        use self::libbacktrace::Symbol as SymbolImp;
-    } else if #[cfg(all(feature = "coresymbolication",
-                        any(target_os = "macos",
-                            target_os = "ios")))] {
-        mod coresymbolication;
-        use self::coresymbolication::resolve as resolve_imp;
-        use self::coresymbolication::Symbol as SymbolImp;
-    } else if #[cfg(all(unix,
-                        not(target_os = "emscripten"),
-                        feature = "dladdr"))] {
-        mod dladdr;
-        use self::dladdr::resolve as resolve_imp;
-        use self::dladdr::Symbol as SymbolImp;
-    } else {
-        mod noop;
-        use self::noop::resolve as resolve_imp;
-        use self::noop::Symbol as SymbolImp;
-    }
-}

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/src/symbolize/noop.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use std::path::Path;
-use std::os::raw::c_void;
-
-use SymbolName;
-
-pub fn resolve(_addr: *mut c_void, _cb: &mut FnMut(&super::Symbol)) {
-}
-
-pub struct Symbol;
-
-impl Symbol {
-    pub fn name(&self) -> Option<SymbolName> {
-        None
-    }
-
-    pub fn addr(&self) -> Option<*mut c_void> {
-        None
-    }
-
-    pub fn filename(&self) -> Option<&Path> {
-        None
-    }
-
-    pub fn lineno(&self) -> Option<u32> {
-        None
-    }
-}

deleted file mode 100644
--- a/third_party/rust/backtrace-0.3.2/tests/smoke.rs
+++ /dev/null
@@ -1,167 +0,0 @@
-extern crate backtrace;
-
-use std::os::raw::c_void;
-use std::thread;
-
-static LIBUNWIND: bool = cfg!(all(unix, feature = "libunwind"));
-static UNIX_BACKTRACE: bool = cfg!(all(unix, feature = "unix-backtrace"));
-static LIBBACKTRACE: bool = cfg!(all(unix, feature = "libbacktrace")) &&
-                            !cfg!(target_os = "macos") && !cfg!(target_os = "ios");
-static CORESYMBOLICATION: bool = cfg!(all(any(target_os = "macos", target_os = "ios"),
-                                          feature = "coresymbolication"));
-static DLADDR: bool = cfg!(all(unix, feature = "dladdr"));
-static DBGHELP: bool = cfg!(all(windows, feature = "dbghelp"));
-static MSVC: bool = cfg!(target_env = "msvc");
-
-#[test]
-fn smoke_test_frames() {
-    frame_1(line!());
-    #[inline(never)] fn frame_1(start_line: u32) { frame_2(start_line) }
-    #[inline(never)] fn frame_2(start_line: u32) { frame_3(start_line) }
-    #[inline(never)] fn frame_3(start_line: u32) { frame_4(start_line) }
-    #[inline(never)] fn frame_4(start_line: u32) {
-        let mut v = Vec::new();
-        backtrace::trace(|cx| {
-            v.push((cx.ip(), cx.symbol_address()));
-            true
-        });
-
-        if v.len() < 5 {
-            assert!(!LIBUNWIND);
-            assert!(!UNIX_BACKTRACE);
-            assert!(!DBGHELP);
-            return
-        }
-
-        // On 32-bit windows apparently the first frame isn't our backtrace
-        // frame but it's actually this frame. I'm not entirely sure why, but at
-        // least it seems consistent?
-        let o = if cfg!(all(windows, target_pointer_width = "32")) {1} else {0};
-        // frame offset 0 is the `backtrace::trace` function, but that's generic
-        assert_frame(&v, o, 1, frame_4 as usize, "frame_4",
-                     "tests/smoke.rs", start_line + 6);
-        assert_frame(&v, o, 2, frame_3 as usize, "frame_3", "tests/smoke.rs",
-                     start_line + 3);
-        assert_frame(&v, o, 3, frame_2 as usize, "frame_2", "tests/smoke.rs",
-                     start_line + 2);
-        assert_frame(&v, o, 4, frame_1 as usize, "frame_1", "tests/smoke.rs",
-                     start_line + 1);
-        assert_frame(&v, o, 5, smoke_test_frames as usize,
-                     "smoke_test_frames", "", 0);
-    }
-
-    fn assert_frame(syms: &[(*mut c_void, *mut c_void)],
-                    offset: usize,
-                    idx: usize,
-                    actual_fn_pointer: usize,
-                    expected_name: &str,
-                    expected_file: &str,
-                    expected_line: u32) {
-        if offset > idx { return }
-        let (ip, sym) = syms[idx - offset];
-        let ip = ip as usize;
-        let sym = sym as usize;
-        assert!(ip >= sym);
-        assert!(sym >= actual_fn_pointer);
-
-        // windows dbghelp is *quite* liberal (and wrong) in many of its reports
-        // right now...
-        if !DBGHELP {
-            assert!(sym - actual_fn_pointer < 1024);
-        }
-
-        let mut resolved = 0;
-        let can_resolve = DLADDR || LIBBACKTRACE || CORESYMBOLICATION || DBGHELP;
-
-        let mut name = None;
-        let mut addr = None;
-        let mut line = None;
-        let mut file = None;
-        backtrace::resolve(ip as *mut c_void, |sym| {
-            resolved += 1;
-            name = sym.name().map(|v| v.to_string());
-            addr = sym.addr();
-            line = sym.lineno();
-            file = sym.filename().map(|v| v.to_path_buf());
-        });
-
-        // dbghelp doesn't always resolve symbols right now
-        match resolved {
-            0 => return assert!(!can_resolve || DBGHELP),
-            _ => {}
-        }
-
-        // * linux dladdr doesn't work (only consults local symbol table)
-        // * windows dbghelp isn't great for GNU
-        if can_resolve &&
-           !(cfg!(target_os = "linux") && DLADDR) &&
-           !(DBGHELP && !MSVC)
-        {
-            let name = name.expect("didn't find a name");
-            assert!(name.contains(expected_name),
-                    "didn't find `{}` in `{}`", expected_name, name);
-        }
-
-        if can_resolve {
-            addr.expect("didn't find a symbol");
-        }
-
-        if (LIBBACKTRACE || CORESYMBOLICATION || (DBGHELP && MSVC)) && cfg!(debug_assertions) {
-            let line = line.expect("didn't find a line number");
-            let file = file.expect("didn't find a line number");
-            if !expected_file.is_empty() {
-                assert!(file.ends_with(expected_file),
-                        "{:?} didn't end with {:?}", file, expected_file);
-            }
-            if expected_line != 0 {
-                assert!(line == expected_line,
-                        "bad line number on frame for `{}`: {} != {}",
-                        expected_name, line, expected_line);
-            }
-        }
-    }
-}
-
-#[test]
-fn many_threads() {
-    let threads = (0..16).map(|_| {
-        thread::spawn(|| {
-            for _ in 0..16 {
-                backtrace::trace(|frame| {
-                    backtrace::resolve(frame.ip(), |symbol| {
-                        let _s = symbol.name().map(|s| s.to_string());
-                    });
-                    true
-                });
-            }
-        })
-    }).collect::<Vec<_>>();
-
-    for t in threads {
-        t.join().unwrap()
-    }
-}
-
-#[test]
-#[cfg(feature = "rustc-serialize")]
-fn is_rustc_serialize() {
-    extern crate rustc_serialize;
-
-    fn is_encode<T: rustc_serialize::Encodable>() {}
-    fn is_decode<T: rustc_serialize::Decodable>() {}
-
-    is_encode::<backtrace::Backtrace>();
-    is_decode::<backtrace::Backtrace>();
-}
-
-#[test]
-#[cfg(feature = "serde")]
-fn is_serde() {
-    extern crate serde;
-
-    fn is_serialize<T: serde::ser::Serialize>() {}
-    fn is_deserialize<T: serde::de::DeserializeOwned>() {}
-
-    is_serialize::<backtrace::Backtrace>();
-    is_deserialize::<backtrace::Backtrace>();
-}