ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
dolphin/Source/Core/Common/FloatUtils.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

102 lines
2.5 KiB
C
Raw Normal View History

Common: Move floating-point utility functions to FloatUtils.h/.cpp Keeps all of the floating-point utility functions in their own file to keep them all together. This also provides a place for other general-purpose floating-point functions to be added in the future, which will be necessary when improving the flag-setting within the interpreter.
2018-05-07 05:18:41 +00:00
// Copyright 2018 Dolphin Emulator Project
treewide: convert GPLv2+ license info to SPDX tags SPDX standardizes how source code conveys its copyright and licensing information. See https://spdx.github.io/spdx-spec/1-rationale/ . SPDX tags are adopted in many large projects, including things like the Linux kernel.
2021-07-05 01:22:19 +00:00
// SPDX-License-Identifier: GPL-2.0-or-later
Common: Move floating-point utility functions to FloatUtils.h/.cpp Keeps all of the floating-point utility functions in their own file to keep them all together. This also provides a place for other general-purpose floating-point functions to be added in the future, which will be necessary when improving the flag-setting within the interpreter.
2018-05-07 05:18:41 +00:00
#pragma once
#include <array>
#include <limits>
FloatUtils: Remove IntDouble and IntFloat Type punning via unions in C++ invokes undefined behavior. Instead, leverage BitCast, our variant of C++2a's std::bit_cast
2018-05-10 14:35:00 +00:00
#include "Common/BitUtils.h"
Common: Move floating-point utility functions to FloatUtils.h/.cpp Keeps all of the floating-point utility functions in their own file to keep them all together. This also provides a place for other general-purpose floating-point functions to be added in the future, which will be necessary when improving the flag-setting within the interpreter.
2018-05-07 05:18:41 +00:00
#include "Common/CommonTypes.h"
namespace Common
{
template <typename T>
constexpr T SNANConstant()
{
return std::numeric_limits<T>::signaling_NaN();
}
// The most significant bit of the fraction is an is-quiet bit on all architectures we care about.
JitArm64: Resolve deprecated enum conversion warning Resolve warning caused by using values from two different enums in a conditional expression which was deprecated in c++20. The warning in question is clang -Wdeprecated-anon-enum-enum-conversion and gcc -Wenum-compare.
2023-08-23 17:36:52 +00:00
static constexpr u64 DOUBLE_QBIT = 0x0008000000000000ULL;
static constexpr u64 DOUBLE_SIGN = 0x8000000000000000ULL;
static constexpr u64 DOUBLE_EXP = 0x7FF0000000000000ULL;
static constexpr u64 DOUBLE_FRAC = 0x000FFFFFFFFFFFFFULL;
static constexpr u64 DOUBLE_ZERO = 0x0000000000000000ULL;
JitArm64: Use LSL+CLS for classifying floats This is a little trick I came up with that lets us restructure our float classification code so we can exit earlier when the float is normal, which is the case more often than not. First we shift left by 1 to get rid of the sign bit, and then we count the number of leading sign bits. If the result is less than 10 (for doubles) or 7 (for floats), the float is normal. This is because, if the float isn't normal, the exponent is either all zeroes or all ones.
2023-10-13 17:27:03 +00:00
static constexpr int DOUBLE_EXP_WIDTH = 11;
static constexpr int DOUBLE_FRAC_WIDTH = 52;
JitArm64: Resolve deprecated enum conversion warning Resolve warning caused by using values from two different enums in a conditional expression which was deprecated in c++20. The warning in question is clang -Wdeprecated-anon-enum-enum-conversion and gcc -Wenum-compare.
2023-08-23 17:36:52 +00:00
static constexpr u32 FLOAT_SIGN = 0x80000000;
static constexpr u32 FLOAT_EXP = 0x7F800000;
static constexpr u32 FLOAT_FRAC = 0x007FFFFF;
static constexpr u32 FLOAT_ZERO = 0x00000000;
JitArm64: Use LSL+CLS for classifying floats This is a little trick I came up with that lets us restructure our float classification code so we can exit earlier when the float is normal, which is the case more often than not. First we shift left by 1 to get rid of the sign bit, and then we count the number of leading sign bits. If the result is less than 10 (for doubles) or 7 (for floats), the float is normal. This is because, if the float isn't normal, the exponent is either all zeroes or all ones.
2023-10-13 17:27:03 +00:00
static constexpr int FLOAT_EXP_WIDTH = 8;
static constexpr int FLOAT_FRAC_WIDTH = 23;
Common: Move floating-point utility functions to FloatUtils.h/.cpp Keeps all of the floating-point utility functions in their own file to keep them all together. This also provides a place for other general-purpose floating-point functions to be added in the future, which will be necessary when improving the flag-setting within the interpreter.
2018-05-07 05:18:41 +00:00
inline bool IsQNAN(double d)
{
FloatUtils: Remove IntDouble and IntFloat Type punning via unions in C++ invokes undefined behavior. Instead, leverage BitCast, our variant of C++2a's std::bit_cast
2018-05-10 14:35:00 +00:00
const u64 i = BitCast<u64>(d);
return ((i & DOUBLE_EXP) == DOUBLE_EXP) && ((i & DOUBLE_QBIT) == DOUBLE_QBIT);
Common: Move floating-point utility functions to FloatUtils.h/.cpp Keeps all of the floating-point utility functions in their own file to keep them all together. This also provides a place for other general-purpose floating-point functions to be added in the future, which will be necessary when improving the flag-setting within the interpreter.
2018-05-07 05:18:41 +00:00
}
inline bool IsSNAN(double d)
{
FloatUtils: Remove IntDouble and IntFloat Type punning via unions in C++ invokes undefined behavior. Instead, leverage BitCast, our variant of C++2a's std::bit_cast
2018-05-10 14:35:00 +00:00
const u64 i = BitCast<u64>(d);
return ((i & DOUBLE_EXP) == DOUBLE_EXP) && ((i & DOUBLE_FRAC) != DOUBLE_ZERO) &&
((i & DOUBLE_QBIT) == DOUBLE_ZERO);
Common: Move floating-point utility functions to FloatUtils.h/.cpp Keeps all of the floating-point utility functions in their own file to keep them all together. This also provides a place for other general-purpose floating-point functions to be added in the future, which will be necessary when improving the flag-setting within the interpreter.
2018-05-07 05:18:41 +00:00
}
inline float FlushToZero(float f)
{
FloatUtils: Remove IntDouble and IntFloat Type punning via unions in C++ invokes undefined behavior. Instead, leverage BitCast, our variant of C++2a's std::bit_cast
2018-05-10 14:35:00 +00:00
u32 i = BitCast<u32>(f);
if ((i & FLOAT_EXP) == 0)
Common: Move floating-point utility functions to FloatUtils.h/.cpp Keeps all of the floating-point utility functions in their own file to keep them all together. This also provides a place for other general-purpose floating-point functions to be added in the future, which will be necessary when improving the flag-setting within the interpreter.
2018-05-07 05:18:41 +00:00
{
FloatUtils: Remove IntDouble and IntFloat Type punning via unions in C++ invokes undefined behavior. Instead, leverage BitCast, our variant of C++2a's std::bit_cast
2018-05-10 14:35:00 +00:00
// Turn into signed zero
i &= FLOAT_SIGN;
Common: Move floating-point utility functions to FloatUtils.h/.cpp Keeps all of the floating-point utility functions in their own file to keep them all together. This also provides a place for other general-purpose floating-point functions to be added in the future, which will be necessary when improving the flag-setting within the interpreter.
2018-05-07 05:18:41 +00:00
}
FloatUtils: Remove IntDouble and IntFloat Type punning via unions in C++ invokes undefined behavior. Instead, leverage BitCast, our variant of C++2a's std::bit_cast
2018-05-10 14:35:00 +00:00
return BitCast<float>(i);
Common: Move floating-point utility functions to FloatUtils.h/.cpp Keeps all of the floating-point utility functions in their own file to keep them all together. This also provides a place for other general-purpose floating-point functions to be added in the future, which will be necessary when improving the flag-setting within the interpreter.
2018-05-07 05:18:41 +00:00
}
inline double FlushToZero(double d)
{
FloatUtils: Remove IntDouble and IntFloat Type punning via unions in C++ invokes undefined behavior. Instead, leverage BitCast, our variant of C++2a's std::bit_cast
2018-05-10 14:35:00 +00:00
u64 i = BitCast<u64>(d);
if ((i & DOUBLE_EXP) == 0)
Common: Move floating-point utility functions to FloatUtils.h/.cpp Keeps all of the floating-point utility functions in their own file to keep them all together. This also provides a place for other general-purpose floating-point functions to be added in the future, which will be necessary when improving the flag-setting within the interpreter.
2018-05-07 05:18:41 +00:00
{
FloatUtils: Remove IntDouble and IntFloat Type punning via unions in C++ invokes undefined behavior. Instead, leverage BitCast, our variant of C++2a's std::bit_cast
2018-05-10 14:35:00 +00:00
// Turn into signed zero
i &= DOUBLE_SIGN;
Common: Move floating-point utility functions to FloatUtils.h/.cpp Keeps all of the floating-point utility functions in their own file to keep them all together. This also provides a place for other general-purpose floating-point functions to be added in the future, which will be necessary when improving the flag-setting within the interpreter.
2018-05-07 05:18:41 +00:00
}
FloatUtils: Remove IntDouble and IntFloat Type punning via unions in C++ invokes undefined behavior. Instead, leverage BitCast, our variant of C++2a's std::bit_cast
2018-05-10 14:35:00 +00:00
return BitCast<double>(i);
Common: Move floating-point utility functions to FloatUtils.h/.cpp Keeps all of the floating-point utility functions in their own file to keep them all together. This also provides a place for other general-purpose floating-point functions to be added in the future, which will be necessary when improving the flag-setting within the interpreter.
2018-05-07 05:18:41 +00:00
}
enum PPCFpClass
{
PPC_FPCLASS_QNAN = 0x11,
PPC_FPCLASS_NINF = 0x9,
PPC_FPCLASS_NN = 0x8,
PPC_FPCLASS_ND = 0x18,
PPC_FPCLASS_NZ = 0x12,
PPC_FPCLASS_PZ = 0x2,
PPC_FPCLASS_PD = 0x14,
PPC_FPCLASS_PN = 0x4,
PPC_FPCLASS_PINF = 0x5,
};
// Uses PowerPC conventions for the return value, so it can be easily
// used directly in CPU emulation.
u32 ClassifyDouble(double dvalue);
u32 ClassifyFloat(float fvalue);
struct BaseAndDec
{
int m_base;
int m_dec;
};
extern const std::array<BaseAndDec, 32> frsqrte_expected;
extern const std::array<BaseAndDec, 32> fres_expected;
// PowerPC approximation algorithms
double ApproximateReciprocalSquareRoot(double val);
double ApproximateReciprocal(double val);
} // namespace Common