---

yaml
---
r: 95868
b: refs/heads/dist-snap
c: 94677c1
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: ff859edb8579be4694fe490249e9800cefe50c8c
+refs/heads/dist-snap: 94677c18af3b639ac374a265af461e5acfe340ca
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/rust.md

@@ -2063,7 +2063,7 @@ The currently implemented features of the compiler are:
 
 * `once_fns` - Onceness guarantees a closure is only executed once. Defining a
                closure as `once` is unlikely to be supported going forward. So
-               they are hidden behind this feature until they are to be removed. 
+               they are hidden behind this feature until they are to be removed.
 
 If a feature is promoted to a language feature, then all existing programs will
 start to receive compilation warnings about #[feature] directives which enabled
@@ -2748,11 +2748,10 @@ do k(3) |j| {
 
 ~~~~ {.ebnf .gram}
 for_expr : "for" pat "in" expr '{' block '}' ;
-~~~~ 
+~~~~
 
-A `for` expression is a syntactic construct for looping
-over elements provided by an implementation of
-`std::iterator::Iterator`.
+A `for` expression is a syntactic construct for looping over elements
+provided by an implementation of `std::iter::Iterator`.
 
 An example of a for loop over the contents of a vector:
 

branches/dist-snap/doc/tutorial-container.md

@@ -69,7 +69,7 @@ heapsort.
 ## Iteration protocol
 
 The iteration protocol is defined by the `Iterator` trait in the
-`std::iterator` module. The minimal implementation of the trait is a `next`
+`std::iter` module. The minimal implementation of the trait is a `next`
 method, yielding the next element from an iterator object:
 
 ~~~

branches/dist-snap/doc/tutorial.md

@@ -759,6 +759,7 @@ different type from `Bar(1, 2)`), and tuple structs' _fields_ do not have
 names.
 
 For example:
+
 ~~~~
 struct MyTup(int, int, f64);
 let mytup: MyTup = MyTup(10, 20, 30.0);

branches/dist-snap/src/librustc/middle/trans/intrinsic.rs

@@ -74,14 +74,24 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
         }
     }
 
-    fn memcpy_intrinsic(bcx: @mut Block, name: &'static str, tp_ty: ty::t, sizebits: u8) {
+    fn copy_intrinsic(bcx: @mut Block, allow_overlap: bool, tp_ty: ty::t) {
         let ccx = bcx.ccx();
         let lltp_ty = type_of::type_of(ccx, tp_ty);
         let align = C_i32(machine::llalign_of_min(ccx, lltp_ty) as i32);
-        let size = match sizebits {
-            32 => C_i32(machine::llsize_of_real(ccx, lltp_ty) as i32),
-            64 => C_i64(machine::llsize_of_real(ccx, lltp_ty) as i64),
-            _ => ccx.sess.fatal("Invalid value for sizebits")
+        let size = machine::llsize_of(ccx, lltp_ty);
+        let int_size = machine::llbitsize_of_real(ccx, ccx.int_type);
+        let name = if allow_overlap {
+            if int_size == 32 {
+                "llvm.memmove.p0i8.p0i8.i32"
+            } else {
+                "llvm.memmove.p0i8.p0i8.i64"
+            }
+        } else {
+            if int_size == 32 {
+                "llvm.memcpy.p0i8.p0i8.i32"
+            } else {
+                "llvm.memcpy.p0i8.p0i8.i64"
+            }
         };
 
         let decl = bcx.fcx.llfn;
@@ -95,14 +105,15 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
         RetVoid(bcx);
     }
 
-    fn memset_intrinsic(bcx: @mut Block, name: &'static str, tp_ty: ty::t, sizebits: u8) {
+    fn memset_intrinsic(bcx: @mut Block, tp_ty: ty::t) {
         let ccx = bcx.ccx();
         let lltp_ty = type_of::type_of(ccx, tp_ty);
         let align = C_i32(machine::llalign_of_min(ccx, lltp_ty) as i32);
-        let size = match sizebits {
-            32 => C_i32(machine::llsize_of_real(ccx, lltp_ty) as i32),
-            64 => C_i64(machine::llsize_of_real(ccx, lltp_ty) as i64),
-            _ => ccx.sess.fatal("Invalid value for sizebits")
+        let size = machine::llsize_of(ccx, lltp_ty);
+        let name = if machine::llbitsize_of_real(ccx, ccx.int_type) == 32 {
+            "llvm.memset.p0i8.i32"
+        } else {
+            "llvm.memset.p0i8.i64"
         };
 
         let decl = bcx.fcx.llfn;
@@ -399,12 +410,9 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
             let lladdr = InBoundsGEP(bcx, ptr, [offset]);
             Ret(bcx, lladdr);
         }
-        "memcpy32" => memcpy_intrinsic(bcx, "llvm.memcpy.p0i8.p0i8.i32", substs.tys[0], 32),
-        "memcpy64" => memcpy_intrinsic(bcx, "llvm.memcpy.p0i8.p0i8.i64", substs.tys[0], 64),
-        "memmove32" => memcpy_intrinsic(bcx, "llvm.memmove.p0i8.p0i8.i32", substs.tys[0], 32),
-        "memmove64" => memcpy_intrinsic(bcx, "llvm.memmove.p0i8.p0i8.i64", substs.tys[0], 64),
-        "memset32" => memset_intrinsic(bcx, "llvm.memset.p0i8.i32", substs.tys[0], 32),
-        "memset64" => memset_intrinsic(bcx, "llvm.memset.p0i8.i64", substs.tys[0], 64),
+        "copy_nonoverlapping_memory" => copy_intrinsic(bcx, false, substs.tys[0]),
+        "copy_memory" => copy_intrinsic(bcx, true, substs.tys[0]),
+        "set_memory" => memset_intrinsic(bcx, substs.tys[0]),
         "sqrtf32" => simple_llvm_intrinsic(bcx, "llvm.sqrt.f32", 1),
         "sqrtf64" => simple_llvm_intrinsic(bcx, "llvm.sqrt.f64", 1),
         "powif32" => simple_llvm_intrinsic(bcx, "llvm.powi.f32", 2),

branches/dist-snap/src/librustc/middle/typeck/check/mod.rs

@@ -3734,7 +3734,7 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
                    mutbl: ast::MutImmutable
                }))
             }
