---

yaml
---
r: 227487
b: refs/heads/try
c: 5ef2504
h: refs/heads/master
i:
  227485: 492feb7
  227483: 5e4f153
  227479: 191c3a9
  227471: 364c2e1
  227455: 21ed1ea
v: v3

Author: aidanhs

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: aca2057ed5fb7af3f8905b2bc01f72fa001c35c8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: 606e4b26c7a1215f8d0bc6f6aabec2c7eb196ae8
+refs/heads/try: 5ef250427d26af88a23e6e0d19bca00fc72ce2bc
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/configure

@@ -521,7 +521,6 @@ fi
 DEFAULT_BUILD="${CFG_CPUTYPE}-${CFG_OSTYPE}"
 
 CFG_SRC_DIR="$(abs_path $(dirname $0))/"
-CFG_SRC_DIR_RELATIVE="$(dirname $0)/"
 CFG_BUILD_DIR="$(pwd)/"
 CFG_SELF="$0"
 CFG_CONFIGURE_ARGS="$@"
@@ -1559,7 +1558,6 @@ done
 step_msg "writing configuration"
 
 putvar CFG_SRC_DIR
-putvar CFG_SRC_DIR_RELATIVE
 putvar CFG_BUILD_DIR
 putvar CFG_OSTYPE
 putvar CFG_CPUTYPE

branches/try/mk/cfg/x86_64-unknown-linux-musl.mk

@@ -3,6 +3,7 @@ CC_x86_64-unknown-linux-musl=$(CFG_MUSL_ROOT)/bin/musl-gcc
 CXX_x86_64-unknown-linux-musl=notaprogram
 CPP_x86_64-unknown-linux-musl=$(CFG_MUSL_ROOT)/bin/musl-gcc -E
 AR_x86_64-unknown-linux-musl=$(AR)
+CFG_INSTALL_ONLY_RLIB_x86_64-unknown-linux-musl = 1
 CFG_LIB_NAME_x86_64-unknown-linux-musl=lib$(1).so
 CFG_STATIC_LIB_NAME_x86_64-unknown-linux-musl=lib$(1).a
 CFG_LIB_GLOB_x86_64-unknown-linux-musl=lib$(1)-*.so

branches/try/mk/crates.mk

@@ -134,7 +134,7 @@ DOC_CRATES := std alloc collections core libc rustc_unicode
 #
 # $(1) is the crate to generate variables for
 define RUST_CRATE
-CRATEFILE_$(1) := $$(SREL)src/lib$(1)/lib.rs
+CRATEFILE_$(1) := $$(S)src/lib$(1)/lib.rs
 RSINPUTS_$(1) := $$(call rwildcard,$(S)src/lib$(1)/,*.rs)
 RUST_DEPS_$(1) := $$(filter-out native:%,$$(DEPS_$(1)))
 NATIVE_DEPS_$(1) := $$(patsubst native:%,%,$$(filter native:%,$$(DEPS_$(1))))

branches/try/mk/main.mk

