Rollup of 9 pull requests

src/Cargo.toml

@@ -2,8 +2,8 @@
 members = [
   "bootstrap",
   "rustc",
-  "rustc/std_shim",
-  "rustc/test_shim",
+  "libstd",
+  "libtest",
   "tools/cargotest",
   "tools/compiletest",
   "tools/error_index_generator",

src/bootstrap/README.md

@@ -267,8 +267,8 @@ build/
 The current build is unfortunately not quite as simple as `cargo build` in a
 directory, but rather the compiler is split into three different Cargo projects:
 
-* `src/rustc/std_shim` - a project which builds and compiles libstd
-* `src/rustc/test_shim` - a project which builds and compiles libtest
+* `src/libstd` - the standard library
+* `src/libtest` - testing support, depends on libstd
 * `src/rustc` - the actual compiler itself
 
 Each "project" has a corresponding Cargo.lock file with all dependencies, and

src/bootstrap/bin/rustc.rs

@@ -68,6 +68,7 @@ fn main() {
     };
     let stage = env::var("RUSTC_STAGE").expect("RUSTC_STAGE was not set");
     let sysroot = env::var_os("RUSTC_SYSROOT").expect("RUSTC_SYSROOT was not set");
+    let mut on_fail = env::var_os("RUSTC_ON_FAIL").map(|of| Command::new(of));
 
     let rustc = env::var_os(rustc).unwrap_or_else(|| panic!("{:?} was not set", rustc));
     let libdir = env::var_os(libdir).unwrap_or_else(|| panic!("{:?} was not set", libdir));
@@ -212,9 +213,20 @@ fn main() {
     }
 
     // Actually run the compiler!
-    std::process::exit(match exec_cmd(&mut cmd) {
-        Ok(s) => s.code().unwrap_or(0xfe),
-        Err(e) => panic!("\n\nfailed to run {:?}: {}\n\n", cmd, e),
+    std::process::exit(if let Some(ref mut on_fail) = on_fail {
+        match cmd.status() {
+            Ok(s) if s.success() => 0,
+            _ => {
+                println!("\nDid not run successfully:\n{:?}\n-------------", cmd);
+                exec_cmd(on_fail).expect("could not run the backup command");
+                1
+            }
+        }
+    } else {
+        std::process::exit(match exec_cmd(&mut cmd) {
+            Ok(s) => s.code().unwrap_or(0xfe),
+            Err(e) => panic!("\n\nfailed to run {:?}: {}\n\n", cmd, e),
+        })
     })
 }
 

src/bootstrap/check.rs

@@ -346,10 +346,10 @@ pub fn krate(build: &Build,
              krate: Option<&str>) {
     let (name, path, features, root) = match mode {
         Mode::Libstd => {
-            ("libstd", "src/rustc/std_shim", build.std_features(), "std_shim")
+            ("libstd", "src/libstd", build.std_features(), "std")
         }
         Mode::Libtest => {
-            ("libtest", "src/rustc/test_shim", String::new(), "test_shim")
+            ("libtest", "src/libtest", String::new(), "test")
         }
         Mode::Librustc => {
             ("librustc", "src/rustc", build.rustc_features(), "rustc-main")

src/bootstrap/compile.rs

@@ -64,7 +64,7 @@ pub fn std(build: &Build, target: &str, compiler: &Compiler) {
     }
     cargo.arg("--features").arg(features)
          .arg("--manifest-path")
-         .arg(build.src.join("src/rustc/std_shim/Cargo.toml"));
+         .arg(build.src.join("src/libstd/Cargo.toml"));
 
     if let Some(target) = build.config.target_config.get(target) {
         if let Some(ref jemalloc) = target.jemalloc {
@@ -162,7 +162,7 @@ pub fn test(build: &Build, target: &str, compiler: &Compiler) {
     build.clear_if_dirty(&out_dir, &libstd_stamp(build, compiler, target));
     let mut cargo = build.cargo(compiler, Mode::Libtest, target, "build");
     cargo.arg("--manifest-path")
-         .arg(build.src.join("src/rustc/test_shim/Cargo.toml"));
+         .arg(build.src.join("src/libtest/Cargo.toml"));
     build.run(&mut cargo);
     update_mtime(build, &libtest_stamp(build, compiler, target));
 }

src/bootstrap/doc.rs

@@ -152,7 +152,7 @@ pub fn std(build: &Build, stage: u32, target: &str) {
 
     let mut cargo = build.cargo(&compiler, Mode::Libstd, target, "doc");
     cargo.arg("--manifest-path")
-         .arg(build.src.join("src/rustc/std_shim/Cargo.toml"))
+         .arg(build.src.join("src/libstd/Cargo.toml"))
          .arg("--features").arg(build.std_features());
 
     // We don't want to build docs for internal std dependencies unless
@@ -198,7 +198,7 @@ pub fn test(build: &Build, stage: u32, target: &str) {
 
     let mut cargo = build.cargo(&compiler, Mode::Libtest, target, "doc");
     cargo.arg("--manifest-path")
-         .arg(build.src.join("src/rustc/test_shim/Cargo.toml"));
+         .arg(build.src.join("src/libtest/Cargo.toml"));
     build.run(&mut cargo);
     cp_r(&out_dir, &out)
 }

src/bootstrap/flags.rs

@@ -28,6 +28,7 @@ use step;
 /// Deserialized version of all flags for this compile.
 pub struct Flags {
     pub verbose: usize, // verbosity level: 0 == not verbose, 1 == verbose, 2 == very verbose
+    pub on_fail: Option<String>,
     pub stage: Option<u32>,
     pub keep_stage: Option<u32>,
     pub build: String,
@@ -81,6 +82,7 @@ impl Flags {
         opts.optopt("", "build", "build target of the stage0 compiler", "BUILD");
         opts.optmulti("", "host", "host targets to build", "HOST");
         opts.optmulti("", "target", "target targets to build", "TARGET");
+        opts.optopt("", "on-fail", "command to run on failure", "CMD");
         opts.optopt("", "stage", "stage to build", "N");
         opts.optopt("", "keep-stage", "stage to keep without recompiling", "N");
         opts.optopt("", "src", "path to the root of the rust checkout", "DIR");
@@ -283,6 +285,7 @@ To learn more about a subcommand, run `./x.py <command> -h`
         Flags {
             verbose: m.opt_count("v"),
             stage: stage,
+            on_fail: m.opt_str("on-fail"),
             keep_stage: m.opt_str("keep-stage").map(|j| j.parse().unwrap()),
             build: m.opt_str("build").unwrap_or_else(|| {
                 env::var("BUILD").unwrap()

src/bootstrap/lib.rs

@@ -499,6 +499,10 @@ impl Build {
             cargo.env("RUSTC_INCREMENTAL", incr_dir);
         }
 
+        if let Some(ref on_fail) = self.flags.on_fail {
+            cargo.env("RUSTC_ON_FAIL", on_fail);
+        }
+
         let verbose = cmp::max(self.config.verbose, self.flags.verbose);
         cargo.env("RUSTC_VERBOSE", format!("{}", verbose));
 

src/bootstrap/metadata.rs

@@ -43,8 +43,8 @@ struct ResolveNode {
 }
 
 pub fn build(build: &mut Build) {
-    build_krate(build, "src/rustc/std_shim");
-    build_krate(build, "src/rustc/test_shim");
+    build_krate(build, "src/libstd");
+    build_krate(build, "src/libtest");
     build_krate(build, "src/rustc");
 }
 

src/bootstrap/step.rs

@@ -246,14 +246,14 @@ pub fn build_rules<'a>(build: &'a Build) -> Rules {
     crate_rule(build,
                &mut rules,
                "libstd-link",
-               "build-crate-std_shim",
+               "build-crate-std",
                compile::std_link)
         .dep(|s| s.name("startup-objects"))
         .dep(|s| s.name("create-sysroot").target(s.host));
     crate_rule(build,
                &mut rules,
                "libtest-link",
-               "build-crate-test_shim",
+               "build-crate-test",
                compile::test_link)
         .dep(|s| s.name("libstd-link"));
     crate_rule(build,
@@ -263,13 +263,13 @@ pub fn build_rules<'a>(build: &'a Build) -> Rules {
                compile::rustc_link)
         .dep(|s| s.name("libtest-link"));
 
-    for (krate, path, _default) in krates("std_shim") {
+    for (krate, path, _default) in krates("std") {
         rules.build(&krate.build_step, path)
              .dep(|s| s.name("startup-objects"))
              .dep(move |s| s.name("rustc").host(&build.config.build).target(s.host))
              .run(move |s| compile::std(build, s.target, &s.compiler()));
     }
-    for (krate, path, _default) in krates("test_shim") {
+    for (krate, path, _default) in krates("test") {
         rules.build(&krate.build_step, path)
              .dep(|s| s.name("libstd-link"))
              .run(move |s| compile::test(build, s.target, &s.compiler()));
@@ -384,7 +384,7 @@ pub fn build_rules<'a>(build: &'a Build) -> Rules {
               "pretty", "run-fail-fulldeps");
     }
 
-    for (krate, path, _default) in krates("std_shim") {
+    for (krate, path, _default) in krates("std") {
         rules.test(&krate.test_step, path)
              .dep(|s| s.name("libtest"))
              .dep(|s| s.name("emulator-copy-libs"))
@@ -400,7 +400,7 @@ pub fn build_rules<'a>(build: &'a Build) -> Rules {
                                     Mode::Libstd, TestKind::Test, None));
 
     // std benchmarks
-    for (krate, path, _default) in krates("std_shim") {
+    for (krate, path, _default) in krates("std") {
         rules.bench(&krate.bench_step, path)
              .dep(|s| s.name("libtest"))
              .dep(|s| s.name("emulator-copy-libs"))
@@ -415,7 +415,7 @@ pub fn build_rules<'a>(build: &'a Build) -> Rules {
          .run(move |s| check::krate(build, &s.compiler(), s.target,
                                     Mode::Libstd, TestKind::Bench, None));
 
-    for (krate, path, _default) in krates("test_shim") {
+    for (krate, path, _default) in krates("test") {
         rules.test(&krate.test_step, path)
              .dep(|s| s.name("libtest"))
              .dep(|s| s.name("emulator-copy-libs"))
@@ -583,13 +583,13 @@ pub fn build_rules<'a>(build: &'a Build) -> Rules {
          .default(build.config.docs)
          .host(true)
          .run(move |s| doc::error_index(build, s.target));
-    for (krate, path, default) in krates("std_shim") {
+    for (krate, path, default) in krates("std") {
         rules.doc(&krate.doc_step, path)
              .dep(|s| s.name("libstd-link"))
              .default(default && build.config.docs)
              .run(move |s| doc::std(build, s.stage, s.target));
     }
-    for (krate, path, default) in krates("test_shim") {
+    for (krate, path, default) in krates("test") {
         rules.doc(&krate.doc_step, path)
              .dep(|s| s.name("libtest-link"))
              .default(default && build.config.compiler_docs)
@@ -1154,23 +1154,23 @@ mod tests {
 
         let mut build = Build::new(flags, config);
         let cwd = env::current_dir().unwrap();
-        build.crates.insert("std_shim".to_string(), ::Crate {
-            name: "std_shim".to_string(),
+        build.crates.insert("std".to_string(), ::Crate {
+            name: "std".to_string(),
             deps: Vec::new(),
-            path: cwd.join("src/std_shim"),
-            doc_step: "doc-std_shim".to_string(),
-            build_step: "build-crate-std_shim".to_string(),
-            test_step: "test-std_shim".to_string(),
-            bench_step: "bench-std_shim".to_string(),
+            path: cwd.join("src/std"),
+            doc_step: "doc-std".to_string(),
+            build_step: "build-crate-std".to_string(),
+            test_step: "test-std".to_string(),
+            bench_step: "bench-std".to_string(),
         });
-        build.crates.insert("test_shim".to_string(), ::Crate {
-            name: "test_shim".to_string(),
+        build.crates.insert("test".to_string(), ::Crate {
+            name: "test".to_string(),
             deps: Vec::new(),
-            path: cwd.join("src/test_shim"),
-            doc_step: "doc-test_shim".to_string(),
-            build_step: "build-crate-test_shim".to_string(),
-            test_step: "test-test_shim".to_string(),
-            bench_step: "bench-test_shim".to_string(),
+            path: cwd.join("src/test"),
+            doc_step: "doc-test".to_string(),
+            build_step: "build-crate-test".to_string(),
+            test_step: "test-test".to_string(),
+            bench_step: "bench-test".to_string(),
         });
         build.crates.insert("rustc-main".to_string(), ::Crate {
             name: "rustc-main".to_string(),
@@ -1360,7 +1360,7 @@ mod tests {
         let all = rules.expand(&plan);
         println!("all rules: {:#?}", all);
         assert!(!all.contains(&step.name("rustc")));
-        assert!(!all.contains(&step.name("build-crate-std_shim").stage(1)));
+        assert!(!all.contains(&step.name("build-crate-std").stage(1)));
 
         // all stage0 compiles should be for the build target, A
         for step in all.iter().filter(|s| s.stage == 0) {
@@ -1425,7 +1425,7 @@ mod tests {
 
         assert!(!plan.iter().any(|s| s.name.contains("rustc")));
         assert!(plan.iter().all(|s| {
-            !s.name.contains("test_shim") || s.target == "C"
+            !s.name.contains("test") || s.target == "C"
         }));
     }
 

src/doc/book/src/procedural-macros.md

@@ -169,7 +169,7 @@ So this is where quotes comes in. The `ast` argument is a struct that gives us
 a representation of our type (which can be either a `struct` or an `enum`).
 Check out the [docs](https://docs.rs/syn/0.10.5/syn/struct.MacroInput.html),
 there is some useful information there. We are able to get the name of the
-type using `ast.ident`. The `quote!` macro let's us write up the Rust code
+type using `ast.ident`. The `quote!` macro lets us write up the Rust code
 that we wish to return and convert it into `Tokens`. `quote!` let's us use some
 really cool templating mechanics; we simply write `#name` and `quote!` will
 replace it with the variable named `name`. You can even do some repetition

src/liballoc_jemalloc/lib.rs

@@ -122,18 +122,6 @@ mod imp {
         let flags = align_to_flags(align);
         unsafe { nallocx(size as size_t, flags) as usize }
     }
-
-    // These symbols are used by jemalloc on android but the really old android
-    // we're building on doesn't have them defined, so just make sure the symbols
-    // are available.
-    #[no_mangle]
-    #[cfg(all(target_os = "android", not(cargobuild)))]
-    pub extern "C" fn pthread_atfork(_prefork: *mut u8,
-                                     _postfork_parent: *mut u8,
-                                     _postfork_child: *mut u8)
-                                     -> i32 {
-        0
-    }
 }
 
 #[cfg(dummy_jemalloc)]

src/librustc/mir/mod.rs

@@ -777,6 +777,12 @@ pub enum StatementKind<'tcx> {
     /// End the current live range for the storage of the local.
     StorageDead(Lvalue<'tcx>),
 
+    InlineAsm {
+        asm: InlineAsm,
+        outputs: Vec<Lvalue<'tcx>>,
+        inputs: Vec<Operand<'tcx>>
+    },
+
     /// No-op. Useful for deleting instructions without affecting statement indices.
     Nop,
 }
@@ -790,7 +796,10 @@ impl<'tcx> Debug for Statement<'tcx> {
             StorageDead(ref lv) => write!(fmt, "StorageDead({:?})", lv),
             SetDiscriminant{lvalue: ref lv, variant_index: index} => {
                 write!(fmt, "discriminant({:?}) = {:?}", lv, index)
-            }
+            },
+            InlineAsm { ref asm, ref outputs, ref inputs } => {
+                write!(fmt, "asm!({:?} : {:?} : {:?})", asm, outputs, inputs)
+            },
             Nop => write!(fmt, "nop"),
         }
     }
@@ -1004,12 +1013,6 @@ pub enum Rvalue<'tcx> {
     /// that `Foo` has a destructor. These rvalues can be optimized
     /// away after type-checking and before lowering.
     Aggregate(AggregateKind<'tcx>, Vec<Operand<'tcx>>),
-
-    InlineAsm {
-        asm: InlineAsm,
-        outputs: Vec<Lvalue<'tcx>>,
-        inputs: Vec<Operand<'tcx>>
-    }
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable)]
@@ -1111,10 +1114,6 @@ impl<'tcx> Debug for Rvalue<'tcx> {
             UnaryOp(ref op, ref a) => write!(fmt, "{:?}({:?})", op, a),
             Discriminant(ref lval) => write!(fmt, "discriminant({:?})", lval),
             Box(ref t) => write!(fmt, "Box({:?})", t),
-            InlineAsm { ref asm, ref outputs, ref inputs } => {
-                write!(fmt, "asm!({:?} : {:?} : {:?})", asm, outputs, inputs)
-            }
-
             Ref(_, borrow_kind, ref lv) => {
                 let kind_str = match borrow_kind {
                     BorrowKind::Shared => "",

src/librustc/mir/tcx.rs

@@ -207,7 +207,6 @@ impl<'tcx> Rvalue<'tcx> {
                     }
                 }
             }
-            Rvalue::InlineAsm { .. } => None
         }
     }
 }