From fdb2837bd90ea3a7209cfe56a8f99b37b4f6b373 Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Fri, 2 Jun 2017 10:59:19 -0700 Subject: [PATCH 1/7] Vec is pronounced 'vec' --- src/libcollections/vec.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 3ef8438bc0bd2..2de27725e956c 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -9,7 +9,7 @@ // except according to those terms. //! A contiguous growable array type with heap-allocated contents, written -//! `Vec` but pronounced 'vector.' +//! `Vec`. //! //! Vectors have `O(1)` indexing, amortized `O(1)` push (to the end) and //! `O(1)` pop (from the end). From e37cfc7dd29aeea001d006e7dbd1a53556f9f1de Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Tue, 6 Jun 2017 14:26:56 -0700 Subject: [PATCH 2/7] bootstrap: improve 'build --help' by explaining what exactly the last example does --- src/bootstrap/flags.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/bootstrap/flags.rs b/src/bootstrap/flags.rs index f100baa5d2ca7..3a265b2f3bbb7 100644 --- a/src/bootstrap/flags.rs +++ b/src/bootstrap/flags.rs @@ -198,7 +198,11 @@ Arguments: For a quick build with a usable compile, you can pass: - ./x.py build --stage 1 src/libtest"); + ./x.py build --stage 1 src/libtest + + This will first build everything once (like --stage 0 without further + arguments would), and then use the compiler built in stage 0 to build + src/libtest and its dependencies."); } "test" => { subcommand_help.push_str("\n From dd23fda9bd6c79ef8e0a389622352759dc159b15 Mon Sep 17 00:00:00 2001 From: Clar Charr Date: Tue, 30 May 2017 00:17:11 -0400 Subject: [PATCH 3/7] Make rustdoc.js use license comments. --- src/librustdoc/html/static/main.js | 20 +++++++++++--------- src/tools/tidy/src/style.rs | 4 +++- 2 files changed, 14 insertions(+), 10 deletions(-) diff --git a/src/librustdoc/html/static/main.js b/src/librustdoc/html/static/main.js index 53e341226af3e..38f83687d1d85 100644 --- a/src/librustdoc/html/static/main.js +++ b/src/librustdoc/html/static/main.js @@ -1,12 +1,14 @@ -// Copyright 2014 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. +/*! + * Copyright 2014 The Rust Project Developers. See the COPYRIGHT + * file at the top-level directory of this distribution and at + * http://rust-lang.org/COPYRIGHT. + * + * Licensed under the Apache License, Version 2.0 or the MIT license + * , at your + * option. This file may not be copied, modified, or distributed + * except according to those terms. + */ /*jslint browser: true, es5: true */ /*globals $: true, rootPath: true */ diff --git a/src/tools/tidy/src/style.rs b/src/tools/tidy/src/style.rs index 8bf683de8704a..35073b63723d4 100644 --- a/src/tools/tidy/src/style.rs +++ b/src/tools/tidy/src/style.rs @@ -169,8 +169,10 @@ fn licenseck(file: &Path, contents: &str) -> bool { lines.windows(LICENSE.lines().count()).any(|window| { let offset = if window.iter().all(|w| w.starts_with("//")) { 2 - } else if window.iter().all(|w| w.starts_with("#")) { + } else if window.iter().all(|w| w.starts_with('#')) { 1 + } else if window.iter().all(|w| w.starts_with(" *")) { + 2 } else { return false }; From 7359c791b50ebe0fa7ccf48faf5a272491c779e3 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Wed, 7 Jun 2017 22:08:48 -0700 Subject: [PATCH 4/7] bootstrap: further clarify build --help --- src/bootstrap/flags.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/bootstrap/flags.rs b/src/bootstrap/flags.rs index 3a265b2f3bbb7..56cbb4cecf2a5 100644 --- a/src/bootstrap/flags.rs +++ b/src/bootstrap/flags.rs @@ -196,13 +196,14 @@ Arguments: ./x.py build ./x.py build --stage 1 - For a quick build with a usable compile, you can pass: + For a quick build of a usable compiler, you can pass: ./x.py build --stage 1 src/libtest This will first build everything once (like --stage 0 without further arguments would), and then use the compiler built in stage 0 to build - src/libtest and its dependencies."); + src/libtest and its dependencies. + Once this is done, build/$ARCH/stage1 contains a usable compiler."); } "test" => { subcommand_help.push_str("\n From 70e48b12e9ed06cc500061b9026aac9ea598a1e8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?M=C3=A1ty=C3=A1s=20Mustoha?= Date: Thu, 8 Jun 2017 12:03:08 +0200 Subject: [PATCH 5/7] Ignore variadic FFI test on AArch64 --- src/test/compile-fail/variadic-ffi.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/test/compile-fail/variadic-ffi.rs b/src/test/compile-fail/variadic-ffi.rs index 125177efc53c7..f245306f4d8f6 100644 --- a/src/test/compile-fail/variadic-ffi.rs +++ b/src/test/compile-fail/variadic-ffi.rs @@ -9,6 +9,7 @@ // except according to those terms. // ignore-arm stdcall isn't suppported +// ignore-aarch64 stdcall isn't suppported extern "stdcall" { fn printf(_: *const u8, ...); //~ ERROR: variadic function must have C or cdecl calling From 52805d233b59503cdfe58ee21e894ed6bb3b1da9 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Tue, 6 Jun 2017 11:34:10 -0700 Subject: [PATCH 6/7] std: Avoid panics in rust_eh_personality This commit removes a few calls to panic and/or assert in `rust_eh_personality`. This function definitely can't itself panic (that'd probably segfault or do something else weird) and I was also noticing that a `pub extern fn foo() {}` cdylib was abnormally large. Turns out all that size was the panicking machinery brought in by the personality function! The change here is to return a `Result` internally so we can bubble up the fatal error, eventually translating to the appropriate error code for the libunwind ABI. --- src/libpanic_unwind/dwarf/eh.rs | 55 +++++++++++++++++++------------- src/libpanic_unwind/gcc.rs | 14 ++++++-- src/libpanic_unwind/seh64_gnu.rs | 9 +++--- 3 files changed, 48 insertions(+), 30 deletions(-) diff --git a/src/libpanic_unwind/dwarf/eh.rs b/src/libpanic_unwind/dwarf/eh.rs index e7994f4e0ef0a..0c326ce371843 100644 --- a/src/libpanic_unwind/dwarf/eh.rs +++ b/src/libpanic_unwind/dwarf/eh.rs @@ -61,9 +61,11 @@ pub enum EHAction { pub const USING_SJLJ_EXCEPTIONS: bool = cfg!(all(target_os = "ios", target_arch = "arm")); -pub unsafe fn find_eh_action(lsda: *const u8, context: &EHContext) -> EHAction { +pub unsafe fn find_eh_action(lsda: *const u8, context: &EHContext) + -> Result +{ if lsda.is_null() { - return EHAction::None; + return Ok(EHAction::None) } let func_start = context.func_start; @@ -72,7 +74,7 @@ pub unsafe fn find_eh_action(lsda: *const u8, context: &EHContext) -> EHAction { let start_encoding = reader.read::(); // base address for landing pad offsets let lpad_base = if start_encoding != DW_EH_PE_omit { - read_encoded_pointer(&mut reader, context, start_encoding) + read_encoded_pointer(&mut reader, context, start_encoding)? } else { func_start }; @@ -90,9 +92,9 @@ pub unsafe fn find_eh_action(lsda: *const u8, context: &EHContext) -> EHAction { if !USING_SJLJ_EXCEPTIONS { while reader.ptr < action_table { - let cs_start = read_encoded_pointer(&mut reader, context, call_site_encoding); - let cs_len = read_encoded_pointer(&mut reader, context, call_site_encoding); - let cs_lpad = read_encoded_pointer(&mut reader, context, call_site_encoding); + let cs_start = read_encoded_pointer(&mut reader, context, call_site_encoding)?; + let cs_len = read_encoded_pointer(&mut reader, context, call_site_encoding)?; + let cs_lpad = read_encoded_pointer(&mut reader, context, call_site_encoding)?; let cs_action = reader.read_uleb128(); // Callsite table is sorted by cs_start, so if we've passed the ip, we // may stop searching. @@ -101,23 +103,23 @@ pub unsafe fn find_eh_action(lsda: *const u8, context: &EHContext) -> EHAction { } if ip < func_start + cs_start + cs_len { if cs_lpad == 0 { - return EHAction::None; + return Ok(EHAction::None) } else { let lpad = lpad_base + cs_lpad; - return interpret_cs_action(cs_action, lpad); + return Ok(interpret_cs_action(cs_action, lpad)) } } } // Ip is not present in the table. This should not happen... but it does: issue #35011. // So rather than returning EHAction::Terminate, we do this. - EHAction::None + Ok(EHAction::None) } else { // SjLj version: // The "IP" is an index into the call-site table, with two exceptions: // -1 means 'no-action', and 0 means 'terminate'. match ip as isize { - -1 => return EHAction::None, - 0 => return EHAction::Terminate, + -1 => return Ok(EHAction::None), + 0 => return Ok(EHAction::Terminate), _ => (), } let mut idx = ip; @@ -129,7 +131,7 @@ pub unsafe fn find_eh_action(lsda: *const u8, context: &EHContext) -> EHAction { // Can never have null landing pad for sjlj -- that would have // been indicated by a -1 call site index. let lpad = (cs_lpad + 1) as usize; - return interpret_cs_action(cs_action, lpad); + return Ok(interpret_cs_action(cs_action, lpad)) } } } @@ -144,21 +146,26 @@ fn interpret_cs_action(cs_action: u64, lpad: usize) -> EHAction { } #[inline] -fn round_up(unrounded: usize, align: usize) -> usize { - assert!(align.is_power_of_two()); - (unrounded + align - 1) & !(align - 1) +fn round_up(unrounded: usize, align: usize) -> Result { + if align.is_power_of_two() { + Ok((unrounded + align - 1) & !(align - 1)) + } else { + Err(()) + } } unsafe fn read_encoded_pointer(reader: &mut DwarfReader, context: &EHContext, encoding: u8) - -> usize { - assert!(encoding != DW_EH_PE_omit); + -> Result { + if encoding == DW_EH_PE_omit { + return Err(()) + } // DW_EH_PE_aligned implies it's an absolute pointer value if encoding == DW_EH_PE_aligned { - reader.ptr = round_up(reader.ptr as usize, mem::size_of::()) as *const u8; - return reader.read::(); + reader.ptr = round_up(reader.ptr as usize, mem::size_of::())? as *const u8; + return Ok(reader.read::()) } let mut result = match encoding & 0x0F { @@ -171,7 +178,7 @@ unsafe fn read_encoded_pointer(reader: &mut DwarfReader, DW_EH_PE_sdata2 => reader.read::() as usize, DW_EH_PE_sdata4 => reader.read::() as usize, DW_EH_PE_sdata8 => reader.read::() as usize, - _ => panic!(), + _ => return Err(()), }; result += match encoding & 0x70 { @@ -179,17 +186,19 @@ unsafe fn read_encoded_pointer(reader: &mut DwarfReader, // relative to address of the encoded value, despite the name DW_EH_PE_pcrel => reader.ptr as usize, DW_EH_PE_funcrel => { - assert!(context.func_start != 0); + if context.func_start == 0 { + return Err(()) + } context.func_start } DW_EH_PE_textrel => (*context.get_text_start)(), DW_EH_PE_datarel => (*context.get_data_start)(), - _ => panic!(), + _ => return Err(()), }; if encoding & DW_EH_PE_indirect != 0 { result = *(result as *const usize); } - result + Ok(result) } diff --git a/src/libpanic_unwind/gcc.rs b/src/libpanic_unwind/gcc.rs index 84abc6bc4a513..aadbeb96b2d23 100644 --- a/src/libpanic_unwind/gcc.rs +++ b/src/libpanic_unwind/gcc.rs @@ -156,7 +156,10 @@ unsafe extern "C" fn rust_eh_personality(version: c_int, if version != 1 { return uw::_URC_FATAL_PHASE1_ERROR; } - let eh_action = find_eh_action(context); + let eh_action = match find_eh_action(context) { + Ok(action) => action, + Err(_) => return uw::_URC_FATAL_PHASE1_ERROR, + }; if actions as i32 & uw::_UA_SEARCH_PHASE as i32 != 0 { match eh_action { EHAction::None | @@ -219,7 +222,10 @@ unsafe extern "C" fn rust_eh_personality(state: uw::_Unwind_State, // _Unwind_Context in our libunwind bindings and fetch the required data from there directly, // bypassing DWARF compatibility functions. - let eh_action = find_eh_action(context); + let eh_action = match find_eh_action(context) { + Ok(action) => action, + Err(_) => return uw::_URC_FAILURE, + }; if search_phase { match eh_action { EHAction::None | @@ -260,7 +266,9 @@ unsafe extern "C" fn rust_eh_personality(state: uw::_Unwind_State, } } -unsafe fn find_eh_action(context: *mut uw::_Unwind_Context) -> EHAction { +unsafe fn find_eh_action(context: *mut uw::_Unwind_Context) + -> Result +{ let lsda = uw::_Unwind_GetLanguageSpecificData(context) as *const u8; let mut ip_before_instr: c_int = 0; let ip = uw::_Unwind_GetIPInfo(context, &mut ip_before_instr); diff --git a/src/libpanic_unwind/seh64_gnu.rs b/src/libpanic_unwind/seh64_gnu.rs index d4906b556b31a..0a9fa7d9a80b4 100644 --- a/src/libpanic_unwind/seh64_gnu.rs +++ b/src/libpanic_unwind/seh64_gnu.rs @@ -128,9 +128,10 @@ unsafe fn find_landing_pad(dc: &c::DISPATCHER_CONTEXT) -> Option { get_data_start: &|| unimplemented!(), }; match find_eh_action(dc.HandlerData, &eh_ctx) { - EHAction::None => None, - EHAction::Cleanup(lpad) | - EHAction::Catch(lpad) => Some(lpad), - EHAction::Terminate => intrinsics::abort(), + Err(_) | + Ok(EHAction::None) => None, + Ok(EHAction::Cleanup(lpad)) | + Ok(EHAction::Catch(lpad)) => Some(lpad), + Ok(EHAction::Terminate) => intrinsics::abort(), } } From 44e6406f9a29e03280f4e16434c06e1d0abfaffc Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Wed, 7 Jun 2017 18:31:35 -0700 Subject: [PATCH 7/7] std: Handle ENOSYS when calling `pipe2` Should help fix an accidental regression from #39386. --- src/libstd/sys/unix/pipe.rs | 29 +++++++++++++++++++++++------ 1 file changed, 23 insertions(+), 6 deletions(-) diff --git a/src/libstd/sys/unix/pipe.rs b/src/libstd/sys/unix/pipe.rs index 706256ff10ec9..ca5ef4bcfc5f4 100644 --- a/src/libstd/sys/unix/pipe.rs +++ b/src/libstd/sys/unix/pipe.rs @@ -11,8 +11,9 @@ use io; use libc::{self, c_int}; use mem; -use sys::{cvt, cvt_r}; +use sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering}; use sys::fd::FileDesc; +use sys::{cvt, cvt_r}; //////////////////////////////////////////////////////////////////////////////// // Anonymous pipes @@ -21,6 +22,9 @@ use sys::fd::FileDesc; pub struct AnonPipe(FileDesc); pub fn anon_pipe() -> io::Result<(AnonPipe, AnonPipe)> { + weak! { fn pipe2(*mut c_int, c_int) -> c_int } + static INVALID: AtomicBool = ATOMIC_BOOL_INIT; + let mut fds = [0; 2]; // Unfortunately the only known way right now to create atomically set the @@ -31,13 +35,26 @@ pub fn anon_pipe() -> io::Result<(AnonPipe, AnonPipe)> { target_os = "freebsd", target_os = "linux", target_os = "netbsd", - target_os = "openbsd")) + target_os = "openbsd")) && + !INVALID.load(Ordering::SeqCst) { - weak! { fn pipe2(*mut c_int, c_int) -> c_int } + if let Some(pipe) = pipe2.get() { - cvt(unsafe { pipe(fds.as_mut_ptr(), libc::O_CLOEXEC) })?; - return Ok((AnonPipe(FileDesc::new(fds[0])), - AnonPipe(FileDesc::new(fds[1])))); + // Note that despite calling a glibc function here we may still + // get ENOSYS. Glibc has `pipe2` since 2.9 and doesn't try to + // emulate on older kernels, so if you happen to be running on + // an older kernel you may see `pipe2` as a symbol but still not + // see the syscall. + match cvt(unsafe { pipe(fds.as_mut_ptr(), libc::O_CLOEXEC) }) { + Ok(_) => { + return Ok((AnonPipe(FileDesc::new(fds[0])), + AnonPipe(FileDesc::new(fds[1])))); + } + Err(ref e) if e.raw_os_error() == Some(libc::ENOSYS) => { + INVALID.store(true, Ordering::SeqCst); + } + Err(e) => return Err(e), + } } } cvt(unsafe { libc::pipe(fds.as_mut_ptr()) })?;