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.

Sign up for GitHub

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

Jump to bottom

Don't use f64 shims for f32 cmath functions on non 32-bit x86 MSVC #68033

Merged
merged 1 commit into from
Jan 16, 2020
Merged

Don't use f64 shims for f32 cmath functions on non 32-bit x86 MSVC #68033

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
60 changes: 8 additions & 52 deletions src/libstd/f32.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -44,23 +44,7 @@ impl f32 {
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn floor(self) -> f32 {
// On MSVC LLVM will lower many math intrinsics to a call to the
// corresponding function. On MSVC, however, many of these functions
// aren't actually available as symbols to call, but rather they are all
// `static inline` functions in header files. This means that from a C
// perspective it's "compatible", but not so much from an ABI
// perspective (which we're worried about).
//
// The inline header functions always just cast to a f64 and do their
// operation, so we do that here as well, but only for MSVC targets.
//
// Note that there are many MSVC-specific float operations which
// redirect to this comment, so `floorf` is just one case of a missing
// function on MSVC, but there are many others elsewhere.
#[cfg(target_env = "msvc")]
return (self as f64).floor() as f32;
#[cfg(not(target_env = "msvc"))]
return unsafe { intrinsics::floorf32(self) };
unsafe { intrinsics::floorf32(self) }
}

/// Returns the smallest integer greater than or equal to a number.
Expand All @@ -78,11 +62,7 @@ impl f32 {
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn ceil(self) -> f32 {
// see notes above in `floor`
#[cfg(target_env = "msvc")]
return (self as f64).ceil() as f32;
#[cfg(not(target_env = "msvc"))]
return unsafe { intrinsics::ceilf32(self) };
unsafe { intrinsics::ceilf32(self) }
}

/// Returns the nearest integer to a number. Round half-way cases away from
Expand Down Expand Up @@ -348,11 +328,7 @@ impl f32 {
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn powf(self, n: f32) -> f32 {
// see notes above in `floor`
#[cfg(target_env = "msvc")]
return (self as f64).powf(n as f64) as f32;
#[cfg(not(target_env = "msvc"))]
return unsafe { intrinsics::powf32(self, n) };
unsafe { intrinsics::powf32(self, n) }
}

/// Takes the square root of a number.
Expand Down Expand Up @@ -399,11 +375,7 @@ impl f32 {
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn exp(self) -> f32 {
// see notes above in `floor`
#[cfg(target_env = "msvc")]
return (self as f64).exp() as f32;
#[cfg(not(target_env = "msvc"))]
return unsafe { intrinsics::expf32(self) };
unsafe { intrinsics::expf32(self) }
}

/// Returns `2^(self)`.
Expand Down Expand Up @@ -447,11 +419,7 @@ impl f32 {
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn ln(self) -> f32 {
// see notes above in `floor`
#[cfg(target_env = "msvc")]
return (self as f64).ln() as f32;
#[cfg(not(target_env = "msvc"))]
return unsafe { intrinsics::logf32(self) };
unsafe { intrinsics::logf32(self) }
}

/// Returns the logarithm of the number with respect to an arbitrary base.
Expand Down Expand Up @@ -521,11 +489,7 @@ impl f32 {
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn log10(self) -> f32 {
// see notes above in `floor`
#[cfg(target_env = "msvc")]
return (self as f64).log10() as f32;
#[cfg(not(target_env = "msvc"))]
return unsafe { intrinsics::log10f32(self) };
unsafe { intrinsics::log10f32(self) }
}

/// The positive difference of two numbers.
Expand Down Expand Up @@ -625,11 +589,7 @@ impl f32 {
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn sin(self) -> f32 {
// see notes in `core::f32::Float::floor`
#[cfg(target_env = "msvc")]
return (self as f64).sin() as f32;
#[cfg(not(target_env = "msvc"))]
return unsafe { intrinsics::sinf32(self) };
unsafe { intrinsics::sinf32(self) }
}

/// Computes the cosine of a number (in radians).
Expand All @@ -649,11 +609,7 @@ impl f32 {
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn cos(self) -> f32 {
// see notes in `core::f32::Float::floor`
#[cfg(target_env = "msvc")]
return (self as f64).cos() as f32;
#[cfg(not(target_env = "msvc"))]
return unsafe { intrinsics::cosf32(self) };
unsafe { intrinsics::cosf32(self) }
}

/// Computes the tangent of a number (in radians).
Expand Down
10 changes: 5 additions & 5 deletions src/libstd/sys/windows/cmath.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -27,7 +27,7 @@ extern "C" {

pub use self::shims::*;

#[cfg(not(target_env = "msvc"))]
#[cfg(not(all(target_env = "msvc", target_arch = "x86")))]
mod shims {
use libc::c_float;

Expand All @@ -43,10 +43,10 @@ mod shims {
}
}

// On MSVC these functions aren't defined, so we just define shims which promote
// everything fo f64, perform the calculation, and then demote back to f32.
// While not precisely correct should be "correct enough" for now.
#[cfg(target_env = "msvc")]
// On 32-bit x86 MSVC these functions aren't defined, so we just define shims
// which promote everything fo f64, perform the calculation, and then demote
// back to f32. While not precisely correct should be "correct enough" for now.
#[cfg(all(target_env = "msvc", target_arch = "x86"))]
mod shims {
use libc::c_float;

Expand Down