RPCS3/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2024-11-25 04:02:42 +01:00
Code Issues Releases Wiki Activity

C-style cast cleanup (partial)

Browse Source 
Replace C-style casts with C++ casts.
This commit is contained in:
Nekotekina 2019-11-28 21:18:37 +03:00
parent 8bd52c9843
commit 5b9df53c13
20 changed files with 280 additions and 334 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Utilities/File.cpp
View File

@ -1234,7 +1234,7 @@ fs::file::file(const std::string& path, bs_t<open_mode> mode)
static_assert(sizeof(iovec) == sizeof(iovec_clone), "Weird iovec size"); static_assert(sizeof(iovec) == sizeof(iovec_clone), "Weird iovec size");
static_assert(offsetof(iovec, iov_len) == offsetof(iovec_clone, iov_len), "Weird iovec::iov_len offset"); static_assert(offsetof(iovec, iov_len) == offsetof(iovec_clone, iov_len), "Weird iovec::iov_len offset");
const auto result = ::writev(m_fd, (const iovec*)buffers, buf_count); const auto result = ::writev(m_fd, reinterpret_cast<const iovec*>(buffers), buf_count);
verify("file::write_gather" HERE), result != -1; verify("file::write_gather" HERE), result != -1;
return result; return result;

4
Utilities/Log.cpp
View File

@ -391,10 +391,10 @@ logs::file_writer::file_writer(const std::string& name)
// Initialize memory mapped file // Initialize memory mapped file
#ifdef _WIN32 #ifdef _WIN32
m_fmap = CreateFileMappingW(m_file.get_handle(), 0, PAGE_READWRITE, s_log_size >> 32, s_log_size & 0xffffffff, 0); m_fmap = CreateFileMappingW(m_file.get_handle(), 0, PAGE_READWRITE, s_log_size >> 32, s_log_size & 0xffffffff, 0);
m_fptr = m_fmap ? (uchar*)MapViewOfFile(m_fmap, FILE_MAP_WRITE, 0, 0, 0) : nullptr; m_fptr = m_fmap ? static_cast<uchar*>(MapViewOfFile(m_fmap, FILE_MAP_WRITE, 0, 0, 0)) : nullptr;
#else #else
m_file.trunc(s_log_size); m_file.trunc(s_log_size);
m_fptr = (uchar*)::mmap(0, s_log_size, PROT_READ | PROT_WRITE, MAP_SHARED, m_file.get_handle(), 0); m_fptr = static_cast<uchar*>(::mmap(0, s_log_size, PROT_READ | PROT_WRITE, MAP_SHARED, m_file.get_handle(), 0));
#endif #endif
verify(name.c_str()), m_fptr; verify(name.c_str()), m_fptr;

99
Utilities/Thread.cpp
View File

