piwalker/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-07-23 14:19:46 -06:00
Code Issues Packages Projects Releases Wiki Activity

Replace Common::BitCast with std::bit_cast

Browse Source
This commit is contained in:
Pokechu22
2022-08-05 21:10:17 -07:00
parent 57c890d4fc
commit fbbfea8e8e
36 changed files with 177 additions and 215 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
Source/UnitTests/Common/Arm64EmitterTest.cpp
View File

@ -1,9 +1,10 @@
// Copyright 2023 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include <bit>
#include "Common/Arm64Emitter.h"
#include "Common/BitSet.h"
#include "Common/BitUtils.h"
#include <gtest/gtest.h>
@ -62,7 +63,7 @@ public:
void Run()
{
const u64 actual = Common::BitCast<u64 (*)()>(m_code_pointer)();
const u64 actual = std::bit_cast<u64 (*)()>(m_code_pointer)();
constexpr u64 expected = 123;
EXPECT_EQ(expected, actual);
}

13
Source/UnitTests/Common/BitUtilsTest.cpp
View File

@ -88,16 +88,3 @@ TEST(BitUtils, IsValidLowMask)
EXPECT_FALSE(Common::IsValidLowMask((u64) ~(0b10000)));
EXPECT_FALSE(Common::IsValidLowMask((u64)(~((u64)(~0b0) >> 1) | 0b1111)));
}
TEST(BitUtils, BitCast)
{
EXPECT_EQ(0x00000000U, Common::BitCast<u32>(0.0f));
EXPECT_EQ(0x80000000U, Common::BitCast<u32>(-0.0f));
EXPECT_EQ(0x3F800000U, Common::BitCast<u32>(1.0f));
EXPECT_EQ(0xBF800000U, Common::BitCast<u32>(-1.0f));
EXPECT_EQ(0x0000000000000000ULL, Common::BitCast<u64>(0.0));
EXPECT_EQ(0x8000000000000000ULL, Common::BitCast<u64>(-0.0));
EXPECT_EQ(0x3FF0000000000000ULL, Common::BitCast<u64>(1.0));
EXPECT_EQ(0xBFF0000000000000ULL, Common::BitCast<u64>(-1.0));
}

14
Source/UnitTests/Common/FloatUtilsTest.cpp
View File

@ -2,12 +2,12 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#include <array>
#include <bit>
#include <limits>
#include <random>
#include <gtest/gtest.h>
#include "Common/BitUtils.h"
#include "Common/FloatUtils.h"
#include "../Core/PowerPC/TestValues.h"
@ -53,16 +53,16 @@ TEST(FloatUtils, FlushToZero)
for (u32 i = 0; i <= 0x007fffffu; ++i)
{
u32 i_tmp = i;
EXPECT_EQ(+0.f, Common::FlushToZero(Common::BitCast<float>(i_tmp)));
EXPECT_EQ(+0.f, Common::FlushToZero(std::bit_cast<float>(i_tmp)));
i_tmp |= 0x80000000u;
EXPECT_EQ(-0.f, Common::FlushToZero(Common::BitCast<float>(i_tmp)));
EXPECT_EQ(-0.f, Common::FlushToZero(std::bit_cast<float>(i_tmp)));
i_tmp = dist(engine);
EXPECT_EQ(i_tmp, Common::BitCast<u32>(Common::FlushToZero(Common::BitCast<float>(i_tmp))));
EXPECT_EQ(i_tmp, std::bit_cast<u32>(Common::FlushToZero(std::bit_cast<float>(i_tmp))));
i_tmp |= 0x80000000u;
EXPECT_EQ(i_tmp, Common::BitCast<u32>(Common::FlushToZero(Common::BitCast<float>(i_tmp))));
EXPECT_EQ(i_tmp, std::bit_cast<u32>(Common::FlushToZero(std::bit_cast<float>(i_tmp))));
}
}
@ -88,11 +88,11 @@ TEST(FloatUtils, ApproximateReciprocalSquareRoot)
for (size_t i = 0; i < double_test_values.size(); ++i)
{
u64 ivalue = double_test_values[i];
double dvalue = Common::BitCast<double>(ivalue);
double dvalue = std::bit_cast<double>(ivalue);
u64 expected = expected_values[i];
u64 actual = Common::BitCast<u64>(Common::ApproximateReciprocalSquareRoot(dvalue));
u64 actual = std::bit_cast<u64>(Common::ApproximateReciprocalSquareRoot(dvalue));
EXPECT_EQ(expected, actual);
}

