53d8b1d051
This PR cuts down on a large number of `#[inline(always)]` and `#[inline]` annotations in libcore for various core functions. The `#[inline(always)]` annotation is almost never needed and is detrimental to debug build times as it forces LLVM to perform inlining when it otherwise wouldn't need to in debug builds. Additionally `#[inline]` is an unnecessary annoation on almost all generic functions because the function will already be monomorphized into other codegen units and otherwise rarely needs the extra "help" from us to tell LLVM to inline something. Overall this PR cut the compile time of a [microbenchmark][1] by 30% from 1s to 0.7s. [1]: https://gist.github.com/alexcrichton/a7d70319a45aa60cf36a6a7bf540dd3a
56 lines
1.9 KiB
Rust
56 lines
1.9 KiB
Rust
// Copyright 2012-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 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
//! Exposes the NonZero lang item which provides optimization hints.
|
|
#![unstable(feature = "nonzero",
|
|
reason = "needs an RFC to flesh out the design",
|
|
issue = "27730")]
|
|
|
|
use ops::CoerceUnsized;
|
|
|
|
/// Unsafe trait to indicate what types are usable with the NonZero struct
|
|
pub unsafe trait Zeroable {}
|
|
|
|
unsafe impl<T:?Sized> Zeroable for *const T {}
|
|
unsafe impl<T:?Sized> Zeroable for *mut T {}
|
|
unsafe impl Zeroable for isize {}
|
|
unsafe impl Zeroable for usize {}
|
|
unsafe impl Zeroable for i8 {}
|
|
unsafe impl Zeroable for u8 {}
|
|
unsafe impl Zeroable for i16 {}
|
|
unsafe impl Zeroable for u16 {}
|
|
unsafe impl Zeroable for i32 {}
|
|
unsafe impl Zeroable for u32 {}
|
|
unsafe impl Zeroable for i64 {}
|
|
unsafe impl Zeroable for u64 {}
|
|
unsafe impl Zeroable for i128 {}
|
|
unsafe impl Zeroable for u128 {}
|
|
|
|
/// A wrapper type for raw pointers and integers that will never be
|
|
/// NULL or 0 that might allow certain optimizations.
|
|
#[lang = "non_zero"]
|
|
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
|
|
pub struct NonZero<T: Zeroable>(T);
|
|
|
|
impl<T: Zeroable> NonZero<T> {
|
|
/// Creates an instance of NonZero with the provided value.
|
|
/// You must indeed ensure that the value is actually "non-zero".
|
|
#[inline]
|
|
pub const unsafe fn new(inner: T) -> NonZero<T> {
|
|
NonZero(inner)
|
|
}
|
|
|
|
/// Gets the inner value.
|
|
pub fn get(self) -> T {
|
|
self.0
|
|
}
|
|
}
|
|
|
|
impl<T: Zeroable+CoerceUnsized<U>, U: Zeroable> CoerceUnsized<NonZero<U>> for NonZero<T> {}
|