---

yaml
---
r: 147818
b: refs/heads/try2
c: 51ace54
h: refs/heads/master
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: 8f26d0b9b8725fa74dc36fcf4abf45dc1ca8c56a
+refs/heads/try2: 51ace54597984b221321d1cac0f80c50f9e00f71
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/driver/driver.rs

@@ -19,7 +19,4 @@ extern mod this = "rustdoc";
 #[cfg(rustc)]
 extern mod this = "rustc";
 
-#[cfg(rustdoc_ng)]
-extern mod this = "rustdoc_ng";
-
 fn main() { this::main() }

branches/try2/src/etc/emacs/rust-mode.el

@@ -54,7 +54,9 @@
     ;; We don't want to indent out to the open bracket if the
     ;; open bracket ends the line
     (when (not (looking-at "[[:blank:]]*\\(?://.*\\)?$"))
-      (when (looking-at "[[:space:]]") (forward-to-word 1))
+      (when (looking-at "[[:space:]]")
+	(forward-word 1)
+	(backward-word 1))
       (current-column))))
 
 (defun rust-mode-indent-line ()

branches/try2/src/libnative/io/net.rs

@@ -205,19 +205,14 @@ pub fn init() {
     }
 
     unsafe {
-        use std::unstable::mutex::{Mutex, MUTEX_INIT};
-        static mut LOCK: Mutex = MUTEX_INIT;
-        static mut INITIALIZED: bool = false;
-        if INITIALIZED { return }
-        LOCK.lock();
-        if !INITIALIZED {
+        use std::unstable::mutex::{Once, ONCE_INIT};
+        static mut INIT: Once = ONCE_INIT;
+        INIT.doit(|| {
             let mut data: WSADATA = intrinsics::init();
             let ret = WSAStartup(0x202,      // version 2.2
                                  &mut data);
             assert_eq!(ret, 0);
-            INITIALIZED = true;
-        }
-        LOCK.unlock();
+        });
     }
 }
 

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

@@ -34,6 +34,7 @@ use std::run;
 use std::str;
 use std::io;
 use std::io::fs;
+use extra::hex::ToHex;
 use extra::tempfile::TempDir;
 use syntax::abi;
 use syntax::ast;
