---

yaml
---
r: 95657
b: refs/heads/dist-snap
c: e4c6523
h: refs/heads/master
i:
  95655: f302933
v: v3

Author: alexcrichton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: c5074ae6463876bbb9511e980fe890bebc881e41
+refs/heads/dist-snap: e4c6523c65c45d0fc4485b9e691043c7b5c61a94
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/.gitmodules

@@ -8,4 +8,4 @@
 	branch = master
 [submodule "src/gyp"]
 	path = src/gyp
-	url = https://github.com/brson/gyp.git
+	url = https://git.chromium.org/external/gyp.git

branches/dist-snap/src/libextra/arc.rs

@@ -117,12 +117,10 @@ pub struct Arc<T> { priv x: UnsafeArc<T> }
  */
 impl<T:Freeze+Send> Arc<T> {
     /// Create an atomically reference counted wrapper.
-    #[inline]
     pub fn new(data: T) -> Arc<T> {
         Arc { x: UnsafeArc::new(data) }
     }
 
-    #[inline]
     pub fn get<'a>(&'a self) -> &'a T {
         unsafe { &*self.x.get_immut() }
     }
@@ -150,7 +148,6 @@ impl<T:Freeze + Send> Clone for Arc<T> {
     * object. However, one of the `arc` objects can be sent to another task,
     * allowing them to share the underlying data.
     */
-    #[inline]
     fn clone(&self) -> Arc<T> {
         Arc { x: self.x.clone() }
     }
@@ -170,7 +167,6 @@ pub struct MutexArc<T> { priv x: UnsafeArc<MutexArcInner<T>> }
 
 impl<T:Send> Clone for MutexArc<T> {
     /// Duplicate a mutex-protected Arc. See arc::clone for more details.
-    #[inline]
     fn clone(&self) -> MutexArc<T> {
         // NB: Cloning the underlying mutex is not necessary. Its reference
         // count would be exactly the same as the shared state's.
@@ -353,7 +349,6 @@ pub struct RWArc<T> {
 
 impl<T:Freeze + Send> Clone for RWArc<T> {
     /// Duplicate a rwlock-protected Arc. See arc::clone for more details.
-    #[inline]
     fn clone(&self) -> RWArc<T> {
         RWArc { x: self.x.clone() }
     }

branches/dist-snap/src/libextra/comm.rs

@@ -136,7 +136,7 @@ pub fn rendezvous<T: Send>() -> (SyncPort<T>, SyncChan<T>) {
 #[cfg(test)]
 mod test {
     use comm::{DuplexStream, rendezvous};
-    use std::rt::test::run_in_uv_task;
+    use std::rt::test::run_in_newsched_task;
     use std::task::spawn_unlinked;
 
 
@@ -165,7 +165,7 @@ mod test {
     #[test]
     fn recv_a_lot() {
         // Rendezvous streams should be able to handle any number of messages being sent
-        do run_in_uv_task {
+        do run_in_newsched_task {
             let (port, chan) = rendezvous();
             do spawn {
                 do 1000000.times { chan.send(()) }

branches/dist-snap/src/librustc/middle/borrowck/gather_loans/mod.rs

@@ -230,15 +230,12 @@ fn gather_loans_in_expr(this: &mut GatherLoanCtxt,
 
         // make sure that the thing we are pointing out stays valid
         // for the lifetime `scope_r` of the resulting ptr:
-        let expr_ty = ty::expr_ty(tcx, ex);
-        if !ty::type_is_bot(expr_ty) {
-            let scope_r = ty_region(tcx, ex.span, expr_ty);
-            this.guarantee_valid(ex.id,
-                                 ex.span,
-                                 base_cmt,
-                                 LoanMutability::from_ast_mutability(mutbl),
-                                 scope_r);
-        }
+        let scope_r = ty_region(tcx, ex.span, ty::expr_ty(tcx, ex));
+        this.guarantee_valid(ex.id,
+                             ex.span,
+                             base_cmt,
+                             LoanMutability::from_ast_mutability(mutbl),
+                             scope_r);
         visit::walk_expr(this, ex, ());
       }
 

branches/dist-snap/src/librustc/middle/trans/base.rs

@@ -288,6 +288,37 @@ pub fn get_extern_const(externs: &mut ExternMap, llmod: ModuleRef,
         return c;
     }
 }
+pub fn umax(cx: @mut Block, a: ValueRef, b: ValueRef) -> ValueRef {
+    let _icx = push_ctxt("umax");
+    let cond = ICmp(cx, lib::llvm::IntULT, a, b);
+    return Select(cx, cond, b, a);
+}
+
+pub fn umin(cx: @mut Block, a: ValueRef, b: ValueRef) -> ValueRef {
+    let _icx = push_ctxt("umin");
+    let cond = ICmp(cx, lib::llvm::IntULT, a, b);
+    return Select(cx, cond, a, b);
+}
+
+// Given a pointer p, returns a pointer sz(p) (i.e., inc'd by sz bytes).
+// The type of the returned pointer is always i8*.  If you care about the
+// return type, use bump_ptr().
+pub fn ptr_offs(bcx: @mut Block, base: ValueRef, sz: ValueRef) -> ValueRef {
+    let _icx = push_ctxt("ptr_offs");
+    let raw = PointerCast(bcx, base, Type::i8p());
+    InBoundsGEP(bcx, raw, [sz])
+}
+
+// Increment a pointer by a given amount and then cast it to be a pointer
+// to a given type.
+pub fn bump_ptr(bcx: @mut Block, t: ty::t, base: ValueRef, sz: ValueRef) ->
+   ValueRef {
+    let _icx = push_ctxt("bump_ptr");
+    let ccx = bcx.ccx();
+    let bumped = ptr_offs(bcx, base, sz);
+    let typ = type_of(ccx, t).ptr_to();
+    PointerCast(bcx, bumped, typ)
+}
 
 // Returns a pointer to the body for the box. The box may be an opaque
 // box. The result will be casted to the type of body_t, if it is statically
@@ -403,6 +434,10 @@ pub fn malloc_general(bcx: @mut Block, t: ty::t, heap: heap) -> MallocResult {
     assert!(heap != heap_exchange);
     malloc_general_dyn(bcx, t, heap, llsize_of(bcx.ccx(), ty))
 }
+pub fn malloc_boxed(bcx: @mut Block, t: ty::t)
+    -> MallocResult {
+    malloc_general(bcx, t, heap_managed)
+}
 
 pub fn heap_for_unique(bcx: @mut Block, t: ty::t) -> heap {
     if ty::type_contents(bcx.tcx(), t).contains_managed() {
@@ -499,6 +534,12 @@ pub fn set_no_split_stack(f: ValueRef) {
     }
 }
 
+pub fn set_glue_inlining(f: ValueRef, t: ty::t) {
+    if ty::type_is_structural(t) {
+        set_optimize_for_size(f);
+    } else { set_always_inline(f); }
+}
+
 // Double-check that we never ask LLVM to declare the same symbol twice. It
 // silently mangles such symbols, breaking our linkage model.
 pub fn note_unique_llvm_symbol(ccx: &mut CrateContext, sym: @str) {

branches/dist-snap/src/librustc/middle/trans/glue.rs

@@ -674,6 +674,7 @@ pub fn declare_generic_glue(ccx: &mut CrateContext, t: ty::t, llfnty: Type,
     debug!("{} is for type {}", fn_nm, ppaux::ty_to_str(ccx.tcx, t));
     note_unique_llvm_symbol(ccx, fn_nm);
     let llfn = decl_cdecl_fn(ccx.llmod, fn_nm, llfnty);
+    set_glue_inlining(llfn, t);
     return llfn;
 }
 

branches/dist-snap/src/libstd/ptr.rs

@@ -47,13 +47,6 @@ impl<T> Clone for *T {
     }
 }
 
-impl<T> Clone for *mut T {
-    #[inline]
-    fn clone(&self) -> *mut T {
-        *self
-    }
-}
-
 /// Return the first offset `i` such that `f(buf[i]) == true`.
 #[inline]
 pub unsafe fn position<T>(buf: *T, f: &fn(&T) -> bool) -> uint {