---

yaml
---
r: 33431
b: refs/heads/snap-stage3
c: 42c05fe
h: refs/heads/master
i:
  33429: 064fc73
  33427: b93e089
  33423: 014d738
v: v3

Author: nikomatsakis

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 48582b360c784a536bd502f9611cfe66c753ce64
+refs/heads/snap-stage3: 42c05fe642efa726dc6cde624b40b638741724ee
 refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libcore/private.rs

@@ -14,6 +14,14 @@ extern mod rustrt {
     fn rust_task_weaken(ch: rust_port_id);
     fn rust_task_unweaken(ch: rust_port_id);
 
+    #[rust_stack]
+    fn rust_atomic_increment(p: &mut libc::intptr_t)
+        -> libc::intptr_t;
+
+    #[rust_stack]
+    fn rust_atomic_decrement(p: &mut libc::intptr_t)
+        -> libc::intptr_t;
+
     #[rust_stack]
     fn rust_compare_and_swap_ptr(address: &mut libc::uintptr_t,
                                  oldval: libc::uintptr_t,
@@ -25,15 +33,6 @@ extern mod rustrt {
     fn rust_unlock_little_lock(lock: rust_little_lock);
 }
 
-#[abi = "rust-intrinsic"]
-extern mod rusti {
-
-    #[cfg(stage1)] #[cfg(stage2)] #[cfg(stage3)]    
-    fn atomic_cxchg(dst: &mut int, old: int, src: int) -> int;
-    fn atomic_xadd(dst: &mut int, src: int) -> int;
-    fn atomic_xsub(dst: &mut int, src: int) -> int;
-}
-
 #[allow(non_camel_case_types)] // runtime type
 type rust_port_id = uint;
 
@@ -44,7 +43,6 @@ type GlobalPtr = *libc::uintptr_t;
  * or, if no channel exists creates and installs a new channel and sets up a
  * new task to receive from it.
  */
-#[cfg(stage0)]
 pub unsafe fn chan_from_global_ptr<T: Send>(
     global: GlobalPtr,
     task_fn: fn() -> task::TaskBuilder,
@@ -105,68 +103,6 @@ pub unsafe fn chan_from_global_ptr<T: Send>(
     }
 }
 
-#[cfg(stage1)] #[cfg(stage2)] #[cfg(stage3)]    
-pub unsafe fn chan_from_global_ptr<T: Send>(
-    global: GlobalPtr,
-    task_fn: fn() -> task::TaskBuilder,
-    f: fn~(comm::Port<T>)
-) -> comm::Chan<T> {
-
-    enum Msg {
-        Proceed,
-        Abort
-    }
-
-    log(debug,~"ENTERING chan_from_global_ptr, before is_prob_zero check");
-    let is_probably_zero = *global == 0u;
-    log(debug,~"after is_prob_zero check");
-    if is_probably_zero {
-        log(debug,~"is probably zero...");
-        // There's no global channel. We must make it
-
-        let (setup_po, setup_ch) = do task_fn().spawn_conversation
-            |move f, setup_po, setup_ch| {
-            let po = comm::Port::<T>();
-            let ch = comm::Chan(&po);
-            comm::send(setup_ch, ch);
-
-            // Wait to hear if we are the official instance of
-            // this global task
-            match comm::recv::<Msg>(setup_po) {
-              Proceed => f(move po),
-              Abort => ()
-            }
-        };
-
-        log(debug,~"before setup recv..");
-        // This is the proposed global channel
-        let ch = comm::recv(setup_po);
-        // 0 is our sentinal value. It is not a valid channel
-        assert *ch != 0;
-
-        // Install the channel
-        log(debug,~"BEFORE COMPARE AND SWAP");
-        rusti::atomic_cxchg(
-            cast::reinterpret_cast(&global),
-            0, cast::reinterpret_cast(&ch));
-        let swapped = *global != 0;
-        log(debug,fmt!("AFTER .. swapped? %?", swapped));
-
-        if swapped {
-            // Success!
-            comm::send(setup_ch, Proceed);
-            ch
-        } else {
-            // Somebody else got in before we did
-            comm::send(setup_ch, Abort);
-            cast::reinterpret_cast(&*global)
-        }
-    } else {
-        log(debug, ~"global != 0");
-        cast::reinterpret_cast(&*global)
-    }
-}
-
 #[test]
 pub fn test_from_global_chan1() {
 
@@ -369,7 +305,7 @@ struct ArcDestruct<T> {
         }
         do task::unkillable {
             let data: ~ArcData<T> = cast::reinterpret_cast(&self.data);
-            let new_count = rusti::atomic_xsub(&mut data.count, 1) - 1;
+            let new_count = rustrt::rust_atomic_decrement(&mut data.count);
             assert new_count >= 0;
             if new_count == 0 {
                 // Were we really last, or should we hand off to an unwrapper?
@@ -405,7 +341,6 @@ fn ArcDestruct<T>(data: *libc::c_void) -> ArcDestruct<T> {
     }
 }
 
-#[cfg(stage0)]
 pub unsafe fn unwrap_shared_mutable_state<T: Send>(rc: SharedMutableState<T>)
         -> T {
     struct DeathThroes<T> {
@@ -438,76 +373,8 @@ pub unsafe fn unwrap_shared_mutable_state<T: Send>(rc: SharedMutableState<T>)
             // Got in. Step 0: Tell destructor not to run. We are now it.
             rc.data = ptr::null();
             // Step 1 - drop our own reference.
-            let new_count = rusti::atomic_xsub(&mut ptr.count, 1) - 1;
-            //assert new_count >= 0;
-            if new_count == 0 {
-                // We were the last owner. Can unwrap immediately.
-                // Also we have to free the server endpoints.
-                let _server: UnwrapProto = cast::transmute(move serverp);
-                option::swap_unwrap(&mut ptr.data)
-                // drop glue takes over.
-            } else {
-                // The *next* person who sees the refcount hit 0 will wake us.
-                let end_result =
-                    DeathThroes { ptr: Some(move ptr),
-                                  response: Some(move c2) };
-                let mut p1 = Some(move p1); // argh
-                do task::rekillable {
-                    pipes::recv_one(option::swap_unwrap(&mut p1));
-                }
-                // Got here. Back in the 'unkillable' without getting killed.
-                // Recover ownership of ptr, then take the data out.
-                let ptr = option::swap_unwrap(&mut end_result.ptr);
-                option::swap_unwrap(&mut ptr.data)
-                // drop glue takes over.
-            }
-        } else {
-            // Somebody else was trying to unwrap. Avoid guaranteed deadlock.
-            cast::forget(move ptr);
-            // Also we have to free the (rejected) server endpoints.
-            let _server: UnwrapProto = cast::transmute(move serverp);
-            fail ~"Another task is already unwrapping this ARC!";
-        }
-    }
-}
-
-#[cfg(stage1)] #[cfg(stage2)] #[cfg(stage3)]    
-pub unsafe fn unwrap_shared_mutable_state<T: Send>(rc: SharedMutableState<T>)
-        -> T {
-    struct DeathThroes<T> {
-        mut ptr:      Option<~ArcData<T>>,
-        mut response: Option<pipes::ChanOne<bool>>,
-        drop unsafe {
-            let response = option::swap_unwrap(&mut self.response);
-            // In case we get killed early, we need to tell the person who
-            // tried to wake us whether they should hand-off the data to us.
-            if task::failing() {
-                pipes::send_one(move response, false);
-                // Either this swap_unwrap or the one below (at "Got here")
-                // ought to run.
-                cast::forget(option::swap_unwrap(&mut self.ptr));
-            } else {
-                assert self.ptr.is_none();
-                pipes::send_one(move response, true);
-            }
-        }
-    }
-
-    do task::unkillable {
-        let ptr: ~ArcData<T> = cast::reinterpret_cast(&rc.data);
-        let (c1,p1) = pipes::oneshot(); // ()
-        let (c2,p2) = pipes::oneshot(); // bool
-        let server: UnwrapProto = ~mut Some((move c1,move p2));
-        let serverp: libc::uintptr_t = cast::transmute(move server);
-        // Try to put our server end in the unwrapper slot.
-        rusti::atomic_cxchg(cast::reinterpret_cast(&ptr.unwrapper),
-                            0, serverp as int);
-        if ptr.unwrapper != 0 {
-            // Got in. Step 0: Tell destructor not to run. We are now it.
-            rc.data = ptr::null();
-            // Step 1 - drop our own reference.
-            let new_count = rusti::atomic_xsub(&mut ptr.count, 1) - 1;
-            //assert new_count >= 0;
+            let new_count = rustrt::rust_atomic_decrement(&mut ptr.count);
+        //    assert new_count >= 0;
             if new_count == 0 {
                 // We were the last owner. Can unwrap immediately.
                 // Also we have to free the server endpoints.
@@ -585,7 +452,7 @@ pub unsafe fn clone_shared_mutable_state<T: Send>(rc: &SharedMutableState<T>)
         -> SharedMutableState<T> {
     unsafe {
         let ptr: ~ArcData<T> = cast::reinterpret_cast(&(*rc).data);
-        let new_count = rusti::atomic_xadd(&mut ptr.count, 1) + 1;
+        let new_count = rustrt::rust_atomic_increment(&mut ptr.count);
         assert new_count >= 2;
         cast::forget(move ptr);
     }

branches/snap-stage3/src/rt/rust_builtin.cpp

@@ -830,6 +830,16 @@ rust_compare_and_swap_ptr(intptr_t *address,
     return sync::compare_and_swap(address, oldval, newval);
 }
 
+extern "C" CDECL intptr_t
+rust_atomic_increment(intptr_t *address) {
+    return sync::increment(address);
+}
+
+extern "C" CDECL intptr_t
+rust_atomic_decrement(intptr_t *address) {
+    return sync::decrement(address);
+}
+
 extern "C" CDECL void
 rust_task_weaken(rust_port_id chan) {
     rust_task *task = rust_get_current_task();

branches/snap-stage3/src/rt/rustrt.def.in

@@ -178,6 +178,8 @@ rust_dbg_do_nothing
 rust_dbg_breakpoint
 rust_osmain_sched_id
 rust_compare_and_swap_ptr
+rust_atomic_increment
+rust_atomic_decrement
 rust_global_env_chan_ptr
 rust_port_take
 rust_port_drop
@@ -205,4 +207,4 @@ rust_gc_metadata
 rust_uv_ip4_port
 rust_uv_ip6_port
 rust_uv_tcp_getpeername
-rust_uv_tcp_getpeername6
+rust_uv_tcp_getpeername6

branches/snap-stage3/src/rustc/lib/llvm.rs

@@ -843,9 +843,6 @@ extern mod llvm {
                         Name: *c_char) -> ValueRef;
 
     /* Atomic Operations */
-    fn LLVMBuildAtomicCmpXchg(B: BuilderRef, LHS: ValueRef,
-                              CMP: ValueRef, RHS: ValueRef,
-                              ++Order: AtomicOrdering) -> ValueRef;
     fn LLVMBuildAtomicRMW(B: BuilderRef, ++Op: AtomicBinOp,
                           LHS: ValueRef, RHS: ValueRef,
                           ++Order: AtomicOrdering) -> ValueRef;

branches/snap-stage3/src/rustc/middle/borrowck/loan.rs

@@ -106,23 +106,26 @@ impl LoanContext {
           cat_discr(base, _) => {
             self.loan(base, req_mutbl)
           }
-          cat_comp(cmt_base, comp_field(*)) |
-          cat_comp(cmt_base, comp_index(*)) |
-          cat_comp(cmt_base, comp_tuple) => {
+          cat_comp(cmt_base, comp_field(_, m)) |
+          cat_comp(cmt_base, comp_index(_, m)) => {
             // For most components, the type of the embedded data is
             // stable.  Therefore, the base structure need only be
             // const---unless the component must be immutable.  In
             // that case, it must also be embedded in an immutable
             // location, or else the whole structure could be
             // overwritten and the component along with it.
-            self.loan_stable_comp(cmt, cmt_base, req_mutbl)
+            self.loan_stable_comp(cmt, cmt_base, req_mutbl, m)
+          }
+          cat_comp(cmt_base, comp_tuple) => {
+            // As above.
+            self.loan_stable_comp(cmt, cmt_base, req_mutbl, m_imm)
           }
           cat_comp(cmt_base, comp_variant(enum_did)) => {
             // For enums, the memory is unstable if there are multiple
             // variants, because if the enum value is overwritten then
             // the memory changes type.
             if ty::enum_is_univariant(self.bccx.tcx, enum_did) {
-                self.loan_stable_comp(cmt, cmt_base, req_mutbl)
+                self.loan_stable_comp(cmt, cmt_base, req_mutbl, m_imm)
             } else {
                 self.loan_unstable_deref(cmt, cmt_base, req_mutbl)
             }
@@ -150,10 +153,59 @@ impl LoanContext {
     fn loan_stable_comp(&self,
                         cmt: cmt,
                         cmt_base: cmt,
-                        req_mutbl: ast::mutability) -> bckres<()> {
-        let base_mutbl = match req_mutbl {
-          m_imm => m_imm,
-          m_const | m_mutbl => m_const
+                        req_mutbl: ast::mutability,
+                        comp_mutbl: ast::mutability) -> bckres<()> {
+        // Determine the mutability that the base component must have,
+        // given the required mutability of the pointer (`req_mutbl`)
+        // and the declared mutability of the component (`comp_mutbl`).
+        // This is surprisingly subtle.
+        //
+        // Note that the *declared* mutability of the component is not
+        // necessarily the same as cmt.mutbl, since a component
+        // declared as immutable but embedded in a mutable context
+        // becomes mutable.  It's best to think of comp_mutbl as being
+        // either MUTABLE or DEFAULT, not MUTABLE or IMMUTABLE.  We
+        // should really patch up the AST to reflect this distinction.
+        //
+        // Let's consider the cases below:
+        //
+        // 1. mut required, mut declared: In this case, the base
+        //    component must merely be const.  The reason is that it
+        //    does not matter if the base component is borrowed as
+        //    mutable or immutable, as the mutability of the base
+        //    component is overridden in the field declaration itself
+        //    (see `compile-fail/borrowck-mut-field-imm-base.rs`)
+        //
+        // 2. mut required, imm declared: This would only be legal if
+        //    the component is embeded in a mutable context.  However,
+        //    we detect mismatches between the mutability of the value
+        //    as a whole and the required mutability in `issue_loan()`
+        //    above.  In any case, presuming that the component IS
+        //    embedded in a mutable context, both the component and
+        //    the base must be loaned as MUTABLE.  This is to ensure
+        //    that there is no loan of the base as IMMUTABLE, which
+        //    would imply that the component must be IMMUTABLE too
+        //    (see `compile-fail/borrowck-imm-field-imm-base.rs`).
+        //
+        // 3. mut required, const declared: this shouldn't really be
+        //    possible, since I don't think you can declare a const
+        //    field, but I guess if we DID permit such a declaration
+        //    it would be equivalent to the case above?
+        //
+        // 4. imm required, * declared: In this case, the base must be
+        //    immutable.  This is true regardless of what was declared
+        //    for this subcomponent, this if the base is mutable, the
+        //    subcomponent must be mutable.
+        //    (see `compile-fail/borrowck-imm-field-mut-base.rs`).
+        //
+        // 5. const required, * declared: In this case, the base need
+        //    only be const, since we don't ultimately care whether
+        //    the subcomponent is mutable or not.
+        let base_mutbl = match (req_mutbl, comp_mutbl) {
+            (m_mutbl, m_mutbl) => m_const, // (1)
+            (m_mutbl, _) => m_mutbl,       // (2, 3)
+            (m_imm, _) => m_imm,           // (4)
+            (m_const, _) => m_const        // (5)
         };
 
         do self.loan(cmt_base, base_mutbl).chain |_ok| {

branches/snap-stage3/src/rustc/middle/trans/build.rs

@@ -813,11 +813,6 @@ fn Resume(cx: block, Exn: ValueRef) -> ValueRef {
 }
 
 // Atomic Operations
-fn AtomicCmpXchg(cx: block, dst: ValueRef,
-                 cmp: ValueRef, src: ValueRef,
-                 order: AtomicOrdering) -> ValueRef {
-    llvm::LLVMBuildAtomicCmpXchg(B(cx), dst, cmp, src, order)
-}
 fn AtomicRMW(cx: block, op: AtomicBinOp,
              dst: ValueRef, src: ValueRef,
              order: AtomicOrdering) -> ValueRef {