---

yaml
---
r: 148287
b: refs/heads/try2
c: 8e5f068
h: refs/heads/master
i:
  148285: 01b78ac
  148283: 18843da
  148279: a436095
  148271: 4383169
  148255: a726f28
  148223: 57cdbda
v: v3

Author: am0d

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 7bebdbd96826cc70c8e39d025a64b76cd64a2ee7
+refs/heads/try2: 8e5f068d695af201382138fbc3e63ce9daa437de
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/index.md

@@ -19,7 +19,7 @@
 [Macros](guide-macros.html)  
 [Packaging](guide-rustpkg.html)  
 [Testing](guide-testing.html)  
-[Conditions](guide-conditions.html)
+[Conditions](guide-conditions.html)  
 [Rust's Runtime](guide-runtime.html)
 
 # Libraries

branches/try2/src/libextra/time.rs

@@ -1459,7 +1459,7 @@ mod tests {
     }
 
     #[test]
-    #[ignore(cfg(target_os = "android"))] // FIXME #10958
+    #[ignore(cfg(android))] // FIXME #10958
     fn run_tests() {
         // The tests race on tzset. So instead of having many independent
         // tests, we will just call the functions now.

branches/try2/src/libgreen/macros.rs

@@ -13,6 +13,7 @@
 #[macro_escape];
 
 use std::fmt;
+use std::libc;
 
 // Indicates whether we should perform expensive sanity checks, including rtassert!
 // XXX: Once the runtime matures remove the `true` below to turn off rtassert, etc.
@@ -123,7 +124,6 @@ memory and partly incapable of presentation to others.",
     abort();
 
     fn abort() -> ! {
-        use std::unstable::intrinsics;
-        unsafe { intrinsics::abort() }
+        unsafe { libc::abort() }
     }
 }

branches/try2/src/librustc/back/abi.rs

@@ -45,8 +45,9 @@ pub static tydesc_field_align: uint = 1u;
 pub static tydesc_field_take_glue: uint = 2u;
 pub static tydesc_field_drop_glue: uint = 3u;
 pub static tydesc_field_visit_glue: uint = 4u;
-pub static tydesc_field_name_offset: uint = 5u;
-pub static n_tydesc_fields: uint = 6u;
+pub static tydesc_field_borrow_offset: uint = 5u;
+pub static tydesc_field_name_offset: uint = 6u;
+pub static n_tydesc_fields: uint = 7u;
 
 // The two halves of a closure: code and environment.
 pub static fn_field_code: uint = 0u;

branches/try2/src/librustc/middle/trans/_match.rs

@@ -1584,9 +1584,14 @@ fn compile_submatch_continue<'r,
     }
 
     if any_uniq_pat(m, col) {
+        let pat_ty = node_id_type(bcx, pat_id);
         let llbox = Load(bcx, val);
+        let unboxed = match ty::get(pat_ty).sty {
+            ty::ty_uniq(..) if !ty::type_contents(bcx.tcx(), pat_ty).owns_managed() => llbox,
+            _ => GEPi(bcx, llbox, [0u, abi::box_field_body])
+        };
         compile_submatch(bcx, enter_uniq(bcx, dm, m, col, val),
-                         vec::append(~[llbox], vals_left), chk);
+                         vec::append(~[unboxed], vals_left), chk);
         return;
     }
 
@@ -2226,8 +2231,13 @@ fn bind_irrefutable_pat<'a>(
             }
         }
         ast::PatUniq(inner) => {
+            let pat_ty = node_id_type(bcx, pat.id);
             let llbox = Load(bcx, val);
-            bcx = bind_irrefutable_pat(bcx, inner, llbox, binding_mode);
+            let unboxed = match ty::get(pat_ty).sty {
+                ty::ty_uniq(..) if !ty::type_contents(bcx.tcx(), pat_ty).owns_managed() => llbox,
+                    _ => GEPi(bcx, llbox, [0u, abi::box_field_body])
+            };
+            bcx = bind_irrefutable_pat(bcx, inner, unboxed, binding_mode);
         }
         ast::PatRegion(inner) => {
             let loaded_val = Load(bcx, val);

branches/try2/src/librustc/middle/trans/base.rs

@@ -368,7 +368,7 @@ pub fn malloc_raw_dyn<'a>(
     } else {
         // we treat ~fn, @fn and @[] as @ here, which isn't ideal
         let langcall = match heap {
-            heap_managed => {
+            heap_managed | heap_managed_unique => {
                 require_alloc_fn(bcx, t, MallocFnLangItem)
             }
             heap_exchange_closure => {
@@ -392,7 +392,9 @@ pub fn malloc_raw_dyn<'a>(
             langcall,
             [tydesc, size],
             None);
-        rslt(r.bcx, PointerCast(r.bcx, r.val, llty))
+        let r = rslt(r.bcx, PointerCast(r.bcx, r.val, llty));
+        maybe_set_managed_unique_rc(r.bcx, r.val, heap);
+        r
     }
 }
 
@@ -439,6 +441,27 @@ pub fn malloc_general<'a>(bcx: &'a Block, t: ty::t, heap: heap)
     malloc_general_dyn(bcx, t, heap, llsize_of(bcx.ccx(), ty))
 }
 
