---

yaml
---
r: 97277
b: refs/heads/dist-snap
c: 8f26d0b
h: refs/heads/master
i:
  97275: a9bb881
v: v3

Author: huonw

[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: 2897549d513ad6fa83a4eaee468e691a84d32055
+refs/heads/dist-snap: 8f26d0b9b8725fa74dc36fcf4abf45dc1ca8c56a
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/driver/driver.rs

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

branches/dist-snap/src/etc/emacs/rust-mode.el

@@ -54,9 +54,7 @@
     ;; 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-word 1)
-	(backward-word 1))
+      (when (looking-at "[[:space:]]") (forward-to-word 1))
       (current-column))))
 
 (defun rust-mode-indent-line ()

branches/dist-snap/src/libnative/io/net.rs

@@ -205,14 +205,19 @@ pub fn init() {
     }
 
     unsafe {
-        use std::unstable::mutex::{Once, ONCE_INIT};
-        static mut INIT: Once = ONCE_INIT;
-        INIT.doit(|| {
+        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 {
             let mut data: WSADATA = intrinsics::init();
             let ret = WSAStartup(0x202,      // version 2.2
                                  &mut data);
             assert_eq!(ret, 0);
-        });
+            INITIALIZED = true;
+        }
+        LOCK.unlock();
     }
 }
 

branches/dist-snap/src/librustc/back/link.rs

@@ -34,7 +34,6 @@ 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;
@@ -310,8 +309,9 @@ pub mod write {
     }
 
     unsafe fn configure_llvm(sess: Session) {
-        use std::unstable::mutex::{Once, ONCE_INIT};
-        static mut INIT: Once = ONCE_INIT;
+        use std::unstable::mutex::{MUTEX_INIT, Mutex};
+        static mut LOCK: Mutex = MUTEX_INIT;
+        static mut CONFIGURED: bool = false;
 
         // Copy what clan does by turning on loop vectorization at O2 and
         // slp vectorization at O3
@@ -340,7 +340,8 @@ pub mod write {
             add(*arg);
         }
 
-        INIT.doit(|| {
+        LOCK.lock();
+        if !CONFIGURED {
             llvm::LLVMInitializePasses();
 
             // Only initialize the platforms supported by Rust here, because
@@ -367,7 +368,9 @@ 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,
@@ -491,10 +494,8 @@ pub fn build_link_meta(sess: Session,
     }
 }
 
-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()
+pub fn truncated_hash_result(symbol_hasher: &mut Sha256) -> ~str {
+    symbol_hasher.result_str()
 }
 
 
@@ -882,11 +883,8 @@ 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. 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);
+            // contain the metadata in a separate file.
+            let metadata = obj_filename.with_filename(METADATA_FILENAME);
             fs::File::create(&metadata).write(trans.metadata);
             a.add_file(&metadata, false);
             fs::unlink(&metadata);

branches/dist-snap/src/librustc/lib/llvm.rs

@@ -1459,16 +1459,15 @@ 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/dist-snap/src/librustc/metadata/encoder.rs

@@ -1140,7 +1140,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
             let impl_vtables = ty::lookup_impl_vtables(tcx, def_id);
             encode_impl_vtables(ebml_w, ecx, &impl_vtables);
         }
-        let elt = ast_map::impl_pretty_name(opt_trait, ty, item.ident);
+        let elt = ast_map::impl_pretty_name(opt_trait, ty);
         encode_path(ecx, ebml_w, path, elt);
         ebml_w.end_tag();
 

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

@@ -3189,21 +3189,8 @@ pub fn trans_crate(sess: session::Session,
                    analysis: &CrateAnalysis,
                    output: &Path) -> CrateTranslation {
     // Before we touch LLVM, make sure that multithreading is enabled.
-    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");
-        }
+    if unsafe { !llvm::LLVMRustStartMultithreading() } {
+        sess.bug("couldn't enable multi-threaded LLVM");
     }
 
     let mut symbol_hasher = Sha256::new();

branches/dist-snap/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/plugins");
+    let path = matches.opt_str("plugin-path").unwrap_or(~"/tmp/rustdoc_ng/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/dist-snap/src/libstd/path/posix.rs

@@ -1404,45 +1404,4 @@ 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/dist-snap/src/libstd/rt/local_ptr.rs

@@ -160,20 +160,30 @@ 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 {
-            tls::create(&mut RT_TLS_KEY);
+            LOCK.lock();
+            if !INITIALIZED {
+                tls::create(&mut RT_TLS_KEY);
+                INITIALIZED = true;
+            }
+            LOCK.unlock();
         }
     }
 
     pub unsafe fn cleanup() {
-        rtassert!(RT_TLS_KEY != -1);
+        rtassert!(INITIALIZED);
         tls::destroy(RT_TLS_KEY);
+        LOCK.destroy();
+        INITIALIZED = false;
     }
 
     /// Give a pointer to thread-local storage.