Register new snapshots

src/libstd/any.rs

@@ -23,28 +23,13 @@ use util::Void;
 ///////////////////////////////////////////////////////////////////////////////
 
 /// `TypeId` represents a globally unique identifier for a type
-#[cfg(stage0)]
-pub struct TypeId {
-    priv t: *intrinsics::TyDesc,
-}
-
-/// `TypeId` represents a globally unique identifier for a type
-#[cfg(not(stage0))]
 pub struct TypeId {
     priv t: u64,
 }
 
 impl TypeId {
     /// Returns the `TypeId` of the type this generic function has been instantiated with
     #[inline]
-    #[cfg(stage0)]
-    pub fn of<T: 'static>() -> TypeId {
-        TypeId{ t: unsafe { intrinsics::get_tydesc::<T>() } }
-    }
-
-    /// Returns the `TypeId` of the type this generic function has been instantiated with
-    #[inline]
-    #[cfg(not(stage0))]
     pub fn of<T: 'static>() -> TypeId {
         TypeId{ t: unsafe { intrinsics::type_id::<T>() } }
     }

src/libstd/ptr.rs

@@ -87,35 +87,6 @@ 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", 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),
-                          count as u32);
-}
-
-/**
- * Copies data from one location to another.
- *
- * Copies `count` elements (not bytes) from `src` to `dst`. The source
- * and destination may overlap.
- */
-#[inline]
-#[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)
 }
@@ -127,39 +98,6 @@ pub unsafe fn copy_memory<T,P:RawPtr<T>>(dst: *mut T, src: P, count: uint) {
  * and destination may *not* overlap.
  */
 #[inline]
-#[cfg(target_word_size = "32", stage0)]
-pub unsafe fn copy_nonoverlapping_memory<T,P:RawPtr<T>>(dst: *mut T,
-                                                        src: P,
-                                                        count: uint) {
-    intrinsics::memcpy32(dst,
-                         cast::transmute_immut_unsafe(src),
-                         count as u32);
-}
-
-/**
- * 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 = "64", stage0)]
-pub unsafe fn copy_nonoverlapping_memory<T,P:RawPtr<T>>(dst: *mut T,
-                                                        src: P,
-                                                        count: uint) {
-    intrinsics::memcpy64(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 *not* overlap.
- */
-#[inline]
-#[cfg(not(stage0))]
 pub unsafe fn copy_nonoverlapping_memory<T,P:RawPtr<T>>(dst: *mut T,
                                                         src: P,
                                                         count: uint) {
@@ -171,27 +109,6 @@ pub unsafe fn copy_nonoverlapping_memory<T,P:RawPtr<T>>(dst: *mut T,
  * bytes of memory starting at `dst` to `c`.
  */
 #[inline]
-#[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);
-}
-
-/**
- * Invokes memset on the specified pointer, setting `count * size_of::<T>()`
- * bytes of memory starting at `dst` to `c`.
- */
-#[inline]
-#[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)
 }

src/libstd/reflect.rs

@@ -382,13 +382,6 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
         true
     }
 
