---

yaml
---
r: 146260
b: refs/heads/try2
c: 2290131
h: refs/heads/master
v: v3

Author: alexcrichton

[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: 671ab42a3b86addf7b90ff126554a092579e589a
+refs/heads/try2: 2290131543af4da764343c546efbd5c6dc9e7d71
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libextra/future.rs

@@ -51,10 +51,9 @@ impl<A:Clone> Future<A> {
 
 impl<A> Future<A> {
     /// Gets the value from this future, forcing evaluation.
-    pub fn unwrap(self) -> A {
-        let mut this = self;
-        this.get_ref();
-        let state = replace(&mut this.state, Evaluating);
+    pub fn unwrap(mut self) -> A {
+        self.get_ref();
+        let state = replace(&mut self.state, Evaluating);
         match state {
             Forced(v) => v,
             _ => fail!( "Logic error." ),

branches/try2/src/librustc/lib/llvm.rs

@@ -693,8 +693,6 @@ pub mod llvm {
         pub fn LLVMAddReturnAttribute(Fn: ValueRef, PA: c_uint);
         pub fn LLVMRemoveReturnAttribute(Fn: ValueRef, PA: c_uint);
 
-        pub fn LLVMAddColdAttribute(Fn: ValueRef);
-
         pub fn LLVMRemoveFunctionAttr(Fn: ValueRef,
                                       PA: c_ulonglong,
                                       HighPA: c_ulonglong);

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

@@ -202,21 +202,19 @@ pub fn get_extern_fn(externs: &mut ExternMap, llmod: ModuleRef, name: &str,
     f
 }
 
-fn get_extern_rust_fn(ccx: &mut CrateContext, inputs: &[ty::t], output: ty::t,
-                      name: &str, did: ast::DefId) -> ValueRef {
+pub fn get_extern_rust_fn(ccx: &mut CrateContext, inputs: &[ty::t], output: ty::t,
+                          name: &str) -> ValueRef {
     match ccx.externs.find_equiv(&name) {
         Some(n) => return *n,
         None => ()
     }
     let f = decl_rust_fn(ccx, inputs, output, name);
-    do csearch::get_item_attrs(ccx.tcx.cstore, did) |meta_items| {
-        set_llvm_fn_attrs(meta_items.iter().map(|&x| attr::mk_attr(x)).to_owned_vec(), f)
-    }
     ccx.externs.insert(name.to_owned(), f);
     f
 }
 
-fn decl_rust_fn(ccx: &mut CrateContext, inputs: &[ty::t], output: ty::t, name: &str) -> ValueRef {
+pub fn decl_rust_fn(ccx: &mut CrateContext, inputs: &[ty::t], output: ty::t,
+                    name: &str) -> ValueRef {
     let llfty = type_of_rust_fn(ccx, inputs, output);
     let llfn = decl_cdecl_fn(ccx.llmod, name, llfty);
 
@@ -483,10 +481,6 @@ pub fn set_llvm_fn_attrs(attrs: &[ast::Attribute], llfn: ValueRef) {
     if contains_name(attrs, "no_split_stack") {
         set_no_split_stack(llfn);
     }
-
-    if contains_name(attrs, "cold") {
-        unsafe { llvm::LLVMAddColdAttribute(llfn) }
-    }
 }
 
 pub fn set_always_inline(f: ValueRef) {
@@ -846,7 +840,7 @@ pub fn trans_external_path(ccx: &mut CrateContext, did: ast::DefId, t: ty::t) ->
         ty::ty_bare_fn(ref fn_ty) => {
             match fn_ty.abis.for_arch(ccx.sess.targ_cfg.arch) {
                 Some(Rust) | Some(RustIntrinsic) => {
-                    get_extern_rust_fn(ccx, fn_ty.sig.inputs, fn_ty.sig.output, name, did)
+                    get_extern_rust_fn(ccx, fn_ty.sig.inputs, fn_ty.sig.output, name)
                 }
                 Some(*) | None => {
                     let c = foreign::llvm_calling_convention(ccx, fn_ty.abis);
@@ -857,7 +851,7 @@ pub fn trans_external_path(ccx: &mut CrateContext, did: ast::DefId, t: ty::t) ->
             }
         }
         ty::ty_closure(ref f) => {
-            get_extern_rust_fn(ccx, f.sig.inputs, f.sig.output, name, did)
+            get_extern_rust_fn(ccx, f.sig.inputs, f.sig.output, name)
         }
         _ => {
             let llty = type_of(ccx, t);
@@ -2850,8 +2844,6 @@ pub fn declare_intrinsics(llmod: ModuleRef) -> HashMap<&'static str, ValueRef> {
     ifn!(intrinsics, "llvm.umul.with.overflow.i64",
         [Type::i64(), Type::i64()], Type::struct_([Type::i64(), Type::i1()], false));
 
-    ifn!(intrinsics, "llvm.expect.i1", [Type::i1(), Type::i1()], Type::i1());
-
     return intrinsics;
 }
 

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

@@ -981,9 +981,7 @@ fn trans_lvalue_unadjusted(bcx: @mut Block, expr: &ast::Expr) -> DatumBlock {
         debug!("trans_index: len {}", bcx.val_to_str(len));
 
         let bounds_check = ICmp(bcx, lib::llvm::IntUGE, ix_val, len);
-        let expect = ccx.intrinsics.get_copy(&("llvm.expect.i1"));
-        let expected = Call(bcx, expect, [bounds_check, C_i1(false)], []);
-        let bcx = do with_cond(bcx, expected) |bcx| {
+        let bcx = do with_cond(bcx, bounds_check) |bcx| {
             controlflow::trans_fail_bounds_check(bcx, index_expr.span, ix_val, len)
         };
         let elt = InBoundsGEP(bcx, base, [ix_val]);

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

@@ -57,7 +57,6 @@ pub fn clear_task_borrow_list() {
     let _ = try_take_task_borrow_list();
 }
 
-#[cold]
 unsafe fn fail_borrowed(box: *mut raw::Box<()>, file: *c_char, line: size_t) -> ! {
     debug_borrow("fail_borrowed: ", box, 0, 0, file, line);
 

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

@@ -113,7 +113,7 @@ impl<T> ChanOne<T> {
 
     // 'do_resched' configures whether the scheduler immediately switches to
     // the receiving task, or leaves the sending task still running.
-    fn try_send_inner(self, val: T, do_resched: bool) -> bool {
+    fn try_send_inner(mut self, val: T, do_resched: bool) -> bool {
         if do_resched {
             rtassert!(!rt::in_sched_context());
         }
@@ -129,9 +129,8 @@ impl<T> ChanOne<T> {
             sched.maybe_yield();
         }
 
-        let mut this = self;
         let mut recvr_active = true;
-        let packet = this.packet();
+        let packet = self.packet();
 
         unsafe {
 
@@ -150,15 +149,15 @@ impl<T> ChanOne<T> {
             // done with the packet. NB: In case of do_resched, this *must*
             // happen before waking up a blocked task (or be unkillable),
             // because we might get a kill signal during the reschedule.
-            this.suppress_finalize = true;
+            self.suppress_finalize = true;
 
             match oldstate {
                 STATE_BOTH => {
                     // Port is not waiting yet. Nothing to do
                 }
                 STATE_ONE => {
                     // Port has closed. Need to clean up.
-                    let _packet: ~Packet<T> = cast::transmute(this.void_packet);
+                    let _packet: ~Packet<T> = cast::transmute(self.void_packet);
                     recvr_active = false;
                 }
                 task_as_state => {
@@ -202,22 +201,20 @@ impl<T> PortOne<T> {
     }
 
     /// As `recv`, but returns `None` if the send end is closed rather than failing.
-    pub fn try_recv(self) -> Option<T> {
-        let mut this = self;
-
+    pub fn try_recv(mut self) -> Option<T> {
         // Optimistic check. If data was sent already, we don't even need to block.
         // No release barrier needed here; we're not handing off our task pointer yet.
-        if !this.optimistic_check() {
+        if !self.optimistic_check() {
             // No data available yet.
             // Switch to the scheduler to put the ~Task into the Packet state.
             let sched: ~Scheduler = Local::take();
             do sched.deschedule_running_task_and_then |sched, task| {
-                this.block_on(sched, task);
+                self.block_on(sched, task);
             }
         }
 
         // Task resumes.
-        this.recv_ready()
+        self.recv_ready()
     }
 }
 
@@ -325,9 +322,8 @@ impl<T> SelectInner for PortOne<T> {
 impl<T> Select for PortOne<T> { }
 
 impl<T> SelectPortInner<T> for PortOne<T> {
-    fn recv_ready(self) -> Option<T> {
-        let mut this = self;
-        let packet = this.packet();
+    fn recv_ready(mut self) -> Option<T> {
+        let packet = self.packet();
 
         // No further memory barrier is needed here to access the
         // payload. Some scenarios:
@@ -348,9 +344,9 @@ impl<T> SelectPortInner<T> for PortOne<T> {
             let payload = (*packet).payload.take();
 
             // The sender has closed up shop. Drop the packet.
-            let _packet: ~Packet<T> = cast::transmute(this.void_packet);
+            let _packet: ~Packet<T> = cast::transmute(self.void_packet);
             // Suppress the synchronizing actions in the finalizer. We're done with the packet.
-            this.suppress_finalize = true;
+            self.suppress_finalize = true;
             return payload;
         }
     }
@@ -378,18 +374,17 @@ impl<T> Drop for ChanOne<T> {
         if self.suppress_finalize { return }
 
         unsafe {
-            let this = cast::transmute_mut(self);
-            let oldstate = (*this.packet()).state.swap(STATE_ONE, SeqCst);
+            let oldstate = (*self.packet()).state.swap(STATE_ONE, SeqCst);
             match oldstate {
                 STATE_BOTH => {
                     // Port still active. It will destroy the Packet.
                 },
                 STATE_ONE => {
-                    let _packet: ~Packet<T> = cast::transmute(this.void_packet);
+                    let _packet: ~Packet<T> = cast::transmute(self.void_packet);
                 },
                 task_as_state => {
                     // The port is blocked waiting for a message we will never send. Wake it.
-                    rtassert!((*this.packet()).payload.is_none());
+                    rtassert!((*self.packet()).payload.is_none());
                     let recvr = BlockedTask::cast_from_uint(task_as_state);
                     do recvr.wake().map |woken_task| {
                         Scheduler::run_task(woken_task);
@@ -406,14 +401,13 @@ impl<T> Drop for PortOne<T> {
         if self.suppress_finalize { return }
 
         unsafe {
-            let this = cast::transmute_mut(self);
-            let oldstate = (*this.packet()).state.swap(STATE_ONE, SeqCst);
+            let oldstate = (*self.packet()).state.swap(STATE_ONE, SeqCst);
             match oldstate {
                 STATE_BOTH => {
                     // Chan still active. It will destroy the packet.
                 },
                 STATE_ONE => {
-                    let _packet: ~Packet<T> = cast::transmute(this.void_packet);
+                    let _packet: ~Packet<T> = cast::transmute(self.void_packet);
                 }
                 task_as_state => {
                     // This case occurs during unwinding, when the blocked

branches/try2/src/libstd/rt/io/net/unix.rs

@@ -243,8 +243,7 @@ mod tests {
             let mut stop = false;
             while !stop{
                 do io_error::cond.trap(|e| {
-                    assert!(e.kind == BrokenPipe || e.kind == NotConnected,
-                            "unknown error {:?}", e);
+                    assert_eq!(e.kind, BrokenPipe);
                     stop = true;
                 }).inside {
                     server.write(buf);