---

yaml
---
r: 144347
b: refs/heads/try2
c: bb9c71f
h: refs/heads/master
i:
  144345: 0ad1d63
  144343: 4dce95f
v: v3

Author: bors

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

branches/try2/mk/rt.mk

@@ -63,7 +63,6 @@ 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 \
@@ -72,13 +71,9 @@ 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,6 +121,9 @@ 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,
@@ -132,7 +135,7 @@ pub fn empty_tm() -> Tm {
         tm_yday: 0_i32,
         tm_isdst: 0_i32,
         tm_gmtoff: 0_i32,
-        tm_zone: ~"",
+        tm_zone: 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/base.rs

@@ -1710,7 +1710,8 @@ pub fn new_fn_ctxt(ccx: @mut CrateContext,
 // field of the fn_ctxt with
 pub fn create_llargs_for_fn_args(cx: @mut FunctionContext,
                                  self_arg: self_arg,
-                                 args: &[ast::arg])
+                                 args: &[ast::arg],
+                                 arg_tys: &[ty::t])
                               -> ~[ValueRef] {
     let _icx = push_ctxt("create_llargs_for_fn_args");
 
@@ -1727,26 +1728,31 @@ pub fn create_llargs_for_fn_args(cx: @mut FunctionContext,
 
     // Return an array containing the ValueRefs that we get from
     // llvm::LLVMGetParam for each argument.
-    vec::from_fn(args.len(), |i| {
-        unsafe {
-            let arg_n = cx.arg_pos(i);
-            let arg = &args[i];
-            let llarg = llvm::LLVMGetParam(cx.llfn, arg_n as c_uint);
-
-            // FIXME #7260: aliasing should be determined by monomorphized ty::t
-            match arg.ty.node {
-                // `~` pointers never alias other parameters, because ownership was transferred
-                ast::ty_uniq(_) => {
-                    llvm::LLVMAddAttribute(llarg, lib::llvm::NoAliasAttribute as c_uint);
+    do vec::from_fn(args.len()) |i| {
+        let arg_n = cx.arg_pos(i);
+        let arg_ty = arg_tys[i];
+        let llarg = unsafe {llvm::LLVMGetParam(cx.llfn, arg_n as c_uint) };
+
+        match ty::get(arg_ty).sty {
+            // `~` pointers never alias other parameters, because
+            // ownership was transferred
+            ty::ty_uniq(*) |
+            ty::ty_evec(_, ty::vstore_uniq) |
+            ty::ty_closure(ty::ClosureTy {sigil: ast::OwnedSigil, _}) => {
+                unsafe {
+                    llvm::LLVMAddAttribute(
+                        llarg, lib::llvm::NoAliasAttribute as c_uint);
                 }
-                // FIXME: #6785: `&mut` can only alias `&const` and `@mut`, we should check for
-                // those in the other parameters and then mark it as `noalias` if there aren't any
-                _ => {}
             }
-
-            llarg
+            // FIXME: #6785: `&mut` can only alias `&const` and
+            // `@mut`, we should check for those in the other
+            // parameters and then mark it as `noalias` if there
+            // aren't any
+            _ => {}
         }
-    })
+
+        llarg
+    }
 }
 
 pub fn copy_args_to_allocas(fcx: @mut FunctionContext,
@@ -1881,7 +1887,6 @@ pub fn trans_closure(ccx: @mut CrateContext,
     debug!("trans_closure(..., param_substs=%s)",
            param_substs.repr(ccx.tcx));
 
-    // Set up arguments to the function.
     let fcx = new_fn_ctxt_w_id(ccx,
                                path,
                                llfndecl,
@@ -1892,21 +1897,23 @@ pub fn trans_closure(ccx: @mut CrateContext,
                                body.info(),
                                Some(body.span));
 
-    let raw_llargs = create_llargs_for_fn_args(fcx, self_arg, decl.inputs);
-
-    // Set the fixed stack segment flag if necessary.
-    if attr::contains_name(attributes, "fixed_stack_segment") {
-        set_no_inline(fcx.llfn);
-        set_fixed_stack_segment(fcx.llfn);
-    }
-
     // Create the first basic block in the function and keep a handle on it to
     //  pass to finish_fn later.
     let bcx_top = fcx.entry_bcx.unwrap();
     let mut bcx = bcx_top;
     let block_ty = node_id_type(bcx, body.id);
 
+    // Set up arguments to the function.
     let arg_tys = ty::ty_fn_args(node_id_type(bcx, id));
+    let raw_llargs = create_llargs_for_fn_args(fcx, self_arg,
+                                               decl.inputs, arg_tys);
+
+    // Set the fixed stack segment flag if necessary.
+    if attr::contains_name(attributes, "fixed_stack_segment") {
+        set_no_inline(fcx.llfn);
+        set_fixed_stack_segment(fcx.llfn);
+    }
+
     bcx = copy_args_to_allocas(fcx, bcx, decl.inputs, raw_llargs, arg_tys);
 
     maybe_load_env(fcx);
@@ -2108,10 +2115,11 @@ pub fn trans_enum_variant_or_tuple_like_struct<A:IdAndTy>(
                                None,
                                None);
 
-    let raw_llargs = create_llargs_for_fn_args(fcx, no_self, fn_args);
+    let arg_tys = ty::ty_fn_args(ctor_ty);
+
+    let raw_llargs = create_llargs_for_fn_args(fcx, no_self, fn_args, arg_tys);
 
     let bcx = fcx.entry_bcx.unwrap();
-    let arg_tys = ty::ty_fn_args(ctor_ty);
 
     insert_synthetic_type_entries(bcx, fn_args, arg_tys);
     let bcx = copy_args_to_allocas(fcx, bcx, fn_args, raw_llargs, arg_tys);

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

@@ -26,16 +26,13 @@ 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,
@@ -61,17 +58,10 @@ 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.map(|x| do_normalize(x)),
+        tys: real_substs.tps.to_owned(),
         vtables: vtables,
-        self_ty: real_substs.self_ty.map(|x| do_normalize(x)),
+        self_ty: real_substs.self_ty.clone(),
         self_vtables: self_vtables
     };
 
@@ -305,61 +295,6 @@ 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), "@10"); // FIXME: #4210: incorrect
+    exact_test(&(@mut 10), "@mut 10");
     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,12 +40,10 @@ 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(synchronized, detailed_leaks, poison_on_free);
+            let region = rust_new_memory_region(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());
@@ -109,8 +107,7 @@ pub fn live_allocs() -> *raw::Box<()> {
 
 extern {
     #[fast_ffi]
-    fn rust_new_memory_region(synchronized: uintptr_t,
-                               detailed_leaks: uintptr_t,
+    fn rust_new_memory_region(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,10 +224,7 @@ 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,6 +14,7 @@ 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;
@@ -129,24 +130,12 @@ memory and partly incapable of presentation to others.",
     }
 }
 
-pub fn set_exit_status(code: int) {
-    #[fixed_stack_segment]; #[inline(never)];
-    unsafe {
-        return rust_set_exit_status_newrt(code as libc::uintptr_t);
-    }
+static mut EXIT_STATUS: AtomicInt = INIT_ATOMIC_INT;
 
-    extern {
-        fn rust_set_exit_status_newrt(code: libc::uintptr_t);
-    }
+pub fn set_exit_status(code: int) {
+    unsafe { EXIT_STATUS.store(code, SeqCst) }
 }
 
 pub fn get_exit_status() -> int {
-    #[fixed_stack_segment]; #[inline(never)];
-    unsafe {
-        return rust_get_exit_status_newrt() as int;
-    }
-
-    extern {
-        fn rust_get_exit_status_newrt() -> libc::uintptr_t;
-    }
+    unsafe { EXIT_STATUS.load(SeqCst) }
 }

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;