---

yaml
---
r: 146261
b: refs/heads/try2
c: 7309158
h: refs/heads/master
i:
  146259: 556d5bb
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: 2290131543af4da764343c546efbd5c6dc9e7d71
+refs/heads/try2: 73091583dd42991213e102daefa9181ce500feb0
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

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

@@ -693,6 +693,8 @@ 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,19 +202,21 @@ pub fn get_extern_fn(externs: &mut ExternMap, llmod: ModuleRef, name: &str,
     f
 }
 
-pub fn get_extern_rust_fn(ccx: &mut CrateContext, inputs: &[ty::t], output: ty::t,
-                          name: &str) -> ValueRef {
+fn get_extern_rust_fn(ccx: &mut CrateContext, inputs: &[ty::t], output: ty::t,
+                      name: &str, did: ast::DefId) -> 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
 }
 
-pub fn decl_rust_fn(ccx: &mut CrateContext, inputs: &[ty::t], output: ty::t,
-                    name: &str) -> ValueRef {
+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);
 
@@ -481,6 +483,10 @@ 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) {
@@ -840,7 +846,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)
+                    get_extern_rust_fn(ccx, fn_ty.sig.inputs, fn_ty.sig.output, name, did)
                 }
                 Some(*) | None => {
                     let c = foreign::llvm_calling_convention(ccx, fn_ty.abis);
@@ -851,7 +857,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)
+            get_extern_rust_fn(ccx, f.sig.inputs, f.sig.output, name, did)
         }
         _ => {
             let llty = type_of(ccx, t);
@@ -2844,6 +2850,8 @@ 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,7 +981,9 @@ 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 bcx = do with_cond(bcx, bounds_check) |bcx| {
+        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| {
             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,6 +57,7 @@ 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/io/net/unix.rs

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

branches/try2/src/libstd/unstable/lang.rs

@@ -16,11 +16,13 @@ use libc::{c_char, size_t, uintptr_t};
 use rt::task;
 use rt::borrowck;
 
+#[cold]
 #[lang="fail_"]
 pub fn fail_(expr: *c_char, file: *c_char, line: size_t) -> ! {
     task::begin_unwind(expr, file, line);
 }
 
+#[cold]
 #[lang="fail_bounds_check"]
 pub fn fail_bounds_check(file: *c_char, line: size_t, index: size_t, len: size_t) -> ! {
     let msg = format!("index out of bounds: the len is {} but the index is {}",

branches/try2/src/libsyntax/ext/expand.rs

@@ -566,12 +566,11 @@ fn expand_non_macro_stmt(exts: SyntaxEnv, s: &Stmt, fld: &MacroExpander)
             // oh dear heaven... this is going to include the enum names, as well....
             // ... but that should be okay, as long as the new names are gensyms
             // for the old ones.
-            let idents = @mut ~[];
-            let name_finder = new_name_finder(idents);
+            let mut name_finder = new_name_finder(~[]);
             name_finder.visit_pat(expanded_pat,());
             // generate fresh names, push them to a new pending list
             let new_pending_renames = @mut ~[];
-            for ident in idents.iter() {
+            for ident in name_finder.ident_accumulator.iter() {
                 let new_name = fresh_name(ident);
                 new_pending_renames.push((*ident,new_name));
             }
@@ -609,7 +608,7 @@ fn expand_non_macro_stmt(exts: SyntaxEnv, s: &Stmt, fld: &MacroExpander)
 // array (passed in to the traversal)
 #[deriving(Clone)]
 struct NewNameFinderContext {
-    ident_accumulator: @mut ~[ast::Ident],
+    ident_accumulator: ~[ast::Ident],
 }
 
 impl Visitor<()> for NewNameFinderContext {
@@ -653,50 +652,13 @@ impl Visitor<()> for NewNameFinderContext {
 
 }
 
-// a visitor that extracts the paths
-// from a given thingy and puts them in a mutable
-// array (passed in to the traversal)
-#[deriving(Clone)]
-struct NewPathExprFinderContext {
-    path_accumulator: @mut ~[ast::Path],
-}
-
-impl Visitor<()> for NewPathExprFinderContext {
-
-    fn visit_expr(&mut self, expr: @ast::Expr, _: ()) {
-        match *expr {
-            ast::Expr{id:_,span:_,node:ast::ExprPath(ref p)} => {
-                self.path_accumulator.push(p.clone());
-                // not calling visit_path, should be fine.
-            }
-            _ => visit::walk_expr(self,expr,())
-        }
-    }
-
-    fn visit_ty(&mut self, typ: &ast::Ty, _: ()) {
-        visit::walk_ty(self, typ, ())
-    }
-
-}
-
 // return a visitor that extracts the pat_ident paths
 // from a given thingy and puts them in a mutable
 // array (passed in to the traversal)
-pub fn new_name_finder(idents: @mut ~[ast::Ident]) -> @mut Visitor<()> {
-    let context = @mut NewNameFinderContext {
+pub fn new_name_finder(idents: ~[ast::Ident]) -> NewNameFinderContext {
+    NewNameFinderContext {
         ident_accumulator: idents,
-    };
-    context as @mut Visitor<()>
-}
-
-// return a visitor that extracts the paths
-// from a given pattern and puts them in a mutable
-// array (passed in to the traversal)
-pub fn new_path_finder(paths: @mut ~[ast::Path]) -> @mut Visitor<()> {
-    let context = @mut NewPathExprFinderContext {
-        path_accumulator: paths,
-    };
-    context as @mut Visitor<()>
+    }
 }
 
 // expand a block. pushes a new exts_frame, then calls expand_block_elts
@@ -1371,6 +1333,42 @@ mod test {
     use util::parser_testing::{string_to_crate, string_to_crate_and_sess};
     use util::parser_testing::{string_to_pat, string_to_tts, strs_to_idents};
     use visit;
+    use visit::Visitor;
+
+    // a visitor that extracts the paths
+    // from a given thingy and puts them in a mutable
+    // array (passed in to the traversal)
+    #[deriving(Clone)]
+    struct NewPathExprFinderContext {
+        path_accumulator: ~[ast::Path],
+    }
+
+    impl Visitor<()> for NewPathExprFinderContext {
+
+        fn visit_expr(&mut self, expr: @ast::Expr, _: ()) {
+            match *expr {
+                ast::Expr{id:_,span:_,node:ast::ExprPath(ref p)} => {
+                    self.path_accumulator.push(p.clone());
+                    // not calling visit_path, should be fine.
+                }
+                _ => visit::walk_expr(self,expr,())
+            }
+        }
+
+        fn visit_ty(&mut self, typ: &ast::Ty, _: ()) {
+            visit::walk_ty(self, typ, ())
+        }
+
+    }
+
+    // return a visitor that extracts the paths
+    // from a given pattern and puts them in a mutable
+    // array (passed in to the traversal)
+    pub fn new_path_finder(paths: ~[ast::Path]) -> NewPathExprFinderContext {
+        NewPathExprFinderContext {
+            path_accumulator: paths
+        }
+    }
 
     // make sure that fail! is present
     #[test] fn fail_exists_test () {
@@ -1498,10 +1496,11 @@ mod test {
         let renamer = new_rename_folder(ast::Ident{name:a_name,ctxt:EMPTY_CTXT},
                                         a2_name);
         let renamed_ast = renamer.fold_crate(item_ast.clone());
-        let varrefs = @mut ~[];
-        visit::walk_crate(&mut new_path_finder(varrefs), &renamed_ast, ());
-        match varrefs {
-            @[ast::Path{segments:[ref seg],_}] =>
+        let mut path_finder = new_path_finder(~[]);
+        visit::walk_crate(&mut path_finder, &renamed_ast, ());
+
+        match path_finder.path_accumulator {
+            [ast::Path{segments:[ref seg],_}] =>
                 assert_eq!(mtwt_resolve(seg.identifier),a2_name),
             _ => assert_eq!(0,1)
         }
@@ -1513,10 +1512,10 @@ mod test {
         let pending_renames = @mut ~[(ast::Ident::new(a_name),a2_name),
                                      (ast::Ident{name:a_name,ctxt:ctxt2},a3_name)];
         let double_renamed = renames_to_fold(pending_renames).fold_crate(item_ast);
-        let varrefs = @mut ~[];
-        visit::walk_crate(&mut new_path_finder(varrefs), &double_renamed, ());
-        match varrefs {
-            @[ast::Path{segments:[ref seg],_}] =>
+        let mut path_finder = new_path_finder(~[]);
+        visit::walk_crate(&mut path_finder, &double_renamed, ());
+        match path_finder.path_accumulator {
+            [ast::Path{segments:[ref seg],_}] =>
                 assert_eq!(mtwt_resolve(seg.identifier),a3_name),
             _ => assert_eq!(0,1)
         }
@@ -1623,11 +1622,15 @@ mod test {
         };
         let cr = expand_crate_str(teststr.to_managed());
         // find the bindings:
-        let bindings = @mut ~[];
-        visit::walk_crate(&mut new_name_finder(bindings),&cr,());
+        let mut name_finder = new_name_finder(~[]);
+        visit::walk_crate(&mut name_finder,&cr,());
+        let bindings = name_finder.ident_accumulator;
+
         // find the varrefs:
-        let varrefs = @mut ~[];
-        visit::walk_crate(&mut new_path_finder(varrefs),&cr,());
+        let mut path_finder = new_path_finder(~[]);
+        visit::walk_crate(&mut path_finder,&cr,());
+        let varrefs = path_finder.path_accumulator;
+
         // must be one check clause for each binding:
         assert_eq!(bindings.len(),bound_connections.len());
         for (binding_idx,shouldmatch) in bound_connections.iter().enumerate() {
@@ -1686,8 +1689,10 @@ foo_module!()
 ";
         let cr = expand_crate_str(crate_str);
         // find the xx binding
-        let bindings = @mut ~[];
-        visit::walk_crate(&mut new_name_finder(bindings), &cr, ());
+        let mut name_finder = new_name_finder(~[]);
+        visit::walk_crate(&mut name_finder, &cr, ());
+        let bindings = name_finder.ident_accumulator;
+
         let cxbinds : ~[&ast::Ident] =
             bindings.iter().filter(|b|{@"xx" == (ident_to_str(*b))}).collect();
         let cxbind = match cxbinds {
@@ -1696,8 +1701,10 @@ foo_module!()
         };
         let resolved_binding = mtwt_resolve(*cxbind);
         // find all the xx varrefs:
-        let varrefs = @mut ~[];
-        visit::walk_crate(&mut new_path_finder(varrefs), &cr, ());
+        let mut path_finder = new_path_finder(~[]);
+        visit::walk_crate(&mut path_finder, &cr, ());
+        let varrefs = path_finder.path_accumulator;
+
         // the xx binding should bind all of the xx varrefs:
         for (idx,v) in varrefs.iter().filter(|p|{ p.segments.len() == 1
                                           && (@"xx" == (ident_to_str(&p.segments[0].identifier)))
@@ -1723,10 +1730,10 @@ foo_module!()
     #[test]
     fn pat_idents(){
         let pat = string_to_pat(@"(a,Foo{x:c @ (b,9),y:Bar(4,d)})");
-        let idents = @mut ~[];
-        let pat_idents = new_name_finder(idents);
+        let mut pat_idents = new_name_finder(~[]);
         pat_idents.visit_pat(pat, ());
-        assert_eq!(idents, @mut strs_to_idents(~["a","c","b","d"]));
+        assert_eq!(pat_idents.ident_accumulator,
+                   strs_to_idents(~["a","c","b","d"]));
     }
 
 }