6
Source/UnitTests/Core/PowerPC/Jit64Common/Frsqrte.cpp
View File

@ -1,9 +1,9 @@
// Copyright 2018 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include <bit>
#include <cstring>
#include "Common/BitUtils.h"
#include "Common/CommonTypes.h"
#include "Common/FloatUtils.h"
#include "Common/ScopeGuard.h"
@ -70,9 +70,9 @@ TEST(Jit64, Frsqrte)
for (const u64 ivalue : double_test_values)
{
double dvalue = Common::BitCast<double>(ivalue);
double dvalue = std::bit_cast<double>(ivalue);
u64 expected = Common::BitCast<u64>(Common::ApproximateReciprocalSquareRoot(dvalue));
u64 expected = std::bit_cast<u64>(Common::ApproximateReciprocalSquareRoot(dvalue));
u64 actual = routines.wrapped_frsqrte(ivalue, fpscr);

11
Source/UnitTests/Core/PowerPC/JitArm64/ConvertSingleDouble.cpp
View File

@ -3,8 +3,9 @@
#include <functional>
#include <bit>
#include "Common/Arm64Emitter.h"
#include "Common/BitUtils.h"
#include "Common/CommonTypes.h"
#include "Common/FPURoundMode.h"
#include "Common/ScopeGuard.h"
@ -53,13 +54,13 @@ public:
gpr.Lock(ARM64Reg::W30);
fpr.Lock(ARM64Reg::Q0, ARM64Reg::Q1);
convert_single_to_double_lower = Common::BitCast<u64 (*)(u32)>(GetCodePtr());
convert_single_to_double_lower = std::bit_cast<u64 (*)(u32)>(GetCodePtr());
m_float_emit.INS(32, ARM64Reg::S0, 0, ARM64Reg::W0);
ConvertSingleToDoubleLower(0, ARM64Reg::D0, ARM64Reg::S0, ARM64Reg::Q1);
m_float_emit.UMOV(64, ARM64Reg::X0, ARM64Reg::D0, 0);
RET();
convert_single_to_double_pair = Common::BitCast<Pair<u64> (*)(u32, u32)>(GetCodePtr());
convert_single_to_double_pair = std::bit_cast<Pair<u64> (*)(u32, u32)>(GetCodePtr());
m_float_emit.INS(32, ARM64Reg::D0, 0, ARM64Reg::W0);
m_float_emit.INS(32, ARM64Reg::D0, 1, ARM64Reg::W1);
ConvertSingleToDoublePair(0, ARM64Reg::Q0, ARM64Reg::D0, ARM64Reg::Q1);
@ -67,13 +68,13 @@ public:
m_float_emit.UMOV(64, ARM64Reg::X1, ARM64Reg::Q0, 1);
RET();
convert_double_to_single_lower = Common::BitCast<u32 (*)(u64)>(GetCodePtr());
convert_double_to_single_lower = std::bit_cast<u32 (*)(u64)>(GetCodePtr());
m_float_emit.INS(64, ARM64Reg::D0, 0, ARM64Reg::X0);
ConvertDoubleToSingleLower(0, ARM64Reg::S0, ARM64Reg::D0);
m_float_emit.UMOV(32, ARM64Reg::W0, ARM64Reg::S0, 0);
RET();
convert_double_to_single_pair = Common::BitCast<Pair<u32> (*)(u64, u64)>(GetCodePtr());
convert_double_to_single_pair = std::bit_cast<Pair<u32> (*)(u64, u64)>(GetCodePtr());
m_float_emit.INS(64, ARM64Reg::Q0, 0, ARM64Reg::X0);
m_float_emit.INS(64, ARM64Reg::Q0, 1, ARM64Reg::X1);
ConvertDoubleToSinglePair(0, ARM64Reg::D0, ARM64Reg::Q0);

10
Source/UnitTests/Core/PowerPC/JitArm64/FPRF.cpp
View File

@ -1,11 +1,11 @@
// Copyright 2021 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include <bit>
#include <functional>
#include <vector>
#include "Common/Arm64Emitter.h"
#include "Common/BitUtils.h"
#include "Common/CommonTypes.h"
#include "Common/ScopeGuard.h"
#include "Core/Core.h"
@ -38,7 +38,7 @@ public:
auto& ppc_state = system.GetPPCState();
fprf_single = Common::BitCast<void (*)(u32)>(GetCodePtr());
fprf_single = std::bit_cast<void (*)(u32)>(GetCodePtr());
MOV(ARM64Reg::X15, ARM64Reg::X30);
MOV(ARM64Reg::X14, PPC_REG);
MOVP2R(PPC_REG, &ppc_state);
@ -47,7 +47,7 @@ public:
MOV(PPC_REG, ARM64Reg::X14);
RET();
fprf_double = Common::BitCast<void (*)(u64)>(GetCodePtr());
fprf_double = std::bit_cast<void (*)(u64)>(GetCodePtr());
MOV(ARM64Reg::X15, ARM64Reg::X30);
MOV(ARM64Reg::X14, PPC_REG);
MOVP2R(PPC_REG, &ppc_state);
@ -82,7 +82,7 @@ TEST(JitArm64, FPRF)
for (const u64 double_input : double_test_values)
{
const u32 expected_double = RunUpdateFPRF(
ppc_state, [&] { ppc_state.UpdateFPRFDouble(Common::BitCast<double>(double_input)); });
ppc_state, [&] { ppc_state.UpdateFPRFDouble(std::bit_cast<double>(double_input)); });
const u32 actual_double = RunUpdateFPRF(ppc_state, [&] { test.fprf_double(double_input); });
if (expected_double != actual_double)
fmt::print("{:016x} -> {:08x} == {:08x}\n", double_input, actual_double, expected_double);
@ -91,7 +91,7 @@ TEST(JitArm64, FPRF)
const u32 single_input = ConvertToSingle(double_input);
const u32 expected_single = RunUpdateFPRF(
ppc_state, [&] { ppc_state.UpdateFPRFSingle(Common::BitCast<float>(single_input)); });
ppc_state, [&] { ppc_state.UpdateFPRFSingle(std::bit_cast<float>(single_input)); });
const u32 actual_single = RunUpdateFPRF(ppc_state, [&] { test.fprf_single(single_input); });
if (expected_single != actual_single)
fmt::print("{:08x} -> {:08x} == {:08x}\n", single_input, actual_single, expected_single);