+pub fn heap_for_unique(bcx: &Block, t: ty::t) -> heap {
+    if ty::type_contents(bcx.tcx(), t).owns_managed() {
+        heap_managed_unique
+    } else {
+        heap_exchange
+    }
+}
+
+pub fn maybe_set_managed_unique_rc(bcx: &Block, bx: ValueRef, heap: heap) {
+    assert!(heap != heap_exchange);
+    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]);
+        let rc_val = C_int(bcx.ccx(), -2);
+        Store(bcx, rc_val, rc);
+    }
+}
+
 // Type descriptor and type glue stuff
 
 pub fn get_tydesc_simple(ccx: &CrateContext, t: ty::t) -> ValueRef {

branches/try2/src/librustc/middle/trans/closure.rs

@@ -150,6 +150,14 @@ pub fn mk_closure_tys(tcx: ty::ctxt,
     return cdata_ty;
 }
 
+fn heap_for_unique_closure(bcx: &Block, t: ty::t) -> heap {
+    if ty::type_contents(bcx.tcx(), t).owns_managed() {
+        heap_managed_unique
+    } else {
+        heap_exchange_closure
+    }
+}
+
 pub fn allocate_cbox<'a>(
                      bcx: &'a Block<'a>,
                      sigil: ast::Sigil,
@@ -165,7 +173,7 @@ pub fn allocate_cbox<'a>(
             tcx.sess.bug("trying to trans allocation of @fn")
         }
         ast::OwnedSigil => {
-            malloc_raw(bcx, cdata_ty, heap_exchange_closure)
+            malloc_raw(bcx, cdata_ty, heap_for_unique_closure(bcx, cdata_ty))
         }
         ast::BorrowedSigil => {
             let cbox_ty = tuplify_box_ty(tcx, cdata_ty);

branches/try2/src/librustc/middle/trans/common.rs

@@ -90,6 +90,7 @@ pub struct tydesc_info {
     tydesc: ValueRef,
     size: ValueRef,
     align: ValueRef,
+    borrow_offset: ValueRef,
     name: ValueRef,
     take_glue: Cell<Option<ValueRef>>,
     drop_glue: Cell<Option<ValueRef>>,
@@ -315,6 +316,7 @@ pub fn warn_not_to_commit(ccx: &CrateContext, msg: &str) {
 #[deriving(Eq)]
 pub enum heap {
     heap_managed,
+    heap_managed_unique,
     heap_exchange,
     heap_exchange_closure
 }
@@ -496,7 +498,7 @@ pub fn add_clean_temp_mem_in_scope_(bcx: &Block, scope_id: Option<ast::NodeId>,
 
 pub fn add_clean_free(cx: &Block, ptr: ValueRef, heap: heap) {
     let free_fn = match heap {
-        heap_managed => {
+        heap_managed | heap_managed_unique => {
             @GCHeapFreeingCleanupFunction {
                 ptr: ptr,
             } as @CleanupFunction

branches/try2/src/librustc/middle/trans/datum.rs

@@ -570,14 +570,19 @@ impl Datum {
         let (content_ty, header) = match ty::get(self.ty).sty {
             ty::ty_box(typ) => (typ, true),
             ty::ty_uniq(typ) => (typ, false),
+            ty::ty_vec(_, ty::vstore_uniq) | ty::ty_str(ty::vstore_uniq) => {
+                let unit_ty = ty::sequence_element_type(bcx.tcx(), self.ty);
+                let unboxed_vec_ty = ty::mk_mut_unboxed_vec(bcx.tcx(), unit_ty);
+                (unboxed_vec_ty, true)
+            }
             _ => {
                 bcx.tcx().sess.bug(format!(
                     "box_body() invoked on non-box type {}",
                     ty_to_str(bcx.tcx(), self.ty)));
             }
         };
 
-        if !header {
+        if !header && !ty::type_contents(bcx.tcx(), content_ty).owns_managed() {
             let ptr = self.to_value_llval(bcx);
             let ty = type_of::type_of(bcx.ccx(), content_ty);
             let body = PointerCast(bcx, ptr, ty.ptr_to());

branches/try2/src/librustc/middle/trans/debuginfo.rs

@@ -2147,6 +2147,10 @@ fn type_metadata(cx: &CrateContext,
                 ty::vstore_fixed(len) => {
                     fixed_vec_metadata(cx, mt.ty, len, usage_site_span)
                 }
+                ty::vstore_uniq if ty::type_contents(cx.tcx, mt.ty).owns_managed() => {
+                    let boxed_vec_metadata = boxed_vec_metadata(cx, mt.ty, usage_site_span);
+                    pointer_type_metadata(cx, t, boxed_vec_metadata)
+                }
                 ty::vstore_uniq => {
                     let vec_metadata = vec_metadata(cx, mt.ty, usage_site_span);
                     pointer_type_metadata(cx, t, vec_metadata)
@@ -2161,8 +2165,12 @@ fn type_metadata(cx: &CrateContext,
             }
         },
         ty::ty_uniq(typ) => {
-            let pointee = type_metadata(cx, typ, usage_site_span);
-            pointer_type_metadata(cx, t, pointee)
+            if ty::type_contents(cx.tcx, typ).owns_managed() {
+                create_pointer_to_box_metadata(cx, t, typ)
+            } else {
+                let pointee = type_metadata(cx, typ, usage_site_span);
+                pointer_type_metadata(cx, t, pointee)
+            }
         }
         ty::ty_ptr(ref mt) | ty::ty_rptr(_, ref mt) => {
             let pointee = type_metadata(cx, mt.ty, usage_site_span);

branches/try2/src/librustc/middle/trans/expr.rs

@@ -398,7 +398,29 @@ pub fn trans_to_datum<'a>(bcx: &'a Block<'a>, expr: &ast::Expr)
                                                      autoderefs));
                 derefd_datum.to_rptr(bcx).to_value_llval(bcx)
             }
-            ty::UniqTraitStore(..) | ty::RegionTraitStore(..) => {
+            ty::UniqTraitStore(..) => {
+                // For a ~T box, there may or may not be a header,
+                // depending on whether the type T references managed
+                // boxes. However, since we do not *know* the type T
+                // for objects, this presents a hurdle. Our solution is
+                // to load the "borrow offset" from the type descriptor;
+                // this value will either be 0 or sizeof(BoxHeader), depending
+                // on the type T.
+                let llopaque =
+                    PointerCast(bcx, source_data, Type::opaque().ptr_to());
+                let lltydesc_ptr_ptr =
+                    PointerCast(bcx, vtable,
+                                bcx.ccx().tydesc_type.ptr_to().ptr_to());
+                let lltydesc_ptr =
+                    Load(bcx, lltydesc_ptr_ptr);
+                let borrow_offset_ptr =
+                    GEPi(bcx, lltydesc_ptr,
+                         [0, abi::tydesc_field_borrow_offset]);
+                let borrow_offset =
+                    Load(bcx, borrow_offset_ptr);
+                InBoundsGEP(bcx, llopaque, [borrow_offset])
+            }
+            ty::RegionTraitStore(..) => {
                 source_data
             }
         };
@@ -586,15 +608,16 @@ fn trans_rvalue_datum_unadjusted<'a>(bcx: &'a Block<'a>, expr: &ast::Expr)
                                                       expr, contents);
         }
         ast::ExprVstore(contents, ast::ExprVstoreUniq) => {
-            return tvec::trans_uniq_or_managed_vstore(bcx, heap_exchange,
+            let heap = heap_for_unique(bcx, expr_ty(bcx, contents));
+            return tvec::trans_uniq_or_managed_vstore(bcx, heap,
                                                       expr, contents);
         }
         ast::ExprBox(_, contents) => {
             // Special case for `~T`. (The other case, for GC, is handled in
             // `trans_rvalue_dps_unadjusted`.)
             let box_ty = expr_ty(bcx, expr);
             let contents_ty = expr_ty(bcx, contents);
-            let heap = heap_exchange;
+            let heap = heap_for_unique(bcx, contents_ty);
             return trans_boxed_expr(bcx, box_ty, contents, contents_ty, heap)
         }
         ast::ExprLit(lit) => {
@@ -1438,7 +1461,8 @@ fn trans_unary_datum<'a>(
             trans_boxed_expr(bcx, un_ty, sub_expr, sub_ty, heap_managed)
         }
         ast::UnUniq => {
-            trans_boxed_expr(bcx, un_ty, sub_expr, sub_ty, heap_exchange)
+            let heap  = heap_for_unique(bcx, un_ty);
+            trans_boxed_expr(bcx, un_ty, sub_expr, sub_ty, heap)
         }
         ast::UnDeref => {
             bcx.sess().bug("deref expressions should have been \

branches/try2/src/librustc/middle/trans/glue.rs

@@ -303,7 +303,11 @@ pub fn make_free_glue<'a>(bcx: &'a Block<'a>, v: ValueRef, t: ty::t)
         with_cond(bcx, not_null, |bcx| {
             let body_datum = box_datum.box_body(bcx);
             let bcx = drop_ty(bcx, body_datum.to_ref_llval(bcx), body_datum.ty);
-            trans_exchange_free(bcx, box_datum.val)
+            if ty::type_contents(bcx.tcx(), t).owns_managed() {
+                trans_free(bcx, box_datum.val)
+            } else {
+                trans_exchange_free(bcx, box_datum.val)
+            }
         })
       }
       ty::ty_vec(_, ty::vstore_uniq) | ty::ty_str(ty::vstore_uniq) |
@@ -546,6 +550,18 @@ pub fn declare_tydesc(ccx: &CrateContext, t: ty::t) -> @tydesc_info {
                  ppaux::ty_to_str(ccx.tcx, t));
     }
 
+    let has_header = match ty::get(t).sty {
+        ty::ty_box(..) => true,
+        ty::ty_uniq(..) => ty::type_contents(ccx.tcx, t).owns_managed(),
+        _ => false
+    };
+
+    let borrow_offset = if has_header {
+        ccx.offsetof_gep(llty, [0u, abi::box_field_body])
+    } else {
+        C_uint(ccx, 0)
+    };
+
     let llsize = llsize_of(ccx, llty);
     let llalign = llalign_of(ccx, llty);
     let name = mangle_internal_name_by_type_and_seq(ccx, t, "tydesc").to_managed();
@@ -564,6 +580,7 @@ pub fn declare_tydesc(ccx: &CrateContext, t: ty::t) -> @tydesc_info {
         tydesc: gvar,
         size: llsize,
         align: llalign,
+        borrow_offset: borrow_offset,
         name: ty_name,
         take_glue: Cell::new(None),
         drop_glue: Cell::new(None),
@@ -673,12 +690,15 @@ pub fn emit_tydescs(ccx: &CrateContext) {
               }
             };
 
+        debug!("ti.borrow_offset: {}", ccx.tn.val_to_str(ti.borrow_offset));
+
         let tydesc = C_named_struct(ccx.tydesc_type,
                                     [ti.size, // size
                                      ti.align, // align
                                      take_glue, // take_glue
                                      drop_glue, // drop_glue
                                      visit_glue, // visit_glue
+                                     ti.borrow_offset, // borrow_offset
                                      ti.name]); // name
 
         unsafe {

branches/try2/src/librustc/middle/trans/reflect.rs

@@ -184,7 +184,11 @@ impl<'a> Reflector<'a> {
           ty::ty_vec(ref mt, vst) => {
               let (name, extra) = self.vstore_name_and_extra(t, vst);
               let extra = extra + self.c_mt(mt);
-              self.visit(~"evec_" + name, extra)
+              if "uniq" == name && ty::type_contents(bcx.tcx(), t).owns_managed() {
+                  self.visit("evec_uniq_managed", extra)
+              } else {
+                  self.visit(~"evec_" + name, extra)
+              }
           }
           // Should remove mt from box and uniq.
           ty::ty_box(typ) => {
@@ -199,7 +203,11 @@ impl<'a> Reflector<'a> {
                   ty: typ,
                   mutbl: ast::MutImmutable,
               });
-              self.visit("uniq", extra)
+              if ty::type_contents(bcx.tcx(), t).owns_managed() {
+                  self.visit("uniq_managed", extra)
+              } else {
+                  self.visit("uniq", extra)
+              }
           }
           ty::ty_ptr(ref mt) => {
               let extra = self.c_mt(mt);