---

yaml
---
r: 58698
b: refs/heads/try
c: 31599fe
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: c081ffbd1e845687202a975ea2e698b623e5722f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 213f7b24ccd9a6833af7e1a329c5e7ffc8f9e3d2
-refs/heads/try: 6f2e429041da1990a91477e37316c73729cb6fe2
+refs/heads/try: 31599fe34799027939a0541d6e95d0fdd07e3155
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

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

@@ -57,6 +57,13 @@ pub static n_tydesc_fields: uint = 8u;
 pub static fn_field_code: uint = 0u;
 pub static fn_field_box: uint = 1u;
 
+// The three fields of a trait object/trait instance: vtable, box, and type
+// description.
+pub static trt_field_vtable: uint = 0u;
+pub static trt_field_box: uint = 1u;
+// This field is only present in unique trait objects, so it comes last.
+pub static trt_field_tydesc: uint = 2u;
+
 pub static vec_elt_fill: uint = 0u;
 
 pub static vec_elt_alloc: uint = 1u;

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

@@ -537,12 +537,12 @@ pub fn make_drop_glue(bcx: block, v0: ValueRef, t: ty::t) {
         closure::make_closure_glue(bcx, v0, t, drop_ty)
       }
       ty::ty_trait(_, _, ty::BoxTraitStore, _) => {
-        let llbox = Load(bcx, GEPi(bcx, v0, [0u, 1u]));
+        let llbox = Load(bcx, GEPi(bcx, v0, [0u, abi::trt_field_box]));
         decr_refcnt_maybe_free(bcx, llbox, ty::mk_opaque_box(ccx.tcx))
       }
       ty::ty_trait(_, _, ty::UniqTraitStore, _) => {
-        let lluniquevalue = GEPi(bcx, v0, [0, 1]);
-        let lltydesc = Load(bcx, GEPi(bcx, v0, [0, 2]));
+        let lluniquevalue = GEPi(bcx, v0, [0, abi::trt_field_box]);
+        let lltydesc = Load(bcx, GEPi(bcx, v0, [0, abi::trt_field_tydesc]));
         call_tydesc_glue_full(bcx, lluniquevalue, lltydesc,
                               abi::tydesc_field_free_glue, None);
         bcx
@@ -601,13 +601,13 @@ pub fn make_take_glue(bcx: block, v: ValueRef, t: ty::t) {
         closure::make_closure_glue(bcx, v, t, take_ty)
       }
       ty::ty_trait(_, _, ty::BoxTraitStore, _) => {
-        let llbox = Load(bcx, GEPi(bcx, v, [0u, 1u]));
+        let llbox = Load(bcx, GEPi(bcx, v, [0u, abi::trt_field_box]));
         incr_refcnt_of_boxed(bcx, llbox);
         bcx
       }
       ty::ty_trait(_, _, ty::UniqTraitStore, _) => {
-        let llval = GEPi(bcx, v, [0, 1]);
-        let lltydesc = Load(bcx, GEPi(bcx, v, [0, 2]));
+        let llval = GEPi(bcx, v, [0, abi::trt_field_box]);
+        let lltydesc = Load(bcx, GEPi(bcx, v, [0, abi::trt_field_tydesc]));
         call_tydesc_glue_full(bcx, llval, lltydesc,
                               abi::tydesc_field_take_glue, None);
         bcx

branches/try/src/librustc/middle/trans/meth.rs

@@ -637,14 +637,15 @@ pub fn trans_trait_callee_from_llval(bcx: block,
            val_str(bcx.ccx().tn, llpair));
     let llvtable = Load(bcx,
                       PointerCast(bcx,
-                                  GEPi(bcx, llpair, [0u, 0u]),
+                                  GEPi(bcx, llpair,
+                                       [0u, abi::trt_field_vtable]),
                                   T_ptr(T_ptr(T_vtable()))));
 
     // Load the box from the @Trait pair and GEP over the box header if
     // necessary:
     let mut llself;
     debug!("(translating trait callee) loading second index from pair");
-    let llbox = Load(bcx, GEPi(bcx, llpair, [0u, 1u]));
+    let llbox = Load(bcx, GEPi(bcx, llpair, [0u, abi::trt_field_box]));
 
     // Munge `llself` appropriately for the type of `self` in the method.
     let self_mode;
@@ -845,27 +846,30 @@ pub fn trans_trait_cast(bcx: block,
 
     match store {
         ty::RegionTraitStore(_) | ty::BoxTraitStore => {
-            let mut llboxdest = GEPi(bcx, lldest, [0u, 1u]);
-            // Just store the pointer into the pair.
+            let mut llboxdest = GEPi(bcx, lldest, [0u, abi::trt_field_box]);
+            // Just store the pointer into the pair. (Region/borrowed
+            // and boxed trait objects are represented as pairs, and
+            // have no type descriptor field.)
             llboxdest = PointerCast(bcx,
                                     llboxdest,
                                     T_ptr(type_of(bcx.ccx(), v_ty)));
             bcx = expr::trans_into(bcx, val, SaveIn(llboxdest));
         }
         ty::UniqTraitStore => {
-            // Translate the uniquely-owned value into the second element of
-            // the triple. (The first element is the vtable.)
-            let mut llvaldest = GEPi(bcx, lldest, [0, 1]);
+            // Translate the uniquely-owned value in the
+            // triple. (Unique trait objects are represented as
+            // triples.)
+            let mut llvaldest = GEPi(bcx, lldest, [0, abi::trt_field_box]);
             llvaldest = PointerCast(bcx,
                                     llvaldest,
                                     T_ptr(type_of(bcx.ccx(), v_ty)));
             bcx = expr::trans_into(bcx, val, SaveIn(llvaldest));
 
-            // Get the type descriptor of the wrapped value and store it into
-            // the third element of the triple as well.
+            // Get the type descriptor of the wrapped value and store
+            // it in the triple as well.
             let tydesc = get_tydesc(bcx.ccx(), v_ty);
             glue::lazily_emit_all_tydesc_glue(bcx.ccx(), tydesc);
-            let lltydescdest = GEPi(bcx, lldest, [0, 2]);
+            let lltydescdest = GEPi(bcx, lldest, [0, abi::trt_field_tydesc]);
             Store(bcx, tydesc.tydesc, lltydescdest);
         }
     }
@@ -875,7 +879,7 @@ pub fn trans_trait_cast(bcx: block,
     let orig = resolve_vtable_in_fn_ctxt(bcx.fcx, orig);
     let vtable = get_vtable(bcx.ccx(), orig);
     Store(bcx, vtable, PointerCast(bcx,
-                                   GEPi(bcx, lldest, [0u, 0u]),
+                                   GEPi(bcx, lldest, [0u, abi::trt_field_vtable]),
                                    T_ptr(val_ty(vtable))));
 
     bcx

branches/try/src/libstd/arena.rs

@@ -32,11 +32,11 @@
 // overhead when initializing plain-old-data and means we don't need
 // to waste time running the destructors of POD.
 
-use list::{MutList, MutCons, MutNil};
 use list;
+use list::{List, Cons, Nil};
 
 use core::at_vec;
-use core::cast::{transmute, transmute_mut_region};
+use core::cast::transmute;
 use core::cast;
 use core::libc::size_t;
 use core::ptr;
@@ -74,28 +74,26 @@ static tydesc_drop_glue_index: size_t = 3 as size_t;
 // will always stay at 0.
 struct Chunk {
     data: @[u8],
-    fill: uint,
+    mut fill: uint,
     is_pod: bool,
 }
 
 pub struct Arena {
     // The head is seperated out from the list as a unbenchmarked
     // microoptimization, to avoid needing to case on the list to
     // access the head.
-    priv head: Chunk,
-    priv pod_head: Chunk,
-    priv chunks: @mut MutList<Chunk>,
+    priv mut head: Chunk,
+    priv mut pod_head: Chunk,
+    priv mut chunks: @List<Chunk>,
 }
 
 #[unsafe_destructor]
 impl Drop for Arena {
     fn finalize(&self) {
         unsafe {
             destroy_chunk(&self.head);
-            for self.chunks.each |chunk| {
-                if !chunk.is_pod {
-                    destroy_chunk(chunk);
-                }
+            for list::each(self.chunks) |chunk| {
+                if !chunk.is_pod { destroy_chunk(chunk); }
             }
         }
     }
@@ -115,7 +113,7 @@ pub fn arena_with_size(initial_size: uint) -> Arena {
     Arena {
         head: chunk(initial_size, false),
         pod_head: chunk(initial_size, true),
-        chunks: @mut MutNil,
+        chunks: @Nil,
     }
 }
 
@@ -172,40 +170,39 @@ unsafe fn un_bitpack_tydesc_ptr(p: uint) -> (*TypeDesc, bool) {
 
 pub impl Arena {
     // Functions for the POD part of the arena
-    priv fn alloc_pod_grow(&mut self, n_bytes: uint, align: uint) -> *u8 {
+    priv fn alloc_pod_grow(&self, n_bytes: uint, align: uint) -> *u8 {
         // Allocate a new chunk.
         let chunk_size = at_vec::capacity(self.pod_head.data);
         let new_min_chunk_size = uint::max(n_bytes, chunk_size);
-        self.chunks = @mut MutCons(copy self.pod_head, self.chunks);
+        self.chunks = @Cons(copy self.pod_head, self.chunks);
         self.pod_head =
             chunk(uint::next_power_of_two(new_min_chunk_size + 1u), true);
 
         return self.alloc_pod_inner(n_bytes, align);
     }
 
     #[inline(always)]
-    priv fn alloc_pod_inner(&mut self, n_bytes: uint, align: uint) -> *u8 {
-        unsafe {
-            // XXX: Borrow check
-            let head = transmute_mut_region(&mut self.pod_head);
+    priv fn alloc_pod_inner(&self, n_bytes: uint, align: uint) -> *u8 {
+        let head = &mut self.pod_head;
 
-            let start = round_up_to(head.fill, align);
-            let end = start + n_bytes;
-            if end > at_vec::capacity(head.data) {
-                return self.alloc_pod_grow(n_bytes, align);
-            }
-            head.fill = end;
+        let start = round_up_to(head.fill, align);
+        let end = start + n_bytes;
+        if end > at_vec::capacity(head.data) {
+            return self.alloc_pod_grow(n_bytes, align);
+        }
+        head.fill = end;
 
-            //debug!("idx = %u, size = %u, align = %u, fill = %u",
-            //       start, n_bytes, align, head.fill);
+        //debug!("idx = %u, size = %u, align = %u, fill = %u",
+        //       start, n_bytes, align, head.fill);
 
+        unsafe {
             ptr::offset(vec::raw::to_ptr(head.data), start)
         }
     }
 
     #[inline(always)]
     #[cfg(stage0)]
-    priv fn alloc_pod<T>(&mut self, op: &fn() -> T) -> &'self T {
+    priv fn alloc_pod<T>(&self, op: &fn() -> T) -> &'self T {
         unsafe {
             let tydesc = sys::get_type_desc::<T>();
             let ptr = self.alloc_pod_inner((*tydesc).size, (*tydesc).align);
@@ -219,7 +216,7 @@ pub impl Arena {
     #[cfg(stage1)]
     #[cfg(stage2)]
     #[cfg(stage3)]
-    priv fn alloc_pod<'a, T>(&'a mut self, op: &fn() -> T) -> &'a T {
+    priv fn alloc_pod<'a, T>(&'a self, op: &fn() -> T) -> &'a T {
         unsafe {
             let tydesc = sys::get_type_desc::<T>();
             let ptr = self.alloc_pod_inner((*tydesc).size, (*tydesc).align);
@@ -230,44 +227,42 @@ pub impl Arena {
     }
 
     // Functions for the non-POD part of the arena
-    priv fn alloc_nonpod_grow(&mut self, n_bytes: uint, align: uint)
-                             -> (*u8, *u8) {
+    priv fn alloc_nonpod_grow(&self, n_bytes: uint, align: uint) -> (*u8, *u8) {
         // Allocate a new chunk.
         let chunk_size = at_vec::capacity(self.head.data);
         let new_min_chunk_size = uint::max(n_bytes, chunk_size);
-        self.chunks = @mut MutCons(copy self.head, self.chunks);
+        self.chunks = @Cons(copy self.head, self.chunks);
         self.head =
             chunk(uint::next_power_of_two(new_min_chunk_size + 1u), false);
 
         return self.alloc_nonpod_inner(n_bytes, align);
     }
 
     #[inline(always)]
-    priv fn alloc_nonpod_inner(&mut self, n_bytes: uint, align: uint)
-                               -> (*u8, *u8) {
-        unsafe {
-            let head = transmute_mut_region(&mut self.head);
-
-            let tydesc_start = head.fill;
-            let after_tydesc = head.fill + sys::size_of::<*TypeDesc>();
-            let start = round_up_to(after_tydesc, align);
-            let end = start + n_bytes;
-            if end > at_vec::capacity(head.data) {
-                return self.alloc_nonpod_grow(n_bytes, align);
-            }
-            head.fill = round_up_to(end, sys::pref_align_of::<*TypeDesc>());
+    priv fn alloc_nonpod_inner(&self, n_bytes: uint, align: uint) -> (*u8, *u8) {
+        let head = &mut self.head;
 
-            //debug!("idx = %u, size = %u, align = %u, fill = %u",
-            //       start, n_bytes, align, head.fill);
+        let tydesc_start = head.fill;
+        let after_tydesc = head.fill + sys::size_of::<*TypeDesc>();
+        let start = round_up_to(after_tydesc, align);
+        let end = start + n_bytes;
+        if end > at_vec::capacity(head.data) {
+            return self.alloc_nonpod_grow(n_bytes, align);
+        }
+        head.fill = round_up_to(end, sys::pref_align_of::<*TypeDesc>());
+
+        //debug!("idx = %u, size = %u, align = %u, fill = %u",
+        //       start, n_bytes, align, head.fill);
 
+        unsafe {
             let buf = vec::raw::to_ptr(head.data);
             return (ptr::offset(buf, tydesc_start), ptr::offset(buf, start));
         }
     }
 
     #[inline(always)]
     #[cfg(stage0)]
-    priv fn alloc_nonpod<T>(&mut self, op: &fn() -> T) -> &'self T {
+    priv fn alloc_nonpod<T>(&self, op: &fn() -> T) -> &'self T {
         unsafe {
             let tydesc = sys::get_type_desc::<T>();
             let (ty_ptr, ptr) =
@@ -291,7 +286,7 @@ pub impl Arena {
     #[cfg(stage1)]
     #[cfg(stage2)]
     #[cfg(stage3)]
-    priv fn alloc_nonpod<'a, T>(&'a mut self, op: &fn() -> T) -> &'a T {
+    priv fn alloc_nonpod<'a, T>(&'a self, op: &fn() -> T) -> &'a T {
         unsafe {
             let tydesc = sys::get_type_desc::<T>();
             let (ty_ptr, ptr) =
@@ -314,16 +309,13 @@ pub impl Arena {
     // The external interface
     #[inline(always)]
     #[cfg(stage0)]
-    fn alloc<T>(&mut self, op: &fn() -> T) -> &'self T {
+    fn alloc<T>(&self, op: &fn() -> T) -> &'self T {
         unsafe {
-            // XXX: Borrow check
-            let this = transmute_mut_region(self);
             if !rusti::needs_drop::<T>() {
-                return this.alloc_pod(op);
+                self.alloc_pod(op)
+            } else {
+                self.alloc_nonpod(op)
             }
-            // XXX: Borrow check
-            let this = transmute_mut_region(self);
-            this.alloc_nonpod(op)
         }
     }
 
@@ -332,16 +324,13 @@ pub impl Arena {
     #[cfg(stage1)]
     #[cfg(stage2)]
     #[cfg(stage3)]
-    fn alloc<'a, T>(&'a mut self, op: &fn() -> T) -> &'a T {
+    fn alloc<'a, T>(&'a self, op: &fn() -> T) -> &'a T {
         unsafe {
-            // XXX: Borrow check
-            let this = transmute_mut_region(self);
             if !rusti::needs_drop::<T>() {
-                return this.alloc_pod(op);
+                self.alloc_pod(op)
+            } else {
+                self.alloc_nonpod(op)
             }
-            // XXX: Borrow check
-            let this = transmute_mut_region(self);
-            this.alloc_nonpod(op)
         }
     }
 }
@@ -359,9 +348,7 @@ fn test_arena_destructors() {
     }
 }
 
-#[test]
-#[should_fail]
-#[ignore(cfg(windows))]
+#[test] #[should_fail] #[ignore(cfg(windows))]
 fn test_arena_destructors_fail() {
     let arena = Arena();
     // Put some stuff in the arena.