Remove the C++ lock_and_signal type

A the same time this purges all runtime support needed for statically
initialized mutexes, moving all users over to the new Mutex type instead.

Author: alexcrichton

mk/rt.mk

@@ -90,7 +90,6 @@ endif
 endif
 
 RUNTIME_CXXS_$(1)_$(2) := \
-              rt/sync/lock_and_signal.cpp \
               rt/rust_builtin.cpp \
               rt/rust_upcall.cpp \
               rt/miniz.cpp \

src/libstd/os.rs

@@ -138,21 +138,19 @@ Accessing environment variables is not generally threadsafe.
 Serialize access through a global lock.
 */
 fn with_env_lock<T>(f: &fn() -> T) -> T {
+    use unstable::mutex::{Mutex, MUTEX_INIT};
     use unstable::finally::Finally;
 
+    static mut lock: Mutex = MUTEX_INIT;
+
     unsafe {
         return do (|| {
-            rust_take_env_lock();
+            lock.lock();
             f()
         }).finally {
-            rust_drop_env_lock();
+            lock.unlock();
         };
     }
-
-    extern {
-        fn rust_take_env_lock();
-        fn rust_drop_env_lock();
-    }
 }
 
 /// Returns a vector of (variable, value) pairs for all the environment

src/libstd/rt/args.rs

@@ -21,32 +21,42 @@
 //! FIXME #7756: This has a lot of C glue for lack of globals.
 
 use option::Option;
+#[cfg(test)] use option::{Some, None};
+#[cfg(test)] use realstd;
+#[cfg(test)] use realargs = realstd::rt::args;
 
 /// One-time global initialization.
-pub unsafe fn init(argc: int, argv: **u8) {
-    imp::init(argc, argv)
-}
+#[cfg(not(test))]
+pub unsafe fn init(argc: int, argv: **u8) { imp::init(argc, argv) }
+#[cfg(test)]
+pub unsafe fn init(argc: int, argv: **u8) { realargs::init(argc, argv) }
 
 /// One-time global cleanup.
-pub fn cleanup() {
-    imp::cleanup()
-}
+#[cfg(not(test))] pub fn cleanup() { imp::cleanup() }
+#[cfg(test)]      pub fn cleanup() { realargs::cleanup() }
 
 /// Take the global arguments from global storage.
-pub fn take() -> Option<~[~str]> {
-    imp::take()
+#[cfg(not(test))] pub fn take() -> Option<~[~str]> { imp::take() }
+#[cfg(test)]      pub fn take() -> Option<~[~str]> {
+    match realargs::take() {
+        realstd::option::Some(a) => Some(a),
+        realstd::option::None => None,
+    }
 }
 
 /// Give the global arguments to global storage.
 ///
 /// It is an error if the arguments already exist.
-pub fn put(args: ~[~str]) {
-    imp::put(args)
-}
+#[cfg(not(test))] pub fn put(args: ~[~str]) { imp::put(args) }
+#[cfg(test)]      pub fn put(args: ~[~str]) { realargs::put(args) }
 
 /// Make a clone of the global arguments.
-pub fn clone() -> Option<~[~str]> {
-    imp::clone()
+#[cfg(not(test))] pub fn clone() -> Option<~[~str]> { imp::clone() }
+#[cfg(test)]      pub fn clone() -> Option<~[~str]> {
+    match realargs::clone() {
+        realstd::option::Some(a) => Some(a),
+        realstd::option::None => None,
+    }
 }
 
 #[cfg(target_os = "linux")]
@@ -58,9 +68,12 @@ mod imp {
     use iter::Iterator;
     use str;
     use unstable::finally::Finally;
+    use unstable::mutex::{Mutex, MUTEX_INIT};
     use util;
     use vec;
 
+    static mut global_args_ptr: uint = 0;
+
     pub unsafe fn init(argc: int, argv: **u8) {
         let args = load_argc_and_argv(argc, argv);
         put(args);
@@ -94,20 +107,22 @@ mod imp {
     }
 
     fn with_lock<T>(f: &fn() -> T) -> T {
+        static mut lock: Mutex = MUTEX_INIT;
+
         do (|| {
             unsafe {
-                rust_take_global_args_lock();
+                lock.lock();
                 f()
             }
         }).finally {
             unsafe {
-                rust_drop_global_args_lock();
+                lock.unlock();
             }
         }
     }
 
     fn get_global_ptr() -> *mut Option<~~[~str]> {
-        unsafe { rust_get_global_args_ptr() }
+        unsafe { cast::transmute(&global_args_ptr) }
     }
 
     // Copied from `os`.
@@ -117,12 +132,6 @@ mod imp {
         }
     }
 
-    extern {
-        fn rust_take_global_args_lock();
-        fn rust_drop_global_args_lock();
-        fn rust_get_global_args_ptr() -> *mut Option<~~[~str]>;
-    }
-
     #[cfg(test)]
     mod tests {
         use option::{Some, None};

src/libstd/rt/local_ptr.rs

@@ -21,17 +21,23 @@ use ptr;
 use cell::Cell;
 use option::{Option, Some, None};
 use unstable::finally::Finally;
+use unstable::mutex::{Mutex, MUTEX_INIT};
 use tls = rt::thread_local_storage;
 
 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_tls_key() {
+    static mut lock: Mutex = MUTEX_INIT;
+    static mut initialized: bool = false;
+
     unsafe {
-        rust_initialize_rt_tls_key(&mut RT_TLS_KEY);
-        extern {
-            fn rust_initialize_rt_tls_key(key: *mut tls::Key);
+        lock.lock();
+        if !initialized {
+            tls::create(&mut RT_TLS_KEY);
+            initialized = true;
         }
+        lock.unlock();
     }
 }
 

src/libstd/rt/test.rs

@@ -14,7 +14,6 @@ use cell::Cell;
 use clone::Clone;
 use container::Container;
 use iter::{Iterator, range};
-use libc;
 use option::{Some, None};
 use os;
 use path::GenericPath;
@@ -361,11 +360,16 @@ pub fn cleanup_task(mut task: ~Task) {
 
 /// Get a port number, starting at 9600, for use in tests
 pub fn next_test_port() -> u16 {
+    use unstable::mutex::{Mutex, MUTEX_INIT};
+    static mut lock: Mutex = MUTEX_INIT;
+    static mut next_offset: u16 = 0;
     unsafe {
-        return rust_dbg_next_port(base_port() as libc::uintptr_t) as u16;
-    }
-    extern {
-        fn rust_dbg_next_port(base: libc::uintptr_t) -> libc::uintptr_t;
+        let base = base_port();
+        lock.lock();
+        let ret = base + next_offset;
+        next_offset += 1;
+        lock.unlock();
+        return ret;
     }
 }
 
@@ -395,13 +399,13 @@ The bots run multiple builds at the same time, and these builds
 all want to use ports. This function figures out which workspace
 it is running in and assigns a port range based on it.
 */
-fn base_port() -> uint {
+fn base_port() -> u16 {
     use os;
     use str::StrSlice;
     use vec::ImmutableVector;
 
-    let base = 9600u;
-    let range = 1000;
+    let base = 9600u16;
+    let range = 1000u16;
 
     let bases = [
         ("32-opt", base + range * 1),

src/libstd/task/mod.rs

@@ -1141,22 +1141,10 @@ fn test_spawn_sched_childs_on_default_sched() {
     po.recv();
 }
 
-#[cfg(test)]
-mod testrt {
-    use libc;
-
-    extern {
-        pub fn rust_dbg_lock_create() -> *libc::c_void;
-        pub fn rust_dbg_lock_destroy(lock: *libc::c_void);
-        pub fn rust_dbg_lock_lock(lock: *libc::c_void);
-        pub fn rust_dbg_lock_unlock(lock: *libc::c_void);
-        pub fn rust_dbg_lock_wait(lock: *libc::c_void);
-        pub fn rust_dbg_lock_signal(lock: *libc::c_void);
-    }
-}
-
 #[test]
 fn test_spawn_sched_blocking() {
+    use unstable::mutex::Mutex;
+
     unsafe {
 
         // Testing that a task in one scheduler can block in foreign code
@@ -1165,16 +1153,18 @@ fn test_spawn_sched_blocking() {
             let (start_po, start_ch) = stream();
             let (fin_po, fin_ch) = stream();
 
-            let lock = testrt::rust_dbg_lock_create();
+            let mut lock = Mutex::new();
+            let lock2 = Cell::new(lock.clone());
 
             do spawn_sched(SingleThreaded) {
-                testrt::rust_dbg_lock_lock(lock);
+                let mut lock = lock2.take();
+                lock.lock();
 
                 start_ch.send(());
 
                 // Block the scheduler thread
-                testrt::rust_dbg_lock_wait(lock);
-                testrt::rust_dbg_lock_unlock(lock);
+                lock.wait();
+                lock.unlock();
 
                 fin_ch.send(());
             };
@@ -1201,11 +1191,11 @@ fn test_spawn_sched_blocking() {
             let child_ch = setup_po.recv();
             child_ch.send(20);
             pingpong(&parent_po, &child_ch);
-            testrt::rust_dbg_lock_lock(lock);
-            testrt::rust_dbg_lock_signal(lock);
-            testrt::rust_dbg_lock_unlock(lock);
+            lock.lock();
+            lock.signal();
+            lock.unlock();
             fin_po.recv();
-            testrt::rust_dbg_lock_destroy(lock);
+            lock.destroy();
         }
     }
 }

src/libstd/unstable/dynamic_lib.rs

@@ -154,14 +154,17 @@ pub mod dl {
     }
 
     pub fn check_for_errors_in<T>(f: &fn()->T) -> Result<T, ~str> {
+        use unstable::mutex::{Mutex, MUTEX_INIT};
+        static mut lock: Mutex = MUTEX_INIT;
+
         unsafe {
             // dlerror isn't thread safe, so we need to lock around this entire
             // sequence. `atomically` asserts that we don't do anything that
             // would cause this task to be descheduled, which could deadlock
             // the scheduler if it happens while the lock is held.
             // FIXME #9105 use a Rust mutex instead of C++ mutexes.
             do atomically {
-                rust_take_dlerror_lock();
+                lock.lock();
                 let _old_error = dlerror();
 
                 let result = f();
@@ -172,7 +175,7 @@ pub mod dl {
                 } else {
                     Err(str::raw::from_c_str(last_error))
                 };
-                rust_drop_dlerror_lock();
+                lock.unlock();
                 ret
             }
         }
@@ -192,11 +195,6 @@ pub mod dl {
         Local = 0,
     }
 
-    extern {
-        fn rust_take_dlerror_lock();
-        fn rust_drop_dlerror_lock();
-    }
-
     #[link_name = "dl"]
     extern {
         fn dlopen(filename: *libc::c_char, flag: libc::c_int) -> *libc::c_void;