piwalker/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-07-23 22:29:39 -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

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++)