@@ -309,9 +310,8 @@ pub mod write {
     }
 
     unsafe fn configure_llvm(sess: Session) {
-        use std::unstable::mutex::{MUTEX_INIT, Mutex};
-        static mut LOCK: Mutex = MUTEX_INIT;
-        static mut CONFIGURED: bool = false;
+        use std::unstable::mutex::{Once, ONCE_INIT};
+        static mut INIT: Once = ONCE_INIT;
 
         // Copy what clan does by turning on loop vectorization at O2 and
         // slp vectorization at O3
@@ -340,8 +340,7 @@ pub mod write {
             add(*arg);
         }
 
-        LOCK.lock();
-        if !CONFIGURED {
+        INIT.doit(|| {
             llvm::LLVMInitializePasses();
 
             // Only initialize the platforms supported by Rust here, because
@@ -368,9 +367,7 @@ pub mod write {
 
             llvm::LLVMRustSetLLVMOptions(llvm_args.len() as c_int,
                                          llvm_args.as_ptr());
-            CONFIGURED = true;
-        }
-        LOCK.unlock();
+        });
     }
 
     unsafe fn populate_llvm_passes(fpm: lib::llvm::PassManagerRef,
@@ -494,8 +491,10 @@ pub fn build_link_meta(sess: Session,
     }
 }
 
-pub fn truncated_hash_result(symbol_hasher: &mut Sha256) -> ~str {
-    symbol_hasher.result_str()
+fn truncated_hash_result(symbol_hasher: &mut Sha256) -> ~str {
+    let output = symbol_hasher.result_bytes();
+    // 64 bits should be enough to avoid collisions.
+    output.slice_to(8).to_hex()
 }
 
 
@@ -883,8 +882,11 @@ fn link_rlib(sess: Session,
     match trans {
         Some(trans) => {
             // Instead of putting the metadata in an object file section, rlibs
-            // contain the metadata in a separate file.
-            let metadata = obj_filename.with_filename(METADATA_FILENAME);
+            // contain the metadata in a separate file. We use a temp directory
+            // here so concurrent builds in the same directory don't try to use
+            // the same filename for metadata (stomping over one another)
+            let tmpdir = TempDir::new("rustc").expect("needs a temp dir");
+            let metadata = tmpdir.path().join(METADATA_FILENAME);
             fs::File::create(&metadata).write(trans.metadata);
             a.add_file(&metadata, false);
             fs::unlink(&metadata);

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

@@ -1459,15 +1459,16 @@ pub mod llvm {
                                                          BufferName: *c_char)
             -> MemoryBufferRef;
 
+        pub fn LLVMIsMultithreaded() -> Bool;
+        pub fn LLVMStartMultithreaded() -> Bool;
+
         /** Returns a string describing the last error caused by an LLVMRust*
             call. */
         pub fn LLVMRustGetLastError() -> *c_char;
 
         /// Print the pass timings since static dtors aren't picking them up.
         pub fn LLVMRustPrintPassTimings();
 
-        pub fn LLVMRustStartMultithreading() -> bool;
-
         pub fn LLVMStructCreateNamed(C: ContextRef, Name: *c_char) -> TypeRef;
 
         pub fn LLVMStructSetBody(StructTy: TypeRef,

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

@@ -3189,8 +3189,21 @@ pub fn trans_crate(sess: session::Session,
                    analysis: &CrateAnalysis,
                    output: &Path) -> CrateTranslation {
     // Before we touch LLVM, make sure that multithreading is enabled.
-    if unsafe { !llvm::LLVMRustStartMultithreading() } {
-        sess.bug("couldn't enable multi-threaded LLVM");
+    unsafe {
+        use std::unstable::mutex::{Once, ONCE_INIT};
+        static mut INIT: Once = ONCE_INIT;
+        static mut POISONED: bool = false;
+        INIT.doit(|| {
+            if llvm::LLVMStartMultithreaded() != 1 {
+                // use an extra bool to make sure that all future usage of LLVM
+                // cannot proceed despite the Once not running more than once.
+                POISONED = true;
+            }
+        });
+
+        if POISONED {
+            sess.bug("couldn't enable multi-threaded LLVM");
+        }
     }
 
     let mut symbol_hasher = Sha256::new();

branches/try2/src/librustdoc/lib.rs

@@ -242,7 +242,7 @@ fn rust_input(cratefile: &str, matches: &getopts::Matches) -> Output {
     }
 
     // Load all plugins/passes into a PluginManager
-    let path = matches.opt_str("plugin-path").unwrap_or(~"/tmp/rustdoc_ng/plugins");
+    let path = matches.opt_str("plugin-path").unwrap_or(~"/tmp/rustdoc/plugins");
     let mut pm = plugins::PluginManager::new(Path::new(path));
     for pass in passes.iter() {
         let plugin = match PASSES.iter().position(|&(p, _, _)| p == *pass) {

branches/try2/src/libstd/path/posix.rs

@@ -1404,4 +1404,45 @@ mod bench {
             posix_home_path.ends_with_path(&Path::new("jome"));
         });
     }
+
+    #[bench]
+    fn is_ancestor_of_path_with_10_dirs(bh: &mut BenchHarness) {
+        let path = Path::new("/home/1/2/3/4/5/6/7/8/9");
+        let mut sub = path.clone();
+        sub.pop();
+        bh.iter(|| {
+            path.is_ancestor_of(&sub);
+        });
+    }
+
+    #[bench]
+    fn path_relative_from_forward(bh: &mut BenchHarness) {
+        let path = Path::new("/a/b/c");
+        let mut other = path.clone();
+        other.pop();
+        bh.iter(|| {
+            path.path_relative_from(&other);
+        });
+    }
+
+    #[bench]
+    fn path_relative_from_same_level(bh: &mut BenchHarness) {
+        let path = Path::new("/a/b/c");
+        let mut other = path.clone();
+        other.pop();
+        other.push("d");
+        bh.iter(|| {
+            path.path_relative_from(&other);
+        });
+    }
+
+    #[bench]
+    fn path_relative_from_backward(bh: &mut BenchHarness) {
+        let path = Path::new("/a/b");
+        let mut other = path.clone();
+        other.push("c");
+        bh.iter(|| {
+            path.path_relative_from(&other);
+        });
+    }
 }

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

@@ -160,30 +160,20 @@ pub mod native {
     use option::{Option, Some, None};
     use ptr;
     use tls = rt::thread_local_storage;
-    use unstable::mutex::{Mutex, MUTEX_INIT};
 
-    static mut LOCK: Mutex = MUTEX_INIT;
-    static mut INITIALIZED: bool = false;
     static mut RT_TLS_KEY: tls::Key = -1;
 
     /// Initialize the TLS key. Other ops will fail if this isn't executed
     /// first.
     pub fn init() {
         unsafe {
-            LOCK.lock();
-            if !INITIALIZED {
-                tls::create(&mut RT_TLS_KEY);
-                INITIALIZED = true;
-            }
-            LOCK.unlock();
+            tls::create(&mut RT_TLS_KEY);
         }
     }
 
     pub unsafe fn cleanup() {
-        rtassert!(INITIALIZED);
+        rtassert!(RT_TLS_KEY != -1);
         tls::destroy(RT_TLS_KEY);
-        LOCK.destroy();
-        INITIALIZED = false;
     }
 
     /// Give a pointer to thread-local storage.