Consolidate raw representations of rust values

This moves the raw struct layout of closures, vectors, boxes, and strings into a
new `unstable::raw` module. This is meant to be a centralized location to find
information for the layout of these values.

As safe method, `repr`, is provided to convert a rust value to its raw
representation. Unsafe methods to convert back are not provided because they are
rarely used and too numerous to write an implementation for each (not much of a
common pattern).

Author: alexcrichton

src/libstd/at_vec.rs

@@ -10,13 +10,13 @@
 
 //! Managed vectors
 
-use cast::transmute;
 use clone::Clone;
 use container::Container;
 use iterator::IteratorUtil;
 use option::Option;
 use sys;
 use uint;
+use unstable::raw::Repr;
 use vec::{ImmutableVector, OwnedVector};
 
 /// Code for dealing with @-vectors. This is pretty incomplete, and
@@ -26,8 +26,8 @@ use vec::{ImmutableVector, OwnedVector};
 #[inline]
 pub fn capacity<T>(v: @[T]) -> uint {
     unsafe {
-        let repr: **raw::VecRepr = transmute(&v);
-        (**repr).unboxed.alloc / sys::size_of::<T>()
+        let box = v.repr();
+        (*box).data.alloc / sys::size_of::<T>()
     }
 }
 
@@ -45,10 +45,10 @@ pub fn capacity<T>(v: @[T]) -> uint {
  */
 #[inline]
 pub fn build_sized<A>(size: uint, builder: &fn(push: &fn(v: A))) -> @[A] {
-    let mut vec: @[A] = @[];
+    let mut vec = @[];
     unsafe { raw::reserve(&mut vec, size); }
     builder(|x| unsafe { raw::push(&mut vec, x) });
-    return unsafe { transmute(vec) };
+    vec
 }
 
 /**
@@ -151,7 +151,7 @@ pub fn to_managed_consume<T>(v: ~[T]) -> @[T] {
         for v.consume_iter().advance |x| {
             raw::push(&mut av, x);
         }
-        transmute(av)
+        av
     }
 }
 
@@ -195,13 +195,9 @@ pub mod raw {
     use ptr;
     use sys;
     use uint;
-    use unstable::intrinsics;
     use unstable::intrinsics::{move_val_init, TyDesc};
-    use vec;
-    use vec::UnboxedVecRepr;
-
-    pub type VecRepr = vec::raw::VecRepr;
-    pub type SliceRepr = vec::raw::SliceRepr;
+    use unstable::intrinsics;
+    use unstable::raw::{Box, Vec};
 
     /**
      * Sets the length of a vector
@@ -211,19 +207,21 @@ pub mod raw {
      * the vector is actually the specified size.
      */
     #[inline]
-    pub unsafe fn set_len<T>(v: @[T], new_len: uint) {
-        let repr: **mut VecRepr = transmute(&v);
-        (**repr).unboxed.fill = new_len * sys::size_of::<T>();
+    pub unsafe fn set_len<T>(v: &mut @[T], new_len: uint) {
+        let repr: *mut Box<Vec<T>> = cast::transmute_copy(v);
+        (*repr).data.fill = new_len * sys::size_of::<T>();
     }
 
     /**
      * Pushes a new value onto this vector.
      */
     #[inline]
     pub unsafe fn push<T>(v: &mut @[T], initval: T) {
-        let repr: **VecRepr = transmute_copy(&v);
-        let fill = (**repr).unboxed.fill;
-        if (**repr).unboxed.alloc > fill {
+        let full = {
+            let repr: *Box<Vec<T>> = cast::transmute_copy(v);
+            (*repr).data.alloc > (*repr).data.fill
+        };
+        if full {
             push_fast(v, initval);
         } else {
             push_slow(v, initval);
@@ -232,16 +230,15 @@ pub mod raw {
 
     #[inline] // really pretty please
     unsafe fn push_fast<T>(v: &mut @[T], initval: T) {
-        let repr: **mut VecRepr = ::cast::transmute(v);
-        let fill = (**repr).unboxed.fill;
-        (**repr).unboxed.fill += sys::size_of::<T>();
-        let p = &((**repr).unboxed.data);
-        let p = ptr::offset(p, fill) as *mut T;
+        let repr: *mut Box<Vec<T>> = cast::transmute_copy(v);
+        let amt = v.len();
+        (*repr).data.fill += sys::size_of::<T>();
+        let p = ptr::offset(&(*repr).data.data as *T, amt) as *mut T;
         move_val_init(&mut(*p), initval);
     }
 
     unsafe fn push_slow<T>(v: &mut @[T], initval: T) {
-        reserve_at_least(&mut *v, v.len() + 1u);
+        reserve_at_least(v, v.len() + 1u);
         push_fast(v, initval);
     }
 
@@ -259,7 +256,7 @@ pub mod raw {
     pub unsafe fn reserve<T>(v: &mut @[T], n: uint) {
         // Only make the (slow) call into the runtime if we have to
         if capacity(*v) < n {
-            let ptr: *mut *mut VecRepr = transmute(v);
+            let ptr: *mut *mut Box<Vec<()>> = transmute(v);
             let ty = intrinsics::get_tydesc::<T>();
             // XXX transmute shouldn't be necessary
             let ty = cast::transmute(ty);
@@ -269,16 +266,14 @@ pub mod raw {
 
     // Implementation detail. Shouldn't be public
     #[allow(missing_doc)]
-    pub fn reserve_raw(ty: *TyDesc, ptr: *mut *mut VecRepr, n: uint) {
+    pub fn reserve_raw(ty: *TyDesc, ptr: *mut *mut Box<Vec<()>>, n: uint) {
 
         unsafe {
             let size_in_bytes = n * (*ty).size;
-            if size_in_bytes > (**ptr).unboxed.alloc {
-                let total_size = size_in_bytes + sys::size_of::<UnboxedVecRepr>();
-                // XXX: UnboxedVecRepr has an extra u8 at the end
-                let total_size = total_size - sys::size_of::<u8>();
-                (*ptr) = local_realloc(*ptr as *(), total_size) as *mut VecRepr;
-                (**ptr).unboxed.alloc = size_in_bytes;
+            if size_in_bytes > (**ptr).data.alloc {
+                let total_size = size_in_bytes + sys::size_of::<Vec<()>>();
+                (*ptr) = local_realloc(*ptr as *(), total_size) as *mut Box<Vec<()>>;
+                (**ptr).data.alloc = size_in_bytes;
             }
         }
 

src/libstd/cast.rs

@@ -133,6 +133,7 @@ pub unsafe fn copy_lifetime_vec<'a,S,T>(_ptr: &'a [S], ptr: &T) -> &'a T {
 #[cfg(test)]
 mod tests {
     use cast::{bump_box_refcount, transmute};
+    use unstable::raw;
 
     #[test]
     fn test_transmute_copy() {
@@ -156,10 +157,9 @@ mod tests {
 
     #[test]
     fn test_transmute() {
-        use managed::raw::BoxRepr;
         unsafe {
             let x = @100u8;
-            let x: *BoxRepr = transmute(x);
+            let x: *raw::Box<u8> = transmute(x);
             assert!((*x).data == 100);
             let _x: @int = transmute(x);
         }

src/libstd/cleanup.rs

@@ -12,8 +12,8 @@
 
 use libc::c_void;
 use ptr::{mut_null};
-use repr::BoxRepr;
 use unstable::intrinsics::TyDesc;
+use unstable::raw;
 
 type DropGlue<'self> = &'self fn(**TyDesc, *c_void);
 
@@ -30,14 +30,13 @@ struct AnnihilateStats {
 }
 
 unsafe fn each_live_alloc(read_next_before: bool,
-                          f: &fn(box: *mut BoxRepr, uniq: bool) -> bool) -> bool {
+                          f: &fn(box: *mut raw::Box<()>, uniq: bool) -> bool) -> bool {
     //! Walks the internal list of allocations
 
     use managed;
     use rt::local_heap;
 
-    let box = local_heap::live_allocs();
-    let mut box: *mut BoxRepr = transmute(box);
+    let mut box = local_heap::live_allocs();
     while box != mut_null() {
         let next_before = (*box).next;
         let uniq = (*box).ref_count == managed::RC_MANAGED_UNIQUE;
@@ -100,7 +99,7 @@ pub unsafe fn annihilate() {
         if uniq {
             stats.n_unique_boxes += 1;
         } else {
-            (*box).header.ref_count = managed::raw::RC_IMMORTAL;
+            (*box).ref_count = managed::RC_IMMORTAL;
         }
     }
 
@@ -126,9 +125,9 @@ pub unsafe fn annihilate() {
     for each_live_alloc(true) |box, uniq| {
         if !uniq {
             stats.n_bytes_freed +=
-                (*((*box).header.type_desc)).size
-                + sys::size_of::<BoxRepr>();
-            local_free(box as *u8);
+                (*((*box).type_desc)).size
+                + sys::size_of::<raw::Box<()>>();
+            local_free(box as *i8);
         }
     }
 

src/libstd/managed.rs

@@ -14,27 +14,8 @@ use ptr::to_unsafe_ptr;
 
 #[cfg(not(test))] use cmp::{Eq, Ord};
 
-pub mod raw {
-    use std::unstable::intrinsics::TyDesc;
-
-    pub static RC_MANAGED_UNIQUE : uint = (-2) as uint;
-    pub static RC_IMMORTAL : uint = 0x77777777;
-
-    #[allow(missing_doc)]
-    pub struct BoxHeaderRepr {
-        ref_count: uint,
-        type_desc: *TyDesc,
-        prev: *BoxRepr,
-        next: *BoxRepr,
-    }
-
-    #[allow(missing_doc)]
-    pub struct BoxRepr {
-        header: BoxHeaderRepr,
-        data: u8
-    }
-
-}
+pub static RC_MANAGED_UNIQUE : uint = (-2) as uint;
+pub static RC_IMMORTAL : uint = 0x77777777;
 
 /// Determine if two shared boxes point to the same object
 #[inline]

src/libstd/reflect.rs

@@ -19,7 +19,7 @@ Runtime type reflection
 use unstable::intrinsics::{Opaque, TyDesc, TyVisitor};
 use libc::c_void;
 use sys;
-use vec;
+use unstable::raw;
 
 /**
  * Trait for visitor that wishes to reflect on data. To use this, create a
@@ -260,7 +260,7 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
     }
 
     fn visit_unboxed_vec(&self, mtbl: uint, inner: *TyDesc) -> bool {
-        self.align_to::<vec::UnboxedVecRepr>();
+        self.align_to::<raw::Vec<()>>();
         if ! self.inner.visit_vec(mtbl, inner) { return false; }
         true
     }

src/libstd/repr.rs

@@ -22,21 +22,17 @@ use container::Container;
 use io::{Writer, WriterUtil};
 use iterator::IteratorUtil;
 use libc::c_void;
-use managed;
 use ptr;
 use reflect;
 use reflect::{MovePtr, align};
 use str::StrSlice;
 use to_str::ToStr;
-use vec::raw::{VecRepr, SliceRepr};
-use vec;
-use vec::{OwnedVector, UnboxedVecRepr};
+use vec::OwnedVector;
 use unstable::intrinsics::{Opaque, TyDesc, TyVisitor, get_tydesc, visit_tydesc};
+use unstable::raw;
 
 #[cfg(test)] use io;
 
-pub use managed::raw::BoxRepr;
-
 /// Helpers
 
 trait EscapedCharWriter {
@@ -198,11 +194,11 @@ impl ReprVisitor {
 
     pub fn write_vec_range(&self,
                            _mtbl: uint,
-                           ptr: *u8,
+                           ptr: *(),
                            len: uint,
                            inner: *TyDesc)
                            -> bool {
-        let mut p = ptr;
+        let mut p = ptr as *u8;
         let (sz, al) = unsafe { ((*inner).size, (*inner).align) };
         self.writer.write_char('[');
         let mut first = true;
@@ -225,7 +221,7 @@ impl ReprVisitor {
 
     pub fn write_unboxed_vec_repr(&self,
                                   mtbl: uint,
-                                  v: &UnboxedVecRepr,
+                                  v: &raw::Vec<()>,
                                   inner: *TyDesc)
                                   -> bool {
         self.write_vec_range(mtbl, ptr::to_unsafe_ptr(&v.data),
@@ -289,7 +285,7 @@ impl TyVisitor for ReprVisitor {
     fn visit_box(&self, mtbl: uint, inner: *TyDesc) -> bool {
         self.writer.write_char('@');
         self.write_mut_qualifier(mtbl);
-        do self.get::<&managed::raw::BoxRepr> |b| {
+        do self.get::<&raw::Box<()>> |b| {
             let p = ptr::to_unsafe_ptr(&b.data) as *c_void;
             self.visit_ptr_inner(p, inner);
         }
@@ -304,7 +300,7 @@ impl TyVisitor for ReprVisitor {
 
     fn visit_uniq_managed(&self, _mtbl: uint, inner: *TyDesc) -> bool {
         self.writer.write_char('~');
-        do self.get::<&managed::raw::BoxRepr> |b| {
+        do self.get::<&raw::Box<()>> |b| {
             let p = ptr::to_unsafe_ptr(&b.data) as *c_void;
             self.visit_ptr_inner(p, inner);
         }
@@ -330,43 +326,43 @@ impl TyVisitor for ReprVisitor {
 
 
     fn visit_unboxed_vec(&self, mtbl: uint, inner: *TyDesc) -> bool {
-        do self.get::<vec::UnboxedVecRepr> |b| {
+        do self.get::<raw::Vec<()>> |b| {
             self.write_unboxed_vec_repr(mtbl, b, inner);
         }
     }
 
     fn visit_evec_box(&self, mtbl: uint, inner: *TyDesc) -> bool {
-        do self.get::<&VecRepr> |b| {
+        do self.get::<&raw::Box<raw::Vec<()>>> |b| {
             self.writer.write_char('@');
             self.write_mut_qualifier(mtbl);
-            self.write_unboxed_vec_repr(mtbl, &b.unboxed, inner);
+            self.write_unboxed_vec_repr(mtbl, &b.data, inner);
         }
     }
 
     fn visit_evec_uniq(&self, mtbl: uint, inner: *TyDesc) -> bool {
-        do self.get::<&UnboxedVecRepr> |b| {
+        do self.get::<&raw::Vec<()>> |b| {
             self.writer.write_char('~');
             self.write_unboxed_vec_repr(mtbl, *b, inner);
         }
     }
 
     fn visit_evec_uniq_managed(&self, mtbl: uint, inner: *TyDesc) -> bool {
-        do self.get::<&VecRepr> |b| {
+        do self.get::<&raw::Box<raw::Vec<()>>> |b| {
             self.writer.write_char('~');
-            self.write_unboxed_vec_repr(mtbl, &b.unboxed, inner);
+            self.write_unboxed_vec_repr(mtbl, &b.data, inner);
         }
     }
 
     fn visit_evec_slice(&self, mtbl: uint, inner: *TyDesc) -> bool {
-        do self.get::<SliceRepr> |s| {
+        do self.get::<raw::Slice<()>> |s| {
             self.writer.write_char('&');
             self.write_vec_range(mtbl, s.data, s.len, inner);
         }
     }
 
     fn visit_evec_fixed(&self, _n: uint, sz: uint, _align: uint,
                         mtbl: uint, inner: *TyDesc) -> bool {
-        do self.get::<u8> |b| {
+        do self.get::<()> |b| {
             self.write_vec_range(mtbl, ptr::to_unsafe_ptr(b), sz, inner);
         }
     }
@@ -547,9 +543,9 @@ impl TyVisitor for ReprVisitor {
 
     fn visit_opaque_box(&self) -> bool {
         self.writer.write_char('@');
-        do self.get::<&managed::raw::BoxRepr> |b| {
+        do self.get::<&raw::Box<()>> |b| {
             let p = ptr::to_unsafe_ptr(&b.data) as *c_void;
-            self.visit_ptr_inner(p, b.header.type_desc);
+            self.visit_ptr_inner(p, b.type_desc);
         }
     }