139018265b
Current implementations of single precision and double precision floating point operations operate on bits of the integer type of same size. The code made use of magic masks which were listed as literal integer values. This is not possible in the case of long double type as the mantissa of quad-precision long double type used on non-x86 architectures is wider that the widest integer type for which we can list literal values. So, in this patch, to avoid using magic masks specified with literal values, we use packed bit-field struct types and let the compiler generate the masks. This new scheme allows us to implement long double flavors of the various floating point operations. To keep the size of the patch small, only the implementations of fabs and trunc have been switched to the new scheme. In following patches, all exisiting implementations will be switched to the new scheme. Reviewers: asteinhauser Differential Revision: https://reviews.llvm.org/D82036
64 lines
2.1 KiB
C++
64 lines
2.1 KiB
C++
//===-- Common operations on floating point numbers -------------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_LIBC_UTILS_FPUTIL_FLOAT_OPERATIONS_H
|
|
#define LLVM_LIBC_UTILS_FPUTIL_FLOAT_OPERATIONS_H
|
|
|
|
#include "BitPatterns.h"
|
|
#include "FloatProperties.h"
|
|
|
|
#include "utils/CPP/TypeTraits.h"
|
|
|
|
namespace __llvm_libc {
|
|
namespace fputil {
|
|
|
|
// Return the bits of a float value.
|
|
template <typename T,
|
|
cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
|
|
static inline typename FloatProperties<T>::BitsType valueAsBits(T x) {
|
|
using BitsType = typename FloatProperties<T>::BitsType;
|
|
return *reinterpret_cast<BitsType *>(&x);
|
|
}
|
|
|
|
// Return the float value from bits.
|
|
template <typename BitsType,
|
|
cpp::EnableIfType<
|
|
cpp::IsFloatingPointType<FloatTypeT<BitsType>>::Value, int> = 0>
|
|
static inline FloatTypeT<BitsType> valueFromBits(BitsType bits) {
|
|
return *reinterpret_cast<FloatTypeT<BitsType> *>(&bits);
|
|
}
|
|
|
|
// Return the bits of abs(x).
|
|
template <typename T,
|
|
cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
|
|
static inline typename FloatProperties<T>::BitsType absBits(T x) {
|
|
return valueAsBits(x) & (~FloatProperties<T>::signMask);
|
|
}
|
|
|
|
template <typename BitsType>
|
|
static inline int getExponentFromBits(BitsType bits) {
|
|
using FPType = typename FloatType<BitsType>::Type;
|
|
using Properties = FloatProperties<FPType>;
|
|
bits &= Properties::exponentMask;
|
|
int e = (bits >> Properties::mantissaWidth); // Shift out the mantissa.
|
|
e -= Properties::exponentOffset; // Zero adjust.
|
|
return e;
|
|
}
|
|
|
|
// Return the zero adjusted exponent value of x.
|
|
template <typename T,
|
|
cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
|
|
static inline int getExponent(T x) {
|
|
return getExponentFromBits(valueAsBits(x));
|
|
}
|
|
|
|
} // namespace fputil
|
|
} // namespace __llvm_libc
|
|
|
|
#endif // LLVM_LIBC_UTILS_FPUTIL_FLOAT_OPERATIONS_H
|