---

yaml
---
r: 102386
b: refs/heads/master
c: 1938e87
h: refs/heads/master
v: v3

Author: michaelwoerister

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 2fba2fea121b616793287f33aa3ee05e8d8893b0
+refs/heads/master: 1938e87393929ab33928210d55bff4bc2d73f6c2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
 refs/heads/try: a97642026c18a624ff6ea01075dd9550f8ed07ff

trunk/man/rustc.1

@@ -1,4 +1,4 @@
-.TH RUSTC "1" "March 2014" "rustc 0.10-pre" "User Commands"
+.TH RUSTC "1" "July 2013" "rustc 0.7" "User Commands"
 .SH NAME
 rustc \- rust compiler
 .SH SYNOPSIS

trunk/man/rustdoc.1

@@ -1,4 +1,4 @@
-.TH RUSTDOC "1" "March 2014" "rustdoc 0.10-pre" "User Commands"
+.TH RUSTDOC "1" "July 2013" "rustdoc 0.7" "User Commands"
 .SH NAME
 rustdoc \- generate documentation from Rust source code
 .SH SYNOPSIS

trunk/src/libextra/stats.rs

@@ -10,6 +10,7 @@
 
 #[allow(missing_doc)];
 
+use std::cmp;
 use std::hash::Hash;
 use std::io;
 use std::mem;
@@ -202,12 +203,12 @@ impl<'a> Stats for &'a [f64] {
 
     fn min(self) -> f64 {
         assert!(self.len() != 0);
-        self.iter().fold(self[0], |p, q| p.min(*q))
+        self.iter().fold(self[0], |p,q| cmp::min(p, *q))
     }
 
     fn max(self) -> f64 {
         assert!(self.len() != 0);
-        self.iter().fold(self[0], |p, q| p.max(*q))
+        self.iter().fold(self[0], |p,q| cmp::max(p, *q))
     }
 
     fn mean(self) -> f64 {
@@ -441,7 +442,6 @@ mod tests {
     use stats::write_boxplot;
     use std::io;
     use std::str;
-    use std::f64;
 
     macro_rules! assert_approx_eq(
         ($a:expr, $b:expr) => ({
@@ -481,14 +481,6 @@ mod tests {
         assert_eq!(summ.iqr, summ2.iqr);
     }
 
-    #[test]
-    fn test_min_max_nan() {
-        let xs = &[1.0, 2.0, f64::NAN, 3.0, 4.0];
-        let summary = Summary::new(xs);
-        assert_eq!(summary.min, 1.0);
-        assert_eq!(summary.max, 4.0);
-    }
-
     #[test]
     fn test_norm2() {
         let val = &[

trunk/src/libstd/rt/bookkeeping.rs renamed to trunk/src/libnative/bookkeeping.rs

@@ -8,21 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Task bookkeeping
+//! 1:1 Task bookkeeping
 //!
-//! This module keeps track of the number of running tasks so that entry points
-//! with libnative know when it's possible to exit the program (once all tasks
-//! have exited).
+//! This module keeps track of the number of running 1:1 tasks so that entry
+//! points with libnative know when it's possible to exit the program (once all
+//! tasks have exited).
 //!
-//! The green counterpart for this is bookkeeping on sched pools, and it's up to
-//! each respective runtime to make sure that they call increment() and
-//! decrement() manually.
+//! The green counterpart for this is bookkeeping on sched pools.
 
-#[experimental]; // this is a massive code smell
-#[doc(hidden)];
-
-use sync::atomics;
-use unstable::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
+use std::sync::atomics;
+use std::unstable::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
 
 static mut TASK_COUNT: atomics::AtomicUint = atomics::INIT_ATOMIC_UINT;
 static mut TASK_LOCK: StaticNativeMutex = NATIVE_MUTEX_INIT;
@@ -44,9 +39,12 @@ pub fn decrement() {
 /// the entry points of native programs
 pub fn wait_for_other_tasks() {
     unsafe {
-        let mut guard = TASK_LOCK.lock();
-        while TASK_COUNT.load(atomics::SeqCst) > 0 {
-            guard.wait();
+        {
+            let mut guard = TASK_LOCK.lock();
+            while TASK_COUNT.load(atomics::SeqCst) > 0 {
+                guard.wait();
+            }
         }
+        TASK_LOCK.destroy();
     }
 }

trunk/src/libnative/io/file_unix.rs

@@ -19,7 +19,6 @@ use std::libc;
 use std::mem;
 use std::rt::rtio;
 use std::vec;
-use std::vec_ng::Vec;
 
 use io::{IoResult, retry, keep_going};
 
@@ -342,7 +341,7 @@ pub fn mkdir(p: &CString, mode: io::FilePermission) -> IoResult<()> {
 
 pub fn readdir(p: &CString) -> IoResult<~[Path]> {
     use std::libc::{dirent_t};
-    use std::libc::{opendir, readdir_r, closedir};
+    use std::libc::{opendir, readdir, closedir};
 
     fn prune(root: &CString, dirs: ~[Path]) -> ~[Path] {
         let root = unsafe { CString::new(root.with_ref(|p| p), false) };
@@ -354,28 +353,23 @@ pub fn readdir(p: &CString) -> IoResult<~[Path]> {
     }
 
     extern {
-        fn rust_dirent_t_size() -> libc::c_int;
-        fn rust_list_dir_val(ptr: *mut dirent_t) -> *libc::c_char;
+        fn rust_list_dir_val(ptr: *dirent_t) -> *libc::c_char;
     }
 
-    let size = unsafe { rust_dirent_t_size() };
-    let mut buf = Vec::<u8>::with_capacity(size as uint);
-    let ptr = buf.as_mut_slice().as_mut_ptr() as *mut dirent_t;
-
     debug!("os::list_dir -- BEFORE OPENDIR");
 
     let dir_ptr = p.with_ref(|buf| unsafe { opendir(buf) });
 
     if dir_ptr as uint != 0 {
         let mut paths = ~[];
         debug!("os::list_dir -- opendir() SUCCESS");
-        let mut entry_ptr = 0 as *mut dirent_t;
-        while unsafe { readdir_r(dir_ptr, ptr, &mut entry_ptr) == 0 } {
-            if entry_ptr.is_null() { break }
+        let mut entry_ptr = unsafe { readdir(dir_ptr) };
+        while entry_ptr as uint != 0 {
             let cstr = unsafe {
                 CString::new(rust_list_dir_val(entry_ptr), false)
             };
             paths.push(Path::new(cstr));
+            entry_ptr = unsafe { readdir(dir_ptr) };
         }
         assert_eq!(unsafe { closedir(dir_ptr) }, 0);
         Ok(prune(p, paths))

trunk/src/libnative/io/timer_helper.rs

@@ -21,10 +21,10 @@
 //! time.
 
 use std::cast;
-use std::rt::bookkeeping;
 use std::rt;
 use std::unstable::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
 
+use bookkeeping;
 use io::timer::{Req, Shutdown};
 use task;
 
@@ -36,8 +36,6 @@ use task;
 static mut HELPER_CHAN: *mut Chan<Req> = 0 as *mut Chan<Req>;
 static mut HELPER_SIGNAL: imp::signal = 0 as imp::signal;
 
-static mut TIMER_HELPER_EXIT: StaticNativeMutex = NATIVE_MUTEX_INIT;
-
 pub fn boot(helper: fn(imp::signal, Port<Req>)) {
     static mut LOCK: StaticNativeMutex = NATIVE_MUTEX_INIT;
     static mut INITIALIZED: bool = false;
@@ -55,7 +53,6 @@ pub fn boot(helper: fn(imp::signal, Port<Req>)) {
             task::spawn(proc() {
                 bookkeeping::decrement();
                 helper(receive, msgp);
-                TIMER_HELPER_EXIT.lock().signal()
             });
 
             rt::at_exit(proc() { shutdown() });
@@ -73,15 +70,17 @@ pub fn send(req: Req) {
 }
 
 fn shutdown() {
-    // Request a shutdown, and then wait for the task to exit
-    unsafe {
-        let mut guard = TIMER_HELPER_EXIT.lock();
-        send(Shutdown);
-        guard.wait();
-        drop(guard);
-        TIMER_HELPER_EXIT.destroy();
-    }
+    // We want to wait for the entire helper task to exit, and in doing so it
+    // will attempt to decrement the global task count. When the helper was
+    // created, it decremented the count so it wouldn't count towards preventing
+    // the program to exit, so here we pair that manual decrement with a manual
+    // increment. We will then wait for the helper thread to exit by calling
+    // wait_for_other_tasks.
+    bookkeeping::increment();
 
+    // Request a shutdown, and then wait for the task to exit
+    send(Shutdown);
+    bookkeeping::wait_for_other_tasks();
 
     // Clean up after ther helper thread
     unsafe {

trunk/src/libnative/io/timer_other.rs

@@ -218,15 +218,8 @@ impl Timer {
     }
 
     pub fn sleep(ms: u64) {
-        let mut to_sleep = libc::timespec {
-            tv_sec: (ms / 1000) as libc::time_t,
-            tv_nsec: ((ms % 1000) * 1000000) as libc::c_long,
-        };
-        while unsafe { libc::nanosleep(&to_sleep, &mut to_sleep) } != 0 {
-            if os::errno() as int != libc::EINTR as int {
-                fail!("failed to sleep, but not because of EINTR?");
-            }
-        }
+        // FIXME: this can fail because of EINTR, what do do?
+        let _ = unsafe { libc::usleep((ms * 1000) as libc::c_uint) };
     }
 
     fn inner(&mut self) -> ~Inner {

trunk/src/libnative/io/timer_timerfd.rs

@@ -23,8 +23,8 @@
 //! why).
 //!
 //! As with timer_other, timers just using sleep() do not use the timerfd at
-//! all. They remove the timerfd from the worker thread and then invoke
-//! nanosleep() to block the calling thread.
+//! all. They remove the timerfd from the worker thread and then invoke usleep()
+//! to block the calling thread.
 //!
 //! As with timer_other, all units in this file are in units of millseconds.
 
@@ -183,15 +183,8 @@ impl Timer {
     }
 
     pub fn sleep(ms: u64) {
-        let mut to_sleep = libc::timespec {
-            tv_sec: (ms / 1000) as libc::time_t,
-            tv_nsec: ((ms % 1000) * 1000000) as libc::c_long,
-        };
-        while unsafe { libc::nanosleep(&to_sleep, &mut to_sleep) } != 0 {
-            if os::errno() as int != libc::EINTR as int {
-                fail!("failed to sleep, but not because of EINTR?");
-            }
-        }
+        // FIXME: this can fail because of EINTR, what do do?
+        let _ = unsafe { libc::usleep((ms * 1000) as libc::c_uint) };
     }
 
     fn remove(&mut self) {

trunk/src/libnative/lib.rs

@@ -58,6 +58,7 @@
 use std::os;
 use std::rt;
 
+mod bookkeeping;
 pub mod io;
 pub mod task;
 
@@ -104,5 +105,6 @@ pub fn start(argc: int, argv: **u8, main: proc()) -> int {
 /// number of arguments.
 pub fn run(main: proc()) -> int {
     main();
+    bookkeeping::wait_for_other_tasks();
     os::get_exit_status()
 }

trunk/src/libnative/task.rs

@@ -16,19 +16,19 @@
 
 use std::any::Any;
 use std::cast;
-use std::rt::bookkeeping;
 use std::rt::env;
 use std::rt::local::Local;
 use std::rt::rtio;
-use std::rt::stack;
 use std::rt::task::{Task, BlockedTask, SendMessage};
 use std::rt::thread::Thread;
 use std::rt;
 use std::task::TaskOpts;
 use std::unstable::mutex::NativeMutex;
+use std::rt::stack;
 
 use io;
 use task;
+use bookkeeping;
 
 /// Creates a new Task which is ready to execute as a 1:1 task.
 pub fn new(stack_bounds: (uint, uint)) -> ~Task {

trunk/src/librustc/back/link.rs

@@ -12,7 +12,7 @@ use back::archive::{Archive, METADATA_FILENAME};
 use back::rpath;
 use back::svh::Svh;
 use driver::driver::{CrateTranslation, OutputFilenames};
-use driver::session::Session;
+use driver::session::{NoDebugInfo, Session};
 use driver::session;
 use lib::llvm::llvm;
 use lib::llvm::ModuleRef;
@@ -92,7 +92,7 @@ pub mod write {
     use back::link::{OutputTypeExe, OutputTypeLlvmAssembly};
     use back::link::{OutputTypeObject};
     use driver::driver::{CrateTranslation, OutputFilenames};
-    use driver::session::Session;
+    use driver::session::{NoDebugInfo, Session};
     use driver::session;
     use lib::llvm::llvm;
     use lib::llvm::{ModuleRef, TargetMachineRef, PassManagerRef};
@@ -148,7 +148,7 @@ pub mod write {
 
             // FIXME: #11906: Omitting frame pointers breaks retrieving the value of a parameter.
             // FIXME: #11954: mac64 unwinding may not work with fp elim
-            let no_fp_elim = sess.opts.debuginfo ||
+            let no_fp_elim = (sess.opts.debuginfo != NoDebugInfo) ||
                              (sess.targ_cfg.os == abi::OsMacos &&
                               sess.targ_cfg.arch == abi::X86_64);
 
@@ -1052,7 +1052,7 @@ fn link_natively(sess: Session, dylib: bool, obj_filename: &Path,
 
     // On OSX, debuggers need this utility to get run to do some munging of
     // the symbols
-    if sess.targ_cfg.os == abi::OsMacos && sess.opts.debuginfo {
+    if sess.targ_cfg.os == abi::OsMacos && (sess.opts.debuginfo != NoDebugInfo) {
         // FIXME (#9639): This needs to handle non-utf8 paths
         match Process::status("dsymutil",
                                   [out_filename.as_str().unwrap().to_owned()]) {

trunk/src/librustc/driver/driver.rs

@@ -11,7 +11,7 @@
 
 use back::link;
 use back::{arm, x86, x86_64, mips};
-use driver::session::{Aggressive, CrateTypeExecutable};
+use driver::session::{Aggressive, CrateTypeExecutable, FullDebugInfo, NoDebugInfo};
 use driver::session::{Session, Session_, No, Less, Default};
 use driver::session;
 use front;
@@ -865,7 +865,11 @@ pub fn build_session_options(matches: &getopts::Matches)
         } else { No }
     };
     let gc = debugging_opts & session::GC != 0;
-    let debuginfo = matches.opt_present("g") || matches.opt_present("debuginfo");
+    let debuginfo = if matches.opt_present("g") || matches.opt_present("debuginfo") {
+        FullDebugInfo
+    } else {
+        NoDebugInfo
+    };
 
     let addl_lib_search_paths = matches.opt_strs("L").map(|s| {
         Path::new(s.as_slice())

trunk/src/librustc/driver/session.rs

@@ -114,6 +114,13 @@ pub enum OptLevel {
     Aggressive // -O3
 }
 
+#[deriving(Clone, Eq)]
+pub enum DebugInfoLevel {
+    NoDebugInfo,
+    LimitedDebugInfo,
+    FullDebugInfo,
+}
+
 #[deriving(Clone)]
 pub struct Options {
     // The crate config requested for the session, which may be combined
@@ -122,7 +129,7 @@ pub struct Options {
 
     gc: bool,
     optimize: OptLevel,
-    debuginfo: bool,
+    debuginfo: DebugInfoLevel,
     lint_opts: ~[(lint::Lint, lint::level)],
     output_types: ~[back::link::OutputType],
     // This was mutable for rustpkg, which updates search paths based on the
@@ -314,7 +321,7 @@ pub fn basic_options() -> @Options {
         crate_types: ~[],
         gc: false,
         optimize: No,
-        debuginfo: false,
+        debuginfo: NoDebugInfo,
         lint_opts: ~[],
         output_types: ~[],
         addl_lib_search_paths: @RefCell::new(HashSet::new()),