8
Source/UnitTests/Core/PowerPC/JitArm64/Fres.cpp
View File

@ -1,10 +1,10 @@
// Copyright 2021 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include <bit>
#include <functional>
#include "Common/Arm64Emitter.h"
#include "Common/BitUtils.h"
#include "Common/CommonTypes.h"
#include "Common/ScopeGuard.h"
#include "Core/Core.h"
@ -33,7 +33,7 @@ public:
const u8* raw_fres = GetCodePtr();
GenerateFres();
fres = Common::BitCast<u64 (*)(u64)>(GetCodePtr());
fres = std::bit_cast<u64 (*)(u64)>(GetCodePtr());
MOV(ARM64Reg::X15, ARM64Reg::X30);
MOV(ARM64Reg::X14, PPC_REG);
MOVP2R(PPC_REG, &system.GetPPCState());
@ -60,9 +60,9 @@ TEST(JitArm64, Fres)
for (const u64 ivalue : double_test_values)
{
const double dvalue = Common::BitCast<double>(ivalue);
const double dvalue = std::bit_cast<double>(ivalue);
const u64 expected = Common::BitCast<u64>(Common::ApproximateReciprocal(dvalue));
const u64 expected = std::bit_cast<u64>(Common::ApproximateReciprocal(dvalue));
const u64 actual = test.fres(ivalue);
if (expected != actual)

7
Source/UnitTests/Core/PowerPC/JitArm64/Frsqrte.cpp
View File

@ -1,6 +1,7 @@
// Copyright 2021 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include <bit>
#include <functional>
#include "Common/Arm64Emitter.h"
@ -33,7 +34,7 @@ public:
const u8* raw_frsqrte = GetCodePtr();
GenerateFrsqrte();
frsqrte = Common::BitCast<u64 (*)(u64)>(GetCodePtr());
frsqrte = std::bit_cast<u64 (*)(u64)>(GetCodePtr());
MOV(ARM64Reg::X15, ARM64Reg::X30);
MOV(ARM64Reg::X14, PPC_REG);
MOVP2R(PPC_REG, &system.GetPPCState());
@ -60,9 +61,9 @@ TEST(JitArm64, Frsqrte)
for (const u64 ivalue : double_test_values)
{
const double dvalue = Common::BitCast<double>(ivalue);
const double dvalue = std::bit_cast<double>(ivalue);
const u64 expected = Common::BitCast<u64>(Common::ApproximateReciprocalSquareRoot(dvalue));
const u64 expected = std::bit_cast<u64>(Common::ApproximateReciprocalSquareRoot(dvalue));
const u64 actual = test.frsqrte(ivalue);
if (expected != actual)

10
Source/UnitTests/Core/PowerPC/JitArm64/MovI2R.cpp
View File

@ -1,13 +1,13 @@
// Copyright 2021 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include <bit>
#include <cstddef>
#include <random>
#include <type_traits>
#include "Common/Arm64Emitter.h"
#include "Common/Assert.h"
#include "Common/BitUtils.h"
#include <gtest/gtest.h>
@ -33,7 +33,7 @@ public:
FlushIcacheSection(const_cast<u8*>(fn), const_cast<u8*>(GetCodePtr()));
const u64 result = Common::BitCast<u64 (*)()>(fn)();
const u64 result = std::bit_cast<u64 (*)()>(fn)();
EXPECT_EQ(value, result);
}
@ -50,7 +50,7 @@ public:
FlushIcacheSection(const_cast<u8*>(fn), const_cast<u8*>(GetCodePtr()));
const u64 result = Common::BitCast<u64 (*)()>(fn)();
const u64 result = std::bit_cast<u64 (*)()>(fn)();
EXPECT_EQ(value, result);
}
};
@ -115,7 +115,7 @@ TEST(JitArm64, MovI2R_LogImm)
TEST(JitArm64, MovI2R_ADP)
{
TestMovI2R test;
const u64 base = Common::BitCast<u64>(test.GetCodePtr());
const u64 base = std::bit_cast<u64>(test.GetCodePtr());
// Test offsets around 0
for (s64 i = -0x20000; i < 0x20000; i++)
@ -138,7 +138,7 @@ TEST(JitArm64, MovI2R_ADP)
TEST(JitArm64, MovI2R_ADRP)
{
TestMovI2R test;
const u64 base = Common::BitCast<u64>(test.GetCodePtr()) & ~0xFFF;
const u64 base = std::bit_cast<u64>(test.GetCodePtr()) & ~0xFFF;
// Test offsets around 0
for (s64 i = -0x20000; i < 0x20000; i++)

4
Source/UnitTests/VideoCommon/VertexLoaderTest.cpp
View File

@ -1,6 +1,7 @@
// Copyright 2014 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include <bit>
#include <limits>
#include <memory>
#include <tuple>
@ -9,7 +10,6 @@
#include <gtest/gtest.h> // NOLINT
#include "Common/BitUtils.h"
#include "Common/Common.h"
#include "Common/MathUtil.h"
#include "VideoCommon/CPMemory.h"
@ -81,7 +81,7 @@ protected:
const float actual = m_dst.Read<float, false>();
if (!actual || actual != actual)
EXPECT_EQ(Common::BitCast<u32>(expected), Common::BitCast<u32>(actual));
EXPECT_EQ(std::bit_cast<u32>(expected), std::bit_cast<u32>(actual));
else
EXPECT_EQ(expected, actual);
}