@@ -322,7 +322,6 @@ $(foreach host,$(CFG_HOST), \
 # exported
 
 export CFG_SRC_DIR
-export CFG_SRC_DIR_RELATIVE
 export CFG_BUILD_DIR
 ifdef CFG_VER_DATE
 export CFG_VER_DATE

branches/try/mk/reconfig.mk

@@ -34,4 +34,4 @@ Makefile config.mk: config.stamp
 
 config.stamp: $(S)configure $(S)Makefile.in $(S)src/snapshots.txt
 	@$(call E, cfg: reconfiguring)
-	$(SREL)configure $(CFG_CONFIGURE_ARGS)
+	$(S)configure $(CFG_CONFIGURE_ARGS)

branches/try/mk/util.mk

@@ -20,4 +20,3 @@ print-%:
 	@echo $*=$($*)
 
 S := $(CFG_SRC_DIR)
-SREL := $(CFG_SRC_DIR_RELATIVE)

branches/try/src/compiletest/common.rs

@@ -124,6 +124,9 @@ pub struct Config {
     // Flags to pass to the compiler when building for the target
     pub target_rustcflags: Option<String>,
 
+    // Run tests using the JIT
+    pub jit: bool,
+
     // Target system to be tested
     pub target: String,
 

branches/try/src/compiletest/compiletest.rs

@@ -79,6 +79,7 @@ pub fn parse_config(args: Vec<String> ) -> Config {
           optopt("", "target-rustcflags", "flags to pass to rustc for target", "FLAGS"),
           optflag("", "verbose", "run tests verbosely, showing all output"),
           optopt("", "logfile", "file to log test execution to", "FILE"),
+          optflag("", "jit", "run tests under the JIT"),
           optopt("", "target", "the target to build for", "TARGET"),
           optopt("", "host", "the host to build for", "HOST"),
           optopt("", "gdb-version", "the version of GDB used", "VERSION STRING"),
@@ -145,6 +146,7 @@ pub fn parse_config(args: Vec<String> ) -> Config {
         runtool: matches.opt_str("runtool"),
         host_rustcflags: matches.opt_str("host-rustcflags"),
         target_rustcflags: matches.opt_str("target-rustcflags"),
+        jit: matches.opt_present("jit"),
         target: opt_str2(matches.opt_str("target")),
         host: opt_str2(matches.opt_str("host")),
         gdb_version: extract_gdb_version(matches.opt_str("gdb-version")),
@@ -184,6 +186,7 @@ pub fn log_config(config: &Config) {
                     opt_str(&config.host_rustcflags)));
     logv(c, format!("target-rustcflags: {}",
                     opt_str(&config.target_rustcflags)));
+    logv(c, format!("jit: {}", config.jit));
     logv(c, format!("target: {}", config.target));
     logv(c, format!("host: {}", config.host));
     logv(c, format!("android-cross-path: {:?}",

branches/try/src/compiletest/runtest.rs

@@ -98,13 +98,17 @@ fn run_cfail_test(config: &Config, props: &TestProps, testfile: &Path) {
 }
 
 fn run_rfail_test(config: &Config, props: &TestProps, testfile: &Path) {
-    let proc_res = compile_test(config, props, testfile);
+    let proc_res = if !config.jit {
+        let proc_res = compile_test(config, props, testfile);
 
-    if !proc_res.status.success() {
-        fatal_proc_rec("compilation failed!", &proc_res);
-    }
+        if !proc_res.status.success() {
+            fatal_proc_rec("compilation failed!", &proc_res);
+        }
 
-    let proc_res = exec_compiled_test(config, props, testfile);
+        exec_compiled_test(config, props, testfile)
+    } else {
+        jit_test(config, props, testfile)
+    };
 
     // The value our Makefile configures valgrind to return on failure
     const VALGRIND_ERR: i32 = 100;
@@ -129,16 +133,24 @@ fn check_correct_failure_status(proc_res: &ProcRes) {
 }
 
 fn run_rpass_test(config: &Config, props: &TestProps, testfile: &Path) {
-    let proc_res = compile_test(config, props, testfile);
+    if !config.jit {
+        let mut proc_res = compile_test(config, props, testfile);
 
-    if !proc_res.status.success() {
-        fatal_proc_rec("compilation failed!", &proc_res);
-    }
+        if !proc_res.status.success() {
+            fatal_proc_rec("compilation failed!", &proc_res);
+        }
 
-    let proc_res = exec_compiled_test(config, props, testfile);
+        proc_res = exec_compiled_test(config, props, testfile);
 
-    if !proc_res.status.success() {
-        fatal_proc_rec("test run failed!", &proc_res);
+        if !proc_res.status.success() {
+            fatal_proc_rec("test run failed!", &proc_res);
+        }
+    } else {
+        let proc_res = jit_test(config, props, testfile);
+
+        if !proc_res.status.success() {
+            fatal_proc_rec("jit failed!", &proc_res);
+        }
     }
 }
 
@@ -1129,6 +1141,10 @@ fn compile_test(config: &Config, props: &TestProps,
     compile_test_(config, props, testfile, &[])
 }
 
+fn jit_test(config: &Config, props: &TestProps, testfile: &Path) -> ProcRes {
+    compile_test_(config, props, testfile, &["--jit".to_string()])
+}
+
 fn compile_test_(config: &Config, props: &TestProps,
                  testfile: &Path, extra_args: &[String]) -> ProcRes {
     let aux_dir = aux_output_dir_name(config, testfile);

branches/try/src/libcore/fmt/mod.rs

@@ -72,7 +72,7 @@ pub trait Write {
     ///
     /// # Errors
     ///
-    /// This function will return an instance of `Error` on error.
+    /// This function will return an instance of `FormatError` on error.
     #[stable(feature = "rust1", since = "1.0.0")]
     fn write_str(&mut self, s: &str) -> Result;
 
@@ -85,7 +85,7 @@ pub trait Write {
     ///
     /// # Errors
     ///
-    /// This function will return an instance of `Error` on error.
+    /// This function will return an instance of `FormatError` on error.
     #[stable(feature = "fmt_write_char", since = "1.1.0")]
     fn write_char(&mut self, c: char) -> Result {
         let mut utf_8 = [0u8; 4];

branches/try/src/test/run-fail/extern-panic.rs

@@ -0,0 +1,52 @@
+// Copyright 2012-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.
+
+// ignore-test linked failure
+// error-pattern:explicit failure
+// Testing that runtime failure doesn't cause callbacks to abort abnormally.
+// Instead the failure will be delivered after the callbacks return.
+#![feature(std_misc, libc)]
+
+extern crate libc;
+use std::task;
+
+mod rustrt {
+    extern crate libc;
+
+    extern {
+        pub fn rust_dbg_call(cb: *u8, data: libc::uintptr_t)
+                             -> libc::uintptr_t;
+    }
+}
+
+extern fn cb(data: libc::uintptr_t) -> libc::uintptr_t {
+    if data == 1 {
+        data
+    } else {
+        count(data - 1) + count(data - 1)
+    }
+}
+
+fn count(n: usize) -> usize {
+    unsafe {
+        task::deschedule();
+        rustrt::rust_dbg_call(cb, n)
+    }
+}
+
+fn main() {
+    for _ in 0..10 {
+        task::spawn(move|| {
+            let result = count(5);
+            println!("result = %?", result);
+            panic!();
+        });
+    }
+}

branches/try/src/test/run-pass/html-literals.rs

@@ -10,6 +10,8 @@
 
 // A test of the macro system. Can we do HTML literals?
 
+// ignore-test FIXME #20673
+
 /*
 
 This is an HTML parser written as a macro. It's all CPS, and we have