---

yaml
---
r: 153310
b: refs/heads/try2
c: f8bc571
h: refs/heads/master
v: v3

Author: hirschenberger

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 7ab9bfab4e623f67ea32db1ec50f8b79c1514e40
+refs/heads/try2: f8bc571df70a0832890bbed82ff80d4c9921b6ac
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/dist.mk

@@ -259,6 +259,7 @@ distcheck-tar-bins: dist-tar-bins
 	$(Q)cd tmp/distcheck && tar -xzf ../../dist/$(PKG_NAME)-$(CFG_BUILD).tar.gz
 	$(Q)mkdir -p tmp/distcheck/tarbininstall
 	$(Q)sh tmp/distcheck/$(PKG_NAME)-$(CFG_BUILD)/install.sh --prefix=tmp/distcheck/tarbininstall
+	$(Q)tmp/distcheck/tarbininstall/bin/rustc --version
 	$(Q)sh tmp/distcheck/$(PKG_NAME)-$(CFG_BUILD)/install.sh --prefix=tmp/distcheck/tarbininstall --uninstall
 	$(Q)rm -Rf tmp/distcheck/$(PKG_NAME)-$(CFG_BUILD)
 	$(Q)rm -Rf tmp/distcheck/tarbininstall

branches/try2/src/libcore/intrinsics.rs

@@ -326,73 +326,19 @@ extern "rust-intrinsic" {
     /// integer, since the conversion would throw away aliasing information.
     pub fn offset<T>(dst: *const T, offset: int) -> *const T;
 
-    /// Copies data from one location to another.
-    ///
-    /// Copies `count` elements (not bytes) from `src` to `dst`. The source
-    /// and destination may *not* overlap.
-    ///
-    /// `copy_nonoverlapping_memory` is semantically equivalent to C's `memcpy`.
-    ///
-    /// # Example
-    ///
-    /// A safe swap function:
-    ///
-    /// ```
-    /// use std::mem;
-    /// use std::ptr;
-    ///
-    /// fn swap<T>(x: &mut T, y: &mut T) {
-    ///     unsafe {
-    ///         // Give ourselves some scratch space to work with
-    ///         let mut t: T = mem::uninitialized();
-    ///
-    ///         // Perform the swap, `&mut` pointers never alias
-    ///         ptr::copy_nonoverlapping_memory(&mut t, &*x, 1);
-    ///         ptr::copy_nonoverlapping_memory(x, &*y, 1);
-    ///         ptr::copy_nonoverlapping_memory(y, &t, 1);
-    ///
-    ///         // y and t now point to the same thing, but we need to completely forget `tmp`
-    ///         // because it's no longer relevant.
-    ///         mem::forget(t);
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// # Safety Note
-    ///
-    /// If the source and destination overlap then the behavior of this
-    /// function is undefined.
-    #[unstable]
+    /// Equivalent to the appropriate `llvm.memcpy.p0i8.0i8.*` intrinsic, with
+    /// a size of `count` * `size_of::<T>()` and an alignment of
+    /// `min_align_of::<T>()`
     pub fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: uint);
 
-    /// Copies data from one location to another.
-    ///
-    /// Copies `count` elements (not bytes) from `src` to `dst`. The source
-    /// and destination may overlap.
-    ///
-    /// `copy_memory` is semantically equivalent to C's `memmove`.
-    ///
-    /// # Example
-    ///
-    /// Efficiently create a Rust vector from an unsafe buffer:
-    ///
-    /// ```
-    /// use std::ptr;
-    ///
-    /// unsafe fn from_buf_raw<T>(ptr: *const T, elts: uint) -> Vec<T> {
-    ///     let mut dst = Vec::with_capacity(elts);
-    ///     dst.set_len(elts);
-    ///     ptr::copy_memory(dst.as_mut_ptr(), ptr, elts);
-    ///     dst
-    /// }
-    /// ```
-    ///
-    #[unstable]
+    /// Equivalent to the appropriate `llvm.memmove.p0i8.0i8.*` intrinsic, with
+    /// a size of `count` * `size_of::<T>()` and an alignment of
+    /// `min_align_of::<T>()`
     pub fn copy_memory<T>(dst: *mut T, src: *const T, count: uint);
 
