---

yaml
---
r: 73311
b: refs/heads/dist-snap
c: 474d998
h: refs/heads/master
i:
  73309: 1809725
  73307: 915319d
  73303: 64efb41
  73295: d71f87d
  73279: 4ff2b52
v: v3

Author: brson

[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: 24609675ebeff66f6299e98e4687618a48cf47e7
+refs/heads/dist-snap: 474d9983beb8a5770a202c552f36c14fa52917a2
 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/clone.rs

@@ -25,9 +25,8 @@ by convention implementing the `Clone` trait and calling the
 use core::kinds::Const;
 
 pub trait Clone {
-    /// Returns a copy of the value. The contents of owned pointers
-    /// are copied to maintain uniqueness, while the contents of
-    /// managed pointers are not copied.
+    /// Return a deep copy of the owned object tree. Types with shared ownership like managed boxes
+    /// are cloned with a shallow copy.
     fn clone(&self) -> Self;
 }
 
@@ -86,9 +85,8 @@ clone_impl!(bool)
 clone_impl!(char)
 
 pub trait DeepClone {
-    /// Return a deep copy of the value. Unlike `Clone`, the contents of shared pointer types
-    /// *are* copied. Note that this is currently unimplemented for managed boxes, as
-    /// it would need to handle cycles, but it is implemented for other smart-pointer types.
+    /// Return a deep copy of the object tree. Types with shared ownership are also copied via a
+    /// deep copy, unlike `Clone`.
     fn deep_clone(&self) -> Self;
 }
 

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/librustc/lib/llvm.rs

@@ -1571,13 +1571,15 @@ pub mod llvm {
         pub unsafe fn LLVMBuildAtomicLoad(B: BuilderRef,
                                           PointerVal: ValueRef,
                                           Name: *c_char,
-                                          Order: AtomicOrdering)
+                                          Order: AtomicOrdering,
+                                          Alignment: c_uint)
                                        -> ValueRef;
 
         pub unsafe fn LLVMBuildAtomicStore(B: BuilderRef,
                                            Val: ValueRef,
                                            Ptr: ValueRef,
-                                           Order: AtomicOrdering)
+                                           Order: AtomicOrdering,
+                                           Alignment: c_uint)
                                         -> ValueRef;
 
         pub unsafe fn LLVMBuildAtomicCmpXchg(B: BuilderRef,

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

@@ -14,6 +14,7 @@ use lib::llvm::{Opcode, IntPredicate, RealPredicate, False};
 use lib::llvm::{ValueRef, TypeRef, BasicBlockRef, BuilderRef, ModuleRef};
 use lib;
 use middle::trans::common::*;
+use middle::trans::machine::llalign_of_min;
 use syntax::codemap::span;
 
 use core::hashmap::HashMap;
@@ -544,7 +545,8 @@ pub fn AtomicLoad(cx: block, PointerVal: ValueRef, order: AtomicOrdering) -> Val
             return llvm::LLVMGetUndef(ccx.int_type);
         }
         count_insn(cx, "load.atomic");
-        return llvm::LLVMBuildAtomicLoad(B(cx), PointerVal, noname(), order);
+        let align = llalign_of_min(*ccx, ccx.int_type);
+        return llvm::LLVMBuildAtomicLoad(B(cx), PointerVal, noname(), order, align as c_uint);
     }
 }
 
@@ -558,7 +560,6 @@ pub fn LoadRangeAssert(cx: block, PointerVal: ValueRef, lo: c_ulonglong,
         let min = llvm::LLVMConstInt(t, lo, signed);
         let max = llvm::LLVMConstInt(t, hi, signed);
 
-
         do vec::as_imm_buf([min, max]) |ptr, len| {
             llvm::LLVMSetMetadata(value, lib::llvm::MD_range as c_uint,
                                   llvm::LLVMMDNode(ptr, len as c_uint));
@@ -586,7 +587,8 @@ pub fn AtomicStore(cx: block, Val: ValueRef, Ptr: ValueRef, order: AtomicOrderin
                val_str(cx.ccx().tn, Val),
                val_str(cx.ccx().tn, Ptr));
         count_insn(cx, "store.atomic");
-        llvm::LLVMBuildAtomicStore(B(cx), Val, Ptr, order);
+        let align = llalign_of_min(cx.ccx(), cx.ccx().int_type);
+        llvm::LLVMBuildAtomicStore(B(cx), Val, Ptr, order, align as c_uint);
     }
 }
 

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

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -8,33 +8,9 @@
 // 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;
@@ -45,7 +21,7 @@ use core::unstable::sync::UnsafeAtomicRcBox;
 use core::ptr;
 use core::task;
 
-/// As sync::condvar, a mechanism for unlock-and-descheduling and signaling.
+/// As sync::condvar, a mechanism for unlock-and-descheduling and signalling.
 pub struct Condvar<'self> {
     is_mutex: bool,
     failed: &'self mut bool,
@@ -117,14 +93,9 @@ pub fn ARC<T:Const + Owned>(data: T) -> ARC<T> {
  * wrapper.
  */
 pub fn get<'a, T:Const + Owned>(rc: &'a ARC<T>) -> &'a T {
-    rc.get()
+    unsafe { &*rc.x.get_immut() }
 }
 
-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.
  *
@@ -537,7 +508,6 @@ 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],