-            "memcpy32" => {
+            "copy_nonoverlapping_memory" => {
               (1,
                ~[
                   ty::mk_ptr(tcx, ty::mt {
@@ -3745,11 +3745,11 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
                       ty: param(ccx, 0),
                       mutbl: ast::MutImmutable
                   }),
-                  ty::mk_u32()
+                  ty::mk_uint()
                ],
                ty::mk_nil())
             }
-            "memcpy64" => {
+            "copy_memory" => {
               (1,
                ~[
                   ty::mk_ptr(tcx, ty::mt {
@@ -3760,61 +3760,19 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
                       ty: param(ccx, 0),
                       mutbl: ast::MutImmutable
                   }),
-                  ty::mk_u64()
+                  ty::mk_uint()
                ],
                ty::mk_nil())
             }
-            "memmove32" => {
-              (1,
-               ~[
-                  ty::mk_ptr(tcx, ty::mt {
-                      ty: param(ccx, 0),
-                      mutbl: ast::MutMutable
-                  }),
-                  ty::mk_ptr(tcx, ty::mt {
-                      ty: param(ccx, 0),
-                      mutbl: ast::MutImmutable
-                  }),
-                  ty::mk_u32()
-               ],
-               ty::mk_nil())
-            }
-            "memmove64" => {
-              (1,
-               ~[
-                  ty::mk_ptr(tcx, ty::mt {
-                      ty: param(ccx, 0),
-                      mutbl: ast::MutMutable
-                  }),
-                  ty::mk_ptr(tcx, ty::mt {
-                      ty: param(ccx, 0),
-                      mutbl: ast::MutImmutable
-                  }),
-                  ty::mk_u64()
-               ],
-               ty::mk_nil())
-            }
-            "memset32" => {
-              (1,
-               ~[
-                  ty::mk_ptr(tcx, ty::mt {
-                      ty: param(ccx, 0),
-                      mutbl: ast::MutMutable
-                  }),
-                  ty::mk_u8(),
-                  ty::mk_u32()
-               ],
-               ty::mk_nil())
-            }
-            "memset64" => {
+            "set_memory" => {
               (1,
                ~[
                   ty::mk_ptr(tcx, ty::mt {
                       ty: param(ccx, 0),
                       mutbl: ast::MutMutable
                   }),
                   ty::mk_u8(),
-                  ty::mk_u64()
+                  ty::mk_uint()
                ],
                ty::mk_nil())
             }

branches/dist-snap/src/libstd/c_str.rs

@@ -330,7 +330,7 @@ fn check_for_null(v: &[u8], buf: *mut libc::c_char) {
 
 /// External iterator for a CString's bytes.
 ///
-/// Use with the `std::iterator` module.
+/// Use with the `std::iter` module.
 pub struct CStringIterator<'self> {
     priv ptr: *libc::c_char,
     priv lifetime: &'self libc::c_char, // FIXME: #5922

branches/dist-snap/src/libstd/cast.rs

@@ -13,26 +13,15 @@
 use ptr::RawPtr;
 use mem;
 use unstable::intrinsics;
+use ptr::copy_nonoverlapping_memory;
 
 /// Casts the value at `src` to U. The two types must have the same length.
-#[cfg(target_word_size = "32")]
 #[inline]
 pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
     let mut dest: U = intrinsics::uninit();
     let dest_ptr: *mut u8 = transmute(&mut dest);
     let src_ptr: *u8 = transmute(src);
-    intrinsics::memcpy32(dest_ptr, src_ptr, mem::size_of::<U>() as u32);
-    dest
-}
-
-/// Casts the value at `src` to U. The two types must have the same length.
-#[cfg(target_word_size = "64")]
-#[inline]
-pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
-    let mut dest: U = intrinsics::uninit();
-    let dest_ptr: *mut u8 = transmute(&mut dest);
-    let src_ptr: *u8 = transmute(src);
-    intrinsics::memcpy64(dest_ptr, src_ptr, mem::size_of::<U>() as u64);
+    copy_nonoverlapping_memory(dest_ptr, src_ptr, mem::size_of::<U>());
     dest
 }
 

branches/dist-snap/src/libstd/ptr.rs

@@ -87,7 +87,7 @@ pub fn is_not_null<T,P:RawPtr<T>>(ptr: P) -> bool { ptr.is_not_null() }
  * and destination may overlap.
  */
 #[inline]
-#[cfg(target_word_size = "32")]
+#[cfg(target_word_size = "32", stage0)]
 pub unsafe fn copy_memory<T,P:RawPtr<T>>(dst: *mut T, src: P, count: uint) {
     intrinsics::memmove32(dst,
                           cast::transmute_immut_unsafe(src),
@@ -101,21 +101,33 @@ pub unsafe fn copy_memory<T,P:RawPtr<T>>(dst: *mut T, src: P, count: uint) {
  * and destination may overlap.
  */
 #[inline]
-#[cfg(target_word_size = "64")]
+#[cfg(target_word_size = "64", stage0)]
 pub unsafe fn copy_memory<T,P:RawPtr<T>>(dst: *mut T, src: P, count: uint) {
     intrinsics::memmove64(dst,
                           cast::transmute_immut_unsafe(src),
                           count as u64);
 }
 
+/**
+ * Copies data from one location to another.
+ *
+ * Copies `count` elements (not bytes) from `src` to `dst`. The source
+ * and destination may overlap.
+ */
+#[inline]
+#[cfg(not(stage0))]
+pub unsafe fn copy_memory<T,P:RawPtr<T>>(dst: *mut T, src: P, count: uint) {
+    intrinsics::copy_memory(dst, cast::transmute_immut_unsafe(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.
  */
 #[inline]
-#[cfg(target_word_size = "32")]
+#[cfg(target_word_size = "32", stage0)]
 pub unsafe fn copy_nonoverlapping_memory<T,P:RawPtr<T>>(dst: *mut T,
                                                         src: P,
                                                         count: uint) {
@@ -131,7 +143,7 @@ pub unsafe fn copy_nonoverlapping_memory<T,P:RawPtr<T>>(dst: *mut T,
  * and destination may *not* overlap.
  */
 #[inline]
-#[cfg(target_word_size = "64")]
+#[cfg(target_word_size = "64", stage0)]
 pub unsafe fn copy_nonoverlapping_memory<T,P:RawPtr<T>>(dst: *mut T,
                                                         src: P,
                                                         count: uint) {
@@ -140,12 +152,26 @@ pub unsafe fn copy_nonoverlapping_memory<T,P:RawPtr<T>>(dst: *mut T,
                          count as u64);
 }
 
+/**
+ * Copies data from one location to another.
+ *
+ * Copies `count` elements (not bytes) from `src` to `dst`. The source
+ * and destination may *not* overlap.
+ */
+#[inline]
+#[cfg(not(stage0))]
+pub unsafe fn copy_nonoverlapping_memory<T,P:RawPtr<T>>(dst: *mut T,
+                                                        src: P,
+                                                        count: uint) {
+    intrinsics::copy_nonoverlapping_memory(dst, cast::transmute_immut_unsafe(src), count)
+}
+
 /**
  * Invokes memset on the specified pointer, setting `count * size_of::<T>()`
  * bytes of memory starting at `dst` to `c`.
  */
 #[inline]
-#[cfg(target_word_size = "32")]
+#[cfg(target_word_size = "32", stage0)]
 pub unsafe fn set_memory<T>(dst: *mut T, c: u8, count: uint) {
     intrinsics::memset32(dst, c, count as u32);
 }
@@ -155,11 +181,21 @@ pub unsafe fn set_memory<T>(dst: *mut T, c: u8, count: uint) {
  * bytes of memory starting at `dst` to `c`.
  */
 #[inline]
-#[cfg(target_word_size = "64")]
+#[cfg(target_word_size = "64", stage0)]
 pub unsafe fn set_memory<T>(dst: *mut T, c: u8, count: uint) {
     intrinsics::memset64(dst, c, count as u64);
 }
 
+/**
+ * Invokes memset on the specified pointer, setting `count * size_of::<T>()`
+ * bytes of memory starting at `dst` to `c`.
+ */
+#[inline]
+#[cfg(not(stage0))]
+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`
  */

branches/dist-snap/src/libstd/str.rs

@@ -352,7 +352,7 @@ Section: Iterators
 */
 
 /// External iterator for a string's characters.
-/// Use with the `std::iterator` module.
+/// Use with the `std::iter` module.
 #[deriving(Clone)]
 pub struct CharIterator<'self> {
     /// The slice remaining to be iterated
@@ -397,7 +397,7 @@ impl<'self> DoubleEndedIterator<char> for CharIterator<'self> {
 }
 
 /// External iterator for a string's characters and their byte offsets.
-/// Use with the `std::iterator` module.
+/// Use with the `std::iter` module.
 #[deriving(Clone)]
 pub struct CharOffsetIterator<'self> {
     /// The original string to be iterated
@@ -439,20 +439,20 @@ impl<'self> DoubleEndedIterator<(uint, char)> for CharOffsetIterator<'self> {
 }
 
 /// External iterator for a string's characters in reverse order.
-/// Use with the `std::iterator` module.
+/// Use with the `std::iter` module.
 pub type CharRevIterator<'self> = Invert<CharIterator<'self>>;
 
 /// External iterator for a string's characters and their byte offsets in reverse order.
-/// Use with the `std::iterator` module.
+/// Use with the `std::iter` module.
 pub type CharOffsetRevIterator<'self> = Invert<CharOffsetIterator<'self>>;
 
 /// External iterator for a string's bytes.
-/// Use with the `std::iterator` module.
+/// Use with the `std::iter` module.
 pub type ByteIterator<'self> =
     Map<'self, &'self u8, u8, vec::VecIterator<'self, u8>>;
 
 /// External iterator for a string's bytes in reverse order.
-/// Use with the `std::iterator` module.
+/// Use with the `std::iter` module.
 pub type ByteRevIterator<'self> = Invert<ByteIterator<'self>>;
 
 /// An iterator over the substrings of a string, separated by `sep`.
@@ -682,7 +682,7 @@ enum NormalizationForm {
 }
 
 /// External iterator for a string's normalization's characters.
-/// Use with the `std::iterator` module.
+/// Use with the `std::iter` module.
 #[deriving(Clone)]
 struct NormalizationIterator<'self> {
     priv kind: NormalizationForm,