---

yaml
---
r: 73292
b: refs/heads/dist-snap
c: 54eafc0
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: b50030718cf28f2a5a81857a26b57442734fe854
-refs/heads/dist-snap: 7bd421776681285bf4dfba09fe7a6dae4c8eecd5
+refs/heads/dist-snap: 54eafc009d1595a04862b242fb6825f9e7b51799
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

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

@@ -12,17 +12,26 @@
 
 use sys;
 use unstable;
-use unstable::intrinsics;
+
+pub mod rusti {
+    #[abi = "rust-intrinsic"]
+    #[link_name = "rusti"]
+    pub extern "rust-intrinsic" {
+        fn forget<T>(x: T);
+
+        fn transmute<T,U>(e: T) -> U;
+    }
+}
 
 /// Casts the value at `src` to U. The two types must have the same length.
 pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
-    let mut dest: U = intrinsics::init();
+    let mut dest: U = unstable::intrinsics::init();
     {
-        let dest_ptr: *mut u8 = transmute(&mut dest);
-        let src_ptr: *u8 = transmute(src);
-        intrinsics::memmove64(dest_ptr,
-                              src_ptr,
-                              sys::size_of::<U>() as u64);
+        let dest_ptr: *mut u8 = rusti::transmute(&mut dest);
+        let src_ptr: *u8 = rusti::transmute(src);
+        unstable::intrinsics::memmove64(dest_ptr,
+                                        src_ptr,
+                                        sys::size_of::<U>() as u64);
     }
     dest
 }
@@ -36,7 +45,7 @@ pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
  * reinterpret_cast on pointer types.
  */
 #[inline(always)]
-pub unsafe fn forget<T>(thing: T) { intrinsics::forget(thing); }
+pub unsafe fn forget<T>(thing: T) { rusti::forget(thing); }
 
 /**
  * Force-increment the reference count on a shared box. If used
@@ -56,7 +65,7 @@ pub unsafe fn bump_box_refcount<T>(t: @T) { forget(t); }
  */
 #[inline(always)]
 pub unsafe fn transmute<L, G>(thing: L) -> G {
-    intrinsics::transmute(thing)
+    rusti::transmute(thing)
 }
 
 /// Coerce an immutable reference to be mutable.

branches/dist-snap/src/libcore/stackwalk.rs

@@ -11,7 +11,6 @@
 #[doc(hidden)]; // FIXME #3538
 
 use cast::transmute;
-use unstable::intrinsics;
 
 pub type Word = uint;
 
