---

yaml
---
r: 273343
b: refs/heads/beta
c: 2ab1f0a
h: refs/heads/master
i:
  273341: 0a2b96d
  273339: fadeb6d
  273335: 3226c20
  273327: 5876c5a
  273311: 527eaa5
  273279: 737377e

Author: petevine

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: 4a67405ba9870d643d3b6314b1b0e52d37b6958e
+refs/heads/beta: 2ab1f0a850f4e02c5dacf882c040b3acee57f86a
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/RELEASES.md

@@ -116,8 +116,8 @@ Compatibility Notes
   that were not intended. In this release, [defaulted type parameters
   appearing outside of type definitions will generate a
   warning][1.7d], which will become an error in future releases.
-* [Parsing "." as a float results in an error instead of 0][1.7p].
-  That is, `".".parse::<f32>()` returns `Err`, not `Ok(0.0)`.
+* [Parsing "." as a float results in an error instead of
+  0][1.7p]. That is, `".".parse::<f32>()` returns `Err`, not `Ok(0)`.
 * [Borrows of closure parameters may not outlive the closure][1.7bc].
 
 [1.7a]: https://github.com/rust-lang/rust/pull/30928

branches/beta/mk/cfg/i586-unknown-linux-gnu.mk

@@ -7,9 +7,9 @@ CFG_LIB_NAME_i586-unknown-linux-gnu=lib$(1).so
 CFG_STATIC_LIB_NAME_i586-unknown-linux-gnu=lib$(1).a
 CFG_LIB_GLOB_i586-unknown-linux-gnu=lib$(1)-*.so
 CFG_LIB_DSYM_GLOB_i586-unknown-linux-gnu=lib$(1)-*.dylib.dSYM
-CFG_JEMALLOC_CFLAGS_i586-unknown-linux-gnu := -m32 $(CFLAGS)
-CFG_GCCISH_CFLAGS_i586-unknown-linux-gnu := -Wall -Werror -g -fPIC -m32 $(CFLAGS)
-CFG_GCCISH_CXXFLAGS_i586-unknown-linux-gnu := -fno-rtti $(CXXFLAGS)
+CFG_JEMALLOC_CFLAGS_i586-unknown-linux-gnu := -m32 $(CFLAGS) -march=pentium
+CFG_GCCISH_CFLAGS_i586-unknown-linux-gnu := -Wall -Werror -g -fPIC -m32 $(CFLAGS) -march=pentium
+CFG_GCCISH_CXXFLAGS_i586-unknown-linux-gnu := -fno-rtti $(CXXFLAGS) -march=pentium
 CFG_GCCISH_LINK_FLAGS_i586-unknown-linux-gnu := -shared -fPIC -ldl -pthread  -lrt -g -m32
 CFG_GCCISH_DEF_FLAG_i586-unknown-linux-gnu := -Wl,--export-dynamic,--dynamic-list=
 CFG_LLC_FLAGS_i586-unknown-linux-gnu :=

branches/beta/src/bootstrap/build/native.rs

@@ -114,8 +114,7 @@ pub fn compiler_rt(build: &Build, target: &str) {
     let arch = target.split('-').next().unwrap();
     let mode = if build.config.rust_optimize {"Release"} else {"Debug"};
     let (dir, build_target, libname) = if target.contains("linux") ||
-                                          target.contains("freebsd") ||
-                                          target.contains("netbsd") {
+                                          target.contains("freebsd") {
         let os = if target.contains("android") {"-android"} else {""};
         let arch = if arch.starts_with("arm") && target.contains("eabihf") {
             "armhf"

branches/beta/src/compiletest/runtest.rs

@@ -1025,10 +1025,6 @@ fn check_expected_errors(revision: Option<&str>,
         expected.replace(r"\", "/")
     }).collect::<Vec<String>>();
 
-    // If the testcase being checked contains at least one expected "help"
-    // message, then we'll ensure that all "help" messages are expected.
-    // Otherwise, all "help" messages reported by the compiler will be ignored.
-    // This logic also applies to "note" messages.
     let (expect_help, expect_note) =
         expected_errors.iter()
                         .fold((false, false),

branches/beta/src/doc/book/getting-started.md

@@ -93,8 +93,8 @@ unofficial locations.
 | `armv7-apple-ios`             |  ✓  |     |     | ARM iOS                    |
 | `armv7s-apple-ios`            |  ✓  |     |     | ARM iOS                    |
 | `aarch64-apple-ios`           |  ✓  |     |     | ARM64 iOS                  |
-| `i686-unknown-freebsd`        |  ✓  |  ✓  |  ✓  | 32-bit FreeBSD             |
-| `x86_64-unknown-freebsd`      |  ✓  |  ✓  |  ✓  | 64-bit FreeBSD             |
+| `i686-unknown-freebsd`        |  ✓  |  ✓  |     | 32-bit FreeBSD             |
+| `x86_64-unknown-freebsd`      |  ✓  |  ✓  |     | 64-bit FreeBSD             |
 | `x86_64-unknown-openbsd`      |  ✓  |  ✓  |     | 64-bit OpenBSD             |
 | `x86_64-unknown-netbsd`       |  ✓  |  ✓  |     | 64-bit NetBSD              |
 | `x86_64-unknown-bitrig`       |  ✓  |  ✓  |     | 64-bit Bitrig              |

branches/beta/src/doc/book/guessing-game.md

@@ -912,7 +912,7 @@ returned by `parse()`, this is an `enum`  like `Ordering`, but in this case,
 each variant has some data associated with it: `Ok` is a success, and `Err` is a
 failure. Each contains more information: the successfully parsed integer, or an
 error type. In this case, we `match` on `Ok(num)`, which sets the name `num` to
-the unwrapped `Ok` value (the integer), and then we  return it on the
+the unwrapped `Ok` value (ythe integer), and then we  return it on the
 right-hand side. In the `Err` case, we don’t care what kind of error it is, so
 we just use the catch all `_` instead of a name. This catches everything that
 isn't `Ok`, and `continue` lets us move to the next iteration of the loop; in

branches/beta/src/doc/book/references-and-borrowing.md

@@ -163,8 +163,8 @@ both at the same time:
 * exactly one mutable reference (`&mut T`).
 
 
-You may notice that this is very similar to, though not exactly the same as,
-the definition of a data race:
+You may notice that this is very similar, though not exactly the same as,
+to the definition of a data race:
 
 > There is a ‘data race’ when two or more pointers access the same memory
 > location at the same time, where at least one of them is writing, and the

branches/beta/src/doc/book/variable-bindings.md

@@ -18,14 +18,14 @@ function, rather than leaving it off. Otherwise, you’ll get an error.
 
 In many languages, a variable binding would be called a *variable*, but Rust’s
 variable bindings have a few tricks up their sleeves. For example the
-left-hand side of a `let` statement is a ‘[pattern][pattern]’, not a
+left-hand side of a `let` expression is a ‘[pattern][pattern]’, not a
 variable name. This means we can do things like:
 
 ```rust
 let (x, y) = (1, 2);
 ```
 
-After this statement is evaluated, `x` will be one, and `y` will be two.
+After this expression is evaluated, `x` will be one, and `y` will be two.
 Patterns are really powerful, and have [their own section][pattern] in the
 book. We don’t need those features for now, so we’ll keep this in the back
 of our minds as we go forward.

branches/beta/src/libcore/intrinsics.rs

@@ -539,32 +539,6 @@ extern "rust-intrinsic" {
     /// Returns the nearest integer to an `f64`. Rounds half-way cases away from zero.
     pub fn roundf64(x: f64) -> f64;
 
-    /// Float addition that allows optimizations based on algebraic rules.
-    /// May assume inputs are finite.
-    #[cfg(not(stage0))]
-    pub fn fadd_fast<T>(a: T, b: T) -> T;
-
-    /// Float subtraction that allows optimizations based on algebraic rules.
-    /// May assume inputs are finite.
-    #[cfg(not(stage0))]
-    pub fn fsub_fast<T>(a: T, b: T) -> T;
-
-    /// Float multiplication that allows optimizations based on algebraic rules.
-    /// May assume inputs are finite.
-    #[cfg(not(stage0))]
-    pub fn fmul_fast<T>(a: T, b: T) -> T;
-
-    /// Float division that allows optimizations based on algebraic rules.
-    /// May assume inputs are finite.
-    #[cfg(not(stage0))]
-    pub fn fdiv_fast<T>(a: T, b: T) -> T;
-
-    /// Float remainder that allows optimizations based on algebraic rules.
-    /// May assume inputs are finite.
-    #[cfg(not(stage0))]
-    pub fn frem_fast<T>(a: T, b: T) -> T;
-
-
     /// Returns the number of bits set in an integer type `T`
     pub fn ctpop<T>(x: T) -> T;
 

branches/beta/src/librustc/middle/liveness.rs

@@ -115,7 +115,6 @@ use middle::pat_util;
 use middle::ty::{self, TyCtxt, ParameterEnvironment};
 use middle::traits::{self, ProjectionMode};
 use middle::infer;
-use middle::subst::Subst;
 use lint;
 use util::nodemap::NodeMap;
 
@@ -1492,15 +1491,14 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
                     if self.live_on_entry(entry_ln, self.s.no_ret_var).is_some() => {
 
                 let param_env = ParameterEnvironment::for_item(&self.ir.tcx, id);
-                let t_ret_subst = t_ret.subst(&self.ir.tcx, &param_env.free_substs);
                 let infcx = infer::new_infer_ctxt(&self.ir.tcx,
                                                   &self.ir.tcx.tables,
                                                   Some(param_env),
                                                   ProjectionMode::Any);
                 let cause = traits::ObligationCause::dummy();
                 let norm = traits::fully_normalize(&infcx,
                                                    cause,
-                                                   &t_ret_subst);
+                                                   &t_ret);
 
                 if norm.unwrap().is_nil() {
                     // for nil return types, it is ok to not return a value expl.

branches/beta/src/librustc_llvm/lib.rs

@@ -1310,7 +1310,6 @@ extern {
                          -> ValueRef;
     pub fn LLVMBuildNot(B: BuilderRef, V: ValueRef, Name: *const c_char)
                         -> ValueRef;
-    pub fn LLVMRustSetHasUnsafeAlgebra(Instr: ValueRef);
 
     /* Memory */
     pub fn LLVMBuildAlloca(B: BuilderRef, Ty: TypeRef, Name: *const c_char)

branches/beta/src/librustc_trans/trans/build.rs

@@ -221,18 +221,6 @@ pub fn FAdd(cx: Block,
     B(cx).fadd(lhs, rhs)
 }
 
-pub fn FAddFast(cx: Block,
-                lhs: ValueRef,
-                rhs: ValueRef,
-                debug_loc: DebugLoc)
-            -> ValueRef {
-    if cx.unreachable.get() {
-        return _Undef(lhs);
-    }
-    debug_loc.apply(cx.fcx);
-    B(cx).fadd_fast(lhs, rhs)
-}
-
 pub fn Sub(cx: Block,
            lhs: ValueRef,
            rhs: ValueRef,
@@ -281,18 +269,6 @@ pub fn FSub(cx: Block,
     B(cx).fsub(lhs, rhs)
 }
 
-pub fn FSubFast(cx: Block,
-                lhs: ValueRef,
-                rhs: ValueRef,
-                debug_loc: DebugLoc)
-            -> ValueRef {
-    if cx.unreachable.get() {
-        return _Undef(lhs);
-    }
-    debug_loc.apply(cx.fcx);
-    B(cx).fsub_fast(lhs, rhs)
-}
-
 pub fn Mul(cx: Block,
            lhs: ValueRef,
            rhs: ValueRef,
@@ -341,18 +317,6 @@ pub fn FMul(cx: Block,
     B(cx).fmul(lhs, rhs)
 }
 
-pub fn FMulFast(cx: Block,
-                lhs: ValueRef,
-                rhs: ValueRef,
-                debug_loc: DebugLoc)
-            -> ValueRef {
-    if cx.unreachable.get() {
-        return _Undef(lhs);
-    }
-    debug_loc.apply(cx.fcx);
-    B(cx).fmul_fast(lhs, rhs)
-}
-
 pub fn UDiv(cx: Block,
             lhs: ValueRef,
             rhs: ValueRef,
@@ -401,18 +365,6 @@ pub fn FDiv(cx: Block,
     B(cx).fdiv(lhs, rhs)
 }
 
-pub fn FDivFast(cx: Block,
-                lhs: ValueRef,
-                rhs: ValueRef,
-                debug_loc: DebugLoc)
-            -> ValueRef {
-    if cx.unreachable.get() {
-        return _Undef(lhs);
-    }
-    debug_loc.apply(cx.fcx);
-    B(cx).fdiv_fast(lhs, rhs)
-}
-
 pub fn URem(cx: Block,
             lhs: ValueRef,
             rhs: ValueRef,
@@ -449,18 +401,6 @@ pub fn FRem(cx: Block,
     B(cx).frem(lhs, rhs)
 }
 
-pub fn FRemFast(cx: Block,
-                lhs: ValueRef,
-                rhs: ValueRef,
-                debug_loc: DebugLoc)
-            -> ValueRef {
-    if cx.unreachable.get() {
-        return _Undef(lhs);
-    }
-    debug_loc.apply(cx.fcx);
-    B(cx).frem_fast(lhs, rhs)
-}
-
 pub fn Shl(cx: Block,
            lhs: ValueRef,
            rhs: ValueRef,

branches/beta/src/librustc_trans/trans/builder.rs

@@ -226,15 +226,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         }
     }
 
-    pub fn fadd_fast(&self, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
-        self.count_insn("fadd");
-        unsafe {
-            let instr = llvm::LLVMBuildFAdd(self.llbuilder, lhs, rhs, noname());
-            llvm::LLVMRustSetHasUnsafeAlgebra(instr);
-            instr
-        }
-    }
-
     pub fn sub(&self, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
         self.count_insn("sub");
         unsafe {
@@ -263,15 +254,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         }
     }
 
-    pub fn fsub_fast(&self, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
-        self.count_insn("sub");
-        unsafe {
-            let instr = llvm::LLVMBuildFSub(self.llbuilder, lhs, rhs, noname());
-            llvm::LLVMRustSetHasUnsafeAlgebra(instr);
-            instr
-        }
-    }
-
     pub fn mul(&self, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
         self.count_insn("mul");
         unsafe {
@@ -300,16 +282,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         }
     }
 
-    pub fn fmul_fast(&self, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
-        self.count_insn("fmul");
-        unsafe {
-            let instr = llvm::LLVMBuildFMul(self.llbuilder, lhs, rhs, noname());
-            llvm::LLVMRustSetHasUnsafeAlgebra(instr);
-            instr
-        }
-    }
-
-
     pub fn udiv(&self, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
         self.count_insn("udiv");
         unsafe {
@@ -338,15 +310,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         }
     }
 
-    pub fn fdiv_fast(&self, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
-        self.count_insn("fdiv");
-        unsafe {
-            let instr = llvm::LLVMBuildFDiv(self.llbuilder, lhs, rhs, noname());
-            llvm::LLVMRustSetHasUnsafeAlgebra(instr);
-            instr
-        }
-    }
-
     pub fn urem(&self, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
         self.count_insn("urem");
         unsafe {
@@ -368,15 +331,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         }
     }
 
-    pub fn frem_fast(&self, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
-        self.count_insn("frem");
-        unsafe {
-            let instr = llvm::LLVMBuildFRem(self.llbuilder, lhs, rhs, noname());
-            llvm::LLVMRustSetHasUnsafeAlgebra(instr);
-            instr
-        }
-    }
-
     pub fn shl(&self, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
         self.count_insn("shl");
         unsafe {

branches/beta/src/librustc_trans/trans/intrinsic.rs

@@ -658,29 +658,6 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
             }
 
         },
-        (_, "fadd_fast") | (_, "fsub_fast") | (_, "fmul_fast") | (_, "fdiv_fast") |
-        (_, "frem_fast") => {
-            let sty = &arg_tys[0].sty;
-            match float_type_width(sty) {
-                Some(_width) =>
-                    match &*name {
-                        "fadd_fast" => FAddFast(bcx, llargs[0], llargs[1], call_debug_location),
-                        "fsub_fast" => FSubFast(bcx, llargs[0], llargs[1], call_debug_location),
-                        "fmul_fast" => FMulFast(bcx, llargs[0], llargs[1], call_debug_location),
-                        "fdiv_fast" => FDivFast(bcx, llargs[0], llargs[1], call_debug_location),
-                        "frem_fast" => FRemFast(bcx, llargs[0], llargs[1], call_debug_location),
-                        _ => unreachable!(),
-                    },
-                None => {
-                    span_invalid_monomorphization_error(
-                        tcx.sess, span,
-                        &format!("invalid monomorphization of `{}` intrinsic: \
-                                  expected basic float type, found `{}`", name, sty));
-                        C_null(llret_ty)
-                }
-            }
-
-        },
 
 
         (_, "return_address") => {
@@ -1723,17 +1700,3 @@ fn int_type_width_signed<'tcx>(sty: &ty::TypeVariants<'tcx>, ccx: &CrateContext)
         _ => None,
     }
 }
-
-// Returns the width of a float TypeVariant
-// Returns None if the type is not a float
-fn float_type_width<'tcx>(sty: &ty::TypeVariants<'tcx>)
-        -> Option<u64> {
-    use rustc::middle::ty::TyFloat;
-    match *sty {
-        TyFloat(t) => Some(match t {
-            ast::FloatTy::F32 => 32,
-            ast::FloatTy::F64 => 64,
-        }),
-        _ => None,
-    }
-}