---

yaml
---
r: 144342
b: refs/heads/try2
c: 3479436
h: refs/heads/master
v: v3

Author: andrew-d

[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: f9979247d1d69c1a8fb7cd1d2829a629baf9d965
+refs/heads/try2: 347943640e9ea1db18d5a7401c0b50a44544599d
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/rt.mk

@@ -63,6 +63,7 @@ endif
 endif
 
 RUNTIME_CXXS_$(1)_$(2) := \
+              rt/sync/timer.cpp \
               rt/sync/lock_and_signal.cpp \
               rt/sync/rust_thread.cpp \
               rt/rust_builtin.cpp \
@@ -71,9 +72,13 @@ RUNTIME_CXXS_$(1)_$(2) := \
               rt/rust_upcall.cpp \
               rt/rust_uv.cpp \
               rt/rust_crate_map.cpp \
+              rt/rust_gc_metadata.cpp \
+              rt/rust_util.cpp \
               rt/rust_log.cpp \
+              rt/rust_exchange_alloc.cpp \
               rt/isaac/randport.cpp \
               rt/miniz.cpp \
+              rt/rust_abi.cpp \
               rt/memory_region.cpp \
               rt/boxed_region.cpp \
               rt/arch/$$(HOST_$(1))/context.cpp \

branches/try2/src/libextra/time.rs

@@ -121,9 +121,6 @@ pub struct Tm {
 }
 
 pub fn empty_tm() -> Tm {
-    // 64 is the max size of the timezone buffer allocated on windows
-    // in rust_localtime. In glibc the max timezone size is supposedly 3.
-    let zone = str::with_capacity(64);
     Tm {
         tm_sec: 0_i32,
         tm_min: 0_i32,
@@ -135,7 +132,7 @@ pub fn empty_tm() -> Tm {
         tm_yday: 0_i32,
         tm_isdst: 0_i32,
         tm_gmtoff: 0_i32,
-        tm_zone: zone,
+        tm_zone: ~"",
         tm_nsec: 0_i32,
     }
 }

branches/try2/src/libextra/uuid.rs

@@ -787,7 +787,7 @@ mod bench {
     pub fn parse_str(bh: &mut BenchHarness) {
         let s = "urn:uuid:F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4";
         do bh.iter {
-            let u = Uuid::parse_string(s);
+            Uuid::parse_string(s);
         }
     }
 }

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

@@ -26,13 +26,16 @@ use middle::trans::type_of;
 use middle::trans::type_use;
 use middle::trans::intrinsic;
 use middle::ty;
+use middle::ty::{FnSig};
 use middle::typeck;
 use util::ppaux::{Repr,ty_to_str};
 
 use syntax::ast;
 use syntax::ast_map;
 use syntax::ast_map::path_name;
 use syntax::ast_util::local_def;
+use syntax::opt_vec;
+use syntax::abi::AbiSet;
 
 pub fn monomorphic_fn(ccx: @mut CrateContext,
                       fn_id: ast::def_id,
@@ -58,10 +61,17 @@ pub fn monomorphic_fn(ccx: @mut CrateContext,
     let _icx = push_ctxt("monomorphic_fn");
     let mut must_cast = false;
 
+    let do_normalize = |t: &ty::t| {
+        match normalize_for_monomorphization(ccx.tcx, *t) {
+          Some(t) => { must_cast = true; t }
+          None => *t
+        }
+    };
+
     let psubsts = @param_substs {
-        tys: real_substs.tps.to_owned(),
+        tys: real_substs.tps.map(|x| do_normalize(x)),
         vtables: vtables,
-        self_ty: real_substs.self_ty.clone(),
+        self_ty: real_substs.self_ty.map(|x| do_normalize(x)),
         self_vtables: self_vtables
     };
 
@@ -295,6 +305,61 @@ pub fn monomorphic_fn(ccx: @mut CrateContext,
     (lldecl, must_cast)
 }
 
+pub fn normalize_for_monomorphization(tcx: ty::ctxt,
+                                      ty: ty::t) -> Option<ty::t> {
+    // FIXME[mono] could do this recursively. is that worthwhile? (#2529)
+    return match ty::get(ty).sty {
+        ty::ty_box(*) => {
+            Some(ty::mk_opaque_box(tcx))
+        }
+        ty::ty_bare_fn(_) => {
+            Some(ty::mk_bare_fn(
+                tcx,
+                ty::BareFnTy {
+                    purity: ast::impure_fn,
+                    abis: AbiSet::Rust(),
+                    sig: FnSig {bound_lifetime_names: opt_vec::Empty,
+                                inputs: ~[],
+                                output: ty::mk_nil()}}))
+        }
+        ty::ty_closure(ref fty) => {
+            Some(normalized_closure_ty(tcx, fty.sigil))
+        }
+        ty::ty_trait(_, _, ref store, _, _) => {
+            let sigil = match *store {
+                ty::UniqTraitStore => ast::OwnedSigil,
+                ty::BoxTraitStore => ast::ManagedSigil,
+                ty::RegionTraitStore(_) => ast::BorrowedSigil,
+            };
+
+            // Traits have the same runtime representation as closures.
+            Some(normalized_closure_ty(tcx, sigil))
+        }
+        ty::ty_ptr(_) => {
+            Some(ty::mk_uint())
+        }
+        _ => {
+            None
+        }
+    };
+
+    fn normalized_closure_ty(tcx: ty::ctxt,
+                             sigil: ast::Sigil) -> ty::t
+    {
+        ty::mk_closure(
+            tcx,
+            ty::ClosureTy {
+                purity: ast::impure_fn,
+                sigil: sigil,
+                onceness: ast::Many,
+                region: ty::re_static,
+                bounds: ty::EmptyBuiltinBounds(),
+                sig: ty::FnSig {bound_lifetime_names: opt_vec::Empty,
+                                inputs: ~[],
+                                output: ty::mk_nil()}})
+    }
+}
+
 pub fn make_mono_id(ccx: @mut CrateContext,
                     item: ast::def_id,
                     substs: &param_substs,

branches/try2/src/libstd/repr.rs

@@ -590,7 +590,7 @@ fn test_repr() {
     exact_test(&(~"he\u10f3llo"), "~\"he\\u10f3llo\"");
 
     exact_test(&(@10), "@10");
-    exact_test(&(@mut 10), "@mut 10");
+    exact_test(&(@mut 10), "@10"); // FIXME: #4210: incorrect
     exact_test(&((@mut 10, 2)), "(@mut 10, 2)");
     exact_test(&(~10), "~10");
     exact_test(&(&10), "&10");

branches/try2/src/libstd/rt/local_heap.rs

@@ -40,10 +40,12 @@ impl LocalHeap {
     #[fixed_stack_segment] #[inline(never)]
     pub fn new() -> LocalHeap {
         unsafe {
+            // Don't need synchronization for the single-threaded local heap
+            let synchronized = false as uintptr_t;
             // XXX: These usually come from the environment
             let detailed_leaks = false as uintptr_t;
             let poison_on_free = false as uintptr_t;
-            let region = rust_new_memory_region(detailed_leaks, poison_on_free);
+            let region = rust_new_memory_region(synchronized, detailed_leaks, poison_on_free);
             assert!(region.is_not_null());
             let boxed = rust_new_boxed_region(region, poison_on_free);
             assert!(boxed.is_not_null());
@@ -107,7 +109,8 @@ pub fn live_allocs() -> *raw::Box<()> {
 
 extern {
     #[fast_ffi]
-    fn rust_new_memory_region(detailed_leaks: uintptr_t,
+    fn rust_new_memory_region(synchronized: uintptr_t,
+                               detailed_leaks: uintptr_t,
                                poison_on_free: uintptr_t) -> *MemoryRegion;
     #[fast_ffi]
     fn rust_delete_memory_region(region: *MemoryRegion);

branches/try2/src/libstd/rt/mod.rs

@@ -224,7 +224,10 @@ pub fn init(argc: int, argv: **u8, crate_map: *u8) {
         args::init(argc, argv);
         env::init();
         logging::init(crate_map);
+        rust_update_gc_metadata(crate_map);
     }
+
+    externfn!(fn rust_update_gc_metadata(crate_map: *u8));
 }
 
 /// One-time runtime cleanup.

branches/try2/src/libstd/rt/util.rs

@@ -14,7 +14,6 @@ use libc;
 use option::{Some, None};
 use os;
 use str::StrSlice;
-use unstable::atomics::{AtomicInt, INIT_ATOMIC_INT, SeqCst};
 
 #[cfg(target_os="macos")]
 use unstable::running_on_valgrind;
@@ -130,12 +129,24 @@ memory and partly incapable of presentation to others.",
     }
 }
 
-static mut EXIT_STATUS: AtomicInt = INIT_ATOMIC_INT;
-
 pub fn set_exit_status(code: int) {
-    unsafe { EXIT_STATUS.store(code, SeqCst) }
+    #[fixed_stack_segment]; #[inline(never)];
+    unsafe {
+        return rust_set_exit_status_newrt(code as libc::uintptr_t);
+    }
+
+    extern {
+        fn rust_set_exit_status_newrt(code: libc::uintptr_t);
+    }
 }
 
 pub fn get_exit_status() -> int {
-    unsafe { EXIT_STATUS.load(SeqCst) }
+    #[fixed_stack_segment]; #[inline(never)];
+    unsafe {
+        return rust_get_exit_status_newrt() as int;
+    }
+
+    extern {
+        fn rust_get_exit_status_newrt() -> libc::uintptr_t;
+    }
 }

branches/try2/src/libstd/run.rs

@@ -949,7 +949,7 @@ fn waitpid(pid: pid_t) -> int {
 #[cfg(test)]
 mod tests {
     use io;
-    use libc::{c_int, uintptr_t};
+    use libc::c_int;
     use option::{Option, None, Some};
     use os;
     use path::Path;

branches/try2/src/rt/memory_region.cpp

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 
+#include "sync/sync.h"
 #include "memory_region.h"
 
 #if RUSTRT_TRACK_ALLOCATIONS >= 3
@@ -41,25 +42,30 @@ inline void memory_region::maybe_print_backtrace(const alloc_header *header) con
 #   endif
 }
 
-memory_region::memory_region(bool detailed_leaks,
+memory_region::memory_region(bool synchronized,
+                             bool detailed_leaks,
                              bool poison_on_free) :
     _parent(NULL), _live_allocations(0),
     _detailed_leaks(detailed_leaks),
-    _poison_on_free(poison_on_free) {
+    _poison_on_free(poison_on_free),
+    _synchronized(synchronized) {
 }
 
 memory_region::memory_region(memory_region *parent) :
     _parent(parent), _live_allocations(0),
     _detailed_leaks(parent->_detailed_leaks),
-    _poison_on_free(parent->_poison_on_free) {
+    _poison_on_free(parent->_poison_on_free),
+    _synchronized(parent->_synchronized) {
 }
 
 void memory_region::add_alloc() {
-    _live_allocations++;
+    //_live_allocations++;
+    sync::increment(_live_allocations);
 }
 
 void memory_region::dec_alloc() {
-    _live_allocations--;
+    //_live_allocations--;
+    sync::decrement(_live_allocations);
 }
 
 void memory_region::free(void *mem) {
@@ -106,6 +112,7 @@ memory_region::realloc(void *mem, size_t orig_size) {
 #   endif
 
 #   if RUSTRT_TRACK_ALLOCATIONS >= 2
+    if (_synchronized) { _lock.lock(); }
     if (_allocation_list[newMem->index] != alloc) {
         printf("at index %d, found %p, expected %p\n",
                alloc->index, _allocation_list[alloc->index], alloc);
@@ -118,6 +125,7 @@ memory_region::realloc(void *mem, size_t orig_size) {
         // printf("realloc: stored %p at index %d, replacing %p\n",
         //        newMem, index, mem);
     }
+    if (_synchronized) { _lock.unlock(); }
 #   endif
 
     return get_data(newMem);
@@ -152,7 +160,9 @@ memory_region::malloc(size_t size, const char *tag) {
 }
 
 memory_region::~memory_region() {
+    if (_synchronized) { _lock.lock(); }
     if (_live_allocations == 0 && !_detailed_leaks) {
+        if (_synchronized) { _lock.unlock(); }
         return;
     }
     char msg[128];
@@ -183,6 +193,7 @@ memory_region::~memory_region() {
         fprintf(stderr, "%s\n", msg);
         assert(false);
     }
+    if (_synchronized) { _lock.unlock(); }
 }
 
 void
@@ -193,6 +204,7 @@ memory_region::release_alloc(void *mem) {
 #   endif
 
 #   if RUSTRT_TRACK_ALLOCATIONS >= 2
+    if (_synchronized) { _lock.lock(); }
     if (((size_t) alloc->index) >= _allocation_list.size()) {
         printf("free: ptr 0x%" PRIxPTR " (%s) index %d is beyond allocation_list of size %zu\n",
                (uintptr_t) get_data(alloc), alloc->tag, alloc->index, _allocation_list.size());
@@ -210,6 +222,7 @@ memory_region::release_alloc(void *mem) {
         _allocation_list[alloc->index] = NULL;
         alloc->index = -1;
     }
+    if (_synchronized) { _lock.unlock(); }
 #   endif
 
     dec_alloc();
@@ -223,7 +236,9 @@ memory_region::claim_alloc(void *mem) {
 #   endif
 
 #   if RUSTRT_TRACK_ALLOCATIONS >= 2
+    if (_synchronized) { _lock.lock(); }
     alloc->index = _allocation_list.append(alloc);
+    if (_synchronized) { _lock.unlock(); }
 #   endif
 
 #   if RUSTRT_TRACK_ALLOCATIONS >= 3

branches/try2/src/rt/memory_region.h

@@ -59,6 +59,7 @@ class memory_region {
     array_list<alloc_header *> _allocation_list;
     const bool _detailed_leaks;
     const bool _poison_on_free;
+    const bool _synchronized;
     lock_and_signal _lock;
 
     void add_alloc();
@@ -76,7 +77,8 @@ class memory_region {
     memory_region& operator=(const memory_region& rhs);
 
 public:
-    memory_region(bool detailed_leaks, bool poison_on_free);
+    memory_region(bool synchronized,
+                  bool detailed_leaks, bool poison_on_free);
     memory_region(memory_region *parent);
     void *malloc(size_t size, const char *tag);
     void *realloc(void *mem, size_t size);