---

yaml
---
r: 85732
b: refs/heads/dist-snap
c: 0a1baef
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 0983ebe5310d4eb6d289f636f7ed0536c08bbc0e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 7b5a91f4b346b99b4e9171eb8deb52d9bf2525ea
+refs/heads/dist-snap: 0a1baef4f57b4ac8558a65b7bd8dc787ebf54840
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/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 \
@@ -75,7 +74,6 @@ RUNTIME_CXXS_$(1)_$(2) := \
               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 \

branches/dist-snap/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/dist-snap/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/dist-snap/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/dist-snap/src/rt/rust_builtin.cpp

@@ -11,7 +11,6 @@
 /* Foreign builtins. */
 
 #include "rust_util.h"
-#include "sync/timer.h"
 #include "sync/rust_thread.h"
 #include "sync/lock_and_signal.h"
 #include "memory_region.h"
@@ -25,6 +24,7 @@
 
 #ifdef __APPLE__
 #include <crt_externs.h>
+#include <mach/mach_time.h>
 #endif
 
 #if !defined(__WIN32__)
@@ -242,10 +242,33 @@ get_time(int64_t *sec, int32_t *nsec) {
 }
 #endif
 
+const uint64_t ns_per_s = 1000000000LL;
+
 extern "C" CDECL void
 precise_time_ns(uint64_t *ns) {
-    timer t;
-    *ns = t.time_ns();
+
+#ifdef __APPLE__
+    uint64_t time = mach_absolute_time();
+    mach_timebase_info_data_t info = {0, 0};
+    if (info.denom == 0) {
+        mach_timebase_info(&info);
+    }
+    uint64_t time_nano = time * (info.numer / info.denom);
+    *ns = time_nano;
+#elif __WIN32__
+    uint64_t ticks_per_s;
+    QueryPerformanceFrequency((LARGE_INTEGER *)&ticks_per_s);
+    if (ticks_per_s == 0LL) {
+        ticks_per_s = 1LL;
+    }
+    uint64_t ticks;
+    QueryPerformanceCounter((LARGE_INTEGER *)&ticks);
+    *ns = ((ticks * ns_per_s) / ticks_per_s);
+#else
+    timespec ts;
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+    *ns = (ts.tv_sec * ns_per_s + ts.tv_nsec);
+#endif
 }
 
 struct rust_tm {
@@ -292,7 +315,7 @@ void tm_to_rust_tm(tm* in_tm, rust_tm* out_tm, int32_t gmtoff,
 
     if (zone != NULL) {
         size_t size = strlen(zone);
-        reserve_vec_exact(&out_tm->tm_zone, size);
+        assert(out_tm->tm_zone->alloc >= size);
         memcpy(out_tm->tm_zone->data, zone, size);
         out_tm->tm_zone->fill = size;
     }

branches/dist-snap/src/rt/rust_exchange_alloc.cpp

@@ -11,7 +11,6 @@
 // Helper functions used only in tests
 
 #include "rust_util.h"
-#include "sync/timer.h"
 #include "sync/rust_thread.h"
 #include "sync/lock_and_signal.h"
 #include "rust_abi.h"

branches/dist-snap/src/rt/rust_exchange_alloc.h

@@ -12,7 +12,6 @@
 #define RUST_UTIL_H
 
 #include <limits.h>
-#include "rust_exchange_alloc.h"
 #include "rust_type.h"
 
 extern struct type_desc str_body_tydesc;
@@ -57,16 +56,6 @@ vec_data(rust_vec *v) {
     return reinterpret_cast<T*>(v->data);
 }
 
-inline void reserve_vec_exact(rust_vec** vpp,
-                              size_t size) {
-    if (size > (*vpp)->alloc) {
-        rust_exchange_alloc exchange_alloc;
-        *vpp = (rust_vec*)exchange_alloc
-            .realloc(*vpp, size + sizeof(rust_vec));
-        (*vpp)->alloc = size;
-    }
-}
-
 typedef rust_vec rust_str;
 
 inline size_t get_box_size(size_t body_size, size_t body_align) {