---

yaml
---
r: 44688
b: refs/heads/master
c: 2f12e26
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: ad414dec67f3f9583938a2a1212e104443fca798
+refs/heads/master: 2f12e26d06ac106c54b293f0125d2c9319ac4191
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

trunk/src/libcore/cleanup.rs

@@ -111,45 +111,102 @@ struct Task {
  * This runs at task death to free all boxes.
  */
 
+struct AnnihilateStats {
+    n_total_boxes: uint,
+    n_unique_boxes: uint,
+    n_bytes_freed: uint
+}
+
+unsafe fn each_live_alloc(f: fn(box: *mut BoxRepr, uniq: bool) -> bool) {
+    use managed;
+
+    let task: *Task = transmute(rustrt::rust_get_task());
+    let box = (*task).boxed_region.live_allocs;
+    let mut box: *mut BoxRepr = transmute(copy box);
+    while box != mut_null() {
+        let next = transmute(copy (*box).header.next);
+        let uniq =
+            (*box).header.ref_count == managed::raw::RC_MANAGED_UNIQUE;
+
+        if ! f(box, uniq) {
+            break
+        }
+
+        box = next
+    }
+}
+
+#[cfg(unix)]
+fn debug_mem() -> bool {
+    use os;
+    use libc;
+    do os::as_c_charp("RUST_DEBUG_MEM") |p| {
+        unsafe { libc::getenv(p) != null() }
+    }
+}
+
+#[cfg(windows)]
+fn debug_mem() -> bool {
+    false
+}
+
 /// Destroys all managed memory (i.e. @ boxes) held by the current task.
 #[cfg(notest)]
 #[lang="annihilate"]
 pub unsafe fn annihilate() {
     use rt::rt_free;
     use io::WriterUtil;
+    use io;
+    use libc;
+    use sys;
+    use managed;
 
-    let task: *Task = transmute(rustrt::rust_get_task());
+    let mut stats = AnnihilateStats {
+        n_total_boxes: 0,
+        n_unique_boxes: 0,
+        n_bytes_freed: 0
+    };
 
     // Pass 1: Make all boxes immortal.
-    let box = (*task).boxed_region.live_allocs;
-    let mut box: *mut BoxRepr = transmute(copy box);
-    while box != mut_null() {
-        debug!("making box immortal: %x", box as uint);
-        (*box).header.ref_count = 0x77777777;
-        box = transmute(copy (*box).header.next);
+    for each_live_alloc |box, uniq| {
+        stats.n_total_boxes += 1;
+        if uniq {
+            stats.n_unique_boxes += 1;
+        } else {
+            (*box).header.ref_count = managed::raw::RC_IMMORTAL;
+        }
     }
 
     // Pass 2: Drop all boxes.
-    let box = (*task).boxed_region.live_allocs;
-    let mut box: *mut BoxRepr = transmute(copy box);
-    while box != mut_null() {
-        debug!("calling drop glue for box: %x", box as uint);
-        let tydesc: *TypeDesc = transmute(copy (*box).header.type_desc);
-        let drop_glue: DropGlue = transmute(((*tydesc).drop_glue, 0));
-        drop_glue(to_unsafe_ptr(&tydesc), transmute(&(*box).data));
-
-        box = transmute(copy (*box).header.next);
+    for each_live_alloc |box, uniq| {
+        if !uniq {
+            let tydesc: *TypeDesc = transmute(copy (*box).header.type_desc);
+            let drop_glue: DropGlue = transmute(((*tydesc).drop_glue, 0));
+            drop_glue(to_unsafe_ptr(&tydesc), transmute(&(*box).data));
+        }
     }
 
     // Pass 3: Free all boxes.
-    loop {
-        let box = (*task).boxed_region.live_allocs;
-        if box == null() { break; }
-        let mut box: *mut BoxRepr = transmute(copy box);
-        assert (*box).header.prev == null();
-
-        debug!("freeing box: %x", box as uint);
-        rt_free(transmute(box));
+    for each_live_alloc |box, uniq| {
+        if !uniq {
+            stats.n_bytes_freed +=
+                (*((*box).header.type_desc)).size
+                + sys::size_of::<BoxRepr>();
+            rt_free(transmute(box));
+        }
+    }
+
+    if debug_mem() {
+        // We do logging here w/o allocation.
+        let dbg = libc::STDERR_FILENO as io::fd_t;
+        dbg.write_str("annihilator stats:");
+        dbg.write_str("\n  total_boxes: ");
+        dbg.write_uint(stats.n_total_boxes);
+        dbg.write_str("\n  unique_boxes: ");
+        dbg.write_uint(stats.n_unique_boxes);
+        dbg.write_str("\n  bytes_freed: ");
+        dbg.write_uint(stats.n_bytes_freed);
+        dbg.write_str("\n");
     }
 }
 

trunk/src/libcore/managed.rs

@@ -16,7 +16,13 @@ use managed::raw::BoxRepr;
 use prelude::*;
 use ptr;
 
+
 pub mod raw {
+
+    pub const RC_EXCHANGE_UNIQUE : uint = (-1) as uint;
+    pub const RC_MANAGED_UNIQUE : uint = (-2) as uint;
+    pub const RC_IMMORTAL : uint = 0x77777777;
+
     use intrinsic::TyDesc;
 
     pub struct BoxHeaderRepr {

trunk/src/libcore/vec.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.
 //
@@ -31,9 +31,14 @@ use vec;
 
 #[abi = "cdecl"]
 pub extern mod rustrt {
+    // These names are terrible. reserve_shared applies
+    // to ~[] and reserve_shared_actual applies to @[].
     unsafe fn vec_reserve_shared(++t: *sys::TypeDesc,
                                  ++v: **raw::VecRepr,
                                  ++n: libc::size_t);
+    unsafe fn vec_reserve_shared_actual(++t: *sys::TypeDesc,
+                                        ++v: **raw::VecRepr,
+                                        ++n: libc::size_t);
 }
 
 /// Returns true if a vector contains no elements
@@ -59,11 +64,17 @@ pub pure fn same_length<T, U>(xs: &[const T], ys: &[const U]) -> bool {
  */
 pub fn reserve<T>(v: &mut ~[T], n: uint) {
     // Only make the (slow) call into the runtime if we have to
+    use managed;
     if capacity(v) < n {
         unsafe {
             let ptr: **raw::VecRepr = cast::transmute(v);
-            rustrt::vec_reserve_shared(sys::get_type_desc::<T>(),
-                                       ptr, n as size_t);
+            let td = sys::get_type_desc::<T>();
+            if ((**ptr).box_header.ref_count ==
+                managed::raw::RC_MANAGED_UNIQUE) {
+                rustrt::vec_reserve_shared_actual(td, ptr, n as size_t);
+            } else {
+                rustrt::vec_reserve_shared(td, ptr, n as size_t);
+            }
         }
     }
 }

trunk/src/librustc/lib/llvm.rs

@@ -1379,7 +1379,12 @@ pub fn type_to_str_inner(names: @TypeNames, +outer0: &[TypeRef], ty: TypeRef)
                         type_to_str_inner(names, outer, out_ty)).to_managed();
           }
           Struct => {
-            let elts = struct_tys(ty);
+            let n_elts = llvm::LLVMCountStructElementTypes(ty) as uint;
+            let mut elts = vec::from_elem(n_elts, 0 as TypeRef);
+            if !elts.is_empty() {
+                llvm::LLVMGetStructElementTypes(
+                    ty, ptr::to_mut_unsafe_ptr(&mut elts[0]));
+            }
             // See [Note at-str]
             return fmt!("{%s}", tys_str(names, outer, elts)).to_managed();
           }
@@ -1440,16 +1445,17 @@ pub fn fn_ty_param_tys(fn_ty: TypeRef) -> ~[TypeRef] {
     }
 }
 
-pub fn struct_tys(struct_ty: TypeRef) -> ~[TypeRef] {
+pub fn struct_element_types(struct_ty: TypeRef) -> ~[TypeRef] {
     unsafe {
-        let n_elts = llvm::LLVMCountStructElementTypes(struct_ty) as uint;
-        if n_elts == 0 {
-            return ~[];
+        let count = llvm::LLVMCountStructElementTypes(struct_ty);
+        let mut buf: ~[TypeRef] =
+            vec::from_elem(count as uint,
+                           cast::transmute::<uint,TypeRef>(0));
+        if buf.len() > 0 {
+            llvm::LLVMGetStructElementTypes(
+                struct_ty, ptr::to_mut_unsafe_ptr(&mut buf[0]));
         }
-        let mut elts = vec::from_elem(n_elts, ptr::null());
-        llvm::LLVMGetStructElementTypes(
-            struct_ty, ptr::to_mut_unsafe_ptr(&mut elts[0]));
-        return elts;
+        return buf;
     }
 }
 

trunk/src/librustc/middle/trans/base.rs

@@ -286,7 +286,7 @@ pub fn malloc_raw_dyn(bcx: block,
     let ccx = bcx.ccx();
 
     let (mk_fn, langcall) = match heap {
-        heap_shared => {
+        heap_managed | heap_managed_unique => {
             (ty::mk_imm_box, bcx.tcx().lang_items.malloc_fn())
         }
         heap_exchange => {
@@ -310,7 +310,9 @@ pub fn malloc_raw_dyn(bcx: block,
         langcall,
         ~[tydesc, size],
         expr::SaveIn(rval));
-    return rslt(bcx, PointerCast(bcx, Load(bcx, rval), llty));
+    let r = rslt(bcx, PointerCast(bcx, Load(bcx, rval), llty));
+    maybe_set_managed_unique_rc(r.bcx, r.val, heap);
+    r
 }
 
 /**
@@ -364,11 +366,31 @@ pub fn malloc_general(bcx: block, t: ty::t, heap: heap)
 }
 pub fn malloc_boxed(bcx: block, t: ty::t)
     -> MallocResult {
-    malloc_general(bcx, t, heap_shared)
+    malloc_general(bcx, t, heap_managed)
 }
+
+pub fn heap_for_unique(bcx: block, t: ty::t) -> heap {
+    if ty::type_contents(bcx.tcx(), t).contains_managed() {
+        heap_managed_unique
+    } else {
+        heap_exchange
+    }
+}
+
+pub fn maybe_set_managed_unique_rc(bcx: block, bx: ValueRef, heap: heap) {
+    if heap == heap_managed_unique {
+        // In cases where we are looking at a unique-typed allocation in the
+        // managed heap (thus have refcount 1 from the managed allocator),
+        // such as a ~(@foo) or such. These need to have their refcount forced
+        // to -2 so the annihilator ignores them.
+        let rc = GEPi(bcx, bx, [0u, abi::box_field_refcnt]);
+        Store(bcx, C_int(bcx.ccx(), -2), rc);
+    }
+}
+
 pub fn malloc_unique(bcx: block, t: ty::t)
     -> MallocResult {
-    malloc_general(bcx, t, heap_exchange)
+    malloc_general(bcx, t, heap_for_unique(bcx, t))
 }
 
 // Type descriptor and type glue stuff
@@ -2150,6 +2172,11 @@ pub fn trans_mod(ccx: @CrateContext, m: ast::_mod) {
     }
 }
 
+pub fn get_pair_fn_ty(llpairty: TypeRef) -> TypeRef {
+    // Bit of a kludge: pick the fn typeref out of the pair.
+    return struct_elt(llpairty, 0u);
+}
+
 pub fn register_fn(ccx: @CrateContext,
                    sp: span,
                    +path: path,

trunk/src/librustc/middle/trans/cabi_x86_64.rs

@@ -14,7 +14,6 @@
 use lib::llvm::{llvm, TypeRef, ValueRef, Integer, Pointer, Float, Double};
 use lib::llvm::{Struct, Array, Attribute};
 use lib::llvm::{StructRetAttribute, ByValAttribute};
-use lib::llvm::struct_tys;
 use middle::trans::common::*;
 use middle::trans::cabi::*;
 
@@ -66,6 +65,19 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] {
         return (off + a - 1u) / a * a;
     }
 
+    fn struct_tys(ty: TypeRef) -> ~[TypeRef] {
+        unsafe {
+            let n = llvm::LLVMCountStructElementTypes(ty);
+        if (n == 0) {
+            return ~[];
+        }
+            let mut elts = vec::from_elem(n as uint, ptr::null());
+            llvm::LLVMGetStructElementTypes(ty,
+                ptr::to_mut_unsafe_ptr(&mut elts[0]));
+            return elts;
+        }
+    }
+
     fn ty_align(ty: TypeRef) -> uint {
         unsafe {
             return match llvm::LLVMGetTypeKind(ty) {

trunk/src/librustc/middle/trans/callee.rs

@@ -380,7 +380,7 @@ pub fn trans_rtcall_or_lang_call_with_type_params(bcx: block,
                                                     fty);
                     let mut llfnty = type_of::type_of(callee.bcx.ccx(),
                                                       substituted);
-                    llfnty = lib::llvm::struct_tys(llfnty)[0];
+                    llfnty = T_ptr(struct_elt(llfnty, 0));
                     new_llval = PointerCast(callee.bcx, fn_data.llfn, llfnty);
                 }
                 _ => fail!()

trunk/src/librustc/middle/trans/closure.rs

@@ -178,10 +178,10 @@ pub fn allocate_cbox(bcx: block, sigil: ast::Sigil, cdata_ty: ty::t)
     // Allocate and initialize the box:
     match sigil {
         ast::ManagedSigil => {
-            malloc_raw(bcx, cdata_ty, heap_shared)
+            malloc_raw(bcx, cdata_ty, heap_managed)
         }
         ast::OwnedSigil => {
-            malloc_raw(bcx, cdata_ty, heap_exchange)
+            malloc_raw(bcx, cdata_ty, heap_for_unique(bcx, cdata_ty))
         }
         ast::BorrowedSigil => {
             let cbox_ty = tuplify_box_ty(tcx, cdata_ty);
@@ -574,7 +574,7 @@ pub fn make_opaque_cbox_free_glue(
         // Free the ty descr (if necc) and the box itself
         match sigil {
             ast::ManagedSigil => glue::trans_free(bcx, cbox),
-            ast::OwnedSigil => glue::trans_unique_free(bcx, cbox),
+            ast::OwnedSigil => glue::trans_exchange_free(bcx, cbox),
             ast::BorrowedSigil => {
                 bcx.sess().bug(~"impossible")
             }