---

yaml
---
r: 144146
b: refs/heads/try2
c: dc9b3e3
h: refs/heads/master
v: v3

Author: msullivan

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

branches/try2/mk/rt.mk

@@ -147,10 +147,10 @@ rt/$(1)/stage$(2)/arch/$$(HOST_$(1))/libmorestack.a: $$(MORESTACK_OBJ_$(1)_$(2))
 	$$(Q)$(AR_$(1)) rcs $$@ $$<
 
 rt/$(1)/stage$(2)/$(CFG_RUNTIME_$(1)): $$(RUNTIME_OBJS_$(1)_$(2)) $$(MKFILE_DEPS) \
-                        $$(RUNTIME_DEF_$(1)_$(2)) $$(LIBUV_LIB_$(1)_$(2)) $$(JEMALLOC_LIB_$(1)_$(2))
+                        $$(RUNTIME_DEF_$(1)_$(2)) $$(LIBUV_LIB_$(1)_$(2))
 	@$$(call E, link: $$@)
 	$$(Q)$$(call CFG_LINK_CXX_$(1),$$@, $$(RUNTIME_OBJS_$(1)_$(2)) \
-	  $$(JEMALLOC_LIB_$(1)_$(2)) $$(CFG_GCCISH_POST_LIB_FLAGS_$(1)) $$(LIBUV_LIB_$(1)_$(2)) \
+	  $$(CFG_GCCISH_POST_LIB_FLAGS_$(1)) $$(LIBUV_LIB_$(1)_$(2)) \
 	  $$(CFG_LIBUV_LINK_FLAGS_$(1)),$$(RUNTIME_DEF_$(1)_$(2)),$$(CFG_RUNTIME_$(1)))
 
 # FIXME: For some reason libuv's makefiles can't figure out the

branches/try2/src/compiletest/runtest.rs

@@ -26,7 +26,6 @@ use std::os;
 use std::str;
 use std::task::{spawn_sched, SingleThreaded};
 use std::vec;
-use std::unstable::running_on_valgrind;
 
 use extra::test::MetricMap;
 