-    #[cfg(stage0)]
-    fn visit_fn_output(&mut self, retstyle: uint, inner: *TyDesc) -> bool {
-        if ! self.inner.visit_fn_output(retstyle, inner) { return false; }
-        true
-    }
-
-    #[cfg(not(stage0))]
     fn visit_fn_output(&mut self, retstyle: uint, variadic: bool, inner: *TyDesc) -> bool {
         if ! self.inner.visit_fn_output(retstyle, variadic, inner) { return false; }
         true

src/libstd/repr.rs

@@ -572,18 +572,6 @@ impl<'self> TyVisitor for ReprVisitor<'self> {
         true
     }
 
-    #[cfg(stage0)]
-    fn visit_fn_output(&mut self, _retstyle: uint, inner: *TyDesc) -> bool {
-        self.writer.write(")".as_bytes());
-        let name = unsafe { (*inner).name };
-        if name != "()" {
-            self.writer.write(" -> ".as_bytes());
-            self.writer.write(name.as_bytes());
-        }
-        true
-    }
-
-    #[cfg(not(stage0))]
     fn visit_fn_output(&mut self, _retstyle: uint, variadic: bool, inner: *TyDesc) -> bool {
         if variadic {
             self.writer.write(", ...".as_bytes());

src/libstd/unstable/intrinsics.rs

@@ -160,9 +160,6 @@ pub trait TyVisitor {
     fn visit_enter_fn(&mut self, purity: uint, proto: uint,
                       n_inputs: uint, retstyle: uint) -> bool;
     fn visit_fn_input(&mut self, i: uint, mode: uint, inner: *TyDesc) -> bool;
-    #[cfg(stage0)]
-    fn visit_fn_output(&mut self, retstyle: uint, inner: *TyDesc) -> bool;
-    #[cfg(not(stage0))]
     fn visit_fn_output(&mut self, retstyle: uint, variadic: bool, inner: *TyDesc) -> bool;
     fn visit_leave_fn(&mut self, purity: uint, proto: uint,
                       n_inputs: uint, retstyle: uint) -> bool;
@@ -313,7 +310,6 @@ extern "rust-intrinsic" {
     /// Gets an identifier which is globally unique to the specified type. This
     /// function will return the same value for a type regardless of whichever
     /// crate it is invoked in.
-    #[cfg(not(stage0))]
     pub fn type_id<T: 'static>() -> u64;
 
     /// Create a value initialized to zero.
@@ -352,40 +348,19 @@ extern "rust-intrinsic" {
     /// integer, since the conversion would throw away aliasing information.
     pub fn offset<T>(dst: *T, offset: int) -> *T;
 
-    /// Equivalent to the `llvm.memcpy.p0i8.0i8.i32` intrinsic, with a size of
-    /// `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`
-    #[cfg(stage0)]
-    pub fn memcpy32<T>(dst: *mut T, src: *T, count: u32);
-    /// Equivalent to the `llvm.memcpy.p0i8.0i8.i64` intrinsic, with a size of
-    /// `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`
-    #[cfg(stage0)]
-    pub fn memcpy64<T>(dst: *mut T, src: *T, count: u64);
-
-    /// Equivalent to the `llvm.memmove.p0i8.0i8.i32` intrinsic, with a size of
-    /// `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`
-    #[cfg(stage0)]
-    pub fn memmove32<T>(dst: *mut T, src: *T, count: u32);
-    /// Equivalent to the `llvm.memmove.p0i8.0i8.i64` intrinsic, with a size of
-    /// `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`
-    #[cfg(stage0)]
-    pub fn memmove64<T>(dst: *mut T, src: *T, count: u64);
-
-    /// Equivalent to the `llvm.memset.p0i8.i32` intrinsic, with a size of
-    /// `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`
-    #[cfg(stage0)]
-    pub fn memset32<T>(dst: *mut T, val: u8, count: u32);
-    /// Equivalent to the `llvm.memset.p0i8.i64` intrinsic, with a size of
-    /// `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`
-    #[cfg(stage0)]
-    pub fn memset64<T>(dst: *mut T, val: u8, count: u64);
-
-    #[cfg(not(stage0))]
+    /// 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: *T, count: uint);
 
-    #[cfg(not(stage0))]
+    /// 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: *T, count: uint);
 
-    #[cfg(not(stage0))]
+    /// 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);
 
     pub fn sqrtf32(x: f32) -> f32;

src/snapshots.txt

@@ -1,3 +1,11 @@
+S 2013-11-04 1c56652
+  freebsd-x86_64 ee44d740de9a786c33ed7d9d14ac5a63ea994024
+  linux-i386 36b80fea26d896089c87abe498631e5036a8a6b6
+  linux-x86_64 314b7ac29d68302ca794da96309ceeafdee5cffe
+  macos-i386 c63a819a0daab78a8d589ff1527d448893fed70b
+  macos-x86_64 e358c90de36039a2f5db98598f9cd2a11d19998a
+  winnt-i386 26fd8dc1ea2e3e801bcb1e6c88108f808d8df8af
+
 S 2013-11-01 8ea2123
   freebsd-x86_64 bc7dea1ca297cfb4bd6d8a32185c6a4fddca3e6b
   linux-i386 4b33599d160d757f6021ff05d0213fba3097dde2