@@ -76,6 +75,13 @@ fn test_simple_deep() {
 
 fn frame_address(f: &fn(x: *u8)) {
     unsafe {
-        intrinsics::frame_address(f)
+        rusti::frame_address(f)
+    }
+}
+
+pub mod rusti {
+    #[abi = "rust-intrinsic"]
+    pub extern "rust-intrinsic" {
+        pub fn frame_address(f: &once fn(x: *u8));
     }
 }

branches/dist-snap/src/libcore/sys.rs

@@ -19,7 +19,6 @@ use libc;
 use libc::{c_void, c_char, size_t};
 use repr;
 use str;
-use unstable::intrinsics;
 
 pub type FreeGlue<'self> = &'self fn(*TypeDesc, *c_void);
 
@@ -39,6 +38,16 @@ pub struct Closure {
     env: *(),
 }
 
+pub mod rusti {
+    #[abi = "rust-intrinsic"]
+    pub extern "rust-intrinsic" {
+        fn get_tydesc<T>() -> *();
+        fn size_of<T>() -> uint;
+        fn pref_align_of<T>() -> uint;
+        fn min_align_of<T>() -> uint;
+    }
+}
+
 pub mod rustrt {
     use libc::{c_char, size_t};
 
@@ -72,7 +81,7 @@ pub fn shape_le<T:Ord>(x1: &T, x2: &T) -> bool {
  */
 #[inline(always)]
 pub fn get_type_desc<T>() -> *TypeDesc {
-    unsafe { intrinsics::get_tydesc::<T>() as *TypeDesc }
+    unsafe { rusti::get_tydesc::<T>() as *TypeDesc }
 }
 
 /// Returns a pointer to a type descriptor.
@@ -84,7 +93,7 @@ pub fn get_type_desc_val<T>(_val: &T) -> *TypeDesc {
 /// Returns the size of a type
 #[inline(always)]
 pub fn size_of<T>() -> uint {
-    unsafe { intrinsics::size_of::<T>() }
+    unsafe { rusti::size_of::<T>() }
 }
 
 /// Returns the size of the type that `_val` points to
@@ -119,7 +128,7 @@ pub fn nonzero_size_of_val<T>(_val: &T) -> uint {
  */
 #[inline(always)]
 pub fn min_align_of<T>() -> uint {
-    unsafe { intrinsics::min_align_of::<T>() }
+    unsafe { rusti::min_align_of::<T>() }
 }
 
 /// Returns the ABI-required minimum alignment of the type of the value that
@@ -132,7 +141,7 @@ pub fn min_align_of_val<T>(_val: &T) -> uint {
 /// Returns the preferred alignment of a type
 #[inline(always)]
 pub fn pref_align_of<T>() -> uint {
-    unsafe { intrinsics::pref_align_of::<T>() }
+    unsafe { rusti::pref_align_of::<T>() }
 }
 
 /// Returns the preferred alignment of the type of the value that

branches/dist-snap/src/libcore/unstable/intrinsics.rs

@@ -114,16 +114,15 @@ pub extern "rust-intrinsic" {
     /// `forget` is unsafe because the caller is responsible for
     /// ensuring the argument is deallocated already.
     pub unsafe fn forget<T>(_: T) -> ();
-    pub fn transmute<T,U>(e: T) -> U;
 
     /// Returns `true` if a type requires drop glue.
     pub fn needs_drop<T>() -> bool;
 
     // XXX: intrinsic uses legacy modes and has reference to TyDesc
     // and TyVisitor which are in librustc
     //fn visit_tydesc(++td: *TyDesc, &&tv: TyVisitor) -> ();
-
-    pub fn frame_address(f: &once fn(*u8));
+    // XXX: intrinsic uses legacy modes
+    //fn frame_address(f: &once fn(*u8));
 
     /// Get the address of the `__morestack` stack growth function.
     pub fn morestack_addr() -> *();

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

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -8,9 +8,33 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-/**
+/*!
  * Concurrency-enabled mechanisms for sharing mutable and/or immutable state
  * between tasks.
+ *
+ * # Example
+ *
+ * In this example, a large vector of floats is shared between several tasks.
+ * With simple pipes, without ARC, a copy would have to be made for each task.
+ *
+ * ~~~
+ * extern mod std;
+ * use std::arc;
+ * let numbers=vec::from_fn(100, |ind| (ind as float)*rand::random());
+ * let shared_numbers=arc::ARC(numbers);
+ *
+ *   for 10.times {
+ *       let (port, chan)  = stream();
+ *       chan.send(shared_numbers.clone());
+ *
+ *       do spawn {
+ *           let shared_numbers=port.recv();
+ *           let local_numbers=shared_numbers.get();
+ *
+ *           // Work with the local numbers
+ *       }
+ *   }
+ * ~~~
  */
 
 use sync;
@@ -21,7 +45,7 @@ use core::unstable::sync::UnsafeAtomicRcBox;
 use core::ptr;
 use core::task;
 
-/// As sync::condvar, a mechanism for unlock-and-descheduling and signalling.
+/// As sync::condvar, a mechanism for unlock-and-descheduling and signaling.
 pub struct Condvar<'self> {
     is_mutex: bool,
     failed: &'self mut bool,
@@ -93,9 +117,14 @@ pub fn ARC<T:Const + Owned>(data: T) -> ARC<T> {
  * wrapper.
  */
 pub fn get<'a, T:Const + Owned>(rc: &'a ARC<T>) -> &'a T {
-    unsafe { &*rc.x.get_immut() }
+    rc.get()
 }
 
+impl<T:Const+Owned> ARC<T> {
+    pub fn get<'a>(&'a self) -> &'a T {
+        unsafe { &*self.x.get_immut() }
+    }
+}
 /**
  * Duplicate an atomically reference counted wrapper.
  *
@@ -508,6 +537,7 @@ mod tests {
         c.send(arc::clone(&arc_v));
 
         assert_eq!((*arc::get(&arc_v))[2], 3);
+        assert_eq!(arc_v.get()[4], 5);
 
         info!(arc_v);
     }

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

@@ -43,7 +43,14 @@ use core::sys::TypeDesc;
 use core::sys;
 use core::uint;
 use core::vec;
-use core::unstable::intrinsics;
+
+pub mod rusti {
+    #[abi = "rust-intrinsic"]
+    pub extern "rust-intrinsic" {
+        fn move_val_init<T>(dst: &mut T, src: T);
+        fn needs_drop<T>() -> bool;
+    }
+}
 
 pub mod rustrt {
     use core::libc::size_t;
@@ -201,7 +208,7 @@ pub impl Arena {
             let tydesc = sys::get_type_desc::<T>();
             let ptr = self.alloc_pod_inner((*tydesc).size, (*tydesc).align);
             let ptr: *mut T = transmute(ptr);
-            intrinsics::move_val_init(&mut (*ptr), op());
+            rusti::move_val_init(&mut (*ptr), op());
             return transmute(ptr);
         }
     }
@@ -254,7 +261,7 @@ pub impl Arena {
             // has *not* been initialized yet.
             *ty_ptr = transmute(tydesc);
             // Actually initialize it
-            intrinsics::move_val_init(&mut(*ptr), op());
+            rusti::move_val_init(&mut(*ptr), op());
             // Now that we are done, update the tydesc to indicate that
             // the object is there.
             *ty_ptr = bitpack_tydesc_ptr(tydesc, true);
@@ -269,7 +276,7 @@ pub impl Arena {
         unsafe {
             // XXX: Borrow check
             let this = transmute_mut_region(self);
-            if !intrinsics::needs_drop::<T>() {
+            if !rusti::needs_drop::<T>() {
                 return this.alloc_pod(op);
             }
             // XXX: Borrow check

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

@@ -11,9 +11,8 @@
 //! A priority queue implemented with a binary heap
 
 use core::old_iter::BaseIter;
-use core::unstable::intrinsics::{move_val_init, init};
-use core::unstable::intrinsics::uninit;
 use core::util::{replace, swap};
+use core::unstable::intrinsics::{init, move_val_init};
 
 pub struct PriorityQueue<T> {
     priv data: ~[T],