@@ -39,21 +38,11 @@ pub fn run(config: config, testfile: ~str) {
     // that destroys parallelism if we let normal schedulers block.
     // It should be possible to remove this spawn once std::run is
     // rewritten to be non-blocking.
-    //
-    // We do _not_ create another thread if we're running on V because
-    // it serializes all threads anyways.
-    if running_on_valgrind() {
+    do spawn_sched(SingleThreaded) {
         let config = config.take();
         let testfile = testfile.take();
         let mut _mm = MetricMap::new();
         run_metrics(config, testfile, &mut _mm);
-    } else {
-        do spawn_sched(SingleThreaded) {
-            let config = config.take();
-            let testfile = testfile.take();
-            let mut _mm = MetricMap::new();
-            run_metrics(config, testfile, &mut _mm);
-        }
     }
 }
 

branches/try2/src/librustc/back/passes.rs

@@ -293,6 +293,7 @@ pub static transform_passes : &'static [(&'static str, &'static str)] = &'static
     ("scalarrepl",                      "Scalar Replacement of Aggregates (DT)"),
     ("scalarrepl-ssa",                  "Scalar Replacement of Aggregates (SSAUp)"),
     ("sccp",                            "Sparse Conditional Constant Propagation"),
+    ("simplify-libcalls",               "Simplify well-known library calls"),
     ("simplifycfg",                     "Simplify the CFG"),
     ("sink",                            "Code sinking"),
     ("strip",                           "Strip all symbols from a module"),

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

@@ -89,6 +89,11 @@ pub enum Attribute {
     ReturnsTwiceAttribute = 1 << 29,
     UWTableAttribute = 1 << 30,
     NonLazyBindAttribute = 1 << 31,
+
+    // Not added to LLVM yet, so may need to stay updated if LLVM changes.
+    // FIXME(#8199): if this changes, be sure to change the relevant constant
+    //               down below
+    // FixedStackSegment = 1 << 41,
 }
 
 // enum for the LLVM IntPredicate type
@@ -842,9 +847,7 @@ pub mod llvm {
         #[fast_ffi]
         pub fn LLVMSetGC(Fn: ValueRef, Name: *c_char);
         #[fast_ffi]
-        pub fn LLVMAddFunctionAttr(Fn: ValueRef, PA: c_uint);
-        #[fast_ffi]
-        pub fn LLVMAddFunctionAttrString(Fn: ValueRef, Name: *c_char);
+        pub fn LLVMAddFunctionAttr(Fn: ValueRef, PA: c_uint, HighPA: c_uint);
         #[fast_ffi]
         pub fn LLVMGetFunctionAttr(Fn: ValueRef) -> c_ulonglong;
         #[fast_ffi]
@@ -2135,7 +2138,23 @@ pub fn ConstFCmp(Pred: RealPredicate, V1: ValueRef, V2: ValueRef) -> ValueRef {
 
 pub fn SetFunctionAttribute(Fn: ValueRef, attr: Attribute) {
     unsafe {
-        llvm::LLVMAddFunctionAttr(Fn, attr as c_uint)
+        let attr = attr as u64;
+        let lower = attr & 0xffffffff;
+        let upper = (attr >> 32) & 0xffffffff;
+        llvm::LLVMAddFunctionAttr(Fn, lower as c_uint, upper as c_uint);
+    }
+}
+
+// FIXME(#8199): this shouldn't require this hackery. On i686
+//               (FixedStackSegment as u64) will return 0 instead of 1 << 41.
+//               Furthermore, if we use a match of any sort then an LLVM
+//               assertion is generated!
+pub fn SetFixedStackSegmentAttribute(Fn: ValueRef) {
+    unsafe {
+        let attr = 1u64 << 41;
+        let lower = attr & 0xffffffff;
+        let upper = (attr >> 32) & 0xffffffff;
+        llvm::LLVMAddFunctionAttr(Fn, lower as c_uint, upper as c_uint);
     }
 }
 /* Memory-managed object interface to type handles. */

branches/try2/src/librustc/middle/borrowck/check_loans.rs

@@ -27,8 +27,7 @@ use syntax::ast::{m_mutbl, m_imm, m_const};
 use syntax::ast;
 use syntax::ast_util;
 use syntax::codemap::span;
-use syntax::visit;
-use syntax::visit::Visitor;
+use syntax::oldvisit;
 use util::ppaux::Repr;
 
 #[deriving(Clone)]
@@ -40,27 +39,6 @@ struct CheckLoanCtxt<'self> {
     reported: @mut HashSet<ast::NodeId>,
 }
 
-struct CheckLoanVisitor;
-
-impl<'self> Visitor<CheckLoanCtxt<'self>> for CheckLoanVisitor {
-    fn visit_expr<'a>(&mut self, ex:@ast::expr, e:CheckLoanCtxt<'a>) {
-        check_loans_in_expr(self, ex, e);
-    }
-    fn visit_local(&mut self, l:@ast::Local, e:CheckLoanCtxt) {
-        check_loans_in_local(self, l, e);
-    }
-    fn visit_block(&mut self, b:&ast::Block, e:CheckLoanCtxt) {
-        check_loans_in_block(self, b, e);
-    }
-    fn visit_pat(&mut self, p:@ast::pat, e:CheckLoanCtxt) {
-        check_loans_in_pat(self, p, e);
-    }
-    fn visit_fn(&mut self, fk:&visit::fn_kind, fd:&ast::fn_decl,
-                b:&ast::Block, s:span, n:ast::NodeId, e:CheckLoanCtxt) {
-        check_loans_in_fn(self, fk, fd, b, s, n, e);
-    }
-}
-
 pub fn check_loans(bccx: @BorrowckCtxt,
                    dfcx_loans: &LoanDataFlow,
                    move_data: move_data::FlowedMoveData,
@@ -76,8 +54,15 @@ pub fn check_loans(bccx: @BorrowckCtxt,
         reported: @mut HashSet::new(),
     };
 
-    let mut vt = CheckLoanVisitor;
-    vt.visit_block(body, clcx);
+    let vt = oldvisit::mk_vt(@oldvisit::Visitor {
+        visit_expr: check_loans_in_expr,
+        visit_local: check_loans_in_local,
+        visit_block: check_loans_in_block,
+        visit_pat: check_loans_in_pat,
+        visit_fn: check_loans_in_fn,
+        .. *oldvisit::default_visitor()
+    });
+    (vt.visit_block)(body, (clcx, vt));
 }
 
 enum MoveError {
@@ -641,27 +626,27 @@ impl<'self> CheckLoanCtxt<'self> {
     }
 }
 
-fn check_loans_in_fn<'a>(visitor: &mut CheckLoanVisitor,
-                         fk: &visit::fn_kind,
+fn check_loans_in_fn<'a>(fk: &oldvisit::fn_kind,
                          decl: &ast::fn_decl,
                          body: &ast::Block,
                          sp: span,
                          id: ast::NodeId,
-                         this: CheckLoanCtxt<'a>) {
+                         (this, visitor): (CheckLoanCtxt<'a>,
+                                           oldvisit::vt<CheckLoanCtxt<'a>>)) {
     match *fk {
-        visit::fk_item_fn(*) |
-        visit::fk_method(*) => {
+        oldvisit::fk_item_fn(*) |
+        oldvisit::fk_method(*) => {
             // Don't process nested items.
             return;
         }
 
-        visit::fk_anon(*) |
-        visit::fk_fn_block(*) => {
+        oldvisit::fk_anon(*) |
+        oldvisit::fk_fn_block(*) => {
             check_captured_variables(this, id, sp);
         }
     }
 
-    visit::walk_fn(visitor, fk, decl, body, sp, id, this);
+    oldvisit::visit_fn(fk, decl, body, sp, id, (this, visitor));
 
     fn check_captured_variables(this: CheckLoanCtxt,
                                 closure_id: ast::NodeId,
@@ -704,16 +689,16 @@ fn check_loans_in_fn<'a>(visitor: &mut CheckLoanVisitor,
     }
 }
 
-fn check_loans_in_local<'a>(vt: &mut CheckLoanVisitor,
-                            local: @ast::Local,
-                            this: CheckLoanCtxt<'a>) {
-    visit::walk_local(vt, local, this);
+fn check_loans_in_local<'a>(local: @ast::Local,
+                            (this, vt): (CheckLoanCtxt<'a>,
+                                         oldvisit::vt<CheckLoanCtxt<'a>>)) {
+    oldvisit::visit_local(local, (this, vt));
 }
 
-fn check_loans_in_expr<'a>(vt: &mut CheckLoanVisitor,
-                           expr: @ast::expr,
-                           this: CheckLoanCtxt<'a>) {
-    visit::walk_expr(vt, expr, this);
+fn check_loans_in_expr<'a>(expr: @ast::expr,
+                           (this, vt): (CheckLoanCtxt<'a>,
+                                        oldvisit::vt<CheckLoanCtxt<'a>>)) {
+    oldvisit::visit_expr(expr, (this, vt));
 
     debug!("check_loans_in_expr(expr=%s)",
            expr.repr(this.tcx()));
@@ -764,19 +749,19 @@ fn check_loans_in_expr<'a>(vt: &mut CheckLoanVisitor,
     }
 }
 
-fn check_loans_in_pat<'a>(vt: &mut CheckLoanVisitor,
-                          pat: @ast::pat,
-                          this: CheckLoanCtxt<'a>)
+fn check_loans_in_pat<'a>(pat: @ast::pat,
+                          (this, vt): (CheckLoanCtxt<'a>,
+                                       oldvisit::vt<CheckLoanCtxt<'a>>))
 {
     this.check_for_conflicting_loans(pat.id);
     this.check_move_out_from_id(pat.id, pat.span);
-    visit::walk_pat(vt, pat, this);
+    oldvisit::visit_pat(pat, (this, vt));
 }
 
-fn check_loans_in_block<'a>(vt: &mut CheckLoanVisitor,
-                            blk: &ast::Block,
-                            this: CheckLoanCtxt<'a>)
+fn check_loans_in_block<'a>(blk: &ast::Block,
+                            (this, vt): (CheckLoanCtxt<'a>,
+                                         oldvisit::vt<CheckLoanCtxt<'a>>))
 {
-    visit::walk_block(vt, blk, this);
+    oldvisit::visit_block(blk, (this, vt));
     this.check_for_conflicting_loans(blk.id);
 }

branches/try2/src/librustc/middle/entry.rs

@@ -15,9 +15,9 @@ use syntax::ast::{Crate, NodeId, item, item_fn};
 use syntax::ast_map;
 use syntax::attr;
 use syntax::codemap::span;
+use syntax::oldvisit::{default_visitor, mk_vt, vt, Visitor, visit_crate};
+use syntax::oldvisit::{visit_item};
 use syntax::parse::token::special_idents;
-use syntax::visit;
-use syntax::visit::Visitor;
 use std::util;
 
 struct EntryContext {
@@ -39,13 +39,7 @@ struct EntryContext {
     non_main_fns: ~[(NodeId, span)],
 }
 
-struct EntryVisitor;
-
-impl Visitor<@mut EntryContext> for EntryVisitor {
-    fn visit_item(&mut self, item:@item, ctxt:@mut EntryContext) {
-        find_item(item, ctxt, self);
-    }
-}
+type EntryVisitor = vt<@mut EntryContext>;
 
 pub fn find_entry_point(session: Session, crate: &Crate, ast_map: ast_map::map) {
 
@@ -71,14 +65,15 @@ pub fn find_entry_point(session: Session, crate: &Crate, ast_map: ast_map::map)
         non_main_fns: ~[],
     };
 
-    let mut v = EntryVisitor;
-
-    visit::walk_crate(&mut v, crate, ctxt);
+    visit_crate(crate, (ctxt, mk_vt(@Visitor {
+        visit_item: |item, (ctxt, visitor)| find_item(item, ctxt, visitor),
+        .. *default_visitor()
+    })));
 
     configure_main(ctxt);
 }
 
-fn find_item(item: @item, ctxt: @mut EntryContext, visitor: &mut EntryVisitor) {
+fn find_item(item: @item, ctxt: @mut EntryContext, visitor: EntryVisitor) {
     match item.node {
         item_fn(*) => {
             if item.ident == special_idents::main {
@@ -125,7 +120,7 @@ fn find_item(item: @item, ctxt: @mut EntryContext, visitor: &mut EntryVisitor) {
         _ => ()
     }
 
-    visit::walk_item(visitor, item, ctxt);
+    visit_item(item, (ctxt, visitor));
 }
 
 fn configure_main(ctxt: @mut EntryContext) {