Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Moves test::black_box to core::hint and fix black_box on wasm32 and asm.js #59336

Merged
merged 8 commits into from
Mar 28, 2019
36 changes: 36 additions & 0 deletions src/libcore/hint.rs
Original file line number Diff line number Diff line change
@@ -91,3 +91,39 @@ pub fn spin_loop() {
}
}
}

/// A function that is opaque to the optimizer, to allow benchmarks to
/// pretend to use outputs to assist in avoiding dead-code
/// elimination.
///
/// This function is a no-op, and does not even read from `dummy`.
#[inline]
#[unstable(feature = "test", issue = "27812")]
pub fn black_box<T>(dummy: T) -> T {
cfg_if! {
if #[cfg(any(
target_arch = "asmjs",
all(
target_arch = "wasm32",
target_os = "emscripten"
)
))] {
#[inline]
unsafe fn black_box_impl<T>(d: T) -> T {
// these targets do not support inline assembly
let ret = crate::ptr::read_volatile(&d);
crate::mem::forget(d);
ret
}
} else {
#[inline]
unsafe fn black_box_impl<T>(d: T) -> T {
// we need to "use" the argument in some way LLVM can't
// introspect.
asm!("" : : "r"(&d));
d
}
}
}
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

To simplify the #[cfg] here, perhaps this could be:

pub fn black_box<T>(dummy: T) -> {
    #[cfg(supports_asm)]
    {
        unsafe { asm!(...); }
        return dummy;
    }
    unsafe {
        let ret = read_volatile(...);
        ...;
    }
}

Maybe with an #[allow(unreachable_code)] or something like that to pacify the linter?

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The last commit adds cfg_if! to the internal_macros.rs and uses it here. I find this looks infinitely better with cfg_if! than with any of the other options, and I suppose we could access it from core::arch as well.

unsafe { black_box_impl(dummy) }
}
81 changes: 81 additions & 0 deletions src/libcore/internal_macros.rs
Original file line number Diff line number Diff line change
@@ -119,3 +119,84 @@ macro_rules! impl_fn_for_zst {
)+
}
}

/// A macro for defining `#[cfg]` if-else statements.
///
/// The macro provided by this crate, `cfg_if`, is similar to the `if/elif` C
/// preprocessor macro by allowing definition of a cascade of `#[cfg]` cases,
/// emitting the implementation which matches first.
///
/// This allows you to conveniently provide a long list `#[cfg]`'d blocks of code
/// without having to rewrite each clause multiple times.
///
/// # Example
///
/// ```
/// #[macro_use]
/// extern crate cfg_if;
///
/// cfg_if! {
/// if #[cfg(unix)] {
/// fn foo() { /* unix specific functionality */ }
/// } else if #[cfg(target_pointer_width = "32")] {
/// fn foo() { /* non-unix, 32-bit functionality */ }
/// } else {
/// fn foo() { /* fallback implementation */ }
/// }
/// }
///
/// # fn main() {}
/// ```
macro_rules! cfg_if {
// match if/else chains with a final `else`
($(
if #[cfg($($meta:meta),*)] { $($it:item)* }
) else * else {
$($it2:item)*
}) => {
cfg_if! {
@__items
() ;
$( ( ($($meta),*) ($($it)*) ), )*
( () ($($it2)*) ),
}
};

// match if/else chains lacking a final `else`
(
if #[cfg($($i_met:meta),*)] { $($i_it:item)* }
$(
else if #[cfg($($e_met:meta),*)] { $($e_it:item)* }
)*
) => {
cfg_if! {
@__items
() ;
( ($($i_met),*) ($($i_it)*) ),
$( ( ($($e_met),*) ($($e_it)*) ), )*
( () () ),
}
};

// Internal and recursive macro to emit all the items
//
// Collects all the negated cfgs in a list at the beginning and after the
// semicolon is all the remaining items
(@__items ($($not:meta,)*) ; ) => {};
(@__items ($($not:meta,)*) ; ( ($($m:meta),*) ($($it:item)*) ), $($rest:tt)*) => {
// Emit all items within one block, applying an approprate #[cfg]. The
// #[cfg] will require all `$m` matchers specified and must also negate
// all previous matchers.
cfg_if! { @__apply cfg(all($($m,)* not(any($($not),*)))), $($it)* }

// Recurse to emit all other items in `$rest`, and when we do so add all
// our `$m` matchers to the list of `$not` matchers as future emissions
// will have to negate everything we just matched as well.
cfg_if! { @__items ($($not,)* $($m,)*) ; $($rest)* }
};

// Internal macro to Apply a cfg attribute to a list of items
(@__apply $m:meta, $($it:item)*) => {
$(#[$m] $it)*
};
}
18 changes: 1 addition & 17 deletions src/libtest/lib.rs
Original file line number Diff line number Diff line change
@@ -27,23 +27,7 @@ pub use libtest::{
TestResult, TrFailed, TrFailedMsg, TrIgnored, TrOk, stats::Summary
};

/// A function that is opaque to the optimizer, to allow benchmarks to
/// pretend to use outputs to assist in avoiding dead-code
/// elimination.
///
/// This function is a no-op, and does not even read from `dummy`.
#[cfg(not(any(target_arch = "asmjs", target_arch = "wasm32")))]
pub fn black_box<T>(dummy: T) -> T {
// we need to "use" the argument in some way LLVM can't
// introspect.
unsafe { asm!("" : : "r"(&dummy)) }
dummy
}
#[cfg(any(target_arch = "asmjs", target_arch = "wasm32"))]
#[inline(never)]
pub fn black_box<T>(dummy: T) -> T {
dummy
}
pub use std::hint::black_box;

#[cfg(test)]
mod tests {
4 changes: 4 additions & 0 deletions src/tools/tidy/src/pal.rs
Original file line number Diff line number Diff line change
@@ -42,6 +42,10 @@ const EXCEPTION_PATHS: &[&str] = &[
"src/libpanic_abort",
"src/libpanic_unwind",
"src/libunwind",
// black_box implementation is LLVM-version specific and it uses
// target_os to tell targets with different LLVM-versions appart
// (e.g. `wasm32-unknown-emscripten` vs `wasm32-unknown-unknown`):
"src/libcore/hint.rs",
"src/libstd/sys/", // Platform-specific code for std lives here.
// This has the trailing slash so that sys_common is not excepted.
"src/libstd/os", // Platform-specific public interfaces