@ -185,7 +185,7 @@ void decode_x64_reg_op(const u8* code, x64_op_t& out_op, x64_reg_t& out_reg, siz
{ {
if (lock) if (lock)
{ {
LOG_ERROR(MEMORY, "decode_x64_reg_op(%016llxh): LOCK prefix found twice", (size_t)code - out_length); LOG_ERROR(MEMORY, "decode_x64_reg_op(%016llxh): LOCK prefix found twice", code - out_length);
} }
lock = true; lock = true;
@ -195,7 +195,7 @@ void decode_x64_reg_op(const u8* code, x64_op_t& out_op, x64_reg_t& out_reg, siz
{ {
if (repne) if (repne)
{ {
LOG_ERROR(MEMORY, "decode_x64_reg_op(%016llxh): REPNE/REPNZ prefix found twice", (size_t)code - out_length); LOG_ERROR(MEMORY, "decode_x64_reg_op(%016llxh): REPNE/REPNZ prefix found twice", code - out_length);
} }
repne = true; repne = true;
@ -205,7 +205,7 @@ void decode_x64_reg_op(const u8* code, x64_op_t& out_op, x64_reg_t& out_reg, siz
{ {
if (repe) if (repe)
{ {
LOG_ERROR(MEMORY, "decode_x64_reg_op(%016llxh): REP/REPE/REPZ prefix found twice", (size_t)code - out_length); LOG_ERROR(MEMORY, "decode_x64_reg_op(%016llxh): REP/REPE/REPZ prefix found twice", code - out_length);
} }
repe = true; repe = true;
@ -221,7 +221,7 @@ void decode_x64_reg_op(const u8* code, x64_op_t& out_op, x64_reg_t& out_reg, siz
{ {
if (pg2) if (pg2)
{ {
LOG_ERROR(MEMORY, "decode_x64_reg_op(%016llxh): 0x%02x (group 2 prefix) found after 0x%02x", (size_t)code - out_length, prefix, pg2); LOG_ERROR(MEMORY, "decode_x64_reg_op(%016llxh): 0x%02x (group 2 prefix) found after 0x%02x", code - out_length, prefix, pg2);
} }
else else
{ {
@ -234,7 +234,7 @@ void decode_x64_reg_op(const u8* code, x64_op_t& out_op, x64_reg_t& out_reg, siz
{ {
if (oso) if (oso)
{ {
LOG_ERROR(MEMORY, "decode_x64_reg_op(%016llxh): operand-size override prefix found twice", (size_t)code - out_length); LOG_ERROR(MEMORY, "decode_x64_reg_op(%016llxh): operand-size override prefix found twice", code - out_length);
} }
oso = true; oso = true;
@ -243,7 +243,7 @@ void decode_x64_reg_op(const u8* code, x64_op_t& out_op, x64_reg_t& out_reg, siz
case 0x67: // group 4 case 0x67: // group 4
{ {
LOG_ERROR(MEMORY, "decode_x64_reg_op(%016llxh): address-size override prefix found", (size_t)code - out_length, prefix); LOG_ERROR(MEMORY, "decode_x64_reg_op(%016llxh): address-size override prefix found", code - out_length, prefix);
out_op = X64OP_NONE; out_op = X64OP_NONE;
out_reg = X64_NOT_SET; out_reg = X64_NOT_SET;
out_size = 0; out_size = 0;
@ -257,7 +257,7 @@ void decode_x64_reg_op(const u8* code, x64_op_t& out_op, x64_reg_t& out_reg, siz
{ {
if (rex) if (rex)
{ {
LOG_ERROR(MEMORY, "decode_x64_reg_op(%016llxh): 0x%02x (REX prefix) found after 0x%02x", (size_t)code - out_length, prefix, rex); LOG_ERROR(MEMORY, "decode_x64_reg_op(%016llxh): 0x%02x (REX prefix) found after 0x%02x", code - out_length, prefix, rex);
} }
else else
{ {
@ -273,17 +273,17 @@ void decode_x64_reg_op(const u8* code, x64_op_t& out_op, x64_reg_t& out_reg, siz
auto get_modRM_reg = [](const u8* code, const u8 rex) -> x64_reg_t auto get_modRM_reg = [](const u8* code, const u8 rex) -> x64_reg_t
{ {
return (x64_reg_t)(((*code & 0x38) >> 3 | (/* check REX.R bit */ rex & 4 ? 8 : 0)) + X64R_RAX); return x64_reg_t{((*code & 0x38) >> 3 | (/* check REX.R bit */ rex & 4 ? 8 : 0)) + X64R_RAX};
}; };
auto get_modRM_reg_xmm = [](const u8* code, const u8 rex) -> x64_reg_t auto get_modRM_reg_xmm = [](const u8* code, const u8 rex) -> x64_reg_t
{ {
return (x64_reg_t)(((*code & 0x38) >> 3 | (/* check REX.R bit */ rex & 4 ? 8 : 0)) + X64R_XMM0); return x64_reg_t{((*code & 0x38) >> 3 | (/* check REX.R bit */ rex & 4 ? 8 : 0)) + X64R_XMM0};
}; };
auto get_modRM_reg_lh = [](const u8* code) -> x64_reg_t auto get_modRM_reg_lh = [](const u8* code) -> x64_reg_t
{ {
return (x64_reg_t)(((*code & 0x38) >> 3) + X64R_AL); return x64_reg_t{((*code & 0x38) >> 3) + X64R_AL};
}; };
auto get_op_size = [](const u8 rex, const bool oso) -> size_t auto get_op_size = [](const u8 rex, const bool oso) -> size_t
@ -887,57 +887,57 @@ bool get_x64_reg_value(x64_context* context, x64_reg_t reg, size_t d_size, size_
switch (d_size) switch (d_size)
{ {
case 1: out_value = (u8)reg_value; return true; case 1: out_value = static_cast<u8>(reg_value); return true;
case 2: out_value = (u16)reg_value; return true; case 2: out_value = static_cast<u16>(reg_value); return true;
case 4: out_value = (u32)reg_value; return true; case 4: out_value = static_cast<u32>(reg_value); return true;
case 8: out_value = reg_value; return true; case 8: out_value = reg_value; return true;
} }
} }
else if (reg - X64R_AL < 4 && d_size == 1) else if (reg - X64R_AL < 4 && d_size == 1)
{ {
out_value = (u8)(*X64REG(context, reg - X64R_AL)); out_value = static_cast<u8>(*X64REG(context, reg - X64R_AL));
return true; return true;
} }
else if (reg - X64R_AH < 4 && d_size == 1) else if (reg - X64R_AH < 4 && d_size == 1)
{ {
out_value = (u8)(*X64REG(context, reg - X64R_AH) >> 8); out_value = static_cast<u8>(*X64REG(context, reg - X64R_AH) >> 8);
return true; return true;
} }
else if (reg == X64_IMM8) else if (reg == X64_IMM8)
{ {
// load the immediate value (assuming it's at the end of the instruction) // load the immediate value (assuming it's at the end of the instruction)
const s8 imm_value = *(s8*)(RIP(context) + i_size - 1); const s8 imm_value = *reinterpret_cast<s8*>(RIP(context) + i_size - 1);
switch (d_size) switch (d_size)
{ {
case 1: out_value = (u8)imm_value; return true; case 1: out_value = static_cast<u8>(imm_value); return true;
case 2: out_value = (u16)imm_value; return true; // sign-extended case 2: out_value = static_cast<u16>(imm_value); return true; // sign-extended
case 4: out_value = (u32)imm_value; return true; // sign-extended case 4: out_value = static_cast<u32>(imm_value); return true; // sign-extended
case 8: out_value = (u64)imm_value; return true; // sign-extended case 8: out_value = static_cast<u64>(imm_value); return true; // sign-extended
} }
} }
else if (reg == X64_IMM16) else if (reg == X64_IMM16)
{ {
const s16 imm_value = *(s16*)(RIP(context) + i_size - 2); const s16 imm_value = *reinterpret_cast<s16*>(RIP(context) + i_size - 2);
switch (d_size) switch (d_size)
{ {
case 2: out_value = (u16)imm_value; return true; case 2: out_value = static_cast<u16>(imm_value); return true;
} }
} }
else if (reg == X64_IMM32) else if (reg == X64_IMM32)
{ {
const s32 imm_value = *(s32*)(RIP(context) + i_size - 4); const s32 imm_value = *reinterpret_cast<s32*>(RIP(context) + i_size - 4);
switch (d_size) switch (d_size)
{ {
case 4: out_value = (u32)imm_value; return true; case 4: out_value = static_cast<u32>(imm_value); return true;
case 8: out_value = (u64)imm_value; return true; // sign-extended case 8: out_value = static_cast<u64>(imm_value); return true; // sign-extended
} }
} }
else if (reg == X64R_ECX) else if (reg == X64R_ECX)
{ {
out_value = (u32)RCX(context); out_value = static_cast<u32>(RCX(context));
return true; return true;
} }
else if (reg >= X64_BIT_O && reg <= X64_BIT_NLE) else if (reg >= X64_BIT_O && reg <= X64_BIT_NLE)
@ -964,7 +964,7 @@ bool get_x64_reg_value(x64_context* context, x64_reg_t reg, size_t d_size, size_
return true; return true;
} }
LOG_ERROR(MEMORY, "get_x64_reg_value(): invalid arguments (reg=%d, d_size=%lld, i_size=%lld)", (u32)reg, d_size, i_size); LOG_ERROR(MEMORY, "get_x64_reg_value(): invalid arguments (reg=%d, d_size=%lld, i_size=%lld)", +reg, d_size, i_size);
return false; return false;
} }
@ -983,7 +983,7 @@ bool put_x64_reg_value(x64_context* context, x64_reg_t reg, size_t d_size, u64 v
} }
} }
LOG_ERROR(MEMORY, "put_x64_reg_value(): invalid destination (reg=%d, d_size=%lld, value=0x%llx)", (u32)reg, d_size, value); LOG_ERROR(MEMORY, "put_x64_reg_value(): invalid destination (reg=%d, d_size=%lld, value=0x%llx)", +reg, d_size, value);
return false; return false;
} }
@ -1038,7 +1038,7 @@ bool set_x64_cmp_flags(x64_context* context, size_t d_size, u64 x, u64 y, bool c
EFLAGS(context) &= ~0x800; // clear OF EFLAGS(context) &= ~0x800; // clear OF
} }
const u8 p1 = (u8)diff ^ ((u8)diff >> 4); const u8 p1 = static_cast<u8>(diff) ^ (static_cast<u8>(diff) >> 4);
const u8 p2 = p1 ^ (p1 >> 2); const u8 p2 = p1 ^ (p1 >> 2);
const u8 p3 = p2 ^ (p2 >> 1); const u8 p3 = p2 ^ (p2 >> 1);
@ -1145,7 +1145,7 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
} }
} }
auto code = (const u8*)RIP(context); const u8* const code = reinterpret_cast<u8*>(RIP(context));
x64_op_t op; x64_op_t op;
x64_reg_t reg; x64_reg_t reg;
@ -1159,7 +1159,7 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
{ {
if (op == X64OP_NONE) if (op == X64OP_NONE)
{ {
LOG_ERROR(MEMORY, "decode_x64_reg_op(%p): unsupported opcode: %s", code, *(be_t<v128, 1>*)code); LOG_ERROR(MEMORY, "decode_x64_reg_op(%p): unsupported opcode: %s", code, *reinterpret_cast<const be_t<v128, 1>*>(code));
} }
}; };
@ -1192,7 +1192,7 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
if (a_size != 4 || !d_size || !i_size) if (a_size != 4 || !d_size || !i_size)
{ {
LOG_ERROR(MEMORY, "Invalid or unsupported instruction (op=%d, reg=%d, d_size=%lld, a_size=0x%llx, i_size=%lld)", (u32)op, (u32)reg, d_size, a_size, i_size); LOG_ERROR(MEMORY, "Invalid or unsupported instruction (op=%d, reg=%d, d_size=%lld, a_size=0x%llx, i_size=%lld)", +op, +reg, d_size, a_size, i_size);
report_opcode(); report_opcode();
return false; return false;
} }
@ -1253,7 +1253,8 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
return false; return false;
} }
if (!thread->write_reg(addr, op == X64OP_STORE ? se_storage<u32>::swap((u32)reg_value) : (u32)reg_value)) u32 val32 = static_cast<u32>(reg_value);
if (!thread->write_reg(addr, op == X64OP_STORE ? se_storage<u32>::swap(val32) : val32))
{ {
return false; return false;
} }
@ -1264,7 +1265,7 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
case X64OP_STOS: case X64OP_STOS:
default: default:
{ {
LOG_ERROR(MEMORY, "Invalid or unsupported operation (op=%d, reg=%d, d_size=%lld, i_size=%lld)", (u32)op, (u32)reg, d_size, i_size); LOG_ERROR(MEMORY, "Invalid or unsupported operation (op=%d, reg=%d, d_size=%lld, i_size=%lld)", +op, +reg, d_size, i_size);
report_opcode(); report_opcode();
return false; return false;
} }
@ -1475,13 +1476,13 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
static LONG exception_handler(PEXCEPTION_POINTERS pExp) static LONG exception_handler(PEXCEPTION_POINTERS pExp)
{ {
const u64 addr64 = pExp->ExceptionRecord->ExceptionInformation[1] - (u64)vm::g_base_addr; const u64 addr64 = pExp->ExceptionRecord->ExceptionInformation[1] - reinterpret_cast<u64>(vm::g_base_addr);
const u64 exec64 = (pExp->ExceptionRecord->ExceptionInformation[1] - (u64)vm::g_exec_addr) / 2; const u64 exec64 = (pExp->ExceptionRecord->ExceptionInformation[1] - reinterpret_cast<u64>(vm::g_exec_addr)) / 2;
const bool is_writing = pExp->ExceptionRecord->ExceptionInformation[0] != 0; const bool is_writing = pExp->ExceptionRecord->ExceptionInformation[0] != 0;
if (pExp->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION && addr64 < 0x100000000ull) if (pExp->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION && addr64 < 0x100000000ull)
{ {
if (thread_ctrl::get_current() && handle_access_violation((u32)addr64, is_writing, pExp->ContextRecord)) if (thread_ctrl::get_current() && handle_access_violation(static_cast<u32>(addr64), is_writing, pExp->ContextRecord))
{ {
return EXCEPTION_CONTINUE_EXECUTION; return EXCEPTION_CONTINUE_EXECUTION;
} }
@ -1489,7 +1490,7 @@ static LONG exception_handler(PEXCEPTION_POINTERS pExp)
if (pExp->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION && exec64 < 0x100000000ull) if (pExp->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION && exec64 < 0x100000000ull)
{ {
if (thread_ctrl::get_current() && handle_access_violation((u32)exec64, is_writing, pExp->ContextRecord)) if (thread_ctrl::get_current() && handle_access_violation(static_cast<u32>(exec64), is_writing, pExp->ContextRecord))
{ {
return EXCEPTION_CONTINUE_EXECUTION; return EXCEPTION_CONTINUE_EXECUTION;
} }
@ -1546,7 +1547,7 @@ static LONG exception_filter(PEXCEPTION_POINTERS pExp)
MODULEINFO info; MODULEINFO info;
if (GetModuleInformation(GetCurrentProcess(), module, &info, sizeof(info))) if (GetModuleInformation(GetCurrentProcess(), module, &info, sizeof(info)))
{ {
const DWORD64 base = (DWORD64)info.lpBaseOfDll; const DWORD64 base = reinterpret_cast<DWORD64>(info.lpBaseOfDll);
if (pExp->ContextRecord->Rip >= base && pExp->ContextRecord->Rip < base + info.SizeOfImage) if (pExp->ContextRecord->Rip >= base && pExp->ContextRecord->Rip < base + info.SizeOfImage)
{ {
@ -1596,7 +1597,7 @@ const bool s_exception_handler_set = []() -> bool
static void signal_handler(int sig, siginfo_t* info, void* uct) static void signal_handler(int sig, siginfo_t* info, void* uct)
{ {
x64_context* context = (ucontext_t*)uct; x64_context* context = static_cast<ucontext_t*>(uct);
#ifdef __APPLE__ #ifdef __APPLE__
const bool is_writing = context->uc_mcontext->__es.__err & 0x2; const bool is_writing = context->uc_mcontext->__es.__err & 0x2;
@ -1610,14 +1611,14 @@ static void signal_handler(int sig, siginfo_t* info, void* uct)
const bool is_writing = context->uc_mcontext.gregs[REG_ERR] & 0x2; const bool is_writing = context->uc_mcontext.gregs[REG_ERR] & 0x2;
#endif #endif
const u64 addr64 = (u64)info->si_addr - (u64)vm::g_base_addr; const u64 addr64 = reinterpret_cast<u64>(info->si_addr) - reinterpret_cast<u64>(vm::g_base_addr);
const u64 exec64 = ((u64)info->si_addr - (u64)vm::g_exec_addr) / 2; const u64 exec64 = (reinterpret_cast<u64>(info->si_addr) - reinterpret_cast<u64>(vm::g_exec_addr)) / 2;
const auto cause = is_writing ? "writing" : "reading"; const auto cause = is_writing ? "writing" : "reading";
if (addr64 < 0x100000000ull) if (addr64 < 0x100000000ull)
{ {
// Try to process access violation // Try to process access violation
if (thread_ctrl::get_current() && handle_access_violation((u32)addr64, is_writing, context)) if (thread_ctrl::get_current() && handle_access_violation(static_cast<u32>(addr64), is_writing, context))
{ {
return; return;
} }
@ -1625,7 +1626,7 @@ static void signal_handler(int sig, siginfo_t* info, void* uct)
if (exec64 < 0x100000000ull) if (exec64 < 0x100000000ull)
{ {
if (thread_ctrl::get_current() && handle_access_violation((u32)exec64, is_writing, context)) if (thread_ctrl::get_current() && handle_access_violation(static_cast<u32>(exec64), is_writing, context))
{ {
return; return;
} }
@ -1864,9 +1865,9 @@ thread_base::~thread_base()
if (m_thread) if (m_thread)
{ {
#ifdef _WIN32 #ifdef _WIN32
CloseHandle((HANDLE)m_thread.raw()); CloseHandle(reinterpret_cast<HANDLE>(m_thread.raw()));
#else #else
pthread_detach((pthread_t)m_thread.raw()); pthread_detach(reinterpret_cast<pthread_t>(m_thread.raw()));
#endif #endif
} }
} }
@ -1895,10 +1896,10 @@ u64 thread_base::get_cycles()
u64 cycles; u64 cycles;
#ifdef _WIN32 #ifdef _WIN32
if (QueryThreadCycleTime((HANDLE)m_thread.load(), &cycles)) if (QueryThreadCycleTime(reinterpret_cast<HANDLE>(m_thread.load()), &cycles))
{ {
#elif __APPLE__ #elif __APPLE__
mach_port_name_t port = pthread_mach_thread_np((pthread_t)m_thread.load()); mach_port_name_t port = pthread_mach_thread_np(reinterpret_cast<pthread_t>(m_thread.load()));
mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT; mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
thread_basic_info_data_t info; thread_basic_info_data_t info;
kern_return_t ret = thread_info(port, THREAD_BASIC_INFO, (thread_info_t)&info, &count); kern_return_t ret = thread_info(port, THREAD_BASIC_INFO, (thread_info_t)&info, &count);
@ -1909,7 +1910,7 @@ u64 thread_base::get_cycles()
#else #else
clockid_t _clock; clockid_t _clock;
struct timespec thread_time; struct timespec thread_time;
if (!pthread_getcpuclockid((pthread_t)m_thread.load(), &_clock) && !clock_gettime(_clock, &thread_time)) if (!pthread_getcpuclockid(reinterpret_cast<pthread_t>(m_thread.load()), &_clock) && !clock_gettime(_clock, &thread_time))
{ {
cycles = static_cast<u64>(thread_time.tv_sec) * 1'000'000'000 + thread_time.tv_nsec; cycles = static_cast<u64>(thread_time.tv_sec) * 1'000'000'000 + thread_time.tv_nsec;
#endif #endif

17
Utilities/VirtualMemory.cpp
View File

@ -80,7 +80,8 @@ namespace utils
#ifdef _WIN32 #ifdef _WIN32
verify(HERE), ::VirtualAlloc(pointer, size, MEM_COMMIT, +prot); verify(HERE), ::VirtualAlloc(pointer, size, MEM_COMMIT, +prot);
#else #else
verify(HERE), ::mprotect((void*)((u64)pointer & -4096), size + ((u64)pointer & 4095), +prot) != -1; const u64 ptr64 = reinterpret_cast<u64>(pointer);
verify(HERE), ::mprotect(reinterpret_cast<void*>(ptr64 & -4096), size + (ptr64 & 4095), +prot) != -1;
#endif #endif
} }
@ -115,13 +116,13 @@ namespace utils
void memory_protect(void* pointer, std::size_t size, protection prot) void memory_protect(void* pointer, std::size_t size, protection prot)
{ {
#ifdef _WIN32 #ifdef _WIN32
for (u64 addr = (u64)pointer, end = addr + size; addr < end;) for (u64 addr = reinterpret_cast<u64>(pointer), end = addr + size; addr < end;)
{ {
const u64 boundary = (addr + 0x10000) & -0x10000; const u64 boundary = (addr + 0x10000) & -0x10000;
const u64 block_size = std::min(boundary, end) - addr; const u64 block_size = std::min(boundary, end) - addr;
DWORD old; DWORD old;
if (!::VirtualProtect((LPVOID)addr, block_size, +prot, &old)) if (!::VirtualProtect(reinterpret_cast<LPVOID>(addr), block_size, +prot, &old))
{ {
fmt::throw_exception("VirtualProtect failed (%p, 0x%x, addr=0x%x, error=%#x)", pointer, size, addr, GetLastError()); fmt::throw_exception("VirtualProtect failed (%p, 0x%x, addr=0x%x, error=%#x)", pointer, size, addr, GetLastError());
} }
@ -130,7 +131,8 @@ namespace utils
addr += block_size; addr += block_size;
} }
#else #else
verify(HERE), ::mprotect((void*)((u64)pointer & -4096), size + ((u64)pointer & 4095), +prot) != -1; const u64 ptr64 = reinterpret_cast<u64>(pointer);
verify(HERE), ::mprotect(reinterpret_cast<void*>(ptr64 & -4096), size + (ptr64 & 4095), +prot) != -1;
#endif #endif
} }
@ -202,13 +204,14 @@ namespace utils
return nullptr; return nullptr;
#else #else
return static_cast<u8*>(::mmap((void*)((u64)ptr & -0x10000), m_size, +prot, MAP_SHARED | (ptr ? MAP_FIXED : 0), m_file, 0)); const u64 ptr64 = reinterpret_cast<u64>(ptr);
return static_cast<u8*>(::mmap(reinterpret_cast<void*>(ptr64 & -0x10000), m_size, +prot, MAP_SHARED | (ptr ? MAP_FIXED : 0), m_file, 0));
#endif #endif
} }
u8* shm::map_critical(void* ptr, protection prot) u8* shm::map_critical(void* ptr, protection prot)
{ {
const auto target = (u8*)((u64)ptr & -0x10000); const auto target = reinterpret_cast<u8*>(reinterpret_cast<u64>(ptr) & -0x10000);
#ifdef _WIN32 #ifdef _WIN32
::MEMORY_BASIC_INFORMATION mem; ::MEMORY_BASIC_INFORMATION mem;
@ -245,7 +248,7 @@ namespace utils
void shm::unmap_critical(void* ptr) void shm::unmap_critical(void* ptr)
{ {
const auto target = (u8*)((u64)ptr & -0x10000); const auto target = reinterpret_cast<u8*>(reinterpret_cast<u64>(ptr) & -0x10000);
this->unmap(target); this->unmap(target);

8
Utilities/cfmt.h
View File

@ -341,7 +341,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
if (!ctx.type) if (!ctx.type)
{ {
ctx.type = (u8)src.type(ctx.args); ctx.type = static_cast<u8>(src.type(ctx.args));
if (!ctx.type) if (!ctx.type)
{ {
@ -403,7 +403,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
if (!ctx.type) if (!ctx.type)
{ {
ctx.type = (u8)src.type(ctx.args); ctx.type = static_cast<u8>(src.type(ctx.args));
if (!ctx.type) if (!ctx.type)
{ {
@ -460,7 +460,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
if (!ctx.type) if (!ctx.type)
{ {
ctx.type = (u8)src.type(ctx.args); ctx.type = static_cast<u8>(src.type(ctx.args));
if (!ctx.type) if (!ctx.type)
{ {
@ -524,7 +524,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
if (!ctx.type) if (!ctx.type)
{ {
ctx.type = (u8)src.type(ctx.args); ctx.type = static_cast<u8>(src.type(ctx.args));
if (!ctx.type) if (!ctx.type)
{ {

12
Utilities/dynamic_library.cpp
View File

@ -9,7 +9,7 @@
namespace utils namespace utils
{ {
dynamic_library::dynamic_library(const std::string &path) dynamic_library::dynamic_library(const std::string& path)
{ {
load(path); load(path);
} }
@ -19,7 +19,7 @@ namespace utils
close(); close();
} }
bool dynamic_library::load(const std::string &path) bool dynamic_library::load(const std::string& path)
{ {
#ifdef _WIN32 #ifdef _WIN32
m_handle = LoadLibraryA(path.c_str()); m_handle = LoadLibraryA(path.c_str());
@ -32,19 +32,19 @@ namespace utils
void dynamic_library::close() void dynamic_library::close()
{ {
#ifdef _WIN32 #ifdef _WIN32
FreeLibrary((HMODULE)m_handle); FreeLibrary(reinterpret_cast<HMODULE>(m_handle));
#else #else
dlclose(m_handle); dlclose(m_handle);
#endif #endif
m_handle = nullptr; m_handle = nullptr;
} }
void *dynamic_library::get_impl(const std::string &name) const void* dynamic_library::get_impl(const std::string& name) const
{ {
#ifdef _WIN32 #ifdef _WIN32
return (void*)GetProcAddress((HMODULE)m_handle, name.c_str()); return reinterpret_cast<void*>(GetProcAddress(reinterpret_cast<HMODULE>(m_handle), name.c_str()));
#else #else
return dlsym(m_handle, (char *)name.c_str()); return dlsym(m_handle, name.c_str());
#endif #endif
} }

34
Utilities/dynamic_library.h
View File

@ -4,35 +4,35 @@ namespace utils
{ {
class dynamic_library class dynamic_library
{ {
void *m_handle = nullptr; void* m_handle = nullptr;
public: public:
dynamic_library() = default; dynamic_library() = default;
dynamic_library(const std::string &path); dynamic_library(const std::string& path);
~dynamic_library(); ~dynamic_library();
bool load(const std::string &path); bool load(const std::string& path);
void close(); void close();
private: private:
void *get_impl(const std::string &name) const; void* get_impl(const std::string& name) const;
public: public:
template<typename Type = void> template <typename Type = void>
Type *get(const std::string &name) const Type* get(const std::string& name) const
{ {
Type *result; Type* result;
*(void **)(&result) = get_impl(name); *reinterpret_cast<void**>(&result) = get_impl(name);
return result; return result;
} }
template<typename Type> template <typename Type>
bool get(Type *&function, const std::string &name) const bool get(Type*& function, const std::string& name) const
{ {
*(void **)(&function) = get_impl(name); *reinterpret_cast<void**>(&function) = get_impl(name);
return !!function; return function != nullptr;
} }
bool loaded() const; bool loaded() const;
@ -51,15 +51,15 @@ namespace utils
template <typename R, typename... Args> template <typename R, typename... Args>
struct dynamic_import<R(Args...)> struct dynamic_import<R(Args...)>
{ {
R(*ptr)(Args...); R (*ptr)(Args...);
const char* const lib; const char* const lib;
const char* const name; const char* const name;
// Constant initialization // Constant initialization
constexpr dynamic_import(const char* lib, const char* name) constexpr dynamic_import(const char* lib, const char* name)
: ptr(nullptr) : ptr(nullptr)
, lib(lib) , lib(lib)
, name(name) , name(name)
{ {
} }
@ -68,7 +68,7 @@ namespace utils
if (!ptr) if (!ptr)
{ {
// TODO: atomic // TODO: atomic
ptr = reinterpret_cast<R(*)(Args...)>(get_proc_address(lib, name)); ptr = reinterpret_cast<R (*)(Args...)>(get_proc_address(lib, name));
} }
} }

176
rpcs3/Crypto/aes.cpp
View File

@ -38,20 +38,20 @@
#ifndef GET_UINT32_LE #ifndef GET_UINT32_LE
#define GET_UINT32_LE(n,b,i) \ #define GET_UINT32_LE(n,b,i) \
{ \ { \
(n) = ( (uint32_t) (b)[(i) ] ) \ (n) = ( static_cast<uint32_t>((b)[(i) ]) ) \
| ( (uint32_t) (b)[(i) + 1] << 8 ) \ | ( static_cast<uint32_t>((b)[(i) + 1]) << 8 ) \
| ( (uint32_t) (b)[(i) + 2] << 16 ) \ | ( static_cast<uint32_t>((b)[(i) + 2]) << 16 ) \
| ( (uint32_t) (b)[(i) + 3] << 24 ); \ | ( static_cast<uint32_t>((b)[(i) + 3]) << 24 );\
} }
#endif #endif
#ifndef PUT_UINT32_LE #ifndef PUT_UINT32_LE
#define PUT_UINT32_LE(n,b,i) \ #define PUT_UINT32_LE(n,b,i) \
{ \ { \
(b)[(i) ] = (unsigned char) ( (n) ); \ (b)[(i) ] = static_cast<unsigned char> ( (n) ); \
(b)[(i) + 1] = (unsigned char) ( (n) >> 8 ); \ (b)[(i) + 1] = static_cast<unsigned char> ( (n) >> 8 ); \
(b)[(i) + 2] = (unsigned char) ( (n) >> 16 ); \ (b)[(i) + 2] = static_cast<unsigned char> ( (n) >> 16 ); \
(b)[(i) + 3] = (unsigned char) ( (n) >> 24 ); \ (b)[(i) + 3] = static_cast<unsigned char> ( (n) >> 24 ); \
} }
#endif #endif
@ -326,10 +326,10 @@ static const uint32_t RCON[10] =
* Forward S-box & tables * Forward S-box & tables
*/ */
static unsigned char FSb[256]; static unsigned char FSb[256];
static uint32_t FT0[256]; static uint32_t FT0[256];
static uint32_t FT1[256]; static uint32_t FT1[256];
static uint32_t FT2[256]; static uint32_t FT2[256];
static uint32_t FT3[256]; static uint32_t FT3[256];
/* /*
* Reverse S-box & tables * Reverse S-box & tables
@ -375,7 +375,7 @@ static void aes_gen_tables( void )
*/ */
for( i = 0, x = 1; i < 10; i++ ) for( i = 0, x = 1; i < 10; i++ )
{ {
RCON[i] = (uint32_t) x; RCON[i] = static_cast<uint32_t>(x;
x = XTIME( x ) & 0xFF; x = XTIME( x ) & 0xFF;
} }
@ -408,10 +408,10 @@ static void aes_gen_tables( void )
y = XTIME( x ) & 0xFF; y = XTIME( x ) & 0xFF;
z = ( y ^ x ) & 0xFF; z = ( y ^ x ) & 0xFF;
FT0[i] = ( (uint32_t) y ) ^ FT0[i] = ( static_cast<uint32_t>(y ) ^
( (uint32_t) x << 8 ) ^ ( static_cast<uint32_t>(x << 8 ) ^
( (uint32_t) x << 16 ) ^ ( static_cast<uint32_t>(x << 16 ) ^
( (uint32_t) z << 24 ); ( static_cast<uint32_t>(z << 24 );
FT1[i] = ROTL8( FT0[i] ); FT1[i] = ROTL8( FT0[i] );
FT2[i] = ROTL8( FT1[i] ); FT2[i] = ROTL8( FT1[i] );
@ -419,10 +419,10 @@ static void aes_gen_tables( void )
x = RSb[i]; x = RSb[i];
RT0[i] = ( (uint32_t) MUL( 0x0E, x ) ) ^ RT0[i] = ( static_cast<uint32_t>(MUL( 0x0E, x ) ) ^
( (uint32_t) MUL( 0x09, x ) << 8 ) ^ ( static_cast<uint32_t>(MUL( 0x09, x ) << 8 ) ^
( (uint32_t) MUL( 0x0D, x ) << 16 ) ^ ( static_cast<uint32_t>(MUL( 0x0D, x ) << 16 ) ^
( (uint32_t) MUL( 0x0B, x ) << 24 ); ( static_cast<uint32_t>(MUL( 0x0B, x ) << 24 );
RT1[i] = ROTL8( RT0[i] ); RT1[i] = ROTL8( RT0[i] );
RT2[i] = ROTL8( RT1[i] ); RT2[i] = ROTL8( RT1[i] );
@ -460,7 +460,7 @@ int aes_setkey_enc( aes_context *ctx, const unsigned char *key, unsigned int key
ctx->rk = RK = ctx->buf; ctx->rk = RK = ctx->buf;
if( aesni_supports( POLARSSL_AESNI_AES ) ) if( aesni_supports( POLARSSL_AESNI_AES ) )
return( aesni_setkey_enc( (unsigned char *) ctx->rk, key, keysize ) ); return( aesni_setkey_enc( reinterpret_cast<unsigned char*>(ctx->rk), key, keysize ) );
for( i = 0; i < (keysize >> 5); i++ ) for( i = 0; i < (keysize >> 5); i++ )
{ {
@ -474,10 +474,10 @@ int aes_setkey_enc( aes_context *ctx, const unsigned char *key, unsigned int key
for( i = 0; i < 10; i++, RK += 4 ) for( i = 0; i < 10; i++, RK += 4 )
{ {
RK[4] = RK[0] ^ RCON[i] ^ RK[4] = RK[0] ^ RCON[i] ^
( (uint32_t) FSb[ ( RK[3] >> 8 ) & 0xFF ] ) ^ ( static_cast<uint32_t>(FSb[ ( RK[3] >> 8 ) & 0xFF ]) ) ^
( (uint32_t) FSb[ ( RK[3] >> 16 ) & 0xFF ] << 8 ) ^ ( static_cast<uint32_t>(FSb[ ( RK[3] >> 16 ) & 0xFF ]) << 8 ) ^
( (uint32_t) FSb[ ( RK[3] >> 24 ) & 0xFF ] << 16 ) ^ ( static_cast<uint32_t>(FSb[ ( RK[3] >> 24 ) & 0xFF ]) << 16 ) ^
( (uint32_t) FSb[ ( RK[3] ) & 0xFF ] << 24 ); ( static_cast<uint32_t>(FSb[ ( RK[3] ) & 0xFF ]) << 24 );
RK[5] = RK[1] ^ RK[4]; RK[5] = RK[1] ^ RK[4];
RK[6] = RK[2] ^ RK[5]; RK[6] = RK[2] ^ RK[5];
@ -490,10 +490,10 @@ int aes_setkey_enc( aes_context *ctx, const unsigned char *key, unsigned int key
for( i = 0; i < 8; i++, RK += 6 ) for( i = 0; i < 8; i++, RK += 6 )
{ {
RK[6] = RK[0] ^ RCON[i] ^ RK[6] = RK[0] ^ RCON[i] ^
( (uint32_t) FSb[ ( RK[5] >> 8 ) & 0xFF ] ) ^ ( static_cast<uint32_t>(FSb[ ( RK[5] >> 8 ) & 0xFF ]) ) ^
( (uint32_t) FSb[ ( RK[5] >> 16 ) & 0xFF ] << 8 ) ^ ( static_cast<uint32_t>(FSb[ ( RK[5] >> 16 ) & 0xFF ]) << 8 ) ^
( (uint32_t) FSb[ ( RK[5] >> 24 ) & 0xFF ] << 16 ) ^ ( static_cast<uint32_t>(FSb[ ( RK[5] >> 24 ) & 0xFF ]) << 16 ) ^
( (uint32_t) FSb[ ( RK[5] ) & 0xFF ] << 24 ); ( static_cast<uint32_t>(FSb[ ( RK[5] ) & 0xFF ]) << 24 );
RK[7] = RK[1] ^ RK[6]; RK[7] = RK[1] ^ RK[6];
RK[8] = RK[2] ^ RK[7]; RK[8] = RK[2] ^ RK[7];
@ -508,20 +508,20 @@ int aes_setkey_enc( aes_context *ctx, const unsigned char *key, unsigned int key
for( i = 0; i < 7; i++, RK += 8 ) for( i = 0; i < 7; i++, RK += 8 )
{ {
RK[8] = RK[0] ^ RCON[i] ^ RK[8] = RK[0] ^ RCON[i] ^
( (uint32_t) FSb[ ( RK[7] >> 8 ) & 0xFF ] ) ^ ( static_cast<uint32_t>(FSb[ ( RK[7] >> 8 ) & 0xFF ]) ) ^
( (uint32_t) FSb[ ( RK[7] >> 16 ) & 0xFF ] << 8 ) ^ ( static_cast<uint32_t>(FSb[ ( RK[7] >> 16 ) & 0xFF ]) << 8 ) ^
( (uint32_t) FSb[ ( RK[7] >> 24 ) & 0xFF ] << 16 ) ^ ( static_cast<uint32_t>(FSb[ ( RK[7] >> 24 ) & 0xFF ]) << 16 ) ^
( (uint32_t) FSb[ ( RK[7] ) & 0xFF ] << 24 ); ( static_cast<uint32_t>(FSb[ ( RK[7] ) & 0xFF ]) << 24 );
RK[9] = RK[1] ^ RK[8]; RK[9] = RK[1] ^ RK[8];
RK[10] = RK[2] ^ RK[9]; RK[10] = RK[2] ^ RK[9];
RK[11] = RK[3] ^ RK[10]; RK[11] = RK[3] ^ RK[10];
RK[12] = RK[4] ^ RK[12] = RK[4] ^
( (uint32_t) FSb[ ( RK[11] ) & 0xFF ] ) ^ ( static_cast<uint32_t>(FSb[ ( RK[11] ) & 0xFF ]) ) ^
( (uint32_t) FSb[ ( RK[11] >> 8 ) & 0xFF ] << 8 ) ^ ( static_cast<uint32_t>(FSb[ ( RK[11] >> 8 ) & 0xFF ]) << 8 ) ^
( (uint32_t) FSb[ ( RK[11] >> 16 ) & 0xFF ] << 16 ) ^ ( static_cast<uint32_t>(FSb[ ( RK[11] >> 16 ) & 0xFF ]) << 16 ) ^
( (uint32_t) FSb[ ( RK[11] >> 24 ) & 0xFF ] << 24 ); ( static_cast<uint32_t>(FSb[ ( RK[11] >> 24 ) & 0xFF ]) << 24 );
RK[13] = RK[5] ^ RK[12]; RK[13] = RK[5] ^ RK[12];
RK[14] = RK[6] ^ RK[13]; RK[14] = RK[6] ^ RK[13];
@ -564,8 +564,8 @@ int aes_setkey_dec( aes_context *ctx, const unsigned char *key, unsigned int key
if( aesni_supports( POLARSSL_AESNI_AES ) ) if( aesni_supports( POLARSSL_AESNI_AES ) )
{ {
aesni_inverse_key( (unsigned char *) ctx->rk, aesni_inverse_key( reinterpret_cast<unsigned char*>(ctx->rk),
(const unsigned char *) cty.rk, ctx->nr ); reinterpret_cast<const unsigned char*>(cty.rk), ctx->nr );
goto done; goto done;
} }
@ -676,28 +676,28 @@ int aes_crypt_ecb( aes_context *ctx,
AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 ); AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
X0 = *RK++ ^ \ X0 = *RK++ ^ \
( (uint32_t) RSb[ ( Y0 ) & 0xFF ] ) ^ ( static_cast<uint32_t>(RSb[ ( Y0 ) & 0xFF ]) ) ^
( (uint32_t) RSb[ ( Y3 >> 8 ) & 0xFF ] << 8 ) ^ ( static_cast<uint32_t>(RSb[ ( Y3 >> 8 ) & 0xFF ]) << 8 ) ^
( (uint32_t) RSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^ ( static_cast<uint32_t>(RSb[ ( Y2 >> 16 ) & 0xFF ]) << 16 ) ^
( (uint32_t) RSb[ ( Y1 >> 24 ) & 0xFF ] << 24 ); ( static_cast<uint32_t>(RSb[ ( Y1 >> 24 ) & 0xFF ]) << 24 );
X1 = *RK++ ^ \ X1 = *RK++ ^ \
( (uint32_t) RSb[ ( Y1 ) & 0xFF ] ) ^ ( static_cast<uint32_t>(RSb[ ( Y1 ) & 0xFF ]) ) ^
( (uint32_t) RSb[ ( Y0 >> 8 ) & 0xFF ] << 8 ) ^ ( static_cast<uint32_t>(RSb[ ( Y0 >> 8 ) & 0xFF ]) << 8 ) ^
( (uint32_t) RSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^ ( static_cast<uint32_t>(RSb[ ( Y3 >> 16 ) & 0xFF ]) << 16 ) ^
( (uint32_t) RSb[ ( Y2 >> 24 ) & 0xFF ] << 24 ); ( static_cast<uint32_t>(RSb[ ( Y2 >> 24 ) & 0xFF ]) << 24 );
X2 = *RK++ ^ \ X2 = *RK++ ^ \
( (uint32_t) RSb[ ( Y2 ) & 0xFF ] ) ^ ( static_cast<uint32_t>(RSb[ ( Y2 ) & 0xFF ]) ) ^
( (uint32_t) RSb[ ( Y1 >> 8 ) & 0xFF ] << 8 ) ^ ( static_cast<uint32_t>(RSb[ ( Y1 >> 8 ) & 0xFF ]) << 8 ) ^
( (uint32_t) RSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^ ( static_cast<uint32_t>(RSb[ ( Y0 >> 16 ) & 0xFF ]) << 16 ) ^
( (uint32_t) RSb[ ( Y3 >> 24 ) & 0xFF ] << 24 ); ( static_cast<uint32_t>(RSb[ ( Y3 >> 24 ) & 0xFF ]) << 24 );
X3 = *RK++ ^ \ X3 = *RK++ ^ \
( (uint32_t) RSb[ ( Y3 ) & 0xFF ] ) ^ ( static_cast<uint32_t>(RSb[ ( Y3 ) & 0xFF ]) ) ^
( (uint32_t) RSb[ ( Y2 >> 8 ) & 0xFF ] << 8 ) ^ ( static_cast<uint32_t>(RSb[ ( Y2 >> 8 ) & 0xFF ]) << 8 ) ^
( (uint32_t) RSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^ ( static_cast<uint32_t>(RSb[ ( Y1 >> 16 ) & 0xFF ]) << 16 ) ^
( (uint32_t) RSb[ ( Y0 >> 24 ) & 0xFF ] << 24 ); ( static_cast<uint32_t>(RSb[ ( Y0 >> 24 ) & 0xFF ]) << 24 );
} }
else /* AES_ENCRYPT */ else /* AES_ENCRYPT */
{ {
@ -710,28 +710,28 @@ int aes_crypt_ecb( aes_context *ctx,
AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 ); AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
X0 = *RK++ ^ \ X0 = *RK++ ^ \
( (uint32_t) FSb[ ( Y0 ) & 0xFF ] ) ^ ( static_cast<uint32_t>(FSb[ ( Y0 ) & 0xFF ]) ) ^
( (uint32_t) FSb[ ( Y1 >> 8 ) & 0xFF ] << 8 ) ^ ( static_cast<uint32_t>(FSb[ ( Y1 >> 8 ) & 0xFF ]) << 8 ) ^
( (uint32_t) FSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^ ( static_cast<uint32_t>(FSb[ ( Y2 >> 16 ) & 0xFF ]) << 16 ) ^
( (uint32_t) FSb[ ( Y3 >> 24 ) & 0xFF ] << 24 ); ( static_cast<uint32_t>(FSb[ ( Y3 >> 24 ) & 0xFF ]) << 24 );
X1 = *RK++ ^ \ X1 = *RK++ ^ \
( (uint32_t) FSb[ ( Y1 ) & 0xFF ] ) ^ ( static_cast<uint32_t>(FSb[ ( Y1 ) & 0xFF ]) ) ^
( (uint32_t) FSb[ ( Y2 >> 8 ) & 0xFF ] << 8 ) ^ ( static_cast<uint32_t>(FSb[ ( Y2 >> 8 ) & 0xFF ]) << 8 ) ^
( (uint32_t) FSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^ ( static_cast<uint32_t>(FSb[ ( Y3 >> 16 ) & 0xFF ]) << 16 ) ^
( (uint32_t) FSb[ ( Y0 >> 24 ) & 0xFF ] << 24 ); ( static_cast<uint32_t>(FSb[ ( Y0 >> 24 ) & 0xFF ]) << 24 );
X2 = *RK++ ^ \ X2 = *RK++ ^ \
( (uint32_t) FSb[ ( Y2 ) & 0xFF ] ) ^ ( static_cast<uint32_t>(FSb[ ( Y2 ) & 0xFF ]) ) ^
( (uint32_t) FSb[ ( Y3 >> 8 ) & 0xFF ] << 8 ) ^ ( static_cast<uint32_t>(FSb[ ( Y3 >> 8 ) & 0xFF ]) << 8 ) ^
( (uint32_t) FSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^ ( static_cast<uint32_t>(FSb[ ( Y0 >> 16 ) & 0xFF ]) << 16 ) ^
( (uint32_t) FSb[ ( Y1 >> 24 ) & 0xFF ] << 24 ); ( static_cast<uint32_t>(FSb[ ( Y1 >> 24 ) & 0xFF ]) << 24 );
X3 = *RK++ ^ \ X3 = *RK++ ^ \
( (uint32_t) FSb[ ( Y3 ) & 0xFF ] ) ^ ( static_cast<uint32_t>(FSb[ ( Y3 ) & 0xFF ]) ) ^
( (uint32_t) FSb[ ( Y0 >> 8 ) & 0xFF ] << 8 ) ^ ( static_cast<uint32_t>(FSb[ ( Y0 >> 8 ) & 0xFF ]) << 8 ) ^
( (uint32_t) FSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^ ( static_cast<uint32_t>(FSb[ ( Y1 >> 16 ) & 0xFF ]) << 16 ) ^
( (uint32_t) FSb[ ( Y2 >> 24 ) & 0xFF ] << 24 ); ( static_cast<uint32_t>(FSb[ ( Y2 >> 24 ) & 0xFF ]) << 24 );
} }
PUT_UINT32_LE( X0, output, 0 ); PUT_UINT32_LE( X0, output, 0 );
@ -766,7 +766,7 @@ int aes_crypt_cbc( aes_context *ctx,
aes_crypt_ecb( ctx, mode, input, output ); aes_crypt_ecb( ctx, mode, input, output );
for( i = 0; i < 16; i++ ) for( i = 0; i < 16; i++ )
output[i] = (unsigned char)( output[i] ^ iv[i] ); output[i] ^= iv[i];
memcpy( iv, temp, 16 ); memcpy( iv, temp, 16 );
@ -780,7 +780,7 @@ int aes_crypt_cbc( aes_context *ctx,
while( length > 0 ) while( length > 0 )
{ {
for( i = 0; i < 16; i++ ) for( i = 0; i < 16; i++ )
output[i] = (unsigned char)( input[i] ^ iv[i] ); output[i] = input[i] ^ iv[i];
aes_crypt_ecb( ctx, mode, output, output ); aes_crypt_ecb( ctx, mode, output, output );
memcpy( iv, output, 16 ); memcpy( iv, output, 16 );
@ -816,8 +816,8 @@ int aes_crypt_cfb128( aes_context *ctx,
aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv ); aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );
c = *input++; c = *input++;
*output++ = (unsigned char)( c ^ iv[n] ); *output++ = static_cast<unsigned char>( c ^ iv[n] );
iv[n] = (unsigned char) c; iv[n] = static_cast<unsigned char>(c);
n = (n + 1) & 0x0F; n = (n + 1) & 0x0F;
} }
@ -829,7 +829,7 @@ int aes_crypt_cfb128( aes_context *ctx,
if( n == 0 ) if( n == 0 )
aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv ); aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );
iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ ); iv[n] = *output++ = static_cast<unsigned char>( iv[n] ^ *input++ );
n = (n + 1) & 0x0F; n = (n + 1) & 0x0F;
} }
@ -864,7 +864,7 @@ int aes_crypt_ctr( aes_context *ctx,
break; break;
} }
c = *input++; c = *input++;
*output++ = (unsigned char)( c ^ stream_block[n] ); *output++ = static_cast<unsigned char>( c ^ stream_block[n] );
n = (n + 1) & 0x0F; n = (n + 1) & 0x0F;
} }
@ -890,7 +890,7 @@ void leftshift_onebit(unsigned char *input, unsigned char *output)
int i; int i;
unsigned char overflow = 0; unsigned char overflow = 0;
for (i = 15; i >= 0; i--) for (i = 15; i >= 0; i--)
{ {
output[i] = input[i] << 1; output[i] = input[i] << 1;
output[i] |= overflow; output[i] |= overflow;
@ -901,7 +901,7 @@ void leftshift_onebit(unsigned char *input, unsigned char *output)
void xor_128(unsigned char *a, unsigned char *b, unsigned char *out) void xor_128(unsigned char *a, unsigned char *b, unsigned char *out)
{ {
int i; int i;
for (i = 0; i < 16; i++) for (i = 0; i < 16; i++)
out[i] = a[i] ^ b[i]; out[i] = a[i] ^ b[i];
} }
@ -910,7 +910,7 @@ void generate_subkey(aes_context *ctx, unsigned char *K1, unsigned char *K2)
unsigned char L[16]; unsigned char L[16];
unsigned char Z[16]; unsigned char Z[16];
unsigned char tmp[16]; unsigned char tmp[16];
int i; int i;
for (i = 0; i < 16; i++) Z[i] = 0; for (i = 0; i < 16; i++) Z[i] = 0;
@ -924,7 +924,7 @@ void generate_subkey(aes_context *ctx, unsigned char *K1, unsigned char *K2)
xor_128(tmp,const_Rb,K1); xor_128(tmp,const_Rb,K1);
} }
if ((K1[0] & 0x80) == 0) if ((K1[0] & 0x80) == 0)
{ {
leftshift_onebit(K1,K2); leftshift_onebit(K1,K2);
} else { } else {
@ -936,9 +936,9 @@ void generate_subkey(aes_context *ctx, unsigned char *K1, unsigned char *K2)
void padding (unsigned char *lastb, unsigned char *pad, int length) void padding (unsigned char *lastb, unsigned char *pad, int length)
{ {
int i; int i;
for (i = 0; i < 16; i++) for (i = 0; i < 16; i++)
{ {
if (i < length) if (i < length)
pad[i] = lastb[i]; pad[i] = lastb[i];
else if (i == length) else if (i == length)
pad[i] = 0x80; pad[i] = 0x80;
@ -955,7 +955,7 @@ void aes_cmac(aes_context *ctx, int length, unsigned char *input, unsigned char
generate_subkey(ctx, K1, K2); generate_subkey(ctx, K1, K2);
n = (length + 15) / 16; n = (length + 15) / 16;
if (n == 0) if (n == 0)
{ {
n = 1; n = 1;
flag = 0; flag = 0;
@ -966,7 +966,7 @@ void aes_cmac(aes_context *ctx, int length, unsigned char *input, unsigned char
flag = 0; flag = 0;
} }
if (flag) if (flag)
{ {
xor_128(&input[16 * (n - 1)], K1, M_last); xor_128(&input[16 * (n - 1)], K1, M_last);
} else { } else {
@ -975,10 +975,10 @@ void aes_cmac(aes_context *ctx, int length, unsigned char *input, unsigned char
} }
for (i = 0; i < 16; i++) X[i] = 0; for (i = 0; i < 16; i++) X[i] = 0;
for (i = 0; i < n - 1; i++) for (i = 0; i < n - 1; i++)
{ {
xor_128(X, &input[16*i], Y); xor_128(X, &input[16*i], Y);
aes_crypt_ecb(ctx, AES_ENCRYPT, Y, X); aes_crypt_ecb(ctx, AES_ENCRYPT, Y, X);
} }
xor_128(X,M_last,Y); xor_128(X,M_last,Y);

52
rpcs3/Crypto/ec.cpp
View File

@ -416,49 +416,6 @@ static void point_mul(struct point *d, u8 *a, struct point *b) // a is bignum
} }
} }
static void generate_ecdsa(u8 *R, u8 *S, u8 *k, u8 *hash)
{
u8 e[21];
u8 kk[21];
u8 m[21];
u8 minv[21];
struct point mG;
e[0] = 0;
memcpy(e + 1, hash, 20);
bn_reduce(e, ec_N, 21);
try_again:
prng(m, 21);
m[0] = 0;
if (bn_compare(m, ec_N, 21) >= 0)
goto try_again;
// R = (mG).x
point_mul(&mG, m, &ec_G);
point_from_mon(&mG);
R[0] = 0;
elt_copy(R+1, mG.x);
// S = m**-1*(e + Rk) (mod N)
bn_copy(kk, k, 21);
bn_reduce(kk, ec_N, 21);
bn_to_mon(m, ec_N, 21);
bn_to_mon(e, ec_N, 21);
bn_to_mon(R, ec_N, 21);
bn_to_mon(kk, ec_N, 21);
bn_mon_mul(S, R, kk, ec_N, 21);
bn_add(kk, S, e, ec_N, 21);
bn_mon_inv(minv, m, ec_N, 21);
bn_mon_mul(S, minv, kk, ec_N, 21);
bn_from_mon(R, ec_N, 21);
bn_from_mon(S, ec_N, 21);
}
static int check_ecdsa(struct point *Q, u8 *R, u8 *S, u8 *hash) static int check_ecdsa(struct point *Q, u8 *R, u8 *S, u8 *hash)
{ {
u8 Sinv[21]; u8 Sinv[21];
@ -515,14 +472,14 @@ int ecdsa_set_curve(u8* p, u8* a, u8* b, u8* N, u8* Gx, u8* Gy)
memcpy(ec_N, N, 21); memcpy(ec_N, N, 21);
memcpy(ec_G.x, Gx, 20); memcpy(ec_G.x, Gx, 20);
memcpy(ec_G.y, Gy, 20); memcpy(ec_G.y, Gy, 20);
bn_to_mon(ec_a, ec_p, 20); bn_to_mon(ec_a, ec_p, 20);
bn_to_mon(ec_b, ec_p, 20); bn_to_mon(ec_b, ec_p, 20);
point_to_mon(&ec_G); point_to_mon(&ec_G);
return 0; return 0;
} }
void ecdsa_set_pub(u8 *Q) void ecdsa_set_pub(u8 *Q)
{ {
@ -540,8 +497,3 @@ int ecdsa_verify(u8 *hash, u8 *R, u8 *S)
{ {
return check_ecdsa(&ec_Q, R, S, hash); return check_ecdsa(&ec_Q, R, S, hash);
} }
void ecdsa_sign(u8 *hash, u8 *R, u8 *S)
{
generate_ecdsa(R, S, ec_k, hash);
}

1
rpcs3/Crypto/ec.h
View File

@ -11,4 +11,3 @@ int ecdsa_set_curve(unsigned char *p, unsigned char *a, unsigned char *b, unsign
void ecdsa_set_pub(unsigned char *Q); void ecdsa_set_pub(unsigned char *Q);
void ecdsa_set_priv(unsigned char *k); void ecdsa_set_priv(unsigned char *k);
int ecdsa_verify(unsigned char *hash, unsigned char *R, unsigned char *S); int ecdsa_verify(unsigned char *hash, unsigned char *R, unsigned char *S);
void ecdsa_sign(unsigned char *hash, unsigned char *R, unsigned char *S);

8
rpcs3/Crypto/lz.cpp
View File

@ -146,7 +146,7 @@ int decompress(unsigned char *out, unsigned char *in, unsigned int size)
result = -1; result = -1;
if (code <= size) if (code <= size)
{ {
memcpy(out, (const void *)(in + 5), code); memcpy(out, in + 5, code);
result = static_cast<int>(start - out); result = static_cast<int>(start - out);
} }
} }
@ -165,7 +165,7 @@ int decompress(unsigned char *out, unsigned char *in, unsigned int size)
if (start == end) return static_cast<int>(start - out); if (start == end) return static_cast<int>(start - out);
// Locate first section. // Locate first section.
int sect = (((((((int)(start - out)) & 7) << 8) + prev) >> head) & 7) * 0xFF - 1; int sect = ((((((static_cast<int>(start - out)) & 7) << 8) + prev) >> head) & 7) * 0xFF - 1;
tmp_sect1 = tmp + sect; tmp_sect1 = tmp + sect;
int index = 1; int index = 1;
@ -198,7 +198,7 @@ int decompress(unsigned char *out, unsigned char *in, unsigned int size)
if ((index >= 0) || (bit_flag != 0)) if ((index >= 0) || (bit_flag != 0))
{ {
// Locate next section. // Locate next section.
int sect = (index << 5) | (((((int)(start - out)) << index) & 3) << 3) | (offset & 7); int sect = (index << 5) | ((((static_cast<int>(start - out)) << index) & 3) << 3) | (offset & 7);
tmp_sect1 = tmp + 0xBA8 + sect; tmp_sect1 = tmp + 0xBA8 + sect;
// Decode the data length (8 bit fields). // Decode the data length (8 bit fields).
@ -265,7 +265,7 @@ int decompress(unsigned char *out, unsigned char *in, unsigned int size)
} }
// Update offset. // Update offset.
offset = ((((int)(buf_end - out)) + 1) & 1) + 6; offset = (((static_cast<int>(buf_end - out)) + 1) & 1) + 6;
// Copy data. // Copy data.
do do

26
rpcs3/Crypto/md5.cpp
View File

@ -35,7 +35,7 @@
/* Implementation that should never be optimized out by the compiler */ /* Implementation that should never be optimized out by the compiler */
static void mbedtls_zeroize(void* v, size_t n) static void mbedtls_zeroize(void* v, size_t n)
{ {
volatile unsigned char* p = (volatile unsigned char*)v; auto p = const_cast<volatile char*>(static_cast<char*>(v));
while (n--) while (n--)
*p++ = 0; *p++ = 0;
} }
@ -46,20 +46,20 @@ static void mbedtls_zeroize(void* v, size_t n)
#ifndef GET_UINT32_LE #ifndef GET_UINT32_LE
#define GET_UINT32_LE(n,b,i) \ #define GET_UINT32_LE(n,b,i) \
{ \ { \
(n) = ( (uint32_t) (b)[(i) ] ) \ (n) = ( static_cast<uint32_t>((b)[(i) ]) ) \
| ( (uint32_t) (b)[(i) + 1] << 8 ) \ | ( static_cast<uint32_t>((b)[(i) + 1]) << 8 ) \
| ( (uint32_t) (b)[(i) + 2] << 16 ) \ | ( static_cast<uint32_t>((b)[(i) + 2]) << 16 ) \
| ( (uint32_t) (b)[(i) + 3] << 24 ); \ | ( static_cast<uint32_t>((b)[(i) + 3]) << 24 );\
} }
#endif #endif
#ifndef PUT_UINT32_LE #ifndef PUT_UINT32_LE
#define PUT_UINT32_LE(n,b,i) \ #define PUT_UINT32_LE(n,b,i) \
{ \ { \
(b)[(i) ] = (unsigned char) ( ( (n) ) & 0xFF ); \ (b)[(i) ] = static_cast<unsigned char>(( (n) ) & 0xFF ); \
(b)[(i) + 1] = (unsigned char) ( ( (n) >> 8 ) & 0xFF ); \ (b)[(i) + 1] = static_cast<unsigned char>(( (n) >> 8 ) & 0xFF ); \
(b)[(i) + 2] = (unsigned char) ( ( (n) >> 16 ) & 0xFF ); \ (b)[(i) + 2] = static_cast<unsigned char>(( (n) >> 16 ) & 0xFF ); \
(b)[(i) + 3] = (unsigned char) ( ( (n) >> 24 ) & 0xFF ); \ (b)[(i) + 3] = static_cast<unsigned char>(( (n) >> 24 ) & 0xFF ); \
} }
#endif #endif
@ -258,15 +258,15 @@ int mbedtls_md5_update_ret( mbedtls_md5_context *ctx,
left = ctx->total[0] & 0x3F; left = ctx->total[0] & 0x3F;
fill = 64 - left; fill = 64 - left;
ctx->total[0] += (uint32_t) ilen; ctx->total[0] += static_cast<uint32_t>(ilen);
ctx->total[0] &= 0xFFFFFFFF; ctx->total[0] &= 0xFFFFFFFF;
if( ctx->total[0] < (uint32_t) ilen ) if( ctx->total[0] < static_cast<uint32_t>(ilen) )
ctx->total[1]++; ctx->total[1]++;
if( left && ilen >= fill ) if( left && ilen >= fill )
{ {
memcpy( (void *) (ctx->buffer + left), input, fill ); memcpy( ctx->buffer + left, input, fill );
if( ( ret = mbedtls_internal_md5_process( ctx, ctx->buffer ) ) != 0 ) if( ( ret = mbedtls_internal_md5_process( ctx, ctx->buffer ) ) != 0 )
return( ret ); return( ret );
@ -286,7 +286,7 @@ int mbedtls_md5_update_ret( mbedtls_md5_context *ctx,
if( ilen > 0 ) if( ilen > 0 )
{ {
memcpy( (void *) (ctx->buffer + left), input, ilen ); memcpy( ctx->buffer + left, input, ilen );
} }
return( 0 ); return( 0 );

30
rpcs3/Crypto/sha1.cpp
View File

@ -27,7 +27,7 @@
* *
* http://www.itl.nist.gov/fipspubs/fip180-1.htm * http://www.itl.nist.gov/fipspubs/fip180-1.htm
*/ */
#include "sha1.h" #include "sha1.h"
/* /*
@ -36,20 +36,20 @@
#ifndef GET_UINT32_BE #ifndef GET_UINT32_BE
#define GET_UINT32_BE(n,b,i) \ #define GET_UINT32_BE(n,b,i) \
{ \ { \
(n) = ( (uint32_t) (b)[(i) ] << 24 ) \ (n) = ( static_cast<uint32_t>((b)[(i) ]) << 24 ) \
| ( (uint32_t) (b)[(i) + 1] << 16 ) \ | ( static_cast<uint32_t>((b)[(i) + 1]) << 16 ) \
| ( (uint32_t) (b)[(i) + 2] << 8 ) \ | ( static_cast<uint32_t>((b)[(i) + 2]) << 8 ) \
| ( (uint32_t) (b)[(i) + 3] ); \ | ( static_cast<uint32_t>((b)[(i) + 3]) );\
} }
#endif #endif
#ifndef PUT_UINT32_BE #ifndef PUT_UINT32_BE
#define PUT_UINT32_BE(n,b,i) \ #define PUT_UINT32_BE(n,b,i) \
{ \ { \
(b)[(i) ] = (unsigned char) ( (n) >> 24 ); \ (b)[(i) ] = static_cast<unsigned char> ( (n) >> 24 ); \
(b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \ (b)[(i) + 1] = static_cast<unsigned char> ( (n) >> 16 ); \
(b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \ (b)[(i) + 2] = static_cast<unsigned char> ( (n) >> 8 ); \
(b)[(i) + 3] = (unsigned char) ( (n) ); \ (b)[(i) + 3] = static_cast<unsigned char> ( (n) ); \
} }
#endif #endif
@ -239,15 +239,15 @@ void sha1_update( sha1_context *ctx, const unsigned char *input, size_t ilen )
left = ctx->total[0] & 0x3F; left = ctx->total[0] & 0x3F;
fill = 64 - left; fill = 64 - left;
ctx->total[0] += (uint32_t) ilen; ctx->total[0] += static_cast<uint32_t>(ilen);
ctx->total[0] &= 0xFFFFFFFF; ctx->total[0] &= 0xFFFFFFFF;
if( ctx->total[0] < (uint32_t) ilen ) if( ctx->total[0] < static_cast<uint32_t>(ilen) )
ctx->total[1]++; ctx->total[1]++;
if( left && ilen >= fill ) if( left && ilen >= fill )
{ {
memcpy( (void *) (ctx->buffer + left), input, fill ); memcpy( ctx->buffer + left, input, fill );
sha1_process( ctx, ctx->buffer ); sha1_process( ctx, ctx->buffer );
input += fill; input += fill;
ilen -= fill; ilen -= fill;
@ -262,7 +262,7 @@ void sha1_update( sha1_context *ctx, const unsigned char *input, size_t ilen )
} }
if( ilen > 0 ) if( ilen > 0 )
memcpy( (void *) (ctx->buffer + left), input, ilen ); memcpy( ctx->buffer + left, input, ilen );
} }
static const unsigned char sha1_padding[64] = static const unsigned char sha1_padding[64] =
@ -336,8 +336,8 @@ void sha1_hmac_starts( sha1_context *ctx, const unsigned char *key, size_t keyle
for( i = 0; i < keylen; i++ ) for( i = 0; i < keylen; i++ )
{ {
ctx->ipad[i] = (unsigned char)( ctx->ipad[i] ^ key[i] ); ctx->ipad[i] ^= key[i];
ctx->opad[i] = (unsigned char)( ctx->opad[i] ^ key[i] ); ctx->opad[i] ^= key[i];
} }
sha1_starts( ctx ); sha1_starts( ctx );

30
rpcs3/Crypto/sha256.cpp
View File

@ -42,8 +42,8 @@
#endif /* MBEDTLS_PLATFORM_C */ #endif /* MBEDTLS_PLATFORM_C */
#endif /* MBEDTLS_SELF_TEST */ #endif /* MBEDTLS_SELF_TEST */
#define SHA256_VALIDATE_RET(cond) #define SHA256_VALIDATE_RET(cond)
#define SHA256_VALIDATE(cond) #define SHA256_VALIDATE(cond)
#if !defined(MBEDTLS_SHA256_ALT) #if !defined(MBEDTLS_SHA256_ALT)
@ -53,27 +53,27 @@
#ifndef GET_UINT32_BE #ifndef GET_UINT32_BE
#define GET_UINT32_BE(n,b,i) \ #define GET_UINT32_BE(n,b,i) \
do { \ do { \
(n) = ( (uint32_t) (b)[(i) ] << 24 ) \ (n) = ( static_cast<uint32_t>((b)[(i) ]) << 24 ) \
| ( (uint32_t) (b)[(i) + 1] << 16 ) \ | ( static_cast<uint32_t>((b)[(i) + 1]) << 16 ) \
| ( (uint32_t) (b)[(i) + 2] << 8 ) \ | ( static_cast<uint32_t>((b)[(i) + 2]) << 8 ) \
| ( (uint32_t) (b)[(i) + 3] ); \ | ( static_cast<uint32_t>((b)[(i) + 3]) );\
} while( 0 ) } while( 0 )
#endif #endif
#ifndef PUT_UINT32_BE #ifndef PUT_UINT32_BE
#define PUT_UINT32_BE(n,b,i) \ #define PUT_UINT32_BE(n,b,i) \
do { \ do { \
(b)[(i) ] = (unsigned char) ( (n) >> 24 ); \ (b)[(i) ] = static_cast<unsigned char> ( (n) >> 24 ); \
(b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \ (b)[(i) + 1] = static_cast<unsigned char> ( (n) >> 16 ); \
(b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \ (b)[(i) + 2] = static_cast<unsigned char> ( (n) >> 8 ); \
(b)[(i) + 3] = (unsigned char) ( (n) ); \ (b)[(i) + 3] = static_cast<unsigned char> ( (n) ); \
} while( 0 ) } while( 0 )
#endif #endif
/* Implementation that should never be optimized out by the compiler */ /* Implementation that should never be optimized out by the compiler */
static void mbedtls_zeroize_sha256(void* v, size_t n) static void mbedtls_zeroize_sha256(void* v, size_t n)
{ {
volatile unsigned char* p = (volatile unsigned char*)v; auto p = const_cast<volatile char*>(static_cast<char*>(v));
while (n--) while (n--)
*p++ = 0; *p++ = 0;
} }
@ -288,15 +288,15 @@ int mbedtls_sha256_update_ret( mbedtls_sha256_context *ctx,
left = ctx->total[0] & 0x3F; left = ctx->total[0] & 0x3F;
fill = 64 - left; fill = 64 - left;
ctx->total[0] += (uint32_t) ilen; ctx->total[0] += static_cast<uint32_t>(ilen);
ctx->total[0] &= 0xFFFFFFFF; ctx->total[0] &= 0xFFFFFFFF;
if( ctx->total[0] < (uint32_t) ilen ) if( ctx->total[0] < static_cast<uint32_t>(ilen) )
ctx->total[1]++; ctx->total[1]++;
if( left && ilen >= fill ) if( left && ilen >= fill )
{ {
memcpy( (void *) (ctx->buffer + left), input, fill ); memcpy( ctx->buffer + left, input, fill );
if( ( ret = mbedtls_internal_sha256_process( ctx, ctx->buffer ) ) != 0 ) if( ( ret = mbedtls_internal_sha256_process( ctx, ctx->buffer ) ) != 0 )
return( ret ); return( ret );
@ -316,7 +316,7 @@ int mbedtls_sha256_update_ret( mbedtls_sha256_context *ctx,
} }
if( ilen > 0 ) if( ilen > 0 )
memcpy( (void *) (ctx->buffer + left), input, ilen ); memcpy( ctx->buffer + left, input, ilen );
return( 0 ); return( 0 );
} }

20
rpcs3/Crypto/utils.cpp
View File

@ -9,7 +9,7 @@
#include <memory> #include <memory>
// Auxiliary functions (endian swap, xor and prng). // Auxiliary functions (endian swap, xor).
void xor_key(unsigned char *dest, const u8* src1, const u8* src2) void xor_key(unsigned char *dest, const u8* src1, const u8* src2)
{ {
@ -19,18 +19,10 @@ void xor_key(unsigned char *dest, const u8* src1, const u8* src2)
} }
} }
void prng(unsigned char *dest, int size)
{
srand((u32)time(0));
for(int i = 0; i < size; i++)
dest[i] = (unsigned char)(rand() & 0xFF);
}
// Hex string conversion auxiliary functions. // Hex string conversion auxiliary functions.
u64 hex_to_u64(const char* hex_str) u64 hex_to_u64(const char* hex_str)
{ {
u32 length = (u32) strlen(hex_str); auto length = std::strlen(hex_str);
u64 tmp = 0; u64 tmp = 0;
u64 result = 0; u64 result = 0;
char c; char c;
@ -54,8 +46,8 @@ u64 hex_to_u64(const char* hex_str)
void hex_to_bytes(unsigned char* data, const char* hex_str, unsigned int str_length) void hex_to_bytes(unsigned char* data, const char* hex_str, unsigned int str_length)
{ {
u32 strn_length = (str_length > 0) ? str_length : (u32)std::strlen(hex_str); auto strn_length = (str_length > 0) ? str_length : std::strlen(hex_str);
u32 data_length = strn_length / 2; auto data_length = strn_length / 2;
char tmp_buf[3] = {0, 0, 0}; char tmp_buf[3] = {0, 0, 0};
// Don't convert if the string length is odd. // Don't convert if the string length is odd.
@ -66,7 +58,7 @@ void hex_to_bytes(unsigned char* data, const char* hex_str, unsigned int str_len
tmp_buf[0] = *hex_str++; tmp_buf[0] = *hex_str++;
tmp_buf[1] = *hex_str++; tmp_buf[1] = *hex_str++;
*data++ = (u8)(hex_to_u64(tmp_buf) & 0xFF); *data++ = static_cast<u8>(hex_to_u64(tmp_buf) & 0xFF);
} }
} }
} }
@ -155,6 +147,6 @@ char* extract_file_name(const char* file_path, char real_file_name[MAX_PATH])
if (!p) p = strrchr(file_path, '\\'); if (!p) p = strrchr(file_path, '\\');
if (p) file_path_len = file_path + file_path_len - p - 1; if (p) file_path_len = file_path + file_path_len - p - 1;
strncpy(real_file_name, p ? (p + 1) : file_path, file_path_len + 1); strncpy(real_file_name, p ? (p + 1) : file_path, file_path_len + 1);
return real_file_name; return real_file_name;
} }

7
rpcs3/Crypto/utils.h
View File

@ -14,7 +14,7 @@
#include "lz.h" #include "lz.h"
#include "ec.h" #include "ec.h"
// Auxiliary functions (endian swap, xor, prng and file name). // Auxiliary functions (endian swap, xor, and file name).
inline u16 swap16(u16 i) inline u16 swap16(u16 i)
{ {
#if defined(__GNUG__) #if defined(__GNUG__)
@ -45,11 +45,10 @@ inline u64 swap64(u64 i)
void xor_key(unsigned char *dest, const u8* src1, const u8* src2); void xor_key(unsigned char *dest, const u8* src1, const u8* src2);
inline void xor_key_sse(u8* dest, const u8* src1, const u8* src2) inline void xor_key_sse(u8* dest, const u8* src1, const u8* src2)
{ {
_mm_storeu_si128(&(((__m128i*)dest)[0]), _mm_storeu_si128(reinterpret_cast<__m128i*>(dest),
_mm_xor_si128(_mm_loadu_si128((__m128i*)src1), _mm_loadu_si128((__m128i*)src2))); _mm_xor_si128(_mm_loadu_si128(reinterpret_cast<const __m128i*>(src1)), _mm_loadu_si128(reinterpret_cast<const __m128i*>(src2))));
} }
void prng(unsigned char *dest, int size);
char* extract_file_name(const char* file_path, char real_file_name[MAX_PATH]); char* extract_file_name(const char* file_path, char real_file_name[MAX_PATH]);
// Hex string conversion auxiliary functions. // Hex string conversion auxiliary functions.

2
rpcs3/Emu/Cell/PPUModule.h
View File

@ -285,7 +285,7 @@ inline RT ppu_execute(ppu_thread& ppu, Args... args)
return func(ppu, args...); return func(ppu, args...);
} }
#define REG_FNID(module, nid, func) ppu_module_manager::register_static_function<&func>(#module, ppu_select_name(#func, nid), BIND_FUNC(func, ppu.cia = (u32)ppu.lr & ~3), ppu_generate_id(nid)) #define REG_FNID(module, nid, func) ppu_module_manager::register_static_function<&func>(#module, ppu_select_name(#func, nid), BIND_FUNC(func, ppu.cia = static_cast<u32>(ppu.lr) & ~3), ppu_generate_id(nid))
#define REG_FUNC(module, func) REG_FNID(module, #func, func) #define REG_FUNC(module, func) REG_FNID(module, #func, func)

58
rpcs3/Emu/RSX/VK/VKOverlays.h
View File

@ -171,7 +171,7 @@ namespace vk
check_heap(); check_heap();
const auto size = count * sizeof(f32); const auto size = count * sizeof(f32);
m_vao_offset = (u32)m_vao.alloc<16>(size); m_vao_offset = static_cast<u32>(m_vao.alloc<16>(size));
auto dst = m_vao.map(m_vao_offset, size); auto dst = m_vao.map(m_vao_offset, size);
std::memcpy(dst, data, size); std::memcpy(dst, data, size);
m_vao.unmap(); m_vao.unmap();
@ -352,15 +352,15 @@ namespace vk
virtual void set_up_viewport(vk::command_buffer &cmd, u32 x, u32 y, u32 w, u32 h) virtual void set_up_viewport(vk::command_buffer &cmd, u32 x, u32 y, u32 w, u32 h)
{ {
VkViewport vp{}; VkViewport vp{};
vp.x = (f32)x; vp.x = static_cast<f32>(x);
vp.y = (f32)y; vp.y = static_cast<f32>(y);
vp.width = (f32)w; vp.width = static_cast<f32>(w);
vp.height = (f32)h; vp.height = static_cast<f32>(h);
vp.minDepth = 0.f; vp.minDepth = 0.f;
vp.maxDepth = 1.f; vp.maxDepth = 1.f;
vkCmdSetViewport(cmd, 0, 1, &vp); vkCmdSetViewport(cmd, 0, 1, &vp);
VkRect2D vs = { { (s32)x, (s32)y }, { w, h } }; VkRect2D vs = { { static_cast<s32>(x), static_cast<s32>(y) }, { w, h } };
vkCmdSetScissor(cmd, 0, 1, &vs); vkCmdSetScissor(cmd, 0, 1, &vs);
} }
@ -373,8 +373,8 @@ namespace vk
rp_begin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; rp_begin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
rp_begin.renderPass = render_pass; rp_begin.renderPass = render_pass;
rp_begin.framebuffer = fbo->value; rp_begin.framebuffer = fbo->value;
rp_begin.renderArea.offset.x = (s32)viewport.x1; rp_begin.renderArea.offset.x = static_cast<s32>(viewport.x1);
rp_begin.renderArea.offset.y = (s32)viewport.y1; rp_begin.renderArea.offset.y = static_cast<s32>(viewport.y1);
rp_begin.renderArea.extent.width = viewport.width(); rp_begin.renderArea.extent.width = viewport.width();
rp_begin.renderArea.extent.height = viewport.height(); rp_begin.renderArea.extent.height = viewport.height();
@ -440,8 +440,8 @@ namespace vk
void update_uniforms(vk::command_buffer& /*cmd*/, vk::glsl::program* /*program*/) override void update_uniforms(vk::command_buffer& /*cmd*/, vk::glsl::program* /*program*/) override
{ {
m_ubo_offset = (u32)m_ubo.alloc<256>(128); m_ubo_offset = static_cast<u32>(m_ubo.alloc<256>(128));
auto dst = (f32*)m_ubo.map(m_ubo_offset, 128); auto dst = static_cast<f32*>(m_ubo.map(m_ubo_offset, 128));
dst[0] = src_scale_x; dst[0] = src_scale_x;
dst[1] = src_scale_y; dst[1] = src_scale_y;
dst[2] = 0.f; dst[2] = 0.f;
@ -454,8 +454,8 @@ namespace vk
auto real_src = src->image(); auto real_src = src->image();
verify(HERE), real_src; verify(HERE), real_src;
src_scale_x = f32(src_area.x2) / real_src->width(); src_scale_x = static_cast<f32>(src_area.x2) / real_src->width();
src_scale_y = f32(src_area.y2) / real_src->height(); src_scale_y = static_cast<f32>(src_area.y2) / real_src->height();
overlay_pass::run(cmd, dst_area, dst, src, render_pass); overlay_pass::run(cmd, dst_area, dst, src, render_pass);
} }
@ -637,7 +637,7 @@ namespace vk
region.bufferRowLength = w; region.bufferRowLength = w;
region.bufferImageHeight = h; region.bufferImageHeight = h;
region.imageOffset = {}; region.imageOffset = {};
region.imageExtent = { (u32)w, (u32)h, 1u}; region.imageExtent = { static_cast<u32>(w), static_cast<u32>(h), 1u};
change_image_layout(cmd, tex.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, range); change_image_layout(cmd, tex.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, range);
vkCmdCopyBufferToImage(cmd, upload_heap.heap->value, tex->value, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region); vkCmdCopyBufferToImage(cmd, upload_heap.heap->value, tex->value, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
@ -711,7 +711,7 @@ namespace vk
vk::image_view* find_font(rsx::overlays::font *font, vk::command_buffer &cmd, vk::data_heap &upload_heap) vk::image_view* find_font(rsx::overlays::font *font, vk::command_buffer &cmd, vk::data_heap &upload_heap)
{ {
u64 key = (u64)font; u64 key = reinterpret_cast<u64>(font);
auto found = view_cache.find(key); auto found = view_cache.find(key);
if (found != view_cache.end()) if (found != view_cache.end())
return found->second.get(); return found->second.get();
@ -723,7 +723,7 @@ namespace vk
vk::image_view* find_temp_image(rsx::overlays::image_info *desc, vk::command_buffer &cmd, vk::data_heap &upload_heap, u32 owner_uid) vk::image_view* find_temp_image(rsx::overlays::image_info *desc, vk::command_buffer &cmd, vk::data_heap &upload_heap, u32 owner_uid)
{ {
u64 key = (u64)desc; u64 key = reinterpret_cast<u64>(desc);
auto found = temp_view_cache.find(key); auto found = temp_view_cache.find(key);
if (found != temp_view_cache.end()) if (found != temp_view_cache.end())
return found->second.get(); return found->second.get();
@ -734,8 +734,8 @@ namespace vk
void update_uniforms(vk::command_buffer& /*cmd*/, vk::glsl::program* /*program*/) override void update_uniforms(vk::command_buffer& /*cmd*/, vk::glsl::program* /*program*/) override
{ {
m_ubo_offset = (u32)m_ubo.alloc<256>(128); m_ubo_offset = static_cast<u32>(m_ubo.alloc<256>(128));
auto dst = (f32*)m_ubo.map(m_ubo_offset, 128); auto dst = static_cast<f32*>(m_ubo.map(m_ubo_offset, 128));
// regs[0] = scaling parameters // regs[0] = scaling parameters
dst[0] = m_scale_offset.r; dst[0] = m_scale_offset.r;
@ -752,7 +752,7 @@ namespace vk
// regs[2] = fs config parameters // regs[2] = fs config parameters
dst[8] = m_time; dst[8] = m_time;
dst[9] = m_pulse_glow? 1.f : 0.f; dst[9] = m_pulse_glow? 1.f : 0.f;
dst[10] = m_skip_texture_read? 0.f : (f32)m_texture_type; dst[10] = m_skip_texture_read? 0.f : static_cast<f32>(m_texture_type);
dst[11] = m_clip_enabled ? 1.f : 0.f; dst[11] = m_clip_enabled ? 1.f : 0.f;
// regs[3] = clip rect // regs[3] = clip rect
@ -815,22 +815,22 @@ namespace vk
void run(vk::command_buffer &cmd, const areau& viewport, vk::framebuffer* target, VkRenderPass render_pass, void run(vk::command_buffer &cmd, const areau& viewport, vk::framebuffer* target, VkRenderPass render_pass,
vk::data_heap &upload_heap, rsx::overlays::overlay &ui) vk::data_heap &upload_heap, rsx::overlays::overlay &ui)
{ {
m_scale_offset = color4f((f32)ui.virtual_width, (f32)ui.virtual_height, 1.f, 1.f); m_scale_offset = color4f(ui.virtual_width, ui.virtual_height, 1.f, 1.f);
m_time = (f32)(get_system_time() / 1000) * 0.005f; m_time = static_cast<f32>(get_system_time() / 1000) * 0.005f;
m_viewport_size = { f32(viewport.width()), f32(viewport.height()) }; m_viewport_size = { static_cast<f32>(viewport.width()), static_cast<f32>(viewport.height()) };
for (auto &command : ui.get_compiled().draw_commands) for (auto &command : ui.get_compiled().draw_commands)
{ {
num_drawable_elements = (u32)command.verts.size(); num_drawable_elements = static_cast<u32>(command.verts.size());
const u32 value_count = num_drawable_elements * 4; const u32 value_count = num_drawable_elements * 4;
upload_vertex_data((f32*)command.verts.data(), value_count); upload_vertex_data(reinterpret_cast<f32*>(command.verts.data()), value_count);
set_primitive_type(command.config.primitives); set_primitive_type(command.config.primitives);
m_skip_texture_read = false; m_skip_texture_read = false;
m_color = command.config.color; m_color = command.config.color;
m_pulse_glow = command.config.pulse_glow; m_pulse_glow = command.config.pulse_glow;
m_blur_strength = f32(command.config.blur_strength) * 0.01f; m_blur_strength = static_cast<f32>(command.config.blur_strength) * 0.01f;
m_clip_enabled = command.config.clip_region; m_clip_enabled = command.config.clip_region;
m_clip_region = command.config.clip_rect; m_clip_region = command.config.clip_rect;
m_texture_type = 1; m_texture_type = 1;
@ -849,7 +849,7 @@ namespace vk
src = find_font(command.config.font_ref, cmd, upload_heap); src = find_font(command.config.font_ref, cmd, upload_heap);
break; break;
case rsx::overlays::image_resource_id::raw_image: case rsx::overlays::image_resource_id::raw_image:
src = find_temp_image((rsx::overlays::image_info*)command.config.external_data_ref, cmd, upload_heap, ui.uid); src = find_temp_image(static_cast<rsx::overlays::image_info*>(command.config.external_data_ref), cmd, upload_heap, ui.uid);
break; break;
default: default:
src = view_cache[command.config.texture_ref].get(); src = view_cache[command.config.texture_ref].get();
@ -937,10 +937,10 @@ namespace vk
void set_up_viewport(vk::command_buffer &cmd, u32 x, u32 y, u32 w, u32 h) override void set_up_viewport(vk::command_buffer &cmd, u32 x, u32 y, u32 w, u32 h) override
{ {
VkViewport vp{}; VkViewport vp{};
vp.x = (f32)x; vp.x = static_cast<f32>(x);
vp.y = (f32)y; vp.y = static_cast<f32>(y);
vp.width = (f32)w; vp.width = static_cast<f32>(w);
vp.height = (f32)h; vp.height = static_cast<f32>(h);
vp.minDepth = 0.f; vp.minDepth = 0.f;
vp.maxDepth = 1.f; vp.maxDepth = 1.f;
vkCmdSetViewport(cmd, 0, 1, &vp); vkCmdSetViewport(cmd, 0, 1, &vp);

24
rpcs3/Emu/RSX/VK/VKTextOut.h
View File

@ -11,7 +11,7 @@ namespace vk
private: private:
std::unique_ptr<vk::buffer> m_vertex_buffer; std::unique_ptr<vk::buffer> m_vertex_buffer;
std::unique_ptr<vk::buffer> m_uniforms_buffer; std::unique_ptr<vk::buffer> m_uniforms_buffer;
std::unique_ptr<vk::glsl::program> m_program; std::unique_ptr<vk::glsl::program> m_program;
vk::glsl::shader m_vertex_shader; vk::glsl::shader m_vertex_shader;
vk::glsl::shader m_fragment_shader; vk::glsl::shader m_fragment_shader;
@ -42,7 +42,7 @@ namespace vk
m_descriptor_pool.create(dev, descriptor_pools, 1, 120, 2); m_descriptor_pool.create(dev, descriptor_pools, 1, 120, 2);
VkDescriptorSetLayoutBinding bindings[1] = {}; VkDescriptorSetLayoutBinding bindings[1] = {};
//Scale and offset data plus output color //Scale and offset data plus output color
bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
bindings[0].descriptorCount = 1; bindings[0].descriptorCount = 1;
@ -128,7 +128,7 @@ namespace vk
VkVertexInputAttributeDescription vdesc; VkVertexInputAttributeDescription vdesc;
VkVertexInputBindingDescription vbind; VkVertexInputBindingDescription vbind;
vdesc.binding = 0; vdesc.binding = 0;
vdesc.format = VK_FORMAT_R32G32_SFLOAT; vdesc.format = VK_FORMAT_R32G32_SFLOAT;
vdesc.location = 0; vdesc.location = 0;
@ -195,7 +195,7 @@ namespace vk
CHECK_RESULT(vkCreateGraphicsPipelines(dev, nullptr, 1, &info, NULL, &pipeline)); CHECK_RESULT(vkCreateGraphicsPipelines(dev, nullptr, 1, &info, NULL, &pipeline));
const std::vector<vk::glsl::program_input> unused; const std::vector<vk::glsl::program_input> unused;
m_program = std::make_unique<vk::glsl::program>((VkDevice)dev, pipeline, unused, unused); m_program = std::make_unique<vk::glsl::program>(static_cast<VkDevice>(dev), pipeline, unused, unused);
} }
void load_program(vk::command_buffer &cmd, float scale_x, float scale_y, const float *offsets, size_t nb_offsets, std::array<float, 4> color) void load_program(vk::command_buffer &cmd, float scale_x, float scale_y, const float *offsets, size_t nb_offsets, std::array<float, 4> color)
@ -213,7 +213,7 @@ namespace vk
float scale[] = { scale_x, scale_y }; float scale[] = { scale_x, scale_y };
float colors[] = { color[0], color[1], color[2], color[3] }; float colors[] = { color[0], color[1], color[2], color[3] };
float *dst = (float*)m_uniforms_buffer->map(m_uniform_buffer_offset, 8192); float* dst = static_cast<float*>(m_uniforms_buffer->map(m_uniform_buffer_offset, 8192));
//std140 spec demands that arrays be multiples of 16 bytes //std140 spec demands that arrays be multiples of 16 bytes
for (size_t i = 0; i < nb_offsets; ++i) for (size_t i = 0; i < nb_offsets; ++i)
@ -232,7 +232,7 @@ namespace vk
vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, m_program->pipeline); vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, m_program->pipeline);
vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipeline_layout, 0, 1, &m_descriptor_set, 0, nullptr); vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipeline_layout, 0, 1, &m_descriptor_set, 0, nullptr);
VkDeviceSize zero = 0; VkDeviceSize zero = 0;
vkCmdBindVertexBuffers(cmd, 0, 1, &m_vertex_buffer->value, &zero); vkCmdBindVertexBuffers(cmd, 0, 1, &m_vertex_buffer->value, &zero);
} }
@ -264,15 +264,15 @@ namespace vk
m_render_pass = render_pass; m_render_pass = render_pass;
m_uniform_buffer_size = 983040; m_uniform_buffer_size = 983040;
init_descriptor_set(dev); init_descriptor_set(dev);
init_program(dev); init_program(dev);
GlyphManager glyph_source; GlyphManager glyph_source;
auto points = glyph_source.generate_point_map(); auto points = glyph_source.generate_point_map();
const size_t buffer_size = points.size() * sizeof(GlyphManager::glyph_point); const size_t buffer_size = points.size() * sizeof(GlyphManager::glyph_point);
u8 *dst = (u8*)m_vertex_buffer->map(0, buffer_size); u8* dst = static_cast<u8*>(m_vertex_buffer->map(0, buffer_size));
memcpy(dst, points.data(), buffer_size); memcpy(dst, points.data(), buffer_size);
m_vertex_buffer->unmap(); m_vertex_buffer->unmap();
@ -302,7 +302,7 @@ namespace vk
while (*s) while (*s)
{ {
u8 offset = (u8)*s; u8 offset = static_cast<u8>(*s);
bool to_draw = false; //Can be false for space or unsupported characters bool to_draw = false; //Can be false for space or unsupported characters
auto o = m_offsets.find(offset); auto o = m_offsets.find(offset);
@ -334,8 +334,8 @@ namespace vk
} }
VkViewport vp{}; VkViewport vp{};
vp.width = (f32)target_w; vp.width = static_cast<f32>(target_w);
vp.height = (f32)target_h; vp.height = static_cast<f32>(target_h);
vp.minDepth = 0.f; vp.minDepth = 0.f;
vp.maxDepth = 1.f; vp.maxDepth = 1.f;
vkCmdSetViewport(cmd, 0, 1, &vp); vkCmdSetViewport(cmd, 0, 1, &vp);

4
rpcs3/Emu/System.h
View File

@ -590,8 +590,8 @@ struct cfg_root : cfg::node
{ {
node_sys(cfg::node* _this) : cfg::node(_this, "System") {} node_sys(cfg::node* _this) : cfg::node(_this, "System") {}
cfg::_enum<CellSysutilLang> language{this, "Language", (CellSysutilLang)1}; // CELL_SYSUTIL_LANG_ENGLISH_US cfg::_enum<CellSysutilLang> language{this, "Language", CellSysutilLang{1}}; // CELL_SYSUTIL_LANG_ENGLISH_US
cfg::_enum<CellKbMappingType> keyboard_type{this, "Keyboard Type", (CellKbMappingType)0}; // CELL_KB_MAPPING_101 = US cfg::_enum<CellKbMappingType> keyboard_type{this, "Keyboard Type", CellKbMappingType{0}}; // CELL_KB_MAPPING_101 = US
cfg::_enum<enter_button_assign> enter_button_assignment{this, "Enter button assignment", enter_button_assign::cross}; cfg::_enum<enter_button_assign> enter_button_assignment{this, "Enter button assignment", enter_button_assign::cross};
} sys{this}; } sys{this};