-    /// Invokes memset on the specified pointer, setting `count * size_of::<T>()`
-    /// bytes of memory starting at `dst` to `c`.
-    #[experimental = "uncertain about naming and semantics"]
+    /// Equivalent to the appropriate `llvm.memset.p0i8.*` intrinsic, with a
+    /// size of `count` * `size_of::<T>()` and an alignment of
+    /// `min_align_of::<T>()`
     pub fn set_memory<T>(dst: *mut T, val: u8, count: uint);
 
     /// Equivalent to the appropriate `llvm.memcpy.p0i8.0i8.*` intrinsic, with

branches/try2/src/libcore/num/f32.rs

@@ -11,6 +11,8 @@
 //! Operations and constants for 32-bits floats (`f32` type)
 
 #![doc(primitive = "f32")]
+// FIXME: MIN_VALUE and MAX_VALUE literals are parsed as -inf and inf #14353
+#![allow(type_overflow)]
 
 use intrinsics;
 use mem;

branches/try2/src/libcore/num/f64.rs

@@ -11,6 +11,8 @@
 //! Operations and constants for 64-bits floats (`f64` type)
 
 #![doc(primitive = "f64")]
+// FIXME: MIN_VALUE and MAX_VALUE literals are parsed as -inf and inf #14353
+#![allow(type_overflow)]
 
 use intrinsics;
 use mem;

branches/try2/src/libcore/ptr.rs

@@ -95,10 +95,6 @@ use option::{Some, None, Option};
 
 use cmp::{PartialEq, Eq, PartialOrd, Equiv, Ordering, Less, Equal, Greater};
 
-pub use intrinsics::copy_memory;
-pub use intrinsics::copy_nonoverlapping_memory;
-pub use intrinsics::set_memory;
-
 /// Create a null pointer.
 ///
 /// # Example
@@ -127,6 +123,86 @@ pub fn null<T>() -> *const T { 0 as *const T }
 #[unstable = "may need a different name after pending changes to pointer types"]
 pub fn mut_null<T>() -> *mut T { 0 as *mut T }
 
+/// Copies data from one location to another.
+///
+/// Copies `count` elements (not bytes) from `src` to `dst`. The source
+/// and destination may overlap.
+///
+/// `copy_memory` is semantically equivalent to C's `memmove`.
+///
+/// # Example
+///
+/// Efficiently create a Rust vector from an unsafe buffer:
+///
+/// ```
+/// use std::ptr;
+///
+/// unsafe fn from_buf_raw<T>(ptr: *const T, elts: uint) -> Vec<T> {
+///     let mut dst = Vec::with_capacity(elts);
+///     dst.set_len(elts);
+///     ptr::copy_memory(dst.as_mut_ptr(), ptr, elts);
+///     dst
+/// }
+/// ```
+///
+#[inline]
+#[unstable]
+pub unsafe fn copy_memory<T>(dst: *mut T, src: *const T, count: uint) {
+    intrinsics::copy_memory(dst, src, count)
+}
+
+/// Copies data from one location to another.
+///
+/// Copies `count` elements (not bytes) from `src` to `dst`. The source
+/// and destination may *not* overlap.
+///
+/// `copy_nonoverlapping_memory` is semantically equivalent to C's `memcpy`.
+///
+/// # Example
+///
+/// A safe swap function:
+///
+/// ```
+/// use std::mem;
+/// use std::ptr;
+///
+/// fn swap<T>(x: &mut T, y: &mut T) {
+///     unsafe {
+///         // Give ourselves some scratch space to work with
+///         let mut t: T = mem::uninitialized();
+///
+///         // Perform the swap, `&mut` pointers never alias
+///         ptr::copy_nonoverlapping_memory(&mut t, &*x, 1);
+///         ptr::copy_nonoverlapping_memory(x, &*y, 1);
+///         ptr::copy_nonoverlapping_memory(y, &t, 1);
+///
+///         // y and t now point to the same thing, but we need to completely forget `tmp`
+///         // because it's no longer relevant.
+///         mem::forget(t);
+///     }
+/// }
+/// ```
+///
+/// # Safety Note
+///
+/// If the source and destination overlap then the behavior of this
+/// function is undefined.
+#[inline]
+#[unstable]
+pub unsafe fn copy_nonoverlapping_memory<T>(dst: *mut T,
+                                            src: *const T,
+                                            count: uint) {
+    intrinsics::copy_nonoverlapping_memory(dst, src, count)
+}
+
+/// Invokes memset on the specified pointer, setting `count * size_of::<T>()`
+/// bytes of memory starting at `dst` to `c`.
+#[inline]
+#[experimental = "uncertain about naming and semantics"]
+pub unsafe fn set_memory<T>(dst: *mut T, c: u8, count: uint) {
+    intrinsics::set_memory(dst, c, count)
+}
+
 /// Zeroes out `count * size_of::<T>` bytes of memory at `dst`
 #[inline]
 #[experimental = "uncertain about naming and semantics"]

branches/try2/src/librustc/lint/builtin.rs

@@ -37,14 +37,7 @@ use lint::{Context, LintPass, LintArray};
 
 use std::cmp;
 use std::collections::HashMap;
-use std::i16;
-use std::i32;
-use std::i64;
-use std::i8;
-use std::u16;
-use std::u32;
-use std::u64;
-use std::u8;
+use std::{i8, i16, i32, i64, u8, u16, u32, u64, f32, f64};
 use std::gc::Gc;
 use syntax::abi;
 use syntax::ast_map;
@@ -214,7 +207,21 @@ impl LintPass for TypeLimits {
                                          "literal out of range for its type");
                         }
                     },
-
+                    ty::ty_float(t) => {
+                        let (min, max) = float_ty_range(t);
+                        let lit_val: f64 = match lit.node {
+                            ast::LitFloat(ref v, _) |
+                            ast::LitFloatUnsuffixed(ref v) => match from_str(v.get()) {
+                                Some(f) => f,
+                                None => return
+                            },
+                            _ => fail!()
+                        };
+                        if lit_val < min || lit_val > max {
+                            cx.span_lint(TYPE_OVERFLOW, e.span,
+                                         "literal out of range for its type");
+                        }
+                    },
                     _ => ()
                 };
             },
@@ -265,6 +272,13 @@ impl LintPass for TypeLimits {
             }
         }
 
+        fn float_ty_range(float_ty: ast::FloatTy) -> (f64, f64) {
+            match float_ty {
+                ast::TyF32  => (f32::MIN_VALUE as f64, f32::MAX_VALUE as f64),
+                ast::TyF64  => (f64::MIN_VALUE,        f64::MAX_VALUE)
+            }
+        }
+
         fn check_limits(tcx: &ty::ctxt, binop: ast::BinOp,
                         l: &ast::Expr, r: &ast::Expr) -> bool {
             let (lit, expr, swap) = match (&l.node, &r.node) {

branches/try2/src/librustc/middle/trans/base.rs

@@ -862,12 +862,9 @@ pub fn trans_external_path(ccx: &CrateContext, did: ast::DefId, t: ty::t) -> Val
         ty::ty_bare_fn(ref fn_ty) => {
             match fn_ty.abi.for_target(ccx.sess().targ_cfg.os,
                                        ccx.sess().targ_cfg.arch) {
-                Some(Rust) => {
+                Some(Rust) | Some(RustIntrinsic) => {
                     get_extern_rust_fn(ccx, t, name.as_slice(), did)
                 }
-                Some(RustIntrinsic) => {
-                    ccx.sess().bug("unexpected intrinsic in trans_external_path")
-                }
                 Some(..) | None => {
                     foreign::register_foreign_item_fn(ccx, fn_ty.abi, t,
                                                       name.as_slice(), None)
@@ -1784,9 +1781,9 @@ fn register_fn(ccx: &CrateContext,
                -> ValueRef {
     match ty::get(node_type).sty {
         ty::ty_bare_fn(ref f) => {
-            assert!(f.abi == Rust);
+            assert!(f.abi == Rust || f.abi == RustIntrinsic);
         }
-        _ => fail!("expected bare rust fn")
+        _ => fail!("expected bare rust fn or an intrinsic")
     };
 
     let llfn = decl_rust_fn(ccx, node_type, sym.as_slice());