This is an archive of the discontinued LLVM Phabricator instance.

Differential D115082

[libc][NFC] refactor math implementations
AbandonedPublic

Authored by gchatelet on Dec 3 2021, 3:00 PM.

Details

Reviewers
lntue
Summary

Move math functions from src/math/generic to src/math folder.

Diff Detail

Event Timeline

gchatelet created this revision.Dec 3 2021, 3:00 PM
Herald added a project: Restricted Project. · View Herald TranscriptDec 3 2021, 3:00 PM
Herald added subscribers: libc-commits, ecnelises, tschuett, mgorny. · View Herald Transcript
gchatelet requested review of this revision.Dec 3 2021, 3:00 PM
gchatelet updated this revision to Diff 391751.Dec 3 2021, 3:04 PM
  • Remove commented lines
Harbormaster completed remote builds in B137444: Diff 391751.Dec 3 2021, 3:05 PM
gchatelet updated this revision to Diff 391753.Dec 3 2021, 3:05 PM

rebase

Harbormaster completed remote builds in B137446: Diff 391753.Dec 3 2021, 3:09 PM
gchatelet added a reviewer: lntue.Dec 3 2021, 3:09 PM
gchatelet added subscribers: sivachandra, michaelrj.
gchatelet added inline comments.Dec 3 2021, 3:15 PM
libc/src/math/sqrt.cpp
9–24

@lntue I'm not entirely sure that the redirection to subfolder makes sense. The inlined version would look like this

#include "sqrt.h"
#include "src/__support/architectures.h"
#include "src/__support/FPUtil/Sqrt.h"
#include "src/__support/common.h"
namespace __llvm_libc {

LLVM_LIBC_FUNCTION(double, sqrt, (double x)) {
#if defined(LLVM_LIBC_ARCH_AARCH64)
  double y;
  __asm__ __volatile__("fsqrt %d0, %d1\n\t" : "=w"(y) : "w"(x));
  return y;
#elif defined(LLVM_LIBC_ARCH_X86)
  double result;
  __asm__ __volatile__("sqrtsd %x1, %x0" : "=x"(result) : "x"(x));
  return result;
#else
  return fputil::sqrt(x);
#endif
}

} // namespace __llvm_libc

I find it more readable and it's less files overal. Let me know what you think

lntue added inline comments.Dec 3 2021, 5:21 PM
libc/src/math/sqrt.cpp
9–24

In my opinion, having #ifdef inside the function definition like this will be hard to read for more complicated functions, but for one-line functions like sqrt probably doesn't matter. It is also a bit hard to figure out which one has arch specializations, and which arch is missing, compared to separate files.

Another option for separate files that I think work quite well for organizing files and readability is to use separate namespaces for separate arc, something like

#if define(LLVM_LIBC_ARCH_AARCH64)
#include ...
namespace impl = ::llvm_libc::fputil::aarch64;
#elif defined(LLVM_LIBC_ARCH_X86)
#include ...
namespace impl = ::llvm_libc::fputil::x86;
#else
#include ...
namespace impl = ::__llvm_libc::fputil::generic;
#endif

LLVM_LIBC_FUNCTION(double, sqrt, (double x)) { return impl::sqrt(x); }

One function that I'm optimizing is polyeval, for which by separating arch's, it is easier to manage and copy-paste than #if #else inside the real implementations. But again, I'm fine with this one-line functions such as sqrt.

sivachandra added inline comments.Dec 3 2021, 8:00 PM
libc/src/math/sqrt.cpp
9–24

In general I favor what @lntue has said. Even if sqrt is just a one liner, I will vote for consistency across all one-liner and not-a-one-liner implemention.

gchatelet planned changes to this revision.Dec 6 2021, 2:22 AM
gchatelet added inline comments.
libc/src/math/sqrt.cpp
9–24

SGTM, I agree that being able to know which arch is implemented just by glancing at the filesystem is valuable, also consistency is important. So I'll stick to the subfolder approach as you both of you suggested.

This patch and the following ones will largely impact the build system (CMakeLists.txt and downstream) so to save me some time I will move forward with D114712 first. Once Bazel setup is in place we will be able to restructure the build system more easily (no separate downstream fixes).

In the meantime, @michaelrj @lntue @sivachandra please move forward with your various pending patches, I'll rebase (or recreate) mine when I'm ready to move forward.

Thank you

gchatelet abandoned this revision.Nov 28 2022, 1:59 AM
Herald added a project: Restricted Project. · View Herald TranscriptNov 28 2022, 1:59 AM

Revision Contents

PathSize
libc/
src/
math/
560 lines
aarch64/
generic/
8 lines
8 lines
2 lines
2 lines
2 lines
2 lines
7 lines
7 lines
7 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
8 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
8 lines
2 lines
7 lines
7 lines
11 lines
10 lines
8 lines
8 lines
8 lines
2 lines
cos.cpp/
generic/
sqrt.cpp
14 lines
2 lines
2 lines
generic/
internal/
31 lines
internal/
generic/
22 lines
105 lines
33 lines
128 lines
108 lines
27 lines
51 lines
142 lines
sin.cpp/
generic/
sqrt.cpp
14 lines
tan.cpp/
generic/
sqrt.cpp
14 lines
x86_64/

Diff 391753

libc/src/math/CMakeLists.txt

add_subdirectory(generic) add_subdirectory(internal)
if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_ARCHITECTURE})
add_subdirectory(${LIBC_TARGET_ARCHITECTURE})
endif()
function(add_math_entrypoint_object name)
# We prefer machine specific implementation if available. Hence we check
# that first and return early if we are able to add an alias target for the
# machine specific implementation.
get_fq_target_name("${LIBC_TARGET_ARCHITECTURE}.${name}" fq_machine_specific_target_name)
if(TARGET ${fq_machine_specific_target_name})
add_entrypoint_object( add_entrypoint_object(
${name} fmaf
ALIAS SRCS fmaf.cpp
DEPENDS HDRS fmaf.h
.${LIBC_TARGET_ARCHITECTURE}.${name} DEPENDS libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS -O2
) )
return()
endif()
get_fq_target_name("generic.${name}" fq_generic_target_name)
if(TARGET ${fq_generic_target_name})
add_entrypoint_object( add_entrypoint_object(
${name} fma
ALIAS SRCS fma.cpp
DEPENDS HDRS fma.h
.generic.${name} DEPENDS libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS -O2
) )
return()
endif()
# Add a dummy entrypoint object for missing implementations. They will be skipped function(add_math_entrypoint_object name)
# anyway as there will be no entry for them in the target entrypoints list. cmake_parse_arguments(
"MATH_IMPL"
"" # Optional arguments
"" # Single value arguments
"DEPENDS;COMPILE_OPTIONS" # Multi value arguments
${ARGN})
add_entrypoint_object( add_entrypoint_object(
${name} ${name}
SRCS SRCS ${name}.cpp
dummy_srcs HDRS ${name}.h
HDRS DEPENDS ${MATH_IMPL_DEPENDS}
dummy_hdrs COMPILE_OPTIONS -O3 ${MATH_IMPL_COMPILE_OPTIONS}
) )
endfunction() endfunction()
add_entrypoint_object( add_math_entrypoint_object(
fmaf ceil
SRCS DEPENDS libc.src.__support.FPUtil.fputil
fmaf.cpp )
HDRS
fmaf.h add_math_entrypoint_object(
ceilf
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
ceill
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
cos
)
add_math_entrypoint_object(
cosf
DEPENDS DEPENDS
libc.src.__support.FPUtil.fputil libc.include.math
COMPILE_OPTIONS libc.src.errno.__errno_location
-O2 libc.src.math.internal.sincosf_utils
) )
add_entrypoint_object( add_math_entrypoint_object(
fma sin
SRCS )
fma.cpp
HDRS add_math_entrypoint_object(
fma.h sinf
DEPENDS DEPENDS
libc.include.math
libc.src.__support.FPUtil.fputil libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS libc.src.errno.__errno_location
-O2 libc.src.math.internal.sincosf_utils
COMPILE_OPTIONS -O3
)
add_math_entrypoint_object(
sincosf
DEPENDS
libc.include.math
libc.src.errno.__errno_location
libc.src.math.internal.sincosf_utils
)
add_math_entrypoint_object(
fabs
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
fabsf
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
fabsl
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
trunc
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
truncf
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
truncl
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
floor
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
floorf
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
floorl
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
round
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
roundf
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
roundl
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
lround
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
lroundf
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
lroundl
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
llround
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
llroundf
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
llroundl
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
rint
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
rintf
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
rintl
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
lrint
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
lrintf
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
lrintl
DEPENDS libc.src.__support.FPUtil.fputil
) )
add_math_entrypoint_object(ceil) add_math_entrypoint_object(
add_math_entrypoint_object(ceilf) llrint
add_math_entrypoint_object(ceill) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(copysign) add_math_entrypoint_object(
add_math_entrypoint_object(copysignf) llrintf
add_math_entrypoint_object(copysignl) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(cos) add_math_entrypoint_object(
add_math_entrypoint_object(cosf) llrintl
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(expf) add_math_entrypoint_object(
nearbyint
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(exp2f) add_math_entrypoint_object(
nearbyintf
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(expm1f) add_math_entrypoint_object(
nearbyintl
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(fabs) add_math_entrypoint_object(
add_math_entrypoint_object(fabsf) expf
add_math_entrypoint_object(fabsl) DEPENDS
libc.src.math.internal.exp_utils
libc.src.math.internal.math_utils
libc.include.math
)
add_math_entrypoint_object(fdim) add_math_entrypoint_object(
add_math_entrypoint_object(fdimf) exp2f
add_math_entrypoint_object(fdiml) DEPENDS
libc.src.math.internal.exp_utils
libc.src.math.internal.math_utils
libc.include.math
)
add_math_entrypoint_object(floor) add_math_entrypoint_object(
add_math_entrypoint_object(floorf) expm1f
add_math_entrypoint_object(floorl) DEPENDS libc.include.math
libc.src.math.expf
libc.src.math.fabsf
)
add_math_entrypoint_object(fmax) add_math_entrypoint_object(
add_math_entrypoint_object(fmaxf) copysign
add_math_entrypoint_object(fmaxl) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(fmin) add_math_entrypoint_object(
add_math_entrypoint_object(fminf) copysignf
add_math_entrypoint_object(fminl) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(frexp) add_math_entrypoint_object(
add_math_entrypoint_object(frexpf) copysignl
add_math_entrypoint_object(frexpl) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(hypot) add_math_entrypoint_object(
add_math_entrypoint_object(hypotf) frexp
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(ilogb) add_math_entrypoint_object(
add_math_entrypoint_object(ilogbf) frexpf
add_math_entrypoint_object(ilogbl) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(ldexp) add_math_entrypoint_object(
add_math_entrypoint_object(ldexpf) frexpl
add_math_entrypoint_object(ldexpl) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(logb) add_math_entrypoint_object(
add_math_entrypoint_object(logbf) ilogb
add_math_entrypoint_object(logbl) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(llrint) add_math_entrypoint_object(
add_math_entrypoint_object(llrintf) ilogbf
add_math_entrypoint_object(llrintl) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(llround) add_math_entrypoint_object(
add_math_entrypoint_object(llroundf) ilogbl
add_math_entrypoint_object(llroundl) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(lrint) add_math_entrypoint_object(
add_math_entrypoint_object(lrintf) ldexp
add_math_entrypoint_object(lrintl) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(lround) add_math_entrypoint_object(
add_math_entrypoint_object(lroundf) ldexpf
add_math_entrypoint_object(lroundl) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(modf) add_math_entrypoint_object(
add_math_entrypoint_object(modff) ldexpl
add_math_entrypoint_object(modfl) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(nearbyint) add_math_entrypoint_object(
add_math_entrypoint_object(nearbyintf) logb
add_math_entrypoint_object(nearbyintl) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
logbf
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(nextafter) add_math_entrypoint_object(
add_math_entrypoint_object(nextafterf) logbl
add_math_entrypoint_object(nextafterl) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(remainder) add_math_entrypoint_object(
add_math_entrypoint_object(remainderf) modf
add_math_entrypoint_object(remainderl) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(remquo) add_math_entrypoint_object(
add_math_entrypoint_object(remquof) modff
add_math_entrypoint_object(remquol) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(rint) add_math_entrypoint_object(
add_math_entrypoint_object(rintf) modfl
add_math_entrypoint_object(rintl) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(round) add_math_entrypoint_object(
add_math_entrypoint_object(roundf) fmin
add_math_entrypoint_object(roundl) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(sincosf) add_math_entrypoint_object(
fminf
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(sin) add_math_entrypoint_object(
add_math_entrypoint_object(sinf) fminl
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(sqrt) add_math_entrypoint_object(
add_math_entrypoint_object(sqrtf) fmax
add_math_entrypoint_object(sqrtl) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(tan) add_math_entrypoint_object(
fmaxf
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(trunc) add_math_entrypoint_object(
add_math_entrypoint_object(truncf) fmaxl
add_math_entrypoint_object(truncl) DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
sqrt
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
tan
)
add_math_entrypoint_object(
sqrtf
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
sqrtl
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
remquof
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
remquo
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
remquol
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
remainderf
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
remainder
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
remainderl
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
hypotf
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
fdim
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
fdimf
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
fdiml
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
hypot
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
nextafter
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
nextafterf
DEPENDS libc.src.__support.FPUtil.fputil
)
add_math_entrypoint_object(
nextafterl
DEPENDS libc.src.__support.FPUtil.fputil
)

libc/src/math/aarch64/CMakeLists.txt

  • This file was deleted.
add_entrypoint_object(
ceil
SRCS
ceil.cpp
HDRS
../ceil.h
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
ceilf
SRCS
ceilf.cpp
HDRS
../ceilf.h
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
floor
SRCS
floor.cpp
HDRS
../floor.h
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
floorf
SRCS
floorf.cpp
HDRS
../floorf.h
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
trunc
SRCS
trunc.cpp
HDRS
../trunc.h
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
truncf
SRCS
truncf.cpp
HDRS
../truncf.h
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
round
SRCS
round.cpp
HDRS
../round.h
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
roundf
SRCS
roundf.cpp
HDRS
../roundf.h
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
sqrt
SRCS
sqrt.cpp
HDRS
../sqrt.h
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
sqrtf
SRCS
sqrtf.cpp
HDRS
../sqrtf.h
COMPILE_OPTIONS
-O2
)

libc/src/math/ceil.cpp

  • This file was moved from libc/src/math/generic/ceil.cpp.
//===-- Implementation of ceil function -----------------------------------===// //===-- Implementation of ceil function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/ceil.h" #include "src/__support/architectures.h"
#if defined(LLVM_LIBC_ARCH_AARCH64)
#include "aarch64/ceil.cpp"
#else
#include "ceil.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, ceil, (double x)) { return fputil::ceil(x); } LLVM_LIBC_FUNCTION(double, ceil, (double x)) { return fputil::ceil(x); }
} // namespace __llvm_libc } // namespace __llvm_libc
#endif

libc/src/math/ceilf.cpp

  • This file was moved from libc/src/math/generic/ceilf.cpp.
//===-- Implementation of ceilf function ----------------------------------===// //===-- Implementation of ceilf function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/ceilf.h" #include "src/__support/architectures.h"
#if defined(LLVM_LIBC_ARCH_AARCH64)
#include "aarch64/ceilf.cpp"
#else
#include "ceilf.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, ceilf, (float x)) { return fputil::ceil(x); } LLVM_LIBC_FUNCTION(float, ceilf, (float x)) { return fputil::ceil(x); }
} // namespace __llvm_libc } // namespace __llvm_libc
#endif

libc/src/math/ceill.cpp

  • This file was moved from libc/src/math/generic/ceill.cpp.
//===-- Implementation of ceill function ----------------------------------===// //===-- Implementation of ceill function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/ceill.h" #include "ceill.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, ceill, (long double x)) { LLVM_LIBC_FUNCTION(long double, ceill, (long double x)) {
return fputil::ceil(x); return fputil::ceil(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/copysign.cpp

  • This file was moved from libc/src/math/generic/copysign.cpp.
//===-- Implementation of copysign function -------------------------------===// //===-- Implementation of copysign function -------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/copysign.h" #include "copysign.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, copysign, (double x, double y)) { LLVM_LIBC_FUNCTION(double, copysign, (double x, double y)) {
return fputil::copysign(x, y); return fputil::copysign(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/copysignf.cpp

  • This file was moved from libc/src/math/generic/copysignf.cpp.
//===-- Implementation of copysignf function ------------------------------===// //===-- Implementation of copysignf function ------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/copysignf.h" #include "copysignf.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, copysignf, (float x, float y)) { LLVM_LIBC_FUNCTION(float, copysignf, (float x, float y)) {
return fputil::copysign(x, y); return fputil::copysign(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/copysignl.cpp

  • This file was moved from libc/src/math/generic/copysignl.cpp.
//===-- Implementation of copysignl function ------------------------------===// //===-- Implementation of copysignl function ------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/copysignl.h" #include "copysignl.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, copysignl, (long double x, long double y)) { LLVM_LIBC_FUNCTION(long double, copysignl, (long double x, long double y)) {
return fputil::copysign(x, y); return fputil::copysign(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/cos.cpp

  • This file was copied from libc/src/math/generic/sqrt.cpp.
//===-- Implementation of sqrt function -----------------------------------===// //===-- Implementation of the cos function --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/sqrt.h" #include "src/__support/architectures.h"
#include "src/__support/FPUtil/Sqrt.h"
#include "src/__support/common.h"
namespace __llvm_libc { #if defined(LLVM_LIBC_ARCH_X86)
#include "x86_64/cos.cpp"
LLVM_LIBC_FUNCTION(double, sqrt, (double x)) { return fputil::sqrt(x); } #endif
} // namespace __llvm_libc

libc/src/math/cosf.cpp

  • This file was moved from libc/src/math/generic/cosf.cpp.
//===-- Single-precision cos function -------------------------------------===// //===-- Single-precision cos function -------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/cosf.h" #include "cosf.h"
#include "math_utils.h" #include "internal/math_utils.h"
#include "sincosf_utils.h" #include "internal/sincosf_utils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include <math.h> #include <math.h>
#include <stdint.h> #include <stdint.h>
namespace __llvm_libc { namespace __llvm_libc {
// Fast cosf implementation. Worst-case ULP is 0.5607, maximum relative // Fast cosf implementation. Worst-case ULP is 0.5607, maximum relative
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libc/src/math/exp2f.cpp

  • This file was moved from libc/src/math/generic/exp2f.cpp.
//===-- Single-precision 2^x function -------------------------------------===// //===-- Single-precision 2^x function -------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/exp2f.h" #include "exp2f.h"
#include "exp_utils.h" #include "internal/exp_utils.h"
#include "math_utils.h" #include "internal/math_utils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include <math.h> #include <math.h>
#include <stdint.h> #include <stdint.h>
#define T exp2f_data.tab #define T exp2f_data.tab
#define C exp2f_data.poly #define C exp2f_data.poly
#define SHIFT exp2f_data.shift_scaled #define SHIFT exp2f_data.shift_scaled
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libc/src/math/expf.cpp

  • This file was moved from libc/src/math/generic/expf.cpp.
//===-- Single-precision e^x function -------------------------------------===// //===-- Single-precision e^x function -------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/expf.h" #include "expf.h"
#include "exp_utils.h" #include "internal/exp_utils.h"
#include "math_utils.h" #include "internal/math_utils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include <math.h> #include <math.h>
#include <stdint.h> #include <stdint.h>
#define InvLn2N exp2f_data.invln2_scaled #define InvLn2N exp2f_data.invln2_scaled
#define T exp2f_data.tab #define T exp2f_data.tab
#define C exp2f_data.poly_scaled #define C exp2f_data.poly_scaled
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

libc/src/math/expm1f.cpp

  • This file was moved from libc/src/math/generic/expm1f.cpp.
//===-- Implementation of expm1f function ---------------------------------===// //===-- Implementation of expm1f function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/expm1f.h" #include "expm1f.h"
#include "expf.h"
#include "src/__support/FPUtil/BasicOperations.h" #include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/FPUtil/PolyEval.h" #include "src/__support/FPUtil/PolyEval.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "src/math/expf.h"
namespace __llvm_libc { namespace __llvm_libc {
// When |x| > Ln2, catastrophic cancellation does not occur with the // When |x| > Ln2, catastrophic cancellation does not occur with the
// subtraction expf(x) - 1.0f, so we use it to compute expm1f(x). // subtraction expf(x) - 1.0f, so we use it to compute expm1f(x).
// //
// We divide [-Ln2; Ln2] into 3 subintervals [-Ln2; -1/8], [-1/8; 1/8], // We divide [-Ln2; Ln2] into 3 subintervals [-Ln2; -1/8], [-1/8; 1/8],
// [1/8; Ln2]. And we use a degree-6 polynomial to approximate exp(x) - 1 in // [1/8; Ln2]. And we use a degree-6 polynomial to approximate exp(x) - 1 in
Show All 36 Lines

libc/src/math/fabs.cpp

  • This file was moved from libc/src/math/generic/fabs.cpp.
//===-- Implementation of fabs function -----------------------------------===// //===-- Implementation of fabs function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fabs.h" #include "fabs.h"
#include "src/__support/FPUtil/BasicOperations.h" #include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, fabs, (double x)) { return fputil::abs(x); } LLVM_LIBC_FUNCTION(double, fabs, (double x)) { return fputil::abs(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/fabsf.cpp

  • This file was moved from libc/src/math/generic/fabsf.cpp.
//===-- Implementation of fabsf function ----------------------------------===// //===-- Implementation of fabsf function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fabsf.h" #include "fabsf.h"
#include "src/__support/FPUtil/BasicOperations.h" #include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, fabsf, (float x)) { return fputil::abs(x); } LLVM_LIBC_FUNCTION(float, fabsf, (float x)) { return fputil::abs(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/fabsl.cpp

  • This file was moved from libc/src/math/generic/fabsl.cpp.
//===-- Implementation of fabsf function ----------------------------------===// //===-- Implementation of fabsf function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fabsl.h" #include "fabsl.h"
#include "src/__support/FPUtil/BasicOperations.h" #include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, fabsl, (long double x)) { LLVM_LIBC_FUNCTION(long double, fabsl, (long double x)) {
return fputil::abs(x); return fputil::abs(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/fdim.cpp

  • This file was moved from libc/src/math/generic/fdim.cpp.
//===-- Implementation of fdim function -----------------------------------===// //===-- Implementation of fdim function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fdim.h" #include "fdim.h"
#include "src/__support/FPUtil/BasicOperations.h" #include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, fdim, (double x, double y)) { LLVM_LIBC_FUNCTION(double, fdim, (double x, double y)) {
return fputil::fdim(x, y); return fputil::fdim(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/fdimf.cpp

  • This file was moved from libc/src/math/generic/fdimf.cpp.
//===-- Implementation of fdimf function ----------------------------------===// //===-- Implementation of fdimf function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fdimf.h" #include "fdimf.h"
#include "src/__support/FPUtil/BasicOperations.h" #include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, fdimf, (float x, float y)) { LLVM_LIBC_FUNCTION(float, fdimf, (float x, float y)) {
return fputil::fdim(x, y); return fputil::fdim(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/fdiml.cpp

  • This file was moved from libc/src/math/generic/fdiml.cpp.
//===-- Implementation of fdiml function ----------------------------------===// //===-- Implementation of fdiml function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fdiml.h" #include "fdiml.h"
#include "src/__support/FPUtil/BasicOperations.h" #include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, fdiml, (long double x, long double y)) { LLVM_LIBC_FUNCTION(long double, fdiml, (long double x, long double y)) {
return fputil::fdim(x, y); return fputil::fdim(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/floor.cpp

  • This file was moved from libc/src/math/generic/floor.cpp.
//===-- Implementation of floor function ----------------------------------===// //===-- Implementation of floor function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/floor.h" #include "src/__support/architectures.h"
#if defined(LLVM_LIBC_ARCH_AARCH64)
#include "aarch64/floor.cpp"
#else
#include "floor.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, floor, (double x)) { return fputil::floor(x); } LLVM_LIBC_FUNCTION(double, floor, (double x)) { return fputil::floor(x); }
} // namespace __llvm_libc } // namespace __llvm_libc
#endif

libc/src/math/floorf.cpp

  • This file was moved from libc/src/math/generic/floorf.cpp.
//===-- Implementation of floorf function ---------------------------------===// //===-- Implementation of floorf function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/floorf.h" #include "src/__support/architectures.h"
#if defined(LLVM_LIBC_ARCH_AARCH64)
#include "aarch64/floorf.cpp"
#else
#include "floorf.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, floorf, (float x)) { return fputil::floor(x); } LLVM_LIBC_FUNCTION(float, floorf, (float x)) { return fputil::floor(x); }
} // namespace __llvm_libc } // namespace __llvm_libc
#endif

libc/src/math/floorl.cpp

  • This file was moved from libc/src/math/generic/floorl.cpp.
//===-- Implementation of floorl function ---------------------------------===// //===-- Implementation of floorl function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/floorl.h" #include "floorl.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, floorl, (long double x)) { LLVM_LIBC_FUNCTION(long double, floorl, (long double x)) {
return fputil::floor(x); return fputil::floor(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/fma.cpp

//===-- Implementation of fma function ------------------------------------===// //===-- Implementation of fma function ------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fma.h" #include "fma.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "src/__support/FPUtil/FMA.h" #include "src/__support/FPUtil/FMA.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, fma, (double x, double y, double z)) { LLVM_LIBC_FUNCTION(double, fma, (double x, double y, double z)) {
return fputil::fma(x, y, z); return fputil::fma(x, y, z);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/fmaf.cpp

//===-- Implementation of fmaf function -----------------------------------===// //===-- Implementation of fmaf function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fmaf.h" #include "fmaf.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "src/__support/FPUtil/FMA.h" #include "src/__support/FPUtil/FMA.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, fmaf, (float x, float y, float z)) { LLVM_LIBC_FUNCTION(float, fmaf, (float x, float y, float z)) {
return fputil::fma(x, y, z); return fputil::fma(x, y, z);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/fmax.cpp

  • This file was moved from libc/src/math/generic/fmax.cpp.
//===-- Implementation of fmax function -----------------------------------===// //===-- Implementation of fmax function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fmax.h" #include "fmax.h"
#include "src/__support/FPUtil/BasicOperations.h" #include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, fmax, (double x, double y)) { LLVM_LIBC_FUNCTION(double, fmax, (double x, double y)) {
return fputil::fmax(x, y); return fputil::fmax(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/fmaxf.cpp

  • This file was moved from libc/src/math/generic/fmaxf.cpp.
//===-- Implementation of fmaxf function ----------------------------------===// //===-- Implementation of fmaxf function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fmaxf.h" #include "fmaxf.h"
#include "src/__support/FPUtil/BasicOperations.h" #include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, fmaxf, (float x, float y)) { LLVM_LIBC_FUNCTION(float, fmaxf, (float x, float y)) {
return fputil::fmax(x, y); return fputil::fmax(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/fmaxl.cpp

  • This file was moved from libc/src/math/generic/fmaxl.cpp.
//===-- Implementation of fmaxl function ----------------------------------===// //===-- Implementation of fmaxl function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fmaxl.h" #include "fmaxl.h"
#include "src/__support/FPUtil/BasicOperations.h" #include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, fmaxl, (long double x, long double y)) { LLVM_LIBC_FUNCTION(long double, fmaxl, (long double x, long double y)) {
return fputil::fmax(x, y); return fputil::fmax(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/fmin.cpp

  • This file was moved from libc/src/math/generic/fmin.cpp.
//===-- Implementation of fmin function -----------------------------------===// //===-- Implementation of fmin function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fmin.h" #include "fmin.h"
#include "src/__support/FPUtil/BasicOperations.h" #include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, fmin, (double x, double y)) { LLVM_LIBC_FUNCTION(double, fmin, (double x, double y)) {
return fputil::fmin(x, y); return fputil::fmin(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/fminf.cpp

  • This file was moved from libc/src/math/generic/fminf.cpp.
//===-- Implementation of fminf function ----------------------------------===// //===-- Implementation of fminf function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fminf.h" #include "fminf.h"
#include "src/__support/FPUtil/BasicOperations.h" #include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, fminf, (float x, float y)) { LLVM_LIBC_FUNCTION(float, fminf, (float x, float y)) {
return fputil::fmin(x, y); return fputil::fmin(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/fminl.cpp

  • This file was moved from libc/src/math/generic/fminl.cpp.
//===-- Implementation of fminl function ----------------------------------===// //===-- Implementation of fminl function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/fminl.h" #include "fminl.h"
#include "src/__support/FPUtil/BasicOperations.h" #include "src/__support/FPUtil/BasicOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, fminl, (long double x, long double y)) { LLVM_LIBC_FUNCTION(long double, fminl, (long double x, long double y)) {
return fputil::fmin(x, y); return fputil::fmin(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/frexp.cpp

  • This file was moved from libc/src/math/generic/frexp.cpp.
//===-- Implementation of frexp function ----------------------------------===// //===-- Implementation of frexp function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/frexp.h" #include "frexp.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, frexp, (double x, int *exp)) { LLVM_LIBC_FUNCTION(double, frexp, (double x, int *exp)) {
return fputil::frexp(x, *exp); return fputil::frexp(x, *exp);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/frexpf.cpp

  • This file was moved from libc/src/math/generic/frexpf.cpp.
//===-- Implementation of frexpf function ---------------------------------===// //===-- Implementation of frexpf function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/frexpf.h" #include "frexpf.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, frexpf, (float x, int *exp)) { LLVM_LIBC_FUNCTION(float, frexpf, (float x, int *exp)) {
return fputil::frexp(x, *exp); return fputil::frexp(x, *exp);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/frexpl.cpp

  • This file was moved from libc/src/math/generic/frexpl.cpp.
//===-- Implementation of frexpl function ---------------------------------===// //===-- Implementation of frexpl function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/frexpl.h" #include "frexpl.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, frexpl, (long double x, int *exp)) { LLVM_LIBC_FUNCTION(long double, frexpl, (long double x, int *exp)) {
return fputil::frexp(x, *exp); return fputil::frexp(x, *exp);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/generic/CMakeLists.txt

  • This file was deleted.
add_entrypoint_object(
ceil
SRCS
ceil.cpp
HDRS
../ceil.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
ceilf
SRCS
ceilf.cpp
HDRS
../ceilf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
ceill
SRCS
ceill.cpp
HDRS
../ceill.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_object_library(
math_utils
SRCS
math_utils.cpp
HDRS
math_utils.h
DEPENDS
libc.include.errno
libc.include.math
libc.src.errno.__errno_location
)
add_object_library(
sincosf_utils
HDRS
sincosf_utils.h
SRCS
sincosf_data.cpp
DEPENDS
.math_utils
)
add_entrypoint_object(
cosf
SRCS
cosf.cpp
HDRS
../cosf.h
DEPENDS
.sincosf_utils
libc.include.math
libc.src.errno.__errno_location
)
add_entrypoint_object(
sinf
SRCS
sinf.cpp
HDRS
../sinf.h
DEPENDS
.sincosf_utils
libc.include.math
libc.src.errno.__errno_location
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O3
)
add_entrypoint_object(
sincosf
SRCS
sincosf.cpp
HDRS
../sincosf.h
DEPENDS
.sincosf_utils
libc.include.math
libc.src.errno.__errno_location
)
add_entrypoint_object(
fabs
SRCS
fabs.cpp
HDRS
../fabs.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
fabsf
SRCS
fabsf.cpp
HDRS
../fabsf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
fabsl
SRCS
fabsl.cpp
HDRS
../fabsl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
trunc
SRCS
trunc.cpp
HDRS
../trunc.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
truncf
SRCS
truncf.cpp
HDRS
../truncf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
truncl
SRCS
truncl.cpp
HDRS
../truncl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
floor
SRCS
floor.cpp
HDRS
../floor.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
floorf
SRCS
floorf.cpp
HDRS
../floorf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
floorl
SRCS
floorl.cpp
HDRS
../floorl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
round
SRCS
round.cpp
HDRS
../round.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
roundf
SRCS
roundf.cpp
HDRS
../roundf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
roundl
SRCS
roundl.cpp
HDRS
../roundl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
lround
SRCS
lround.cpp
HDRS
../lround.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
lroundf
SRCS
lroundf.cpp
HDRS
../lroundf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
lroundl
SRCS
lroundl.cpp
HDRS
../lroundl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
llround
SRCS
llround.cpp
HDRS
../llround.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
llroundf
SRCS
llroundf.cpp
HDRS
../llroundf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
llroundl
SRCS
llroundl.cpp
HDRS
../llroundl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
rint
SRCS
rint.cpp
HDRS
../rint.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
rintf
SRCS
rintf.cpp
HDRS
../rintf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
rintl
SRCS
rintl.cpp
HDRS
../rintl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
lrint
SRCS
lrint.cpp
HDRS
../lrint.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
lrintf
SRCS
lrintf.cpp
HDRS
../lrintf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
lrintl
SRCS
lrintl.cpp
HDRS
../lrintl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
llrint
SRCS
llrint.cpp
HDRS
../llrint.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
llrintf
SRCS
llrintf.cpp
HDRS
../llrintf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
llrintl
SRCS
llrintl.cpp
HDRS
../llrintl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
nearbyint
SRCS
nearbyint.cpp
HDRS
../nearbyint.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
nearbyintf
SRCS
nearbyintf.cpp
HDRS
../nearbyintf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
nearbyintl
SRCS
nearbyintl.cpp
HDRS
../nearbyintl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_object_library(
exp_utils
HDRS
exp_utils.h
SRCS
exp_utils.cpp
DEPENDS
.math_utils
)
add_entrypoint_object(
expf
SRCS
expf.cpp
HDRS
../expf.h
DEPENDS
.exp_utils
.math_utils
libc.include.math
)
add_entrypoint_object(
exp2f
SRCS
exp2f.cpp
HDRS
../exp2f.h
DEPENDS
.exp_utils
.math_utils
libc.include.math
)
add_entrypoint_object(
expm1f
SRCS
expm1f.cpp
HDRS
../expm1f.h
DEPENDS
libc.include.math
libc.src.math.expf
libc.src.math.fabsf
)
add_entrypoint_object(
copysign
SRCS
copysign.cpp
HDRS
../copysign.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
copysignf
SRCS
copysignf.cpp
HDRS
../copysignf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
copysignl
SRCS
copysignl.cpp
HDRS
../copysignl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
frexp
SRCS
frexp.cpp
HDRS
../frexp.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
frexpf
SRCS
frexpf.cpp
HDRS
../frexpf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
frexpl
SRCS
frexpl.cpp
HDRS
../frexpl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
ilogb
SRCS
ilogb.cpp
HDRS
../ilogb.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
ilogbf
SRCS
ilogbf.cpp
HDRS
../ilogbf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
ilogbl
SRCS
ilogbl.cpp
HDRS
../ilogbl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
ldexp
SRCS
ldexp.cpp
HDRS
../ldexp.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
ldexpf
SRCS
ldexpf.cpp
HDRS
../ldexpf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
ldexpl
SRCS
ldexpl.cpp
HDRS
../ldexpl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
logb
SRCS
logb.cpp
HDRS
../logb.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
logbf
SRCS
logbf.cpp
HDRS
../logbf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
logbl
SRCS
logbl.cpp
HDRS
../logbl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
modf
SRCS
modf.cpp
HDRS
../modf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
modff
SRCS
modff.cpp
HDRS
../modff.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
modfl
SRCS
modfl.cpp
HDRS
../modfl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
fmin
SRCS
fmin.cpp
HDRS
../fmin.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
fminf
SRCS
fminf.cpp
HDRS
../fminf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
fminl
SRCS
fminl.cpp
HDRS
../fminl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
fmax
SRCS
fmax.cpp
HDRS
../fmax.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
fmaxf
SRCS
fmaxf.cpp
HDRS
../fmaxf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
fmaxl
SRCS
fmaxl.cpp
HDRS
../fmaxl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
sqrt
SRCS
sqrt.cpp
HDRS
../sqrt.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
sqrtf
SRCS
sqrtf.cpp
HDRS
../sqrtf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
sqrtl
SRCS
sqrtl.cpp
HDRS
../sqrtl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
remquof
SRCS
remquof.cpp
HDRS
../remquof.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
remquo
SRCS
remquo.cpp
HDRS
../remquo.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
remquol
SRCS
remquol.cpp
HDRS
../remquol.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
remainderf
SRCS
remainderf.cpp
HDRS
../remainderf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
remainder
SRCS
remainder.cpp
HDRS
../remainder.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
remainderl
SRCS
remainderl.cpp
HDRS
../remainderl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
hypotf
SRCS
hypotf.cpp
HDRS
../hypotf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
fdim
SRCS
fdim.cpp
HDRS
../fdim.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
fdimf
SRCS
fdimf.cpp
HDRS
../fdimf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
fdiml
SRCS
fdiml.cpp
HDRS
../fdiml.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
hypot
SRCS
hypot.cpp
HDRS
../hypot.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
nextafter
SRCS
nextafter.cpp
HDRS
../nextafter.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
nextafterf
SRCS
nextafterf.cpp
HDRS
../nextafterf.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
nextafterl
SRCS
nextafterl.cpp
HDRS
../nextafterl.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O2
)
add_object_library(
dp_trig
SRCS
dp_trig.cpp
HDRS
dp_trig.h
DEPENDS
libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS
-O3
)

libc/src/math/generic/ceil.cpp

  • This file was moved to libc/src/math/ceil.cpp.

libc/src/math/generic/ceilf.cpp

  • This file was moved to libc/src/math/ceilf.cpp.

libc/src/math/generic/ceill.cpp

  • This file was moved to libc/src/math/ceill.cpp.

libc/src/math/generic/copysign.cpp

  • This file was moved to libc/src/math/copysign.cpp.

libc/src/math/generic/copysignf.cpp

  • This file was moved to libc/src/math/copysignf.cpp.

libc/src/math/generic/copysignl.cpp

  • This file was moved to libc/src/math/copysignl.cpp.

libc/src/math/generic/cosf.cpp

  • This file was moved to libc/src/math/cosf.cpp.

libc/src/math/generic/dp_trig.h

  • This file was moved to libc/src/math/internal/dp_trig.h.

libc/src/math/generic/dp_trig.cpp

  • This file was moved to libc/src/math/internal/dp_trig.cpp.

libc/src/math/generic/exp2f.cpp

  • This file was moved to libc/src/math/exp2f.cpp.

libc/src/math/generic/exp_utils.h

  • This file was moved to libc/src/math/internal/exp_utils.h.

libc/src/math/generic/exp_utils.cpp

  • This file was moved to libc/src/math/internal/exp_utils.cpp.

libc/src/math/generic/expf.cpp

  • This file was moved to libc/src/math/expf.cpp.

libc/src/math/generic/expm1f.cpp

  • This file was moved to libc/src/math/expm1f.cpp.

libc/src/math/generic/fabs.cpp

  • This file was moved to libc/src/math/fabs.cpp.

libc/src/math/generic/fabsf.cpp

  • This file was moved to libc/src/math/fabsf.cpp.

libc/src/math/generic/fabsl.cpp

  • This file was moved to libc/src/math/fabsl.cpp.

libc/src/math/generic/fdim.cpp

  • This file was moved to libc/src/math/fdim.cpp.

libc/src/math/generic/fdimf.cpp

  • This file was moved to libc/src/math/fdimf.cpp.

libc/src/math/generic/fdiml.cpp

  • This file was moved to libc/src/math/fdiml.cpp.

libc/src/math/generic/floor.cpp

  • This file was moved to libc/src/math/floor.cpp.

libc/src/math/generic/floorf.cpp

  • This file was moved to libc/src/math/floorf.cpp.

libc/src/math/generic/floorl.cpp

  • This file was moved to libc/src/math/floorl.cpp.

libc/src/math/generic/fmax.cpp

  • This file was moved to libc/src/math/fmax.cpp.

libc/src/math/generic/fmaxf.cpp

  • This file was moved to libc/src/math/fmaxf.cpp.

libc/src/math/generic/fmaxl.cpp

  • This file was moved to libc/src/math/fmaxl.cpp.

libc/src/math/generic/fmin.cpp

  • This file was moved to libc/src/math/fmin.cpp.

libc/src/math/generic/fminf.cpp

  • This file was moved to libc/src/math/fminf.cpp.

libc/src/math/generic/fminl.cpp

  • This file was moved to libc/src/math/fminl.cpp.

libc/src/math/generic/frexp.cpp

  • This file was moved to libc/src/math/frexp.cpp.

libc/src/math/generic/frexpf.cpp

  • This file was moved to libc/src/math/frexpf.cpp.

libc/src/math/generic/frexpl.cpp

  • This file was moved to libc/src/math/frexpl.cpp.

libc/src/math/generic/hypot.cpp

  • This file was moved to libc/src/math/hypot.cpp.

libc/src/math/generic/hypotf.cpp

  • This file was moved to libc/src/math/hypotf.cpp.

libc/src/math/generic/ilogb.cpp

  • This file was moved to libc/src/math/ilogb.cpp.

libc/src/math/generic/ilogbf.cpp

  • This file was moved to libc/src/math/ilogbf.cpp.

libc/src/math/generic/ilogbl.cpp

  • This file was moved to libc/src/math/ilogbl.cpp.

libc/src/math/generic/ldexp.cpp

  • This file was moved to libc/src/math/ldexp.cpp.

libc/src/math/generic/ldexpf.cpp

  • This file was moved to libc/src/math/ldexpf.cpp.

libc/src/math/generic/ldexpl.cpp

  • This file was moved to libc/src/math/ldexpl.cpp.

libc/src/math/generic/llrint.cpp

  • This file was moved to libc/src/math/llrint.cpp.

libc/src/math/generic/llrintf.cpp

  • This file was moved to libc/src/math/llrintf.cpp.

libc/src/math/generic/llrintl.cpp

  • This file was moved to libc/src/math/llrintl.cpp.

libc/src/math/generic/llround.cpp

  • This file was moved to libc/src/math/llround.cpp.

libc/src/math/generic/llroundf.cpp

  • This file was moved to libc/src/math/llroundf.cpp.

libc/src/math/generic/llroundl.cpp

  • This file was moved to libc/src/math/llroundl.cpp.

libc/src/math/generic/logb.cpp

  • This file was moved to libc/src/math/logb.cpp.

libc/src/math/generic/logbf.cpp

  • This file was moved to libc/src/math/logbf.cpp.

libc/src/math/generic/logbl.cpp

  • This file was moved to libc/src/math/logbl.cpp.

libc/src/math/generic/lrint.cpp

  • This file was moved to libc/src/math/lrint.cpp.

libc/src/math/generic/lrintf.cpp

  • This file was moved to libc/src/math/lrintf.cpp.

libc/src/math/generic/lrintl.cpp

  • This file was moved to libc/src/math/lrintl.cpp.

libc/src/math/generic/lround.cpp

  • This file was moved to libc/src/math/lround.cpp.

libc/src/math/generic/lroundf.cpp

  • This file was moved to libc/src/math/lroundf.cpp.

libc/src/math/generic/lroundl.cpp

  • This file was moved to libc/src/math/lroundl.cpp.

libc/src/math/generic/math_utils.h

  • This file was moved to libc/src/math/internal/math_utils.h.

libc/src/math/generic/math_utils.cpp

  • This file was moved to libc/src/math/internal/math_utils.cpp.

libc/src/math/generic/modf.cpp

  • This file was moved to libc/src/math/modf.cpp.

libc/src/math/generic/modff.cpp

  • This file was moved to libc/src/math/modff.cpp.

libc/src/math/generic/modfl.cpp

  • This file was moved to libc/src/math/modfl.cpp.

libc/src/math/generic/nearbyint.cpp

  • This file was moved to libc/src/math/nearbyint.cpp.

libc/src/math/generic/nearbyintf.cpp

  • This file was moved to libc/src/math/nearbyintf.cpp.

libc/src/math/generic/nearbyintl.cpp

  • This file was moved to libc/src/math/nearbyintl.cpp.

libc/src/math/generic/nextafter.cpp

  • This file was moved to libc/src/math/nextafter.cpp.

libc/src/math/generic/nextafterf.cpp

  • This file was moved to libc/src/math/nextafterf.cpp.

libc/src/math/generic/nextafterl.cpp

  • This file was moved to libc/src/math/nextafterl.cpp.

libc/src/math/generic/remainder.cpp

  • This file was moved to libc/src/math/remainder.cpp.

libc/src/math/generic/remainderf.cpp

  • This file was moved to libc/src/math/remainderf.cpp.

libc/src/math/generic/remainderl.cpp

  • This file was moved to libc/src/math/remainderl.cpp.

libc/src/math/generic/remquo.cpp

  • This file was moved to libc/src/math/remquo.cpp.

libc/src/math/generic/remquof.cpp

  • This file was moved to libc/src/math/remquof.cpp.

libc/src/math/generic/remquol.cpp

  • This file was moved to libc/src/math/remquol.cpp.

libc/src/math/generic/rint.cpp

  • This file was moved to libc/src/math/rint.cpp.

libc/src/math/generic/rintf.cpp

  • This file was moved to libc/src/math/rintf.cpp.

libc/src/math/generic/rintl.cpp

  • This file was moved to libc/src/math/rintl.cpp.

libc/src/math/generic/round.cpp

  • This file was moved to libc/src/math/round.cpp.

libc/src/math/generic/roundf.cpp

  • This file was moved to libc/src/math/roundf.cpp.

libc/src/math/generic/roundl.cpp

  • This file was moved to libc/src/math/roundl.cpp.

libc/src/math/generic/sincosf.cpp

  • This file was moved to libc/src/math/sincosf.cpp.

libc/src/math/generic/sincosf_data.cpp

  • This file was moved to libc/src/math/internal/sincosf_data.cpp.

libc/src/math/generic/sincosf_utils.h

  • This file was moved to libc/src/math/internal/sincosf_utils.h.

libc/src/math/generic/sinf.cpp

  • This file was moved to libc/src/math/sinf.cpp.

libc/src/math/generic/sqrt.cpp

  • This file was deleted after being copied to libc/src/math/cos.cpp, libc/src/math/sin.cpp, libc/src/math/sqrt.cpp, libc/src/math/tan.cpp.
The contents of this file were not changed.

libc/src/math/generic/sqrtf.cpp

  • This file was moved to libc/src/math/sqrtf.cpp.

libc/src/math/generic/sqrtl.cpp

  • This file was moved to libc/src/math/sqrtl.cpp.

libc/src/math/generic/trunc.cpp

  • This file was moved to libc/src/math/trunc.cpp.

libc/src/math/generic/truncf.cpp

  • This file was moved to libc/src/math/truncf.cpp.

libc/src/math/generic/truncl.cpp

  • This file was moved to libc/src/math/truncl.cpp.

libc/src/math/hypot.cpp

  • This file was moved from libc/src/math/generic/hypot.cpp.
//===-- Implementation of hypot function ----------------------------------===// //===-- Implementation of hypot function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/hypot.h" #include "hypot.h"
#include "src/__support/FPUtil/Hypot.h" #include "src/__support/FPUtil/Hypot.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, hypot, (double x, double y)) { LLVM_LIBC_FUNCTION(double, hypot, (double x, double y)) {
return __llvm_libc::fputil::hypot(x, y); return __llvm_libc::fputil::hypot(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/hypotf.cpp

  • This file was moved from libc/src/math/generic/hypotf.cpp.
//===-- Implementation of hypotf function ---------------------------------===// //===-- Implementation of hypotf function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/hypotf.h" #include "hypotf.h"
#include "src/__support/FPUtil/Hypot.h" #include "src/__support/FPUtil/Hypot.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, hypotf, (float x, float y)) { LLVM_LIBC_FUNCTION(float, hypotf, (float x, float y)) {
return __llvm_libc::fputil::hypot(x, y); return __llvm_libc::fputil::hypot(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/ilogb.cpp

  • This file was moved from libc/src/math/generic/ilogb.cpp.
//===-- Implementation of ilogb function ----------------------------------===// //===-- Implementation of ilogb function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/ilogb.h" #include "ilogb.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, ilogb, (double x)) { return fputil::ilogb(x); } LLVM_LIBC_FUNCTION(int, ilogb, (double x)) { return fputil::ilogb(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/ilogbf.cpp

  • This file was moved from libc/src/math/generic/ilogbf.cpp.
//===-- Implementation of ilogbf function ---------------------------------===// //===-- Implementation of ilogbf function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/ilogbf.h" #include "ilogbf.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, ilogbf, (float x)) { return fputil::ilogb(x); } LLVM_LIBC_FUNCTION(int, ilogbf, (float x)) { return fputil::ilogb(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/ilogbl.cpp

  • This file was moved from libc/src/math/generic/ilogbl.cpp.
//===-- Implementation of ilogbl function ---------------------------------===// //===-- Implementation of ilogbl function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/ilogbl.h" #include "ilogbl.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(int, ilogbl, (long double x)) { return fputil::ilogb(x); } LLVM_LIBC_FUNCTION(int, ilogbl, (long double x)) { return fputil::ilogb(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/internal/CMakeLists.txt

  • This file was added.
add_object_library(
math_utils
SRCS math_utils.cpp
HDRS math_utils.h
DEPENDS
libc.include.errno
libc.include.math
libc.src.errno.__errno_location
)
add_object_library(
sincosf_utils
HDRS sincosf_utils.h
SRCS sincosf_data.cpp
DEPENDS .math_utils
)
add_object_library(
exp_utils
HDRS exp_utils.h
SRCS exp_utils.cpp
DEPENDS .math_utils
)
add_object_library(
dp_trig
SRCS dp_trig.cpp
HDRS dp_trig.h
DEPENDS libc.src.__support.FPUtil.fputil
COMPILE_OPTIONS -O3
)

libc/src/math/internal/dp_trig.h

  • This file was moved from libc/src/math/generic/dp_trig.h.
//===-- Utilities for double precision trigonometric functions --*- C++ -*-===// //===-- Utilities for double precision trigonometric functions --*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_SRC_MATH_GENERIC_DP_TRIG_H #ifndef LLVM_LIBC_SRC_MATH_GENERIC_DP_TRIG_H
#define LLVM_LIBC_SRC_MATH_GENERIC_DP_TRIG_H #define LLVM_LIBC_SRC_MATH_GENERIC_DP_TRIG_H
namespace __llvm_libc { namespace __llvm_libc {
double mod_2pi(double); double mod_2pi(double);
double mod_pi_over_2(double); double mod_pi_over_2(double);
double mod_pi_over_4(double); double mod_pi_over_4(double);
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_GENERIC_DP_TRIG_H #endif // LLVM_LIBC_SRC_MATH_GENERIC_DP_TRIG_H

libc/src/math/internal/dp_trig.cpp

  • This file was moved from libc/src/math/generic/dp_trig.cpp.
//===-- Utilities for double precision trigonometric functions ------------===// //===-- Utilities for double precision trigonometric functions ------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/__support/FPUtil/FPBits.h" #include "src/__support/FPUtil/FPBits.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/FPUtil/UInt.h" #include "src/__support/FPUtil/UInt.h"
#include "src/__support/FPUtil/XFloat.h" #include "src/__support/FPUtil/XFloat.h"
using FPBits = __llvm_libc::fputil::FPBits<double>; using FPBits = __llvm_libc::fputil::FPBits<double>;
namespace __llvm_libc { namespace __llvm_libc {
// Implementation is based on the Payne and Hanek range reduction algorithm. // Implementation is based on the Payne and Hanek range reduction algorithm.
// The caller should ensure that x is positive. // The caller should ensure that x is positive.
// Consider: // Consider:
// x/y = x * 1/y = I + F // x/y = x * 1/y = I + F
// I is the integral part and F the fractional part of the result of the // I is the integral part and F the fractional part of the result of the
// division operation. Then M = mod(x, y) = F * y. In order to compute M, we // division operation. Then M = mod(x, y) = F * y. In order to compute M, we
// first compute F. We do it by dropping bits from 1/y which would only // first compute F. We do it by dropping bits from 1/y which would only
// contribute integral results in the operation x * 1/y. This helps us get // contribute integral results in the operation x * 1/y. This helps us get
// accurate values of F even when x is a very large number. // accurate values of F even when x is a very large number.
// //
// Internal operations are performed at 192 bits of precision. // Internal operations are performed at 192 bits of precision.
static double mod_impl(double x, const uint64_t y_bits[3], static double mod_impl(double x, const uint64_t y_bits[3],
const uint64_t inv_y_bits[20], int y_exponent, const uint64_t inv_y_bits[20], int y_exponent,
int inv_y_exponent) { int inv_y_exponent) {
FPBits bits(x); FPBits bits(x);
int exponent = bits.getExponent(); int exponent = bits.getExponent();
int bit_drop = (exponent - 52) + inv_y_exponent + 1; int bit_drop = (exponent - 52) + inv_y_exponent + 1;
bit_drop = bit_drop >= 0 ? bit_drop : 0; bit_drop = bit_drop >= 0 ? bit_drop : 0;
int word_drop = bit_drop / 64; int word_drop = bit_drop / 64;
bit_drop %= 64; bit_drop %= 64;
fputil::UInt<256> man4; fputil::UInt<256> man4;
for (size_t i = 0; i < 4; ++i) { for (size_t i = 0; i < 4; ++i) {
man4[3 - i] = inv_y_bits[word_drop + i]; man4[3 - i] = inv_y_bits[word_drop + i];
} }
man4.shift_left(bit_drop); man4.shift_left(bit_drop);
fputil::UInt<192> man_bits; fputil::UInt<192> man_bits;
for (size_t i = 0; i < 3; ++i) for (size_t i = 0; i < 3; ++i)
man_bits[i] = man4[i + 1]; man_bits[i] = man4[i + 1];
fputil::XFloat<192> result(inv_y_exponent - word_drop * 64 - bit_drop, fputil::XFloat<192> result(inv_y_exponent - word_drop * 64 - bit_drop,
man_bits); man_bits);
result.mul(x); result.mul(x);
result.drop_int(); // |result| now holds fractional part of x/y. result.drop_int(); // |result| now holds fractional part of x/y.
fputil::UInt<192> y_man; fputil::UInt<192> y_man;
for (size_t i = 0; i < 3; ++i) for (size_t i = 0; i < 3; ++i)
y_man[i] = y_bits[2 - i]; y_man[i] = y_bits[2 - i];
fputil::XFloat<192> y_192(y_exponent, y_man); fputil::XFloat<192> y_192(y_exponent, y_man);
return result.mul(y_192); return result.mul(y_192);
} }
static constexpr int TwoPIExponent = 2; static constexpr int TwoPIExponent = 2;
// The mantissa bits of 2 * PI. // The mantissa bits of 2 * PI.
// The most signification bits are in the first uint64_t word // The most signification bits are in the first uint64_t word
// and the least signification bits are in the last word. The // and the least signification bits are in the last word. The
// first word includes the implicit '1' bit. // first word includes the implicit '1' bit.
static constexpr uint64_t TwoPI[] = {0xc90fdaa22168c234, 0xc4c6628b80dc1cd1, static constexpr uint64_t TwoPI[] = {0xc90fdaa22168c234, 0xc4c6628b80dc1cd1,
0x29024e088a67cc74}; 0x29024e088a67cc74};
static constexpr int InvTwoPIExponent = -3; static constexpr int InvTwoPIExponent = -3;
// The mantissa bits of 1/(2 * PI). // The mantissa bits of 1/(2 * PI).
// The most signification bits are in the first uint64_t word // The most signification bits are in the first uint64_t word
// and the least signification bits are in the last word. The // and the least signification bits are in the last word. The
// first word includes the implicit '1' bit. // first word includes the implicit '1' bit.
static constexpr uint64_t InvTwoPI[] = { static constexpr uint64_t InvTwoPI[] = {
0xa2f9836e4e441529, 0xfc2757d1f534ddc0, 0xdb6295993c439041, 0xa2f9836e4e441529, 0xfc2757d1f534ddc0, 0xdb6295993c439041,
0xfe5163abdebbc561, 0xb7246e3a424dd2e0, 0x6492eea09d1921c, 0xfe5163abdebbc561, 0xb7246e3a424dd2e0, 0x6492eea09d1921c,
0xfe1deb1cb129a73e, 0xe88235f52ebb4484, 0xe99c7026b45f7e41, 0xfe1deb1cb129a73e, 0xe88235f52ebb4484, 0xe99c7026b45f7e41,
0x3991d639835339f4, 0x9c845f8bbdf9283b, 0x1ff897ffde05980f, 0x3991d639835339f4, 0x9c845f8bbdf9283b, 0x1ff897ffde05980f,
0xef2f118b5a0a6d1f, 0x6d367ecf27cb09b7, 0x4f463f669e5fea2d, 0xef2f118b5a0a6d1f, 0x6d367ecf27cb09b7, 0x4f463f669e5fea2d,
0x7527bac7ebe5f17b, 0x3d0739f78a5292ea, 0x6bfb5fb11f8d5d08, 0x7527bac7ebe5f17b, 0x3d0739f78a5292ea, 0x6bfb5fb11f8d5d08,
0x56033046fc7b6bab, 0xf0cfbc209af4361e}; 0x56033046fc7b6bab, 0xf0cfbc209af4361e};
double mod_2pi(double x) { double mod_2pi(double x) {
static constexpr double _2pi = 6.283185307179586; static constexpr double _2pi = 6.283185307179586;
if (x < _2pi) if (x < _2pi)
return x; return x;
return mod_impl(x, TwoPI, InvTwoPI, TwoPIExponent, InvTwoPIExponent); return mod_impl(x, TwoPI, InvTwoPI, TwoPIExponent, InvTwoPIExponent);
} }
// Returns mod(x, pi/2) // Returns mod(x, pi/2)
double mod_pi_over_2(double x) { double mod_pi_over_2(double x) {
static constexpr double pi_over_2 = 1.5707963267948966; static constexpr double pi_over_2 = 1.5707963267948966;
if (x < pi_over_2) if (x < pi_over_2)
return x; return x;
return mod_impl(x, TwoPI, InvTwoPI, TwoPIExponent - 2, InvTwoPIExponent + 2); return mod_impl(x, TwoPI, InvTwoPI, TwoPIExponent - 2, InvTwoPIExponent + 2);
} }
// Returns mod(x, pi/4) // Returns mod(x, pi/4)
double mod_pi_over_4(double x) { double mod_pi_over_4(double x) {
static constexpr double pi_over_4 = 0.7853981633974483; static constexpr double pi_over_4 = 0.7853981633974483;
if (x < pi_over_4) if (x < pi_over_4)
return x; return x;
return mod_impl(x, TwoPI, InvTwoPI, TwoPIExponent - 3, InvTwoPIExponent + 3); return mod_impl(x, TwoPI, InvTwoPI, TwoPIExponent - 3, InvTwoPIExponent + 3);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/internal/exp_utils.h

  • This file was moved from libc/src/math/generic/exp_utils.h.
//===-- Collection of utils for exp and friends -----------------*- C++ -*-===// //===-- Collection of utils for exp and friends -----------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_SRC_MATH_EXP_UTILS_H #ifndef LLVM_LIBC_SRC_MATH_EXP_UTILS_H
#define LLVM_LIBC_SRC_MATH_EXP_UTILS_H #define LLVM_LIBC_SRC_MATH_EXP_UTILS_H
#include <stdint.h> #include <stdint.h>
#define EXP2F_TABLE_BITS 5 #define EXP2F_TABLE_BITS 5
#define EXP2F_POLY_ORDER 3 #define EXP2F_POLY_ORDER 3
#define N (1 << EXP2F_TABLE_BITS) #define N (1 << EXP2F_TABLE_BITS)
namespace __llvm_libc { namespace __llvm_libc {
struct Exp2fDataTable { struct Exp2fDataTable {
uint64_t tab[1 << EXP2F_TABLE_BITS]; uint64_t tab[1 << EXP2F_TABLE_BITS];
double shift_scaled; double shift_scaled;
double poly[EXP2F_POLY_ORDER]; double poly[EXP2F_POLY_ORDER];
double shift; double shift;
double invln2_scaled; double invln2_scaled;
double poly_scaled[EXP2F_POLY_ORDER]; double poly_scaled[EXP2F_POLY_ORDER];
}; };
extern const Exp2fDataTable exp2f_data; extern const Exp2fDataTable exp2f_data;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_EXP_UTILS_H #endif // LLVM_LIBC_SRC_MATH_EXP_UTILS_H

libc/src/math/internal/exp_utils.cpp

  • This file was moved from libc/src/math/generic/exp_utils.cpp.
//===-- Implemention of exp and friends' utils ----------------------------===// //===-- Implemention of exp and friends' utils ----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "exp_utils.h" #include "exp_utils.h"
#include "math_utils.h" #include "math_utils.h"
namespace __llvm_libc { namespace __llvm_libc {
const Exp2fDataTable exp2f_data = { const Exp2fDataTable exp2f_data = {
// :tab[i] = uint(2^(i/N)) - (i << 52-BITS) // :tab[i] = uint(2^(i/N)) - (i << 52-BITS)
// used for computing 2^(k/N) for an int |k| < 150 N as // used for computing 2^(k/N) for an int |k| < 150 N as
// double(tab[k%N] + (k << 52-BITS)) // double(tab[k%N] + (k << 52-BITS))
{ {
// tab // tab
#if N == 8 #if N == 8
0x3ff0000000000000, 0x3ff0000000000000,
0x3fef72b83c7d517b, 0x3fef72b83c7d517b,
0x3fef06fe0a31b715, 0x3fef06fe0a31b715,
0x3feebfdad5362a27, 0x3feebfdad5362a27,
0x3feea09e667f3bcd, 0x3feea09e667f3bcd,
0x3feeace5422aa0db, 0x3feeace5422aa0db,
0x3feee89f995ad3ad, 0x3feee89f995ad3ad,
0x3fef5818dcfba487, 0x3fef5818dcfba487,
#elif N == 16 #elif N == 16
0x3ff0000000000000, 0x3ff0000000000000,
0x3fefb5586cf9890f, 0x3fefb5586cf9890f,
0x3fef72b83c7d517b, 0x3fef72b83c7d517b,
0x3fef387a6e756238, 0x3fef387a6e756238,
0x3fef06fe0a31b715, 0x3fef06fe0a31b715,
0x3feedea64c123422, 0x3feedea64c123422,
0x3feebfdad5362a27, 0x3feebfdad5362a27,
0x3feeab07dd485429, 0x3feeab07dd485429,
0x3feea09e667f3bcd, 0x3feea09e667f3bcd,
0x3feea11473eb0187, 0x3feea11473eb0187,
0x3feeace5422aa0db, 0x3feeace5422aa0db,
0x3feec49182a3f090, 0x3feec49182a3f090,
0x3feee89f995ad3ad, 0x3feee89f995ad3ad,
0x3fef199bdd85529c, 0x3fef199bdd85529c,
0x3fef5818dcfba487, 0x3fef5818dcfba487,
0x3fefa4afa2a490da, 0x3fefa4afa2a490da,
#elif N == 32 #elif N == 32
0x3ff0000000000000, 0x3fefd9b0d3158574, 0x3fefb5586cf9890f, 0x3ff0000000000000, 0x3fefd9b0d3158574, 0x3fefb5586cf9890f,
0x3fef9301d0125b51, 0x3fef72b83c7d517b, 0x3fef54873168b9aa, 0x3fef9301d0125b51, 0x3fef72b83c7d517b, 0x3fef54873168b9aa,
0x3fef387a6e756238, 0x3fef1e9df51fdee1, 0x3fef06fe0a31b715, 0x3fef387a6e756238, 0x3fef1e9df51fdee1, 0x3fef06fe0a31b715,
0x3feef1a7373aa9cb, 0x3feedea64c123422, 0x3feece086061892d, 0x3feef1a7373aa9cb, 0x3feedea64c123422, 0x3feece086061892d,
0x3feebfdad5362a27, 0x3feeb42b569d4f82, 0x3feeab07dd485429, 0x3feebfdad5362a27, 0x3feeb42b569d4f82, 0x3feeab07dd485429,
0x3feea47eb03a5585, 0x3feea09e667f3bcd, 0x3fee9f75e8ec5f74, 0x3feea47eb03a5585, 0x3feea09e667f3bcd, 0x3fee9f75e8ec5f74,
0x3feea11473eb0187, 0x3feea589994cce13, 0x3feeace5422aa0db, 0x3feea11473eb0187, 0x3feea589994cce13, 0x3feeace5422aa0db,
0x3feeb737b0cdc5e5, 0x3feec49182a3f090, 0x3feed503b23e255d, 0x3feeb737b0cdc5e5, 0x3feec49182a3f090, 0x3feed503b23e255d,
0x3feee89f995ad3ad, 0x3feeff76f2fb5e47, 0x3fef199bdd85529c, 0x3feee89f995ad3ad, 0x3feeff76f2fb5e47, 0x3fef199bdd85529c,
0x3fef3720dcef9069, 0x3fef5818dcfba487, 0x3fef7c97337b9b5f, 0x3fef3720dcef9069, 0x3fef5818dcfba487, 0x3fef7c97337b9b5f,
0x3fefa4afa2a490da, 0x3fefd0765b6e4540, 0x3fefa4afa2a490da, 0x3fefd0765b6e4540,
#elif N == 64 #elif N == 64
0x3ff0000000000000, 0x3fefec9a3e778061, 0x3fefd9b0d3158574, 0x3ff0000000000000, 0x3fefec9a3e778061, 0x3fefd9b0d3158574,
0x3fefc74518759bc8, 0x3fefb5586cf9890f, 0x3fefa3ec32d3d1a2, 0x3fefc74518759bc8, 0x3fefb5586cf9890f, 0x3fefa3ec32d3d1a2,
0x3fef9301d0125b51, 0x3fef829aaea92de0, 0x3fef72b83c7d517b, 0x3fef9301d0125b51, 0x3fef829aaea92de0, 0x3fef72b83c7d517b,
0x3fef635beb6fcb75, 0x3fef54873168b9aa, 0x3fef463b88628cd6, 0x3fef635beb6fcb75, 0x3fef54873168b9aa, 0x3fef463b88628cd6,
0x3fef387a6e756238, 0x3fef2b4565e27cdd, 0x3fef1e9df51fdee1, 0x3fef387a6e756238, 0x3fef2b4565e27cdd, 0x3fef1e9df51fdee1,
0x3fef1285a6e4030b, 0x3fef06fe0a31b715, 0x3feefc08b26416ff, 0x3fef1285a6e4030b, 0x3fef06fe0a31b715, 0x3feefc08b26416ff,
0x3feef1a7373aa9cb, 0x3feee7db34e59ff7, 0x3feedea64c123422, 0x3feef1a7373aa9cb, 0x3feee7db34e59ff7, 0x3feedea64c123422,
0x3feed60a21f72e2a, 0x3feece086061892d, 0x3feec6a2b5c13cd0, 0x3feed60a21f72e2a, 0x3feece086061892d, 0x3feec6a2b5c13cd0,
0x3feebfdad5362a27, 0x3feeb9b2769d2ca7, 0x3feeb42b569d4f82, 0x3feebfdad5362a27, 0x3feeb9b2769d2ca7, 0x3feeb42b569d4f82,
0x3feeaf4736b527da, 0x3feeab07dd485429, 0x3feea76f15ad2148, 0x3feeaf4736b527da, 0x3feeab07dd485429, 0x3feea76f15ad2148,
0x3feea47eb03a5585, 0x3feea23882552225, 0x3feea09e667f3bcd, 0x3feea47eb03a5585, 0x3feea23882552225, 0x3feea09e667f3bcd,
0x3fee9fb23c651a2f, 0x3fee9f75e8ec5f74, 0x3fee9feb564267c9, 0x3fee9fb23c651a2f, 0x3fee9f75e8ec5f74, 0x3fee9feb564267c9,
0x3feea11473eb0187, 0x3feea2f336cf4e62, 0x3feea589994cce13, 0x3feea11473eb0187, 0x3feea2f336cf4e62, 0x3feea589994cce13,
0x3feea8d99b4492ed, 0x3feeace5422aa0db, 0x3feeb1ae99157736, 0x3feea8d99b4492ed, 0x3feeace5422aa0db, 0x3feeb1ae99157736,
0x3feeb737b0cdc5e5, 0x3feebd829fde4e50, 0x3feec49182a3f090, 0x3feeb737b0cdc5e5, 0x3feebd829fde4e50, 0x3feec49182a3f090,
0x3feecc667b5de565, 0x3feed503b23e255d, 0x3feede6b5579fdbf, 0x3feecc667b5de565, 0x3feed503b23e255d, 0x3feede6b5579fdbf,
0x3feee89f995ad3ad, 0x3feef3a2b84f15fb, 0x3feeff76f2fb5e47, 0x3feee89f995ad3ad, 0x3feef3a2b84f15fb, 0x3feeff76f2fb5e47,
0x3fef0c1e904bc1d2, 0x3fef199bdd85529c, 0x3fef27f12e57d14b, 0x3fef0c1e904bc1d2, 0x3fef199bdd85529c, 0x3fef27f12e57d14b,
0x3fef3720dcef9069, 0x3fef472d4a07897c, 0x3fef5818dcfba487, 0x3fef3720dcef9069, 0x3fef472d4a07897c, 0x3fef5818dcfba487,
0x3fef69e603db3285, 0x3fef7c97337b9b5f, 0x3fef902ee78b3ff6, 0x3fef69e603db3285, 0x3fef7c97337b9b5f, 0x3fef902ee78b3ff6,
0x3fefa4afa2a490da, 0x3fefba1bee615a27, 0x3fefd0765b6e4540, 0x3fefa4afa2a490da, 0x3fefba1bee615a27, 0x3fefd0765b6e4540,
0x3fefe7c1819e90d8, 0x3fefe7c1819e90d8,
#endif #endif
}, },
as_double(0x4338000000000000) / N, // shift_scaled as_double(0x4338000000000000) / N, // shift_scaled
{ {
// poly // poly
#if N == 8 #if N == 8
as_double(0x3fac6a00335106e2), as_double(0x3fac6a00335106e2),
as_double(0x3fcec0c313449f55), as_double(0x3fcec0c313449f55),
as_double(0x3fe62e431111f69f), as_double(0x3fe62e431111f69f),
#elif N == 16 #elif N == 16
as_double(0x3fac6ac6aa313963), as_double(0x3fac6ac6aa313963),
as_double(0x3fcebfff4532d9ba), as_double(0x3fcebfff4532d9ba),
as_double(0x3fe62e43001bc49f), as_double(0x3fe62e43001bc49f),
#elif N == 32 #elif N == 32
as_double(0x3fac6af84b912394), as_double(0x3fac6af84b912394),
as_double(0x3fcebfce50fac4f3), as_double(0x3fcebfce50fac4f3),
as_double(0x3fe62e42ff0c52d6), as_double(0x3fe62e42ff0c52d6),
#elif N == 64 #elif N == 64
as_double(0x3fac6b04b4221b2a), as_double(0x3fac6b04b4221b2a),
as_double(0x3fcebfc213e184d7), as_double(0x3fcebfc213e184d7),
as_double(0x3fe62e42fefb5b7f), as_double(0x3fe62e42fefb5b7f),
#endif #endif
}, },
as_double(0x4338000000000000), // shift as_double(0x4338000000000000), // shift
as_double(0x3ff71547652b82fe) * N, // invln2_scaled as_double(0x3ff71547652b82fe) * N, // invln2_scaled
{ {
// poly_scaled // poly_scaled
#if N == 8 #if N == 8
as_double(0x3fac6a00335106e2) / N / N / N, as_double(0x3fac6a00335106e2) / N / N / N,
as_double(0x3fcec0c313449f55) / N / N, as_double(0x3fcec0c313449f55) / N / N,
as_double(0x3fe62e431111f69f) / N, as_double(0x3fe62e431111f69f) / N,
#elif N == 16 #elif N == 16
as_double(0x3fac6ac6aa313963) / N / N / N, as_double(0x3fac6ac6aa313963) / N / N / N,
as_double(0x3fcebfff4532d9ba) / N / N, as_double(0x3fcebfff4532d9ba) / N / N,
as_double(0x3fe62e43001bc49f) / N, as_double(0x3fe62e43001bc49f) / N,
#elif N == 32 #elif N == 32
as_double(0x3fac6af84b912394) / N / N / N, as_double(0x3fac6af84b912394) / N / N / N,
as_double(0x3fcebfce50fac4f3) / N / N, as_double(0x3fcebfce50fac4f3) / N / N,
as_double(0x3fe62e42ff0c52d6) / N, as_double(0x3fe62e42ff0c52d6) / N,
#elif N == 64 #elif N == 64
as_double(0x3fac6b04b4221b2a) / N / N / N, as_double(0x3fac6b04b4221b2a) / N / N / N,
as_double(0x3fcebfc213e184d7) / N / N, as_double(0x3fcebfc213e184d7) / N / N,
as_double(0x3fe62e42fefb5b7f) / N, as_double(0x3fe62e42fefb5b7f) / N,
#endif #endif
}, },
}; };
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/internal/math_utils.h

  • This file was moved from libc/src/math/generic/math_utils.h.
//===-- Collection of utils for implementing math functions -----*- C++ -*-===// //===-- Collection of utils for implementing math functions -----*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_SRC_MATH_MATH_UTILS_H #ifndef LLVM_LIBC_SRC_MATH_MATH_UTILS_H
#define LLVM_LIBC_SRC_MATH_MATH_UTILS_H #define LLVM_LIBC_SRC_MATH_MATH_UTILS_H
#include "src/__support/CPP/TypeTraits.h" #include "src/__support/CPP/TypeTraits.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include <errno.h> #include <errno.h>
#include <math.h> #include <math.h>
#include <stdint.h> #include <stdint.h>
namespace __llvm_libc { namespace __llvm_libc {
static inline uint32_t as_uint32_bits(float x) { static inline uint32_t as_uint32_bits(float x) {
return *reinterpret_cast<uint32_t *>(&x); return *reinterpret_cast<uint32_t *>(&x);
} }
static inline uint64_t as_uint64_bits(double x) { static inline uint64_t as_uint64_bits(double x) {
return *reinterpret_cast<uint64_t *>(&x); return *reinterpret_cast<uint64_t *>(&x);
} }
static inline float as_float(uint32_t x) { static inline float as_float(uint32_t x) {
return *reinterpret_cast<float *>(&x); return *reinterpret_cast<float *>(&x);
} }
static inline double as_double(uint64_t x) { static inline double as_double(uint64_t x) {
return *reinterpret_cast<double *>(&x); return *reinterpret_cast<double *>(&x);
} }
static inline uint32_t top12_bits(float x) { return as_uint32_bits(x) >> 20; } static inline uint32_t top12_bits(float x) { return as_uint32_bits(x) >> 20; }
static inline uint32_t top12_bits(double x) { return as_uint64_bits(x) >> 52; } static inline uint32_t top12_bits(double x) { return as_uint64_bits(x) >> 52; }
// Values to trigger underflow and overflow. // Values to trigger underflow and overflow.
template <typename T> struct XFlowValues; template <typename T> struct XFlowValues;
template <> struct XFlowValues<float> { template <> struct XFlowValues<float> {
static const float overflow_value; static const float overflow_value;
static const float underflow_value; static const float underflow_value;
static const float may_underflow_value; static const float may_underflow_value;
}; };
template <> struct XFlowValues<double> { template <> struct XFlowValues<double> {
static const double overflow_value; static const double overflow_value;
static const double underflow_value; static const double underflow_value;
static const double may_underflow_value; static const double may_underflow_value;
}; };
template <typename T> static inline T with_errno(T x, int err) { template <typename T> static inline T with_errno(T x, int err) {
if (math_errhandling & MATH_ERRNO) if (math_errhandling & MATH_ERRNO)
errno = err; errno = err;
return x; return x;
} }
template <typename T> static inline void force_eval(T x) { template <typename T> static inline void force_eval(T x) {
volatile T y UNUSED = x; volatile T y UNUSED = x;
} }
template <typename T> static inline T opt_barrier(T x) { template <typename T> static inline T opt_barrier(T x) {
volatile T y = x; volatile T y = x;
return y; return y;
} }
template <typename T> struct IsFloatOrDouble { template <typename T> struct IsFloatOrDouble {
static constexpr bool Value = static constexpr bool Value =
cpp::IsSame<T, float>::Value || cpp::IsSame<T, double>::Value; cpp::IsSame<T, float>::Value || cpp::IsSame<T, double>::Value;
}; };
template <typename T> template <typename T>
using EnableIfFloatOrDouble = cpp::EnableIfType<IsFloatOrDouble<T>::Value, int>; using EnableIfFloatOrDouble = cpp::EnableIfType<IsFloatOrDouble<T>::Value, int>;
template <typename T, EnableIfFloatOrDouble<T> = 0> template <typename T, EnableIfFloatOrDouble<T> = 0>
T xflow(uint32_t sign, T y) { T xflow(uint32_t sign, T y) {
// Underflow happens when two extremely small values are multiplied. // Underflow happens when two extremely small values are multiplied.
// Likewise, overflow happens when two large values are multiplied. // Likewise, overflow happens when two large values are multiplied.
y = opt_barrier(sign ? -y : y) * y; y = opt_barrier(sign ? -y : y) * y;
return with_errno(y, ERANGE); return with_errno(y, ERANGE);
} }
template <typename T, EnableIfFloatOrDouble<T> = 0> T overflow(uint32_t sign) { template <typename T, EnableIfFloatOrDouble<T> = 0> T overflow(uint32_t sign) {
return xflow(sign, XFlowValues<T>::overflow_value); return xflow(sign, XFlowValues<T>::overflow_value);
} }
template <typename T, EnableIfFloatOrDouble<T> = 0> T underflow(uint32_t sign) { template <typename T, EnableIfFloatOrDouble<T> = 0> T underflow(uint32_t sign) {
return xflow(sign, XFlowValues<T>::underflow_value); return xflow(sign, XFlowValues<T>::underflow_value);
} }
template <typename T, EnableIfFloatOrDouble<T> = 0> template <typename T, EnableIfFloatOrDouble<T> = 0>
T may_underflow(uint32_t sign) { T may_underflow(uint32_t sign) {
return xflow(sign, XFlowValues<T>::may_underflow_value); return xflow(sign, XFlowValues<T>::may_underflow_value);
} }
template <typename T, EnableIfFloatOrDouble<T> = 0> template <typename T, EnableIfFloatOrDouble<T> = 0>
static inline constexpr float invalid(T x) { static inline constexpr float invalid(T x) {
T y = (x - x) / (x - x); T y = (x - x) / (x - x);
return isnan(x) ? y : with_errno(y, EDOM); return isnan(x) ? y : with_errno(y, EDOM);
} }
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_MATH_UTILS_H #endif // LLVM_LIBC_SRC_MATH_MATH_UTILS_H

libc/src/math/internal/math_utils.cpp

  • This file was moved from libc/src/math/generic/math_utils.cpp.
//===-- Implementation of math utils --------------------------------------===// //===-- Implementation of math utils --------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "math_utils.h" #include "math_utils.h"
namespace __llvm_libc { namespace __llvm_libc {
const float XFlowValues<float>::overflow_value = const float XFlowValues<float>::overflow_value =
as_float(0x70000000); // 0x1p97f as_float(0x70000000); // 0x1p97f
const float XFlowValues<float>::underflow_value = const float XFlowValues<float>::underflow_value =
as_float(0x10000000); // 0x1p97f as_float(0x10000000); // 0x1p97f
const float XFlowValues<float>::may_underflow_value = const float XFlowValues<float>::may_underflow_value =
as_float(0x1a200000); // 0x1.4p-75f as_float(0x1a200000); // 0x1.4p-75f
const double XFlowValues<double>::overflow_value = const double XFlowValues<double>::overflow_value =
as_double(0x7000000000000000); // 0x1p769 as_double(0x7000000000000000); // 0x1p769
const double XFlowValues<double>::underflow_value = const double XFlowValues<double>::underflow_value =
as_double(0x1000000000000000); // 0x1p-767 as_double(0x1000000000000000); // 0x1p-767
const double XFlowValues<double>::may_underflow_value = const double XFlowValues<double>::may_underflow_value =
as_double(0x1e58000000000000); // 0x1.8p-538 as_double(0x1e58000000000000); // 0x1.8p-538
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/internal/sincosf_data.cpp

  • This file was moved from libc/src/math/generic/sincosf_data.cpp.
//===-- sinf/cosf data tables ---------------------------------------------===// //===-- sinf/cosf data tables ---------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "math_utils.h" #include "math_utils.h"
#include "sincosf_utils.h" #include "sincosf_utils.h"
#include <stdint.h> #include <stdint.h>
namespace __llvm_libc { namespace __llvm_libc {
// The constants and polynomials for sine and cosine. The 2nd entry // The constants and polynomials for sine and cosine. The 2nd entry
// computes -cos (x) rather than cos (x) to get negation for free. // computes -cos (x) rather than cos (x) to get negation for free.
const sincos_t __sincosf_table[2] = { const sincos_t __sincosf_table[2] = {
{{1.0, -1.0, -1.0, 1.0}, {{1.0, -1.0, -1.0, 1.0},
as_double(0x41645f306dc9c883), as_double(0x41645f306dc9c883),
as_double(0x3ff921fb54442d18), as_double(0x3ff921fb54442d18),
as_double(0x3ff0000000000000), as_double(0x3ff0000000000000),
as_double(0xbfdffffffd0c621c), as_double(0xbfdffffffd0c621c),
as_double(0x3fa55553e1068f19), as_double(0x3fa55553e1068f19),
as_double(0xbf56c087e89a359d), as_double(0xbf56c087e89a359d),
as_double(0x3ef99343027bf8c3), as_double(0x3ef99343027bf8c3),
as_double(0xbfc555545995a603), as_double(0xbfc555545995a603),
as_double(0x3f81107605230bc4), as_double(0x3f81107605230bc4),
as_double(0xbf2994eb3774cf24)}, as_double(0xbf2994eb3774cf24)},
{{1.0, -1.0, -1.0, 1.0}, {{1.0, -1.0, -1.0, 1.0},
as_double(0x41645f306dc9c883), as_double(0x41645f306dc9c883),
as_double(0x3ff921fb54442d18), as_double(0x3ff921fb54442d18),
as_double(0xbff0000000000000), as_double(0xbff0000000000000),
as_double(0x3fdffffffd0c621c), as_double(0x3fdffffffd0c621c),
as_double(0xbfa55553e1068f19), as_double(0xbfa55553e1068f19),
as_double(0x3f56c087e89a359d), as_double(0x3f56c087e89a359d),
as_double(0xbef99343027bf8c3), as_double(0xbef99343027bf8c3),
as_double(0xbfc555545995a603), as_double(0xbfc555545995a603),
as_double(0x3f81107605230bc4), as_double(0x3f81107605230bc4),
as_double(0xbf2994eb3774cf24)}, as_double(0xbf2994eb3774cf24)},
}; };
// Table with 4/PI to 192 bit precision. To avoid unaligned accesses // Table with 4/PI to 192 bit precision. To avoid unaligned accesses
// only 8 new bits are added per entry, making the table 4 times larger. // only 8 new bits are added per entry, making the table 4 times larger.
const uint32_t __inv_pio4[24] = { const uint32_t __inv_pio4[24] = {
0xa2, 0xa2f9, 0xa2f983, 0xa2f9836e, 0xf9836e4e, 0x836e4e44, 0xa2, 0xa2f9, 0xa2f983, 0xa2f9836e, 0xf9836e4e, 0x836e4e44,
0x6e4e4415, 0x4e441529, 0x441529fc, 0x1529fc27, 0x29fc2757, 0xfc2757d1, 0x6e4e4415, 0x4e441529, 0x441529fc, 0x1529fc27, 0x29fc2757, 0xfc2757d1,
0x2757d1f5, 0x57d1f534, 0xd1f534dd, 0xf534ddc0, 0x34ddc0db, 0xddc0db62, 0x2757d1f5, 0x57d1f534, 0xd1f534dd, 0xf534ddc0, 0x34ddc0db, 0xddc0db62,
0xc0db6295, 0xdb629599, 0x6295993c, 0x95993c43, 0x993c4390, 0x3c439041}; 0xc0db6295, 0xdb629599, 0x6295993c, 0x95993c43, 0x993c4390, 0x3c439041};
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/internal/sincosf_utils.h

  • This file was moved from libc/src/math/generic/sincosf_utils.h.
//===-- Collection of utils for cosf/sinf/sincosf ---------------*- C++ -*-===// //===-- Collection of utils for cosf/sinf/sincosf ---------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_SRC_MATH_SINCOSF_UTILS_H #ifndef LLVM_LIBC_SRC_MATH_SINCOSF_UTILS_H
#define LLVM_LIBC_SRC_MATH_SINCOSF_UTILS_H #define LLVM_LIBC_SRC_MATH_SINCOSF_UTILS_H
#include "math_utils.h" #include "math_utils.h"
#include <stdint.h> #include <stdint.h>
namespace __llvm_libc { namespace __llvm_libc {
// 2PI * 2^-64. // 2PI * 2^-64.
static const double pi63 = as_double(0x3c1921fb54442d18); static const double pi63 = as_double(0x3c1921fb54442d18);
// PI / 4. // PI / 4.
static const double pio4 = as_double(0x3fe921fb54442d18); static const double pio4 = as_double(0x3fe921fb54442d18);
// The constants and polynomials for sine and cosine. // The constants and polynomials for sine and cosine.
typedef struct { typedef struct {
double sign[4]; // Sign of sine in quadrants 0..3. double sign[4]; // Sign of sine in quadrants 0..3.
double hpi_inv; // 2 / PI ( * 2^24 ). double hpi_inv; // 2 / PI ( * 2^24 ).
double hpi; // PI / 2. double hpi; // PI / 2.
double c0, c1, c2, c3, c4; // Cosine polynomial. double c0, c1, c2, c3, c4; // Cosine polynomial.
double s1, s2, s3; // Sine polynomial. double s1, s2, s3; // Sine polynomial.
} sincos_t; } sincos_t;
// Polynomial data (the cosine polynomial is negated in the 2nd entry). // Polynomial data (the cosine polynomial is negated in the 2nd entry).
extern const sincos_t __sincosf_table[2]; extern const sincos_t __sincosf_table[2];
// Table with 4/PI to 192 bit precision. // Table with 4/PI to 192 bit precision.
extern const uint32_t __inv_pio4[]; extern const uint32_t __inv_pio4[];
// Top 12 bits of the float representation with the sign bit cleared. // Top 12 bits of the float representation with the sign bit cleared.
static inline uint32_t abstop12(float x) { static inline uint32_t abstop12(float x) {
return (as_uint32_bits(x) >> 20) & 0x7ff; return (as_uint32_bits(x) >> 20) & 0x7ff;
} }
// Compute the sine and cosine of inputs X and X2 (X squared), using the // Compute the sine and cosine of inputs X and X2 (X squared), using the
// polynomial P and store the results in SINP and COSP. N is the quadrant, // polynomial P and store the results in SINP and COSP. N is the quadrant,
// if odd the cosine and sine polynomials are swapped. // if odd the cosine and sine polynomials are swapped.
static inline void sincosf_poly(double x, double x2, const sincos_t *p, int n, static inline void sincosf_poly(double x, double x2, const sincos_t *p, int n,
float *sinp, float *cosp) { float *sinp, float *cosp) {
double x3, x4, x5, x6, s, c, c1, c2, s1; double x3, x4, x5, x6, s, c, c1, c2, s1;
x4 = x2 * x2; x4 = x2 * x2;
x3 = x2 * x; x3 = x2 * x;
c2 = p->c3 + x2 * p->c4; c2 = p->c3 + x2 * p->c4;
s1 = p->s2 + x2 * p->s3; s1 = p->s2 + x2 * p->s3;
// Swap sin/cos result based on quadrant. // Swap sin/cos result based on quadrant.
float *tmp = (n & 1 ? cosp : sinp); float *tmp = (n & 1 ? cosp : sinp);
cosp = (n & 1 ? sinp : cosp); cosp = (n & 1 ? sinp : cosp);
sinp = tmp; sinp = tmp;
c1 = p->c0 + x2 * p->c1; c1 = p->c0 + x2 * p->c1;
x5 = x3 * x2; x5 = x3 * x2;
x6 = x4 * x2; x6 = x4 * x2;
s = x + x3 * p->s1; s = x + x3 * p->s1;
c = c1 + x4 * p->c2; c = c1 + x4 * p->c2;
*sinp = s + x5 * s1; *sinp = s + x5 * s1;
*cosp = c + x6 * c2; *cosp = c + x6 * c2;
} }
// Return the sine of inputs X and X2 (X squared) using the polynomial P. // Return the sine of inputs X and X2 (X squared) using the polynomial P.
// N is the quadrant, and if odd the cosine polynomial is used. // N is the quadrant, and if odd the cosine polynomial is used.
static inline float sinf_poly(double x, double x2, const sincos_t *p, int n) { static inline float sinf_poly(double x, double x2, const sincos_t *p, int n) {
double x3, x4, x6, x7, s, c, c1, c2, s1; double x3, x4, x6, x7, s, c, c1, c2, s1;
if ((n & 1) == 0) { if ((n & 1) == 0) {
x3 = x * x2; x3 = x * x2;
s1 = p->s2 + x2 * p->s3; s1 = p->s2 + x2 * p->s3;
x7 = x3 * x2; x7 = x3 * x2;
s = x + x3 * p->s1; s = x + x3 * p->s1;
return s + x7 * s1; return s + x7 * s1;
} else { } else {
x4 = x2 * x2; x4 = x2 * x2;
c2 = p->c3 + x2 * p->c4; c2 = p->c3 + x2 * p->c4;
c1 = p->c0 + x2 * p->c1; c1 = p->c0 + x2 * p->c1;
x6 = x4 * x2; x6 = x4 * x2;
c = c1 + x4 * p->c2; c = c1 + x4 * p->c2;
return c + x6 * c2; return c + x6 * c2;
} }
} }
// Fast range reduction using single multiply-subtract. Return the modulo of // Fast range reduction using single multiply-subtract. Return the modulo of
// X as a value between -PI/4 and PI/4 and store the quadrant in NP. // X as a value between -PI/4 and PI/4 and store the quadrant in NP.
// The values for PI/2 and 2/PI are accessed via P. Since PI/2 as a double // The values for PI/2 and 2/PI are accessed via P. Since PI/2 as a double
// is accurate to 55 bits and the worst-case cancellation happens at 6 * PI/4, // is accurate to 55 bits and the worst-case cancellation happens at 6 * PI/4,
// the result is accurate for |X| <= 120.0. // the result is accurate for |X| <= 120.0.
static inline double reduce_fast(double x, const sincos_t *p, int *np) { static inline double reduce_fast(double x, const sincos_t *p, int *np) {
double r; double r;
// Use scaled float to int conversion with explicit rounding. // Use scaled float to int conversion with explicit rounding.
// hpi_inv is prescaled by 2^24 so the quadrant ends up in bits 24..31. // hpi_inv is prescaled by 2^24 so the quadrant ends up in bits 24..31.
// This avoids inaccuracies introduced by truncating negative values. // This avoids inaccuracies introduced by truncating negative values.
r = x * p->hpi_inv; r = x * p->hpi_inv;
int n = ((int32_t)r + 0x800000) >> 24; int n = ((int32_t)r + 0x800000) >> 24;
*np = n; *np = n;
return x - n * p->hpi; return x - n * p->hpi;
} }
// Reduce the range of XI to a multiple of PI/2 using fast integer arithmetic. // Reduce the range of XI to a multiple of PI/2 using fast integer arithmetic.
// XI is a reinterpreted float and must be >= 2.0f (the sign bit is ignored). // XI is a reinterpreted float and must be >= 2.0f (the sign bit is ignored).
// Return the modulo between -PI/4 and PI/4 and store the quadrant in NP. // Return the modulo between -PI/4 and PI/4 and store the quadrant in NP.
// Reduction uses a table of 4/PI with 192 bits of precision. A 32x96->128 bit // Reduction uses a table of 4/PI with 192 bits of precision. A 32x96->128 bit
// multiply computes the exact 2.62-bit fixed-point modulo. Since the result // multiply computes the exact 2.62-bit fixed-point modulo. Since the result
// can have at most 29 leading zeros after the binary point, the double // can have at most 29 leading zeros after the binary point, the double
// precision result is accurate to 33 bits. // precision result is accurate to 33 bits.
static inline double reduce_large(uint32_t xi, int *np) { static inline double reduce_large(uint32_t xi, int *np) {
const uint32_t *arr = &__inv_pio4[(xi >> 26) & 15]; const uint32_t *arr = &__inv_pio4[(xi >> 26) & 15];
int shift = (xi >> 23) & 7; int shift = (xi >> 23) & 7;
uint64_t n, res0, res1, res2; uint64_t n, res0, res1, res2;
xi = (xi & 0xffffff) | 0x800000; xi = (xi & 0xffffff) | 0x800000;
xi <<= shift; xi <<= shift;
res0 = xi * arr[0]; res0 = xi * arr[0];
res1 = (uint64_t)xi * arr[4]; res1 = (uint64_t)xi * arr[4];
res2 = (uint64_t)xi * arr[8]; res2 = (uint64_t)xi * arr[8];
res0 = (res2 >> 32) | (res0 << 32); res0 = (res2 >> 32) | (res0 << 32);
res0 += res1; res0 += res1;
n = (res0 + (1ULL << 61)) >> 62; n = (res0 + (1ULL << 61)) >> 62;
res0 -= n << 62; res0 -= n << 62;
double x = (int64_t)res0; double x = (int64_t)res0;
*np = n; *np = n;
return x * pi63; return x * pi63;
} }
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_SINCOSF_UTILS_H #endif // LLVM_LIBC_SRC_MATH_SINCOSF_UTILS_H

libc/src/math/ldexp.cpp

  • This file was moved from libc/src/math/generic/ldexp.cpp.
//===-- Implementation of ldexp function ----------------------------------===// //===-- Implementation of ldexp function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/ldexp.h" #include "ldexp.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, ldexp, (double x, int exp)) { LLVM_LIBC_FUNCTION(double, ldexp, (double x, int exp)) {
return fputil::ldexp(x, exp); return fputil::ldexp(x, exp);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/ldexpf.cpp

  • This file was moved from libc/src/math/generic/ldexpf.cpp.
//===-- Implementation of ldexpf function ---------------------------------===// //===-- Implementation of ldexpf function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/ldexpf.h" #include "ldexpf.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, ldexpf, (float x, int exp)) { LLVM_LIBC_FUNCTION(float, ldexpf, (float x, int exp)) {
return fputil::ldexp(x, exp); return fputil::ldexp(x, exp);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/ldexpl.cpp

  • This file was moved from libc/src/math/generic/ldexpl.cpp.
//===-- Implementation of ldexpl function ---------------------------------===// //===-- Implementation of ldexpl function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/ldexpl.h" #include "ldexpl.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, ldexpl, (long double x, int exp)) { LLVM_LIBC_FUNCTION(long double, ldexpl, (long double x, int exp)) {
return fputil::ldexp(x, exp); return fputil::ldexp(x, exp);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/llrint.cpp

  • This file was moved from libc/src/math/generic/llrint.cpp.
//===-- Implementation of llrint function ---------------------------------===// //===-- Implementation of llrint function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/llrint.h" #include "llrint.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long long, llrint, (double x)) { LLVM_LIBC_FUNCTION(long long, llrint, (double x)) {
return fputil::roundToSignedIntegerUsingCurrentRoundingMode<double, return fputil::roundToSignedIntegerUsingCurrentRoundingMode<double,
long long>(x); long long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/llrintf.cpp

  • This file was moved from libc/src/math/generic/llrintf.cpp.
//===-- Implementation of llrintf function --------------------------------===// //===-- Implementation of llrintf function --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/llrintf.h" #include "llrintf.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long long, llrintf, (float x)) { LLVM_LIBC_FUNCTION(long long, llrintf, (float x)) {
return fputil::roundToSignedIntegerUsingCurrentRoundingMode<float, long long>( return fputil::roundToSignedIntegerUsingCurrentRoundingMode<float, long long>(
x); x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/llrintl.cpp

  • This file was moved from libc/src/math/generic/llrintl.cpp.
//===-- Implementation of llrintl function --------------------------------===// //===-- Implementation of llrintl function --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/llrintl.h" #include "llrintl.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long long, llrintl, (long double x)) { LLVM_LIBC_FUNCTION(long long, llrintl, (long double x)) {
return fputil::roundToSignedIntegerUsingCurrentRoundingMode<long double, return fputil::roundToSignedIntegerUsingCurrentRoundingMode<long double,
long long>(x); long long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/llround.cpp

  • This file was moved from libc/src/math/generic/llround.cpp.
//===-- Implementation of llround function --------------------------------===// //===-- Implementation of llround function --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/llround.h" #include "llround.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long long, llround, (double x)) { LLVM_LIBC_FUNCTION(long long, llround, (double x)) {
return fputil::roundToSignedInteger<double, long long>(x); return fputil::roundToSignedInteger<double, long long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/llroundf.cpp

  • This file was moved from libc/src/math/generic/llroundf.cpp.
//===-- Implementation of llroundf function -------------------------------===// //===-- Implementation of llroundf function -------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/llroundf.h" #include "llroundf.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long long, llroundf, (float x)) { LLVM_LIBC_FUNCTION(long long, llroundf, (float x)) {
return fputil::roundToSignedInteger<float, long long>(x); return fputil::roundToSignedInteger<float, long long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/llroundl.cpp

  • This file was moved from libc/src/math/generic/llroundl.cpp.
//===-- Implementation of llroundl function -------------------------------===// //===-- Implementation of llroundl function -------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/llroundl.h" #include "llroundl.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long long, llroundl, (long double x)) { LLVM_LIBC_FUNCTION(long long, llroundl, (long double x)) {
return fputil::roundToSignedInteger<long double, long long>(x); return fputil::roundToSignedInteger<long double, long long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/logb.cpp

  • This file was moved from libc/src/math/generic/logb.cpp.
//===-- Implementation of logb function -----------------------------------===// //===-- Implementation of logb function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/logb.h" #include "logb.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, logb, (double x)) { return fputil::logb(x); } LLVM_LIBC_FUNCTION(double, logb, (double x)) { return fputil::logb(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/logbf.cpp

  • This file was moved from libc/src/math/generic/logbf.cpp.
//===-- Implementation of logbf function ---------------------------------===// //===-- Implementation of logbf function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/logbf.h" #include "logbf.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, logbf, (float x)) { return fputil::logb(x); } LLVM_LIBC_FUNCTION(float, logbf, (float x)) { return fputil::logb(x); }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/logbl.cpp

  • This file was moved from libc/src/math/generic/logbl.cpp.
//===-- Implementation of logbl function ---------------------------------===// //===-- Implementation of logbl function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/logbl.h" #include "logbl.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, logbl, (long double x)) { LLVM_LIBC_FUNCTION(long double, logbl, (long double x)) {
return fputil::logb(x); return fputil::logb(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/lrint.cpp

  • This file was moved from libc/src/math/generic/lrint.cpp.
//===-- Implementation of lrint function ----------------------------------===// //===-- Implementation of lrint function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/lrint.h" #include "lrint.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long, lrint, (double x)) { LLVM_LIBC_FUNCTION(long, lrint, (double x)) {
return fputil::roundToSignedIntegerUsingCurrentRoundingMode<double, long>(x); return fputil::roundToSignedIntegerUsingCurrentRoundingMode<double, long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/lrintf.cpp

  • This file was moved from libc/src/math/generic/lrintf.cpp.
//===-- Implementation of lrintf function ---------------------------------===// //===-- Implementation of lrintf function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/lrintf.h" #include "lrintf.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long, lrintf, (float x)) { LLVM_LIBC_FUNCTION(long, lrintf, (float x)) {
return fputil::roundToSignedIntegerUsingCurrentRoundingMode<float, long>(x); return fputil::roundToSignedIntegerUsingCurrentRoundingMode<float, long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/lrintl.cpp

  • This file was moved from libc/src/math/generic/lrintl.cpp.
//===-- Implementation of lrintl function ---------------------------------===// //===-- Implementation of lrintl function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/lrintl.h" #include "lrintl.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long, lrintl, (long double x)) { LLVM_LIBC_FUNCTION(long, lrintl, (long double x)) {
return fputil::roundToSignedIntegerUsingCurrentRoundingMode<long double, return fputil::roundToSignedIntegerUsingCurrentRoundingMode<long double,
long>(x); long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/lround.cpp

  • This file was moved from libc/src/math/generic/lround.cpp.
//===-- Implementation of lround function ---------------------------------===// //===-- Implementation of lround function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/lround.h" #include "lround.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long, lround, (double x)) { LLVM_LIBC_FUNCTION(long, lround, (double x)) {
return fputil::roundToSignedInteger<double, long>(x); return fputil::roundToSignedInteger<double, long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/lroundf.cpp

  • This file was moved from libc/src/math/generic/lroundf.cpp.
//===-- Implementation of lroundf function --------------------------------===// //===-- Implementation of lroundf function --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/lroundf.h" #include "lroundf.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long, lroundf, (float x)) { LLVM_LIBC_FUNCTION(long, lroundf, (float x)) {
return fputil::roundToSignedInteger<float, long>(x); return fputil::roundToSignedInteger<float, long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/lroundl.cpp

  • This file was moved from libc/src/math/generic/lroundl.cpp.
//===-- Implementation of lroundl function --------------------------------===// //===-- Implementation of lroundl function --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/lroundl.h" #include "lroundl.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long, lroundl, (long double x)) { LLVM_LIBC_FUNCTION(long, lroundl, (long double x)) {
return fputil::roundToSignedInteger<long double, long>(x); return fputil::roundToSignedInteger<long double, long>(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/modf.cpp

  • This file was moved from libc/src/math/generic/modf.cpp.
//===-- Implementation of modf function -----------------------------------===// //===-- Implementation of modf function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/modf.h" #include "modf.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, modf, (double x, double *iptr)) { LLVM_LIBC_FUNCTION(double, modf, (double x, double *iptr)) {
return fputil::modf(x, *iptr); return fputil::modf(x, *iptr);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/modff.cpp

  • This file was moved from libc/src/math/generic/modff.cpp.
//===-- Implementation of modf function -----------------------------------===// //===-- Implementation of modf function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/modff.h" #include "modff.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, modff, (float x, float *iptr)) { LLVM_LIBC_FUNCTION(float, modff, (float x, float *iptr)) {
return fputil::modf(x, *iptr); return fputil::modf(x, *iptr);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/modfl.cpp

  • This file was moved from libc/src/math/generic/modfl.cpp.
//===-- Implementation of modfl function ----------------------------------===// //===-- Implementation of modfl function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/modfl.h" #include "modfl.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, modfl, (long double x, long double *iptr)) { LLVM_LIBC_FUNCTION(long double, modfl, (long double x, long double *iptr)) {
return fputil::modf(x, *iptr); return fputil::modf(x, *iptr);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/nearbyint.cpp

  • This file was moved from libc/src/math/generic/nearbyint.cpp.
//===-- Implementation of nearbyint function ------------------------------===// //===-- Implementation of nearbyint function ------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/nearbyint.h" #include "nearbyint.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, nearbyint, (double x)) { LLVM_LIBC_FUNCTION(double, nearbyint, (double x)) {
return fputil::roundUsingCurrentRoundingMode(x); return fputil::roundUsingCurrentRoundingMode(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/nearbyintf.cpp

  • This file was moved from libc/src/math/generic/nearbyintf.cpp.
//===-- Implementation of nearbyintf function -----------------------------===// //===-- Implementation of nearbyintf function -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/nearbyintf.h" #include "nearbyintf.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, nearbyintf, (float x)) { LLVM_LIBC_FUNCTION(float, nearbyintf, (float x)) {
return fputil::roundUsingCurrentRoundingMode(x); return fputil::roundUsingCurrentRoundingMode(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/nearbyintl.cpp

  • This file was moved from libc/src/math/generic/nearbyintl.cpp.
//===-- Implementation of nearbyintl function -----------------------------===// //===-- Implementation of nearbyintl function -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/nearbyintl.h" #include "nearbyintl.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, nearbyintl, (long double x)) { LLVM_LIBC_FUNCTION(long double, nearbyintl, (long double x)) {
return fputil::roundUsingCurrentRoundingMode(x); return fputil::roundUsingCurrentRoundingMode(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/nextafter.cpp

  • This file was moved from libc/src/math/generic/nextafter.cpp.
//===-- Implementation of nextafter function ------------------------------===// //===-- Implementation of nextafter function ------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/nextafter.h" #include "nextafter.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, nextafter, (double x, double y)) { LLVM_LIBC_FUNCTION(double, nextafter, (double x, double y)) {
return fputil::nextafter(x, y); return fputil::nextafter(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/nextafterf.cpp

  • This file was moved from libc/src/math/generic/nextafterf.cpp.
//===-- Implementation of nextafterf function -----------------------------===// //===-- Implementation of nextafterf function -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/nextafterf.h" #include "nextafterf.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, nextafterf, (float x, float y)) { LLVM_LIBC_FUNCTION(float, nextafterf, (float x, float y)) {
return fputil::nextafter(x, y); return fputil::nextafter(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/nextafterl.cpp

  • This file was moved from libc/src/math/generic/nextafterl.cpp.
//===-- Implementation of nextafterl function -----------------------------===// //===-- Implementation of nextafterl function -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/nextafterl.h" #include "nextafterl.h"
#include "src/__support/FPUtil/ManipulationFunctions.h" #include "src/__support/FPUtil/ManipulationFunctions.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, nextafterl, (long double x, long double y)) { LLVM_LIBC_FUNCTION(long double, nextafterl, (long double x, long double y)) {
return fputil::nextafter(x, y); return fputil::nextafter(x, y);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/remainder.cpp

  • This file was moved from libc/src/math/generic/remainder.cpp.
//===-- Implementation of remainder function ------------------------------===// //===-- Implementation of remainder function ------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/remainder.h" #include "remainder.h"
#include "src/__support/FPUtil/DivisionAndRemainderOperations.h" #include "src/__support/FPUtil/DivisionAndRemainderOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, remainder, (double x, double y)) { LLVM_LIBC_FUNCTION(double, remainder, (double x, double y)) {
int quotient; int quotient;
return fputil::remquo(x, y, quotient); return fputil::remquo(x, y, quotient);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/remainderf.cpp

  • This file was moved from libc/src/math/generic/remainderf.cpp.
//===-- Implementation of remainderf function -----------------------------===// //===-- Implementation of remainderf function -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/remainderf.h" #include "remainderf.h"
#include "src/__support/FPUtil/DivisionAndRemainderOperations.h" #include "src/__support/FPUtil/DivisionAndRemainderOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, remainderf, (float x, float y)) { LLVM_LIBC_FUNCTION(float, remainderf, (float x, float y)) {
int quotient; int quotient;
return fputil::remquo(x, y, quotient); return fputil::remquo(x, y, quotient);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/remainderl.cpp

  • This file was moved from libc/src/math/generic/remainderl.cpp.
//===-- Implementation of remainderl function -----------------------------===// //===-- Implementation of remainderl function -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/remainderl.h" #include "remainderl.h"
#include "src/__support/FPUtil/DivisionAndRemainderOperations.h" #include "src/__support/FPUtil/DivisionAndRemainderOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, remainderl, (long double x, long double y)) { LLVM_LIBC_FUNCTION(long double, remainderl, (long double x, long double y)) {
int quotient; int quotient;
return fputil::remquo(x, y, quotient); return fputil::remquo(x, y, quotient);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/remquo.cpp

  • This file was moved from libc/src/math/generic/remquo.cpp.
//===-- Implementation of remquo function ---------------------------------===// //===-- Implementation of remquo function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/remquo.h" #include "remquo.h"
#include "src/__support/FPUtil/DivisionAndRemainderOperations.h" #include "src/__support/FPUtil/DivisionAndRemainderOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, remquo, (double x, double y, int *exp)) { LLVM_LIBC_FUNCTION(double, remquo, (double x, double y, int *exp)) {
return fputil::remquo(x, y, *exp); return fputil::remquo(x, y, *exp);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/remquof.cpp

  • This file was moved from libc/src/math/generic/remquof.cpp.
//===-- Implementation of remquof function --------------------------------===// //===-- Implementation of remquof function --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/remquof.h" #include "remquof.h"
#include "src/__support/FPUtil/DivisionAndRemainderOperations.h" #include "src/__support/FPUtil/DivisionAndRemainderOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, remquof, (float x, float y, int *exp)) { LLVM_LIBC_FUNCTION(float, remquof, (float x, float y, int *exp)) {
return fputil::remquo(x, y, *exp); return fputil::remquo(x, y, *exp);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/remquol.cpp

  • This file was moved from libc/src/math/generic/remquol.cpp.
//===-- Implementation of remquol function --------------------------------===// //===-- Implementation of remquol function --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/remquol.h" #include "remquol.h"
#include "src/__support/FPUtil/DivisionAndRemainderOperations.h" #include "src/__support/FPUtil/DivisionAndRemainderOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, remquol, LLVM_LIBC_FUNCTION(long double, remquol,
(long double x, long double y, int *exp)) { (long double x, long double y, int *exp)) {
return fputil::remquo(x, y, *exp); return fputil::remquo(x, y, *exp);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/rint.cpp

  • This file was moved from libc/src/math/generic/rint.cpp.
//===-- Implementation of rint function -----------------------------------===// //===-- Implementation of rint function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/rint.h" #include "rint.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, rint, (double x)) { LLVM_LIBC_FUNCTION(double, rint, (double x)) {
return fputil::roundUsingCurrentRoundingMode(x); return fputil::roundUsingCurrentRoundingMode(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/rintf.cpp

  • This file was moved from libc/src/math/generic/rintf.cpp.
//===-- Implementation of rintf function ----------------------------------===// //===-- Implementation of rintf function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/rintf.h" #include "rintf.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, rintf, (float x)) { LLVM_LIBC_FUNCTION(float, rintf, (float x)) {
return fputil::roundUsingCurrentRoundingMode(x); return fputil::roundUsingCurrentRoundingMode(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/rintl.cpp

  • This file was moved from libc/src/math/generic/rintl.cpp.
//===-- Implementation of rintl function ----------------------------------===// //===-- Implementation of rintl function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/rintl.h" #include "rintl.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, rintl, (long double x)) { LLVM_LIBC_FUNCTION(long double, rintl, (long double x)) {
return fputil::roundUsingCurrentRoundingMode(x); return fputil::roundUsingCurrentRoundingMode(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/round.cpp

  • This file was moved from libc/src/math/generic/round.cpp.
//===-- Implementation of round function ----------------------------------===// //===-- Implementation of round function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/round.h" #include "src/__support/architectures.h"
#if defined(LLVM_LIBC_ARCH_AARCH64)
#include "aarch64/round.cpp"
#else
#include "round.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, round, (double x)) { return fputil::round(x); } LLVM_LIBC_FUNCTION(double, round, (double x)) { return fputil::round(x); }
} // namespace __llvm_libc } // namespace __llvm_libc
#endif

libc/src/math/roundf.cpp

  • This file was moved from libc/src/math/generic/roundf.cpp.
//===-- Implementation of roundf function ---------------------------------===// //===-- Implementation of roundf function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/roundf.h" #include "src/__support/architectures.h"
#if defined(LLVM_LIBC_ARCH_AARCH64)
#include "aarch64/roundf.cpp"
#else
#include "roundf.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, roundf, (float x)) { return fputil::round(x); } LLVM_LIBC_FUNCTION(float, roundf, (float x)) { return fputil::round(x); }
} // namespace __llvm_libc } // namespace __llvm_libc
#endif

libc/src/math/roundl.cpp

  • This file was moved from libc/src/math/generic/roundl.cpp.
//===-- Implementation of roundl function ---------------------------------===// //===-- Implementation of roundl function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/roundl.h" #include "roundl.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) {
return fputil::round(x); return fputil::round(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/sin.cpp

  • This file was copied from libc/src/math/generic/sqrt.cpp.
//===-- Implementation of sqrt function -----------------------------------===// //===-- Implementation of the sin function --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/sqrt.h" #include "src/__support/architectures.h"
#include "src/__support/FPUtil/Sqrt.h"
#include "src/__support/common.h"
namespace __llvm_libc { #if defined(LLVM_LIBC_ARCH_X86)
#include "x86_64/sin.cpp"
LLVM_LIBC_FUNCTION(double, sqrt, (double x)) { return fputil::sqrt(x); } #endif
} // namespace __llvm_libc

libc/src/math/sincosf.cpp

  • This file was moved from libc/src/math/generic/sincosf.cpp.
//===-- Single-precision sincos function ----------------------------------===// //===-- Single-precision sincos function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/sincosf.h" #include "sincosf.h"
#include "math_utils.h" #include "internal/math_utils.h"
#include "sincosf_utils.h" #include "internal/sincosf_utils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include <math.h> #include <math.h>
#include <stdint.h> #include <stdint.h>
namespace __llvm_libc { namespace __llvm_libc {
// Fast sincosf implementation. Worst-case ULP is 0.5607, maximum relative // Fast sincosf implementation. Worst-case ULP is 0.5607, maximum relative
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

libc/src/math/sinf.cpp

  • This file was moved from libc/src/math/generic/sinf.cpp.
//===-- Single-precision sin function -------------------------------------===// //===-- Single-precision sin function -------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/sinf.h" #include "sinf.h"
#include "math_utils.h" #include "internal/math_utils.h"
#include "sincosf_utils.h" #include "internal/sincosf_utils.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include <math.h> #include <math.h>
#include <stdint.h> #include <stdint.h>
namespace __llvm_libc { namespace __llvm_libc {
// Fast sinf implementation. Worst-case ULP is 0.5607, maximum relative // Fast sinf implementation. Worst-case ULP is 0.5607, maximum relative
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

libc/src/math/sqrt.cpp

  • This file was copied from libc/src/math/generic/sqrt.cpp.
//===-- Implementation of sqrt function -----------------------------------===// //===-- Implementation of sqrt function -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/sqrt.h" #include "src/__support/architectures.h"
#if defined(LLVM_LIBC_ARCH_AARCH64)
#include "aarch64/sqrt.cpp"
#elif defined(LLVM_LIBC_ARCH_X86)
#include "x86_64/sqrt.cpp"
#else
#include "sqrt.h"
#include "src/__support/FPUtil/Sqrt.h" #include "src/__support/FPUtil/Sqrt.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, sqrt, (double x)) { return fputil::sqrt(x); } LLVM_LIBC_FUNCTION(double, sqrt, (double x)) { return fputil::sqrt(x); }
} // namespace __llvm_libc } // namespace __llvm_libc
#endif
gchateletAuthorUnsubmitted
Done
ReplyInline Actions

@lntue I'm not entirely sure that the redirection to subfolder makes sense. The inlined version would look like this

#include "sqrt.h"
#include "src/__support/architectures.h"
#include "src/__support/FPUtil/Sqrt.h"
#include "src/__support/common.h"
namespace __llvm_libc {

LLVM_LIBC_FUNCTION(double, sqrt, (double x)) {
#if defined(LLVM_LIBC_ARCH_AARCH64)
  double y;
  __asm__ __volatile__("fsqrt %d0, %d1\n\t" : "=w"(y) : "w"(x));
  return y;
#elif defined(LLVM_LIBC_ARCH_X86)
  double result;
  __asm__ __volatile__("sqrtsd %x1, %x0" : "=x"(result) : "x"(x));
  return result;
#else
  return fputil::sqrt(x);
#endif
}

} // namespace __llvm_libc

I find it more readable and it's less files overal. Let me know what you think

gchatelet: @lntue I'm not entirely sure that the redirection to subfolder makes sense. The inlined version…
lntueUnsubmitted
Not Done
ReplyInline Actions

In my opinion, having #ifdef inside the function definition like this will be hard to read for more complicated functions, but for one-line functions like sqrt probably doesn't matter. It is also a bit hard to figure out which one has arch specializations, and which arch is missing, compared to separate files.

Another option for separate files that I think work quite well for organizing files and readability is to use separate namespaces for separate arc, something like

#if define(LLVM_LIBC_ARCH_AARCH64)
#include ...
namespace impl = ::llvm_libc::fputil::aarch64;
#elif defined(LLVM_LIBC_ARCH_X86)
#include ...
namespace impl = ::llvm_libc::fputil::x86;
#else
#include ...
namespace impl = ::__llvm_libc::fputil::generic;
#endif

LLVM_LIBC_FUNCTION(double, sqrt, (double x)) { return impl::sqrt(x); }

One function that I'm optimizing is polyeval, for which by separating arch's, it is easier to manage and copy-paste than #if #else inside the real implementations. But again, I'm fine with this one-line functions such as sqrt.

lntue: In my opinion, having #ifdef inside the function definition like this will be hard to read for…
sivachandraUnsubmitted
Not Done
ReplyInline Actions

In general I favor what @lntue has said. Even if sqrt is just a one liner, I will vote for consistency across all one-liner and not-a-one-liner implemention.

sivachandra: In general I favor what @lntue has said. Even if `sqrt` is just a one liner, I will vote for…
gchateletAuthorUnsubmitted
Done
ReplyInline Actions

SGTM, I agree that being able to know which arch is implemented just by glancing at the filesystem is valuable, also consistency is important. So I'll stick to the subfolder approach as you both of you suggested.

This patch and the following ones will largely impact the build system (CMakeLists.txt and downstream) so to save me some time I will move forward with D114712 first. Once Bazel setup is in place we will be able to restructure the build system more easily (no separate downstream fixes).

In the meantime, @michaelrj @lntue @sivachandra please move forward with your various pending patches, I'll rebase (or recreate) mine when I'm ready to move forward.

Thank you

gchatelet: SGTM, I agree that being able to know which arch is implemented just by glancing at the…

libc/src/math/sqrtf.cpp

  • This file was moved from libc/src/math/generic/sqrtf.cpp.
//===-- Implementation of sqrtf function ----------------------------------===// //===-- Implementation of sqrtf function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/sqrtf.h" #include "src/__support/architectures.h"
#if defined(LLVM_LIBC_ARCH_AARCH64)
#include "aarch64/sqrtf.cpp"
#elif defined(LLVM_LIBC_ARCH_X86)
#include "x86_64/sqrtf.cpp"
#else
#include "sqrtf.h"
#include "src/__support/FPUtil/Sqrt.h" #include "src/__support/FPUtil/Sqrt.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, sqrtf, (float x)) { return fputil::sqrt(x); } LLVM_LIBC_FUNCTION(float, sqrtf, (float x)) { return fputil::sqrt(x); }
} // namespace __llvm_libc } // namespace __llvm_libc
#endif

libc/src/math/sqrtl.cpp

  • This file was moved from libc/src/math/generic/sqrtl.cpp.
//===-- Implementation of sqrtl function ----------------------------------===// //===-- Implementation of sqrtl function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/sqrtl.h" #include "src/__support/architectures.h"
#if defined(LLVM_LIBC_ARCH_X86)
#include "x86_64/sqrtl.cpp"
#else
#include "sqrtl.h"
#include "src/__support/FPUtil/Sqrt.h" #include "src/__support/FPUtil/Sqrt.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, sqrtl, (long double x)) { LLVM_LIBC_FUNCTION(long double, sqrtl, (long double x)) {
return fputil::sqrt(x); return fputil::sqrt(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc
#endif

libc/src/math/tan.cpp

  • This file was moved from libc/src/math/generic/sqrt.cpp.
//===-- Implementation of sqrt function -----------------------------------===// //===-- Implementation of the tan function --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/sqrt.h" #include "src/__support/architectures.h"
#include "src/__support/FPUtil/Sqrt.h"
#include "src/__support/common.h"
namespace __llvm_libc { #if defined(LLVM_LIBC_ARCH_X86)
#include "x86_64/tan.cpp"
LLVM_LIBC_FUNCTION(double, sqrt, (double x)) { return fputil::sqrt(x); } #endif
} // namespace __llvm_libc

libc/src/math/trunc.cpp

  • This file was moved from libc/src/math/generic/trunc.cpp.
//===-- Implementation of trunc function ----------------------------------===// //===-- Implementation of trunc function ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/trunc.h" #include "src/__support/architectures.h"
#if defined(LLVM_LIBC_ARCH_AARCH64)
#include "aarch64/trunc.cpp"
#else
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "trunc.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(double, trunc, (double x)) { return fputil::trunc(x); } LLVM_LIBC_FUNCTION(double, trunc, (double x)) { return fputil::trunc(x); }
} // namespace __llvm_libc } // namespace __llvm_libc
#endif

libc/src/math/truncf.cpp

  • This file was moved from libc/src/math/generic/truncf.cpp.
//===-- Implementation of truncf function ---------------------------------===// //===-- Implementation of truncf function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/truncf.h" #include "src/__support/architectures.h"
#if defined(LLVM_LIBC_ARCH_AARCH64)
#include "aarch64/truncf.cpp"
#else
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "truncf.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(float, truncf, (float x)) { return fputil::trunc(x); } LLVM_LIBC_FUNCTION(float, truncf, (float x)) { return fputil::trunc(x); }
} // namespace __llvm_libc } // namespace __llvm_libc
#endif

libc/src/math/truncl.cpp

  • This file was moved from libc/src/math/generic/truncl.cpp.
//===-- Implementation of truncl function ---------------------------------===// //===-- Implementation of truncl function ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/truncl.h" #include "truncl.h"
#include "src/__support/FPUtil/NearestIntegerOperations.h" #include "src/__support/FPUtil/NearestIntegerOperations.h"
#include "src/__support/common.h" #include "src/__support/common.h"
namespace __llvm_libc { namespace __llvm_libc {
LLVM_LIBC_FUNCTION(long double, truncl, (long double x)) { LLVM_LIBC_FUNCTION(long double, truncl, (long double x)) {
return fputil::trunc(x); return fputil::trunc(x);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/x86_64/CMakeLists.txt

  • This file was deleted.
add_entrypoint_object(
cos
SRCS
cos.cpp
HDRS
../cos.h
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
sin
SRCS
sin.cpp
HDRS
../sin.h
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
tan
SRCS
tan.cpp
HDRS
../tan.h
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
sqrt
SRCS
sqrt.cpp
HDRS
../sqrt.h
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
sqrtf
SRCS
sqrtf.cpp
HDRS
../sqrtf.h
COMPILE_OPTIONS
-O2
)
add_entrypoint_object(
sqrtl
SRCS
sqrtl.cpp
HDRS
../sqrtl.h
COMPILE_OPTIONS
-O2
)
libc/src/math/truncf.cpp