---

yaml
---
r: 62819
b: refs/heads/snap-stage3
c: d295709
h: refs/heads/master
i:
  62817: a135d21
  62815: c16782e
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 3141acf674fd34f66141c4659a4a239779bb2802
+refs/heads/snap-stage3: d2957091c496be86fe4b648a0ccae08753122661
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/mk/target.mk

@@ -8,6 +8,11 @@
 # option. This file may not be copied, modified, or distributed
 # except according to those terms.
 
+# This is the compile-time target-triple for the compiler. For the compiler at
+# runtime, this should be considered the host-triple. More explanation for why
+# this exists can be found on issue #2400
+export CFG_COMPILER_TRIPLE
+
 # TARGET_STAGE_N template: This defines how target artifacts are built
 # for all stage/target architecture combinations. The arguments:
 # $(1) is the stage
@@ -62,6 +67,7 @@ $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_RUSTLLVM_$(3)): \
 	@$$(call E, cp: $$@)
 	$$(Q)cp $$< $$@
 
+$$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBRUSTC_$(3)): CFG_COMPILER_TRIPLE = $(2)
 $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBRUSTC_$(3)):		\
 		$$(COMPILER_CRATE) $$(COMPILER_INPUTS)		\
                 $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBSYNTAX_$(3)) \

branches/snap-stage3/mk/tests.mk

@@ -307,6 +307,7 @@ $(3)/stage$(1)/test/syntaxtest-$(2)$$(X_$(2)):			\
 	@$$(call E, compile_and_link: $$@)
 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test
 
+$(3)/stage$(1)/test/rustctest-$(2)$$(X_$(2)): CFG_COMPILER_TRIPLE = $(2)
 $(3)/stage$(1)/test/rustctest-$(2)$$(X_$(2)):					\
 		$$(COMPILER_CRATE) $$(COMPILER_INPUTS) \
 		$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_RUSTLLVM_$(2)) \

branches/snap-stage3/src/libextra/base64.rs

@@ -113,7 +113,7 @@ pub trait FromBase64 {
     fn from_base64(&self) -> ~[u8];
 }
 
-impl FromBase64 for ~[u8] {
+impl<'self> FromBase64 for &'self [u8] {
     /**
      * Convert base64 `u8` vector into u8 byte values.
      * Every 4 encoded characters is converted into 3 octets, modulo padding.
@@ -188,7 +188,7 @@ impl FromBase64 for ~[u8] {
     }
 }
 
-impl FromBase64 for ~str {
+impl<'self> FromBase64 for &'self str {
     /**
      * Convert any base64 encoded string (literal, `@`, `&`, or `~`)
      * to the byte values it encodes.
@@ -227,23 +227,23 @@ mod tests {
 
     #[test]
     fn test_to_base64() {
-        assert_eq!((~"").to_base64(), ~"");
-        assert!((~"f").to_base64()      == ~"Zg==");
-        assert_eq!((~"fo").to_base64(), ~"Zm8=");
-        assert_eq!((~"foo").to_base64(), ~"Zm9v");
-        assert!((~"foob").to_base64()   == ~"Zm9vYg==");
-        assert_eq!((~"fooba").to_base64(), ~"Zm9vYmE=");
-        assert_eq!((~"foobar").to_base64(), ~"Zm9vYmFy");
+        assert_eq!("".to_base64(), ~"");
+        assert_eq!("f".to_base64(), ~"Zg==");
+        assert_eq!("fo".to_base64(), ~"Zm8=");
+        assert_eq!("foo".to_base64(), ~"Zm9v");
+        assert_eq!("foob".to_base64(), ~"Zm9vYg==");
+        assert_eq!("fooba".to_base64(), ~"Zm9vYmE=");
+        assert_eq!("foobar".to_base64(), ~"Zm9vYmFy");
     }
 
     #[test]
     fn test_from_base64() {
-        assert_eq!((~"").from_base64(), str::to_bytes(""));
-        assert!((~"Zg==").from_base64() == str::to_bytes("f"));
-        assert_eq!((~"Zm8=").from_base64(), str::to_bytes("fo"));
-        assert_eq!((~"Zm9v").from_base64(), str::to_bytes("foo"));
-        assert!((~"Zm9vYg==").from_base64() == str::to_bytes("foob"));
-        assert_eq!((~"Zm9vYmE=").from_base64(), str::to_bytes("fooba"))
-        assert_eq!((~"Zm9vYmFy").from_base64(), str::to_bytes("foobar"));
+        assert_eq!("".from_base64(), str::to_bytes(""));
+        assert_eq!("Zg==".from_base64(), str::to_bytes("f"));
+        assert_eq!("Zm8=".from_base64(), str::to_bytes("fo"));
+        assert_eq!("Zm9v".from_base64(), str::to_bytes("foo"));
+        assert_eq!("Zm9vYg==".from_base64(), str::to_bytes("foob"));
+        assert_eq!("Zm9vYmE=".from_base64(), str::to_bytes("fooba"))
+        assert_eq!("Zm9vYmFy".from_base64(), str::to_bytes("foobar"));
     }
 }

branches/snap-stage3/src/librustc/driver/driver.rs

@@ -518,15 +518,15 @@ pub fn host_triple() -> ~str {
     // idea of the host triple is the same as for the set of libraries we've
     // actually built.  We can't just take LLVM's host triple because they
     // normalize all ix86 architectures to i386.
-
-    // FIXME (#2400): Instead of grabbing the host triple we really should
-    // be grabbing (at compile time) the target triple that this rustc is
-    // built with and calling that (at runtime) the host triple.
-    let ht = env!("CFG_BUILD_TRIPLE");
+    //
+    // Instead of grabbing the host triple (for the current host), we grab (at
+    // compile time) the target triple that this rustc is built with and
+    // calling that (at runtime) the host triple.
+    let ht = env!("CFG_COMPILER_TRIPLE");
     return if ht != ~"" {
             ht
         } else {
-            fail!("rustc built without CFG_BUILD_TRIPLE")
+            fail!("rustc built without CFG_COMPILER_TRIPLE")
         };
 }
 
@@ -536,15 +536,15 @@ pub fn host_triple() -> ~str {
     // idea of the host triple is the same as for the set of libraries we've
     // actually built.  We can't just take LLVM's host triple because they
     // normalize all ix86 architectures to i386.
-
-    // FIXME (#2400): Instead of grabbing the host triple we really should
-    // be grabbing (at compile time) the target triple that this rustc is
-    // built with and calling that (at runtime) the host triple.
-    let ht = env!("CFG_BUILD_TRIPLE");
+    //
+    // Instead of grabbing the host triple (for the current host), we grab (at
+    // compile time) the target triple that this rustc is built with and
+    // calling that (at runtime) the host triple.
+    let ht = env!("CFG_COMPILER_TRIPLE");
     return if ht != "" {
             ht.to_owned()
         } else {
-            fail!("rustc built without CFG_BUILD_TRIPLE")
+            fail!("rustc built without CFG_COMPILER_TRIPLE")
         };
 }
 

branches/snap-stage3/src/librustc/middle/trans/base.rs

@@ -1506,7 +1506,7 @@ pub fn memzero(cx: block, llptr: ValueRef, llty: TypeRef) {
     let llptr = PointerCast(cx, llptr, T_ptr(T_i8()));
     let llzeroval = C_u8(0);
     let size = IntCast(cx, machine::llsize_of(ccx, llty), ccx.int_type);
-    let align = C_i32(1i32);
+    let align = C_i32(llalign_of_min(ccx, llty) as i32);
     let volatile = C_i1(false);
     Call(cx, llintrinsicfn, [llptr, llzeroval, size, align, volatile]);
 }

branches/snap-stage3/src/librusti/rusti.rc

@@ -454,8 +454,9 @@ mod tests {
         }
     }
 
-    #[test] #[ignore]
+    #[test]
     fn run_all() {
+        // FIXME(#6511):
         // By default, unit tests are run in parallel. Rusti, on the other hand,
         // does not enjoy doing this. I suspect that it is because the LLVM
         // bindings are not thread-safe (when running parallel tests, some tests
@@ -468,7 +469,7 @@ mod tests {
         run_cmds([""]);
 
         debug!("regression test for #5937");
-        run_cmds(["use core;", ""]);
+        run_cmds(["use std;", ""]);
 
         debug!("regression test for #5784");
         run_cmds(["let a = 1;"]);

branches/snap-stage3/src/librustpkg/tests.rs

@@ -93,9 +93,7 @@ fn test_sysroot() -> Path {
     self_path.pop()
 }
 
-// Ignored on i686 -- see #6517
 #[test]
-#[ignore(cfg(target_arch = "x86"))]
 fn test_make_dir_rwx() {
     let temp = &os::tmpdir();
     let dir = temp.push("quux");
@@ -109,7 +107,6 @@ fn test_make_dir_rwx() {
 }
 
 #[test]
-#[ignore(cfg(target_arch = "x86"))]
 fn test_install_valid() {
     let sysroot = test_sysroot();
     debug!("sysroot = %s", sysroot.to_str());
@@ -135,7 +132,6 @@ fn test_install_valid() {
 }
 
 #[test]
-#[ignore(cfg(target_arch = "x86"))]
 fn test_install_invalid() {
     use conditions::nonexistent_package::cond;
     use cond1 = conditions::missing_pkg_files::cond;
@@ -158,7 +154,6 @@ fn test_install_invalid() {
 }
 
 #[test]
-#[ignore(cfg(target_arch = "x86"))]
 fn test_install_url() {
     let workspace = mkdtemp(&os::tmpdir(), "test").expect("couldn't create temp dir");
     let sysroot = test_sysroot();

branches/snap-stage3/src/libstd/num/f32.rs

@@ -86,6 +86,8 @@ delegate!(
     fn erfc(n: c_float) -> c_float = c_float_utils::erfc,
     fn exp_m1(n: c_float) -> c_float = c_float_utils::exp_m1,
     fn abs_sub(a: c_float, b: c_float) -> c_float = c_float_utils::abs_sub,
+    fn fmax(a: c_float, b: c_float) -> c_float = c_float_utils::fmax,
+    fn fmin(a: c_float, b: c_float) -> c_float = c_float_utils::fmin,
     fn next_after(x: c_float, y: c_float) -> c_float = c_float_utils::next_after,
     fn frexp(n: c_float, value: &mut c_int) -> c_float = c_float_utils::frexp,
     fn hypot(x: c_float, y: c_float) -> c_float = c_float_utils::hypot,
@@ -145,16 +147,6 @@ pub fn ge(x: f32, y: f32) -> bool { return x >= y; }
 #[inline(always)]
 pub fn gt(x: f32, y: f32) -> bool { return x > y; }
 
-#[inline(always)]
-pub fn fmax(x: f32, y: f32) -> f32 {
-    if x >= y || y.is_NaN() { x } else { y }
-}
-
-#[inline(always)]
-pub fn fmin(x: f32, y: f32) -> f32 {
-    if x <= y || y.is_NaN() { x } else { y }
-}
-
 
 // FIXME (#1999): replace the predicates below with llvm intrinsics or
 // calls to the libmath macros in the rust runtime for performance.

branches/snap-stage3/src/libstd/num/f64.rs

@@ -87,6 +87,8 @@ delegate!(
     fn erfc(n: c_double) -> c_double = c_double_utils::erfc,
     fn exp_m1(n: c_double) -> c_double = c_double_utils::exp_m1,
     fn abs_sub(a: c_double, b: c_double) -> c_double = c_double_utils::abs_sub,
+    fn fmax(a: c_double, b: c_double) -> c_double = c_double_utils::fmax,
+    fn fmin(a: c_double, b: c_double) -> c_double = c_double_utils::fmin,
     fn next_after(x: c_double, y: c_double) -> c_double = c_double_utils::next_after,
     fn frexp(n: c_double, value: &mut c_int) -> c_double = c_double_utils::frexp,
     fn hypot(x: c_double, y: c_double) -> c_double = c_double_utils::hypot,
@@ -170,15 +172,6 @@ pub fn ge(x: f64, y: f64) -> bool { return x >= y; }
 #[inline(always)]
 pub fn gt(x: f64, y: f64) -> bool { return x > y; }
 
-#[inline(always)]
-pub fn fmax(x: f64, y: f64) -> f64 {
-    if x >= y || y.is_NaN() { x } else { y }
-}
-
-#[inline(always)]
-pub fn fmin(x: f64, y: f64) -> f64 {
-    if x <= y || y.is_NaN() { x } else { y }
-}
 
 // FIXME (#1999): add is_normal, is_subnormal, and fpclassify
 

branches/snap-stage3/src/libstd/vec.rs

@@ -2347,16 +2347,16 @@ impl<T:Eq> OwnedEqVector<T> for ~[T] {
 }
 
 pub trait MutableVector<'self, T> {
-    fn mut_slice(&mut self, start: uint, end: uint) -> &'self mut [T];
+    fn mut_slice(self, start: uint, end: uint) -> &'self mut [T];
 
     unsafe fn unsafe_mut_ref(&self, index: uint) -> *mut T;
     unsafe fn unsafe_set(&self, index: uint, val: T);
 }
 
 impl<'self,T> MutableVector<'self, T> for &'self mut [T] {
     #[inline]
-    fn mut_slice(&mut self, start: uint, end: uint) -> &'self mut [T] {
-        mut_slice(*self, start, end)
+    fn mut_slice(self, start: uint, end: uint) -> &'self mut [T] {
+        mut_slice(self, start, end)
     }
 
     #[inline(always)]