---

yaml
---
r: 227510
b: refs/heads/try
c: 52862e4
h: refs/heads/master
v: v3

Author: aidanhs

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: aca2057ed5fb7af3f8905b2bc01f72fa001c35c8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: 0d82fb55dbb9b28798ea7c2004fa91fe3ae23b86
+refs/heads/try: 52862e4cda1ff72e52dfaea21cf82ae93725b3be
 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/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/liballoc/heap.rs

@@ -345,94 +345,47 @@ mod imp {
           not(jemalloc),
           windows))]
 mod imp {
-    use core::mem::size_of;
-    use libc::{BOOL, DWORD, HANDLE, LPVOID, SIZE_T, INVALID_HANDLE_VALUE};
-    use libc::{WriteFile};
+    use libc::{c_void, size_t};
+    use libc;
     use super::MIN_ALIGN;
 
-    extern "system" {
-        fn GetProcessHeap() -> HANDLE;
-        fn GetStdHandle(nStdHandle: DWORD) -> HANDLE;
-        fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) -> LPVOID;
-        fn HeapReAlloc(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID, dwBytes: SIZE_T) -> LPVOID;
-        fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID) -> BOOL;
-        fn HeapSummary(hHeap: HANDLE, dwFlags: DWORD, lpSummary: LPHEAP_SUMMARY) -> BOOL;
-    }
-
-    #[repr(C)] #[allow(non_snake_case)]
-    struct HEAP_SUMMARY {
-        cb: DWORD,
-        cbAllocated: SIZE_T,
-        cbCommitted: SIZE_T,
-        cbReserved: SIZE_T,
-        cbMaxReserve: SIZE_T,
-    }
-    #[allow(non_camel_case_types)]
-    type LPHEAP_SUMMARY = *mut HEAP_SUMMARY;
-
-    #[repr(C)]
-    struct Header(*mut u8);
-
-    const HEAP_REALLOC_IN_PLACE_ONLY: DWORD = 0x00000010;
-    const STD_OUTPUT_HANDLE: DWORD = -11i32 as u32;
-
-    #[inline]
-    unsafe fn get_header<'a>(ptr: *mut u8) -> &'a mut Header {
-        &mut *(ptr as *mut Header).offset(-1)
-    }
-
-    #[inline]
-    unsafe fn align_ptr(ptr: *mut u8, align: usize) -> *mut u8 {
-        let aligned = ptr.offset((align - (ptr as usize & (align - 1))) as isize);
-        *get_header(aligned) = Header(ptr);
-        aligned
+    extern {
+        fn _aligned_malloc(size: size_t, align: size_t) -> *mut c_void;
+        fn _aligned_realloc(block: *mut c_void, size: size_t,
+                            align: size_t) -> *mut c_void;
+        fn _aligned_free(ptr: *mut c_void);
     }
 
     #[inline]
     pub unsafe fn allocate(size: usize, align: usize) -> *mut u8 {
         if align <= MIN_ALIGN {
-            HeapAlloc(GetProcessHeap(), 0, size as SIZE_T) as *mut u8
+            libc::malloc(size as size_t) as *mut u8
         } else {
-            let ptr = HeapAlloc(GetProcessHeap(), 0, (size + align) as SIZE_T) as *mut u8;
-            if ptr.is_null() { return ptr }
-            align_ptr(ptr, align)
+            _aligned_malloc(size as size_t, align as size_t) as *mut u8
         }
     }
 
     #[inline]
     pub unsafe fn reallocate(ptr: *mut u8, _old_size: usize, size: usize, align: usize) -> *mut u8 {
         if align <= MIN_ALIGN {
-            HeapReAlloc(GetProcessHeap(), 0, ptr as LPVOID, size as SIZE_T) as *mut u8
+            libc::realloc(ptr as *mut c_void, size as size_t) as *mut u8
         } else {
-            let header = get_header(ptr);
-            let new = HeapReAlloc(GetProcessHeap(), 0, header.0 as LPVOID,
-                                  (size + align) as SIZE_T) as *mut u8;
-            if new.is_null() { return new }
-            align_ptr(new, align)
+            _aligned_realloc(ptr as *mut c_void, size as size_t, align as size_t) as *mut u8
         }
     }
 
     #[inline]
-    pub unsafe fn reallocate_inplace(ptr: *mut u8, old_size: usize, size: usize,
-                                     align: usize) -> usize {
-        if align <= MIN_ALIGN {
-            let new = HeapReAlloc(GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY, ptr as LPVOID,
-                                  size as SIZE_T) as *mut u8;
-            if new.is_null() { old_size } else { size }
-        } else {
-            old_size
-        }
+    pub unsafe fn reallocate_inplace(_ptr: *mut u8, old_size: usize, _size: usize,
+                                     _align: usize) -> usize {
+        old_size
     }
 
     #[inline]
     pub unsafe fn deallocate(ptr: *mut u8, _old_size: usize, align: usize) {
         if align <= MIN_ALIGN {
-            let err = HeapFree(GetProcessHeap(), 0, ptr as LPVOID);
-            debug_assert!(err != 0);
+            libc::free(ptr as *mut libc::c_void)
         } else {
-            let header = get_header(ptr);
-            let err = HeapFree(GetProcessHeap(), 0, header.0 as LPVOID);
-            debug_assert!(err != 0);
+            _aligned_free(ptr as *mut c_void)
         }
     }
 
@@ -441,45 +394,7 @@ mod imp {
         size
     }
 
-    pub fn stats_print() {
-        use core::fmt::{Error, Result, Write};
-        use core::ptr::null_mut;
-        use core::raw::Repr;
-        use core::result::Result::{Ok, Err};
-        struct Console(HANDLE);
-        impl Write for Console {
-            fn write_str(&mut self, s: &str) -> Result {
-                let repr = s.repr();
-                let mut written = 0;
-                let err = unsafe { WriteFile(self.0, repr.data as LPVOID, repr.len as DWORD,
-                                             &mut written, null_mut()) };
-                if written as usize != repr.len { return Err(Error) }
-                if err == 0 { return Err(Error) }
-                Ok(())
-            }
-        }
-        let mut hs = HEAP_SUMMARY {
-            cb: size_of::<HEAP_SUMMARY>() as DWORD,
-            cbAllocated: 0,
-            cbCommitted: 0,
-            cbReserved: 0,
-            cbMaxReserve: 0,
-        };
-        let err = unsafe { HeapSummary(GetProcessHeap(), 0, &mut hs) };
-        assert!(err != 0);
-        let handle = unsafe { GetStdHandle(STD_OUTPUT_HANDLE) };
-        if handle.is_null() || handle == INVALID_HANDLE_VALUE { panic!("Failed to open stdout") }
-        let mut out = Console(handle);
-        writeln!(&mut out, "Allocated: {}", hs.cbAllocated).unwrap();
-        writeln!(&mut out, "Committed: {}", hs.cbCommitted).unwrap();
-        writeln!(&mut out, "Reserved: {}", hs.cbReserved).unwrap();
-        writeln!(&mut out, "MaxReserve: {}", hs.cbMaxReserve).unwrap();
-    }
-
-    #[test]
-    fn alignment_header_size() {
-        assert!(size_of::<Header>() <= MIN_ALIGN);
-    }
+    pub fn stats_print() {}
 }
 
 #[cfg(test)]

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/libcore/result.rs

@@ -731,26 +731,6 @@ impl<T, E: fmt::Debug> Result<T, E> {
                 panic!("called `Result::unwrap()` on an `Err` value: {:?}", e)
         }
     }
-
-    /// Unwraps a result, yielding the content of an `Ok`.
-    ///
-    /// Panics if the value is an `Err`, with a panic message including the
-    /// passed message, and the content of the `Err`.
-    ///
-    /// # Examples
-    /// ```{.should_panic}
-    /// #![feature(result_expect)]
-    /// let x: Result<u32, &str> = Err("emergency failure");
-    /// x.expect("Testing expect"); // panics with `Testing expect: emergency failure`
-    /// ```
-    #[inline]
-    #[unstable(feature = "result_expect", reason = "newly introduced")]
-    pub fn expect(self, msg: &str) -> T {
-        match self {
-            Ok(t) => t,
-            Err(e) => panic!("{}: {:?}", msg, e),
-        }
-    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]

branches/try/src/libcoretest/lib.rs

@@ -28,7 +28,6 @@
 #![feature(cell_extras)]
 #![feature(iter_empty)]
 #![feature(iter_once)]
-#![feature(result_expect)]
 
 extern crate core;
 extern crate test;

branches/try/src/libcoretest/result.rs

@@ -137,16 +137,3 @@ pub fn test_unwrap_or_else_panic() {
     let bad_err: Result<isize, &'static str> = Err("Unrecoverable mess.");
     let _ : isize = bad_err.unwrap_or_else(handler);
 }
-
-
-#[test]
-pub fn test_expect_ok() {
-    let ok: Result<isize, &'static str> = Ok(100);
-    assert_eq!(ok.expect("Unexpected error"), 100);
-}
-#[test]
-#[should_panic(expected="Got expected error: \"All good\"")]
-pub fn test_expect_err() {
-    let err: Result<isize, &'static str> = Err("All good");
-    err.expect("Got expected error");
-}

branches/try/src/liblibc/lib.rs

@@ -146,7 +146,10 @@ pub use funcs::bsd43::*;
 #[link(name = "m")]
 extern {}
 
-#[cfg(all(target_env = "musl", not(test)))]
+// When compiling rust with musl, statically include libc.a in liblibc.rlib.
+// A cargo build of the libc crate will therefore automatically pick up the
+// libc.a symbols because liblibc is transitively linked to by the stdlib.
+#[cfg(all(target_env = "musl", not(feature = "cargo-build"), not(test)))]
 #[link(name = "c", kind = "static")]
 extern {}