---

yaml
---
r: 114576
b: refs/heads/master
c: 3b56724
h: refs/heads/master
v: v3

Author: luqmana

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: cb3c4f9c8293cf792bff887ff170f8c774ac8457
+refs/heads/master: 3b56724c217612b4adc64a59dca9b1fd8cff081d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ec0258a381b88b5574e3f8ce72ae553ac3a574b7
 refs/heads/try: 7c6c492fb2af9a85f21ff952942df3523b22fd17

trunk/configure

@@ -406,7 +406,7 @@ opt optimize 1 "build optimized rust code"
 opt optimize-cxx 1 "build optimized C++ code"
 opt optimize-llvm 1 "build optimized LLVM"
 opt optimize-tests 1 "build tests with optimizations"
-opt libcpp 1 "build with clang's libcpp"
+opt libcpp 1 "build with llvm with libc++ instead of libstdc++ when using clang"
 opt llvm-assertions 1 "build LLVM with assertions"
 opt debug 1 "build with extra debug fun"
 opt ratchet-bench 0 "ratchet benchmarks"
@@ -1136,7 +1136,7 @@ do
         CXXFLAGS=$LLVM_CXXFLAGS
         LDFLAGS=$LLVM_LDFLAGS
 
-        if [ "$CFG_DISABLE_LIBCPP" != 1 ]; then
+        if [ "$CFG_DISABLE_LIBCPP" != 1 ] && [ "$CFG_USING_CLANG" == 1 ]; then
             LLVM_OPTS="$LLVM_OPTS --enable-libcpp"
         fi
 

trunk/mk/docs.mk

@@ -287,7 +287,6 @@ $(foreach crate,$(COMPILER_DOC_CRATES),$(eval $(call DEF_LIB_DOC,$(crate),COMPIL
 ifdef CFG_DISABLE_DOCS
   $(info cfg: disabling doc build (CFG_DISABLE_DOCS))
   DOC_TARGETS :=
-  COMPILER_DOC_TARGETS :=
 endif
 
 docs: $(DOC_TARGETS)

trunk/src/doc/rust.md

@@ -1435,7 +1435,7 @@ trait Circle : Shape { fn radius() -> f64; }
 ~~~~
 
 the syntax `Circle : Shape` means that types that implement `Circle` must also have an implementation for `Shape`.
-Multiple supertraits are separated by `+`, `trait Circle : Shape + Eq { }`.
+Multiple supertraits are separated by spaces, `trait Circle : Shape Eq { }`.
 In an implementation of `Circle` for a given type `T`, methods can refer to `Shape` methods,
 since the typechecker checks that any type with an implementation of `Circle` also has an implementation of `Shape`.
 

trunk/src/libcore/failure.rs

@@ -28,25 +28,13 @@
 
 #![allow(dead_code, missing_doc)]
 
-use fmt;
-use intrinsics;
-#[cfg(not(test), stage0)]
+#[cfg(not(test))]
 use str::raw::c_str_to_static_slice;
+use fmt;
 
 #[cold] #[inline(never)] // this is the slow path, always
 #[lang="fail_"]
-#[cfg(not(test), not(stage0))]
-fn fail_(expr: &'static str, file: &'static str, line: uint) -> ! {
-    format_args!(|args| -> () {
-        begin_unwind(args, file, line);
-    }, "{}", expr);
-
-    unsafe { intrinsics::abort() }
-}
-
-#[cold] #[inline(never)] // this is the slow path, always
-#[lang="fail_"]
-#[cfg(not(test), stage0)]
+#[cfg(not(test))]
 fn fail_(expr: *u8, file: *u8, line: uint) -> ! {
     unsafe {
         let expr = c_str_to_static_slice(expr as *i8);
@@ -55,30 +43,19 @@ fn fail_(expr: *u8, file: *u8, line: uint) -> ! {
             begin_unwind(args, file, line);
         }, "{}", expr);
 
-        intrinsics::abort()
+        loop {}
     }
 }
 
 #[cold]
 #[lang="fail_bounds_check"]
-#[cfg(not(test), not(stage0))]
-fn fail_bounds_check(file: &'static str, line: uint,
-                     index: uint, len: uint) -> ! {
-    format_args!(|args| -> () {
-        begin_unwind(args, file, line);
-    }, "index out of bounds: the len is {} but the index is {}", len, index);
-    unsafe { intrinsics::abort() }
-}
-
-#[cold]
-#[lang="fail_bounds_check"]
-#[cfg(not(test), stage0)]
+#[cfg(not(test))]
 fn fail_bounds_check(file: *u8, line: uint, index: uint, len: uint) -> ! {
     let file = unsafe { c_str_to_static_slice(file as *i8) };
     format_args!(|args| -> () {
         begin_unwind(args, file, line);
     }, "index out of bounds: the len is {} but the index is {}", len, index);
-    unsafe { intrinsics::abort() }
+    loop {}
 }
 
 #[cold]

trunk/src/liblibc/lib.rs

@@ -235,7 +235,6 @@ pub use funcs::bsd43::{shutdown};
 #[cfg(windows)] pub use types::os::arch::extra::{LARGE_INTEGER, LPVOID, LONG};
 #[cfg(windows)] pub use types::os::arch::extra::{time64_t, OVERLAPPED, LPCWSTR};
 #[cfg(windows)] pub use types::os::arch::extra::{LPOVERLAPPED, SIZE_T, LPDWORD};
-#[cfg(windows)] pub use types::os::arch::extra::{SECURITY_ATTRIBUTES};
 #[cfg(windows)] pub use funcs::c95::string::{wcslen};
 #[cfg(windows)] pub use funcs::posix88::stat_::{wstat, wutime, wchmod, wrmdir};
 #[cfg(windows)] pub use funcs::bsd43::{closesocket};
@@ -1141,12 +1140,8 @@ pub mod types {
                 pub type LPWCH = *mut WCHAR;
                 pub type LPCH = *mut CHAR;
 
-                pub struct SECURITY_ATTRIBUTES {
-                    pub nLength: DWORD,
-                    pub lpSecurityDescriptor: LPVOID,
-                    pub bInheritHandle: BOOL,
-                }
-                pub type LPSECURITY_ATTRIBUTES = *mut SECURITY_ATTRIBUTES;
+                // Not really, but opaque to us.
+                pub type LPSECURITY_ATTRIBUTES = LPVOID;
 
                 pub type LPVOID = *mut c_void;
                 pub type LPCVOID = *c_void;

trunk/src/libnative/io/process.rs

@@ -244,8 +244,7 @@ struct SpawnProcessResult {
 }
 
 #[cfg(windows)]
-fn spawn_process_os(cfg: ProcessConfig,
-                    in_fd: c_int, out_fd: c_int, err_fd: c_int)
+fn spawn_process_os(cfg: ProcessConfig, in_fd: c_int, out_fd: c_int, err_fd: c_int)
                  -> IoResult<SpawnProcessResult> {
     use libc::types::os::arch::extra::{DWORD, HANDLE, STARTUPINFO};
     use libc::consts::os::extra::{
@@ -279,51 +278,38 @@ fn spawn_process_os(cfg: ProcessConfig,
 
         let cur_proc = GetCurrentProcess();
 
-        // Similarly to unix, we don't actually leave holes for the stdio file
-        // descriptors, but rather open up /dev/null equivalents. These
-        // equivalents are drawn from libuv's windows process spawning.
-        let set_fd = |fd: c_int, slot: &mut HANDLE, is_stdin: bool| {
-            if fd == -1 {
-                let access = if is_stdin {
-                    libc::FILE_GENERIC_READ
-                } else {
-                    libc::FILE_GENERIC_WRITE | libc::FILE_READ_ATTRIBUTES
-                };
-                let size = mem::size_of::<libc::SECURITY_ATTRIBUTES>();
-                let mut sa = libc::SECURITY_ATTRIBUTES {
-                    nLength: size as libc::DWORD,
-                    lpSecurityDescriptor: ptr::mut_null(),
-                    bInheritHandle: 1,
-                };
-                *slot = os::win32::as_utf16_p("NUL", |filename| {
-                    libc::CreateFileW(filename,
-                                      access,
-                                      libc::FILE_SHARE_READ |
-                                          libc::FILE_SHARE_WRITE,
-                                      &mut sa,
-                                      libc::OPEN_EXISTING,
-                                      0,
-                                      ptr::mut_null())
-                });
-                if *slot == INVALID_HANDLE_VALUE as libc::HANDLE {
-                    return Err(super::last_error())
-                }
-            } else {
-                let orig = get_osfhandle(fd) as HANDLE;
-                if orig == INVALID_HANDLE_VALUE as HANDLE {
-                    return Err(super::last_error())
-                }
-                if DuplicateHandle(cur_proc, orig, cur_proc, slot,
-                                   0, TRUE, DUPLICATE_SAME_ACCESS) == FALSE {
-                    return Err(super::last_error())
-                }
+        if in_fd != -1 {
+            let orig_std_in = get_osfhandle(in_fd) as HANDLE;
+            if orig_std_in == INVALID_HANDLE_VALUE as HANDLE {
+                fail!("failure in get_osfhandle: {}", os::last_os_error());
+            }
+            if DuplicateHandle(cur_proc, orig_std_in, cur_proc, &mut si.hStdInput,
+                               0, TRUE, DUPLICATE_SAME_ACCESS) == FALSE {
+                fail!("failure in DuplicateHandle: {}", os::last_os_error());
+            }
+        }
+
+        if out_fd != -1 {
+            let orig_std_out = get_osfhandle(out_fd) as HANDLE;
+            if orig_std_out == INVALID_HANDLE_VALUE as HANDLE {
+                fail!("failure in get_osfhandle: {}", os::last_os_error());
+            }
+            if DuplicateHandle(cur_proc, orig_std_out, cur_proc, &mut si.hStdOutput,
+                               0, TRUE, DUPLICATE_SAME_ACCESS) == FALSE {
+                fail!("failure in DuplicateHandle: {}", os::last_os_error());
             }
-            Ok(())
-        };
+        }
 
-        try!(set_fd(in_fd, &mut si.hStdInput, true));
-        try!(set_fd(out_fd, &mut si.hStdOutput, false));
-        try!(set_fd(err_fd, &mut si.hStdError, false));
+        if err_fd != -1 {
+            let orig_std_err = get_osfhandle(err_fd) as HANDLE;
+            if orig_std_err == INVALID_HANDLE_VALUE as HANDLE {
+                fail!("failure in get_osfhandle: {}", os::last_os_error());
+            }
+            if DuplicateHandle(cur_proc, orig_std_err, cur_proc, &mut si.hStdError,
+                               0, TRUE, DUPLICATE_SAME_ACCESS) == FALSE {
+                fail!("failure in DuplicateHandle: {}", os::last_os_error());
+            }
+        }
 
         let cmd_str = make_command_line(cfg.program, cfg.args);
         let mut pi = zeroed_process_information();
@@ -352,9 +338,9 @@ fn spawn_process_os(cfg: ProcessConfig,
             })
         });
 
-        assert!(CloseHandle(si.hStdInput) != 0);
-        assert!(CloseHandle(si.hStdOutput) != 0);
-        assert!(CloseHandle(si.hStdError) != 0);
+        if in_fd != -1 { assert!(CloseHandle(si.hStdInput) != 0); }
+        if out_fd != -1 { assert!(CloseHandle(si.hStdOutput) != 0); }
+        if err_fd != -1 { assert!(CloseHandle(si.hStdError) != 0); }
 
         match create_err {
             Some(err) => return Err(err),
@@ -393,9 +379,9 @@ fn zeroed_startupinfo() -> libc::types::os::arch::extra::STARTUPINFO {
         wShowWindow: 0,
         cbReserved2: 0,
         lpReserved2: ptr::mut_null(),
-        hStdInput: libc::INVALID_HANDLE_VALUE as libc::HANDLE,
-        hStdOutput: libc::INVALID_HANDLE_VALUE as libc::HANDLE,
-        hStdError: libc::INVALID_HANDLE_VALUE as libc::HANDLE,
+        hStdInput: ptr::mut_null(),
+        hStdOutput: ptr::mut_null(),
+        hStdError: ptr::mut_null()
     }
 }
 
@@ -503,10 +489,6 @@ fn spawn_process_os(cfg: ProcessConfig, in_fd: c_int, out_fd: c_int, err_fd: c_i
             let mut input = file::FileDesc::new(pipe.input, true);
             let mut output = file::FileDesc::new(pipe.out, true);
 
-            // We may use this in the child, so perform allocations before the
-            // fork
-            let devnull = "/dev/null".to_c_str();
-
             set_cloexec(output.fd());
 
             let pid = fork();
@@ -581,29 +563,21 @@ fn spawn_process_os(cfg: ProcessConfig, in_fd: c_int, out_fd: c_int, err_fd: c_i
 
             rustrt::rust_unset_sigprocmask();
 
-            // If a stdio file descriptor is set to be ignored (via a -1 file
-            // descriptor), then we don't actually close it, but rather open
-            // up /dev/null into that file descriptor. Otherwise, the first file
-            // descriptor opened up in the child would be numbered as one of the
-            // stdio file descriptors, which is likely to wreak havoc.
-            let setup = |src: c_int, dst: c_int| {
-                let src = if src == -1 {
-                    let flags = if dst == libc::STDIN_FILENO {
-                        libc::O_RDONLY
-                    } else {
-                        libc::O_RDWR
-                    };
-                    devnull.with_ref(|p| libc::open(p, flags, 0))
-                } else {
-                    src
-                };
-                src != -1 && retry(|| dup2(src, dst)) != -1
-            };
-
-            if !setup(in_fd, libc::STDIN_FILENO) { fail(&mut output) }
-            if !setup(out_fd, libc::STDOUT_FILENO) { fail(&mut output) }
-            if !setup(err_fd, libc::STDERR_FILENO) { fail(&mut output) }
-
+            if in_fd == -1 {
+                let _ = libc::close(libc::STDIN_FILENO);
+            } else if retry(|| dup2(in_fd, 0)) == -1 {
+                fail(&mut output);
+            }
+            if out_fd == -1 {
+                let _ = libc::close(libc::STDOUT_FILENO);
+            } else if retry(|| dup2(out_fd, 1)) == -1 {
+                fail(&mut output);
+            }
+            if err_fd == -1 {
+                let _ = libc::close(libc::STDERR_FILENO);
+            } else if retry(|| dup2(err_fd, 2)) == -1 {
+                fail(&mut output);
+            }
             // close all other fds
             for fd in range(3, getdtablesize()).rev() {
                 if fd != output.fd() {

trunk/src/librustc/back/link.rs

@@ -1019,8 +1019,6 @@ fn link_staticlib(sess: &Session, obj_filename: &Path, out_filename: &Path) {
     a.add_native_library("compiler-rt").unwrap();
 
     let crates = sess.cstore.get_used_crates(cstore::RequireStatic);
-    let mut all_native_libs = vec![];
-
     for &(cnum, ref path) in crates.iter() {
         let name = sess.cstore.get_crate_data(cnum).name.clone();
         let p = match *path {
@@ -1031,25 +1029,17 @@ fn link_staticlib(sess: &Session, obj_filename: &Path, out_filename: &Path) {
             }
         };
         a.add_rlib(&p, name.as_slice(), sess.lto()).unwrap();
-
         let native_libs = csearch::get_native_libraries(&sess.cstore, cnum);
-        all_native_libs.extend(native_libs.move_iter());
-    }
-
-    if !all_native_libs.is_empty() {
-        sess.warn("link against the following native artifacts when linking against \
-                  this static library");
-        sess.note("the order and any duplication can be significant on some platforms, \
-                  and so may need to be preserved");
-    }
-
-    for &(kind, ref lib) in all_native_libs.iter() {
-        let name = match kind {
-            cstore::NativeStatic => "static library",
-            cstore::NativeUnknown => "library",
-            cstore::NativeFramework => "framework",
-        };
-        sess.note(format!("{}: {}", name, *lib).as_slice());
+        for &(kind, ref lib) in native_libs.iter() {
+            let name = match kind {
+                cstore::NativeStatic => "static library",
+                cstore::NativeUnknown => "library",
+                cstore::NativeFramework => "framework",
+            };
+            sess.warn(format!("unlinked native {}: {}",
+                              name,
+                              *lib).as_slice());
+        }
     }
 }
 

trunk/src/librustc/middle/trans/common.rs

@@ -596,8 +596,7 @@ pub fn C_cstr(cx: &CrateContext, s: InternedString, null_terminated: bool) -> Va
 pub fn C_str_slice(cx: &CrateContext, s: InternedString) -> ValueRef {
     unsafe {
         let len = s.get().len();
-        let cs = llvm::LLVMConstPointerCast(C_cstr(cx, s, false),
-                                            Type::i8p(cx).to_ref());
+        let cs = llvm::LLVMConstPointerCast(C_cstr(cx, s, false), Type::i8p(cx).to_ref());
         C_struct(cx, [cs, C_uint(cx, len)], false)
     }
 }
@@ -844,6 +843,19 @@ pub fn find_vtable(tcx: &ty::ctxt,
     param_bounds.get(n_bound).clone()
 }
 
+pub fn filename_and_line_num_from_span(bcx: &Block, span: Span)
+                                       -> (ValueRef, ValueRef) {
+    let loc = bcx.sess().codemap().lookup_char_pos(span.lo);
+    let filename_cstr = C_cstr(bcx.ccx(),
+                               token::intern_and_get_ident(loc.file
+                                                              .name
+                                                              .as_slice()),
+                               true);
+    let filename = build::PointerCast(bcx, filename_cstr, Type::i8p(bcx.ccx()));
+    let line = C_int(bcx.ccx(), loc.line as int);
+    (filename, line)
+}
+
 // Casts a Rust bool value to an i1.
 pub fn bool_to_i1(bcx: &Block, llval: ValueRef) -> ValueRef {
     build::ICmp(bcx, lib::llvm::IntNE, llval, C_bool(bcx.ccx(), false))