1 // Licensed to the .NET Foundation under one or more agreements.
2 // The .NET Foundation licenses this file to you under the MIT license.
4 // File: FloatSingle.cpp
9 #include "floatsingle.h"
11 // Windows x86 and Windows ARM/ARM64 may not define _isnanf() or _copysignf() but they do
12 // define _isnan() and _copysign(). We will redirect the macros to these other functions if
13 // the macro is not defined for the platform. This has the side effect of a possible implicit
14 // upcasting for arguments passed in and an explicit downcasting for the _copysign() call.
15 #if (defined(TARGET_X86) || defined(TARGET_ARM) || defined(TARGET_ARM64)) && !defined(TARGET_UNIX)
17 #if !defined(_copysignf)
18 #define _copysignf (float)_copysign
23 // The default compilation mode is /fp:precise, which disables floating-point intrinsics. This
24 // default compilation mode has previously caused performance regressions in floating-point code.
25 // We enable /fp:fast semantics for the majority of the math functions, as it will speed up performance
26 // and is really unlikely to cause any other code regressions.
28 ////////////////////////////////////////////////////////////////////////////////////
29 ////////////////////////////////////////////////////////////////////////////////////
30 ////////////////////////////////////////////////////////////////////////////////////
32 /// beginning of /fp:fast scope
34 ////////////////////////////////////////////////////////////////////////////////////
35 ////////////////////////////////////////////////////////////////////////////////////
36 ////////////////////////////////////////////////////////////////////////////////////
39 #pragma float_control(push)
40 #pragma float_control(precise, off)
43 /*=====================================Abs=====================================
45 ==============================================================================*/
46 FCIMPL1_V(float, COMSingle::Abs, float x)
49 return (float)fabsf(x);
52 /*=====================================Acos=====================================
54 ==============================================================================*/
55 FCIMPL1_V(float, COMSingle::Acos, float x)
58 return (float)acosf(x);
61 /*=====================================Acosh====================================
63 ==============================================================================*/
64 FCIMPL1_V(float, COMSingle::Acosh, float x)
67 return (float)acoshf(x);
70 /*=====================================Asin=====================================
72 ==============================================================================*/
73 FCIMPL1_V(float, COMSingle::Asin, float x)
76 return (float)asinf(x);
79 /*=====================================Asinh====================================
81 ==============================================================================*/
82 FCIMPL1_V(float, COMSingle::Asinh, float x)
85 return (float)asinhf(x);
88 /*=====================================Atan=====================================
90 ==============================================================================*/
91 FCIMPL1_V(float, COMSingle::Atan, float x)
94 return (float)atanf(x);
97 /*=====================================Atanh====================================
99 ==============================================================================*/
100 FCIMPL1_V(float, COMSingle::Atanh, float x)
103 return (float)atanhf(x);
106 /*=====================================Atan2====================================
108 ==============================================================================*/
109 FCIMPL2_VV(float, COMSingle::Atan2, float y, float x)
112 return (float)atan2f(y, x);
115 /*====================================Cbrt======================================
117 ==============================================================================*/
118 FCIMPL1_V(float, COMSingle::Cbrt, float x)
121 return (float)cbrtf(x);
124 #if defined(_MSC_VER) && defined(TARGET_AMD64)
125 // The /fp:fast form of `ceilf` for AMD64 does not correctly handle: `-1.0 < value <= -0.0`
126 // https://github.com/dotnet/runtime/issues/11003
127 #pragma float_control(push)
128 #pragma float_control(precise, on)
131 /*====================================Ceil======================================
133 ==============================================================================*/
134 FCIMPL1_V(float, COMSingle::Ceil, float x)
137 return (float)ceilf(x);
140 #if defined(_MSC_VER) && defined(TARGET_AMD64)
141 #pragma float_control(pop)
144 /*=====================================Cos======================================
146 ==============================================================================*/
147 FCIMPL1_V(float, COMSingle::Cos, float x)
150 return (float)cosf(x);
153 /*=====================================Cosh=====================================
155 ==============================================================================*/
156 FCIMPL1_V(float, COMSingle::Cosh, float x)
159 return (float)coshf(x);
162 /*=====================================Exp======================================
164 ==============================================================================*/
165 FCIMPL1_V(float, COMSingle::Exp, float x)
168 return (float)expf(x);
171 /*====================================Floor=====================================
173 ==============================================================================*/
174 FCIMPL1_V(float, COMSingle::Floor, float x)
177 return (float)floorf(x);
180 /*=====================================FMod=====================================
182 ==============================================================================*/
183 FCIMPL2_VV(float, COMSingle::FMod, float x, float y)
186 return (float)fmodf(x, y);
189 /*=====================================FusedMultiplyAdd==========================
191 ==============================================================================*/
192 FCIMPL3_VVV(float, COMSingle::FusedMultiplyAdd, float x, float y, float z)
195 return (float)fmaf(x, y, z);
198 /*=====================================Ilog2====================================
200 ==============================================================================*/
201 FCIMPL1_V(int, COMSingle::ILogB, float x)
204 return (int)ilogbf(x);
207 /*=====================================Log======================================
209 ==============================================================================*/
210 FCIMPL1_V(float, COMSingle::Log, float x)
213 return (float)logf(x);
216 /*=====================================Log2=====================================
218 ==============================================================================*/
219 FCIMPL1_V(float, COMSingle::Log2, float x)
222 return (float)log2f(x);
225 /*====================================Log10=====================================
227 ==============================================================================*/
228 FCIMPL1_V(float, COMSingle::Log10, float x)
231 return (float)log10f(x);
234 /*=====================================ModF=====================================
236 ==============================================================================*/
237 FCIMPL2_VI(float, COMSingle::ModF, float x, float* intptr)
240 return (float)modff(x, intptr);
243 /*=====================================Pow======================================
245 ==============================================================================*/
246 FCIMPL2_VV(float, COMSingle::Pow, float x, float y)
249 return (float)powf(x, y);
252 /*=====================================Sin======================================
254 ==============================================================================*/
255 FCIMPL1_V(float, COMSingle::Sin, float x)
258 return (float)sinf(x);
261 /*====================================SinCos====================================
263 ==============================================================================*/
264 FCIMPL3_VII(void, COMSingle::SinCos, float x, float* pSin, float* pCos)
271 sincosf(x, pSin, pCos);
276 /*=====================================Sinh=====================================
278 ==============================================================================*/
279 FCIMPL1_V(float, COMSingle::Sinh, float x)
282 return (float)sinhf(x);
285 /*=====================================Sqrt=====================================
287 ==============================================================================*/
288 FCIMPL1_V(float, COMSingle::Sqrt, float x)
291 return (float)sqrtf(x);
294 /*=====================================Tan======================================
296 ==============================================================================*/
297 FCIMPL1_V(float, COMSingle::Tan, float x)
300 return (float)tanf(x);
303 /*=====================================Tanh=====================================
305 ==============================================================================*/
306 FCIMPL1_V(float, COMSingle::Tanh, float x)
309 return (float)tanhf(x);
313 #pragma float_control(pop)
316 ////////////////////////////////////////////////////////////////////////////////////
317 ////////////////////////////////////////////////////////////////////////////////////
318 ////////////////////////////////////////////////////////////////////////////////////
320 /// End of /fp:fast scope
322 ////////////////////////////////////////////////////////////////////////////////////
323 ////////////////////////////////////////////////////////////////////////////////////
324 ////////////////////////////////////////////////////////////////////////////////////