archive/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-07-05 06:21:26 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

C-style cast cleanup V

Browse source
This commit is contained in:
Nekotekina 2019-12-03 00:31:34 +03:00
parent 46ca39ec4d
commit 185c067d5b
44 changed files with 439 additions and 435 deletions
Download patch file Download diff file Expand all files Collapse all files

2
rpcs3/Emu/CPU/CPUTranslator.h
View file

@ -2753,7 +2753,7 @@ public:
if (cv || llvm::isa<llvm::ConstantAggregateZero>(c)) if (cv || llvm::isa<llvm::ConstantAggregateZero>(c))
{ {
result.value = llvm::ConstantDataVector::get(m_context, llvm::makeArrayRef((const u8*)mask._bytes, 16)); result.value = llvm::ConstantDataVector::get(m_context, llvm::makeArrayRef(reinterpret_cast<const u8*>(&mask), 16));
result.value = m_ir->CreateZExt(result.value, get_type<u32[16]>()); result.value = m_ir->CreateZExt(result.value, get_type<u32[16]>());
result.value = m_ir->CreateShuffleVector(data0, zeros, result.value); result.value = m_ir->CreateShuffleVector(data0, zeros, result.value);
return result; return result;

2
rpcs3/Emu/Cell/Modules/StaticHLE.cpp
View file

@ -121,7 +121,7 @@ uint16_t statichle_handler::gen_CRC16(const uint8_t* data_p, size_t length)
crc = ~crc; crc = ~crc;
data = crc; data = crc;
crc = (crc << 8) | ((data >> 8) & 0xff); crc = (crc << 8) | ((data >> 8) & 0xff);
return (unsigned short)(crc); return static_cast<u16>(crc);
} }
bool statichle_handler::check_against_patterns(vm::cptr<u8>& data, u32 size, u32 addr) bool statichle_handler::check_against_patterns(vm::cptr<u8>& data, u32 size, u32 addr)

4
rpcs3/Emu/Cell/Modules/cellL10n.cpp
View file

@ -235,7 +235,7 @@ s32 _ConvertStr(s32 src_code, const void *src, s32 src_len, s32 dst_code, void *
if (dst != NULL) if (dst != NULL)
{ {
size_t dstLen = *dst_len; size_t dstLen = *dst_len;
size_t ictd = iconv(ict, (char **)&src, &srcLen, (char **)&dst, &dstLen); size_t ictd = iconv(ict, const_cast<char**>(reinterpret_cast<const char**>(&src)), &srcLen, reinterpret_cast<char**>(&dst), &dstLen);
*dst_len -= dstLen; *dst_len -= dstLen;
if (ictd == -1) if (ictd == -1)
{ {
@ -260,7 +260,7 @@ s32 _ConvertStr(s32 src_code, const void *src, s32 src_len, s32 dst_code, void *
{ {
char *bufPtr = buf; char *bufPtr = buf;
size_t bufLeft = sizeof(buf); size_t bufLeft = sizeof(buf);
size_t ictd = iconv(ict, (char **)&src, &srcLen, (char **)&bufPtr, &bufLeft); size_t ictd = iconv(ict, const_cast<char**>(reinterpret_cast<const char**>(&src)), &srcLen, reinterpret_cast<char**>(&dst), &bufLeft);
*dst_len += sizeof(buf) - bufLeft; *dst_len += sizeof(buf) - bufLeft;
if (ictd == -1 && errno != E2BIG) if (ictd == -1 && errno != E2BIG)
{ {

24
rpcs3/Emu/Cell/Modules/cellMic.cpp
View file

@ -124,8 +124,8 @@ void microphone_device::variable_byteswap(const void* src, void* dst, const u32
{ {
switch (bytesize) switch (bytesize)
{ {
case 4: *(u32*)dst = *(be_t<u32>*)src; break; case 4: *static_cast<u32*>(dst) = *static_cast<const be_t<u32>*>(src); break;
case 2: *(u16*)dst = *(be_t<u16>*)src; break; case 2: *static_cast<u16*>(dst) = *static_cast<const be_t<u16>*>(src); break;
} }
} }
@ -668,7 +668,7 @@ s32 cellMicStop(u32 dev_num)
s32 cellMicGetDeviceAttr(u32 dev_num, CellMicDeviceAttr deviceAttributes, vm::ptr<u32> arg1, vm::ptr<u32> arg2) s32 cellMicGetDeviceAttr(u32 dev_num, CellMicDeviceAttr deviceAttributes, vm::ptr<u32> arg1, vm::ptr<u32> arg2)
{ {
cellMic.trace("cellMicGetDeviceAttr(dev_num=%d, deviceAttribute=%d, arg1=*0x%x, arg2=*0x%x)", dev_num, (u32)deviceAttributes, arg1, arg2); cellMic.trace("cellMicGetDeviceAttr(dev_num=%d, deviceAttribute=%d, arg1=*0x%x, arg2=*0x%x)", dev_num, +deviceAttributes, arg1, arg2);
if (!arg1 || (!arg2 && deviceAttributes == CELLMIC_DEVATTR_CHANVOL)) if (!arg1 || (!arg2 && deviceAttributes == CELLMIC_DEVATTR_CHANVOL))
return CELL_MIC_ERROR_PARAM; return CELL_MIC_ERROR_PARAM;
@ -699,7 +699,7 @@ s32 cellMicGetDeviceAttr(u32 dev_num, CellMicDeviceAttr deviceAttributes, vm::pt
s32 cellMicSetDeviceAttr(u32 dev_num, CellMicDeviceAttr deviceAttributes, u32 arg1, u32 arg2) s32 cellMicSetDeviceAttr(u32 dev_num, CellMicDeviceAttr deviceAttributes, u32 arg1, u32 arg2)
{ {
cellMic.trace("cellMicSetDeviceAttr(dev_num=%d, deviceAttributes=%d, arg1=%d, arg2=%d)", dev_num, (u32)deviceAttributes, arg1, arg2); cellMic.trace("cellMicSetDeviceAttr(dev_num=%d, deviceAttributes=%d, arg1=%d, arg2=%d)", dev_num, +deviceAttributes, arg1, arg2);
const auto mic_thr = g_fxo->get<mic_thread>(); const auto mic_thr = g_fxo->get<mic_thread>();
const std::lock_guard lock(mic_thr->mutex); const std::lock_guard lock(mic_thr->mutex);
@ -732,27 +732,27 @@ s32 cellMicSetDeviceAttr(u32 dev_num, CellMicDeviceAttr deviceAttributes, u32 ar
s32 cellMicGetSignalAttr(u32 dev_num, CellMicSignalAttr sig_attrib, vm::ptr<void> value) s32 cellMicGetSignalAttr(u32 dev_num, CellMicSignalAttr sig_attrib, vm::ptr<void> value)
{ {
cellMic.todo("cellMicGetSignalAttr(dev_num=%d, sig_attrib=%d, value=*0x%x)", dev_num, (u32)sig_attrib, value); cellMic.todo("cellMicGetSignalAttr(dev_num=%d, sig_attrib=%d, value=*0x%x)", dev_num, +sig_attrib, value);
return CELL_OK; return CELL_OK;
} }
s32 cellMicSetSignalAttr(u32 dev_num, CellMicSignalAttr sig_attrib, vm::ptr<void> value) s32 cellMicSetSignalAttr(u32 dev_num, CellMicSignalAttr sig_attrib, vm::ptr<void> value)
{ {
cellMic.todo("cellMicSetSignalAttr(dev_num=%d, sig_attrib=%d, value=*0x%x)", dev_num, (u32)sig_attrib, value); cellMic.todo("cellMicSetSignalAttr(dev_num=%d, sig_attrib=%d, value=*0x%x)", dev_num, +sig_attrib, value);
return CELL_OK; return CELL_OK;
} }
s32 cellMicGetSignalState(u32 dev_num, CellMicSignalState sig_state, vm::ptr<void> value) s32 cellMicGetSignalState(u32 dev_num, CellMicSignalState sig_state, vm::ptr<void> value)
{ {
cellMic.todo("cellMicGetSignalState(dev_num=%d, sig_state=%d, value=*0x%x)", dev_num, (u32)sig_state, value); cellMic.todo("cellMicGetSignalState(dev_num=%d, sig_state=%d, value=*0x%x)", dev_num, +sig_state, value);
const auto mic_thr = g_fxo->get<mic_thread>(); const auto mic_thr = g_fxo->get<mic_thread>();
const std::lock_guard lock(mic_thr->mutex); const std::lock_guard lock(mic_thr->mutex);
if (!mic_thr->init) if (!mic_thr->init)
return CELL_MIC_ERROR_NOT_INIT; return CELL_MIC_ERROR_NOT_INIT;
be_t<u32>* ival = (be_t<u32>*)value.get_ptr(); be_t<u32>* ival = vm::_ptr<u32>(value.addr());
be_t<f32>* fval = (be_t<f32>*)value.get_ptr(); be_t<f32>* fval = vm::_ptr<f32>(value.addr());
switch (sig_state) switch (sig_state)
{ {
@ -897,8 +897,7 @@ s32 cellMicReadRaw(u32 dev_num, vm::ptr<void> data, u32 maxBytes)
if (!mic.is_opened() || !(mic.get_signal_types() & CELLMIC_SIGTYPE_RAW)) if (!mic.is_opened() || !(mic.get_signal_types() & CELLMIC_SIGTYPE_RAW))
return CELL_MIC_ERROR_NOT_OPEN; return CELL_MIC_ERROR_NOT_OPEN;
u8* res_buf = (u8*)data.get_ptr(); return mic.read_raw(vm::_ptr<u8>(data.addr()), maxBytes);
return mic.read_raw(res_buf, maxBytes);
} }
s32 cellMicRead(u32 dev_num, vm::ptr<void> data, u32 maxBytes) s32 cellMicRead(u32 dev_num, vm::ptr<void> data, u32 maxBytes)
@ -918,8 +917,7 @@ s32 cellMicRead(u32 dev_num, vm::ptr<void> data, u32 maxBytes)
if (!mic.is_opened() || !(mic.get_signal_types() & CELLMIC_SIGTYPE_DSP)) if (!mic.is_opened() || !(mic.get_signal_types() & CELLMIC_SIGTYPE_DSP))
return CELL_MIC_ERROR_NOT_OPEN; return CELL_MIC_ERROR_NOT_OPEN;
u8* res_buf = (u8*)data.get_ptr(); return mic.read_dsp(vm::_ptr<u8>(data.addr()), maxBytes);
return mic.read_dsp(res_buf, maxBytes);
} }
s32 cellMicReadAux(u32 dev_num, vm::ptr<void> data, s32 max_bytes) s32 cellMicReadAux(u32 dev_num, vm::ptr<void> data, s32 max_bytes)

2
rpcs3/Emu/Cell/Modules/cellMsgDialog.cpp
View file

@ -554,7 +554,7 @@ error_code cellMsgDialogProgressBarInc(u32 progressBarIndex, u32 delta)
{ {
if (auto dlg = manager->get<rsx::overlays::message_dialog>()) if (auto dlg = manager->get<rsx::overlays::message_dialog>())
{ {
return dlg->progress_bar_increment(progressBarIndex, (f32)delta); return dlg->progress_bar_increment(progressBarIndex, static_cast<f32>(delta));
} }
} }

4
rpcs3/Emu/Cell/Modules/cellOskDialog.cpp
View file

@ -105,7 +105,7 @@ error_code cellOskDialogLoadAsync(u32 container, vm::ptr<CellOskDialogParam> dia
} }
// Get the OSK options // Get the OSK options
u32 maxLength = (inputFieldInfo->limit_length >= CELL_OSKDIALOG_STRING_SIZE) ? 511 : (u32)inputFieldInfo->limit_length; u32 maxLength = (inputFieldInfo->limit_length >= CELL_OSKDIALOG_STRING_SIZE) ? 511 : u32{inputFieldInfo->limit_length};
u32 options = dialogParam->prohibitFlgs; u32 options = dialogParam->prohibitFlgs;
// Get init text and prepare return value // Get init text and prepare return value
@ -176,7 +176,7 @@ error_code cellOskDialogLoadAsync(u32 container, vm::ptr<CellOskDialogParam> dia
sysutil_register_cb([&, length = i](ppu_thread& cb_ppu) -> s32 sysutil_register_cb([&, length = i](ppu_thread& cb_ppu) -> s32
{ {
return_value = ccb(cb_ppu, string_to_send, (s32)length); return_value = ccb(cb_ppu, string_to_send, static_cast<s32>(length));
cellOskDialog.warning("osk_confirm_callback return_value=%d", return_value); cellOskDialog.warning("osk_confirm_callback return_value=%d", return_value);
for (u32 i = 0; i < CELL_OSKDIALOG_STRING_SIZE - 1; i++) for (u32 i = 0; i < CELL_OSKDIALOG_STRING_SIZE - 1; i++)

2
rpcs3/Emu/Cell/Modules/cellPad.cpp
View file

@ -574,7 +574,7 @@ error_code cellPadSetActDirect(u32 port_no, vm::ptr<CellPadActParam> param)
return CELL_PAD_ERROR_INVALID_PARAMETER; return CELL_PAD_ERROR_INVALID_PARAMETER;
// Note: signed check unlike the usual unsigned check // Note: signed check unlike the usual unsigned check
if ((s32)g_ps3_process_info.sdk_ver > 0x1FFFFF) if (static_cast<s32>(g_ps3_process_info.sdk_ver) > 0x1FFFFF)
{ {
// make sure reserved bits are 0 // make sure reserved bits are 0
for (int i = 0; i < 6; i++) for (int i = 0; i < 6; i++)

30
rpcs3/Emu/Cell/Modules/cellPamf.cpp
View file

@ -117,7 +117,7 @@ s32 pamfStreamTypeToEsFilterId(u8 type, u8 ch, CellCodecEsFilterId& pEsFilterId)
u8 pamfGetStreamType(vm::ptr<CellPamfReader> pSelf, u32 stream) u8 pamfGetStreamType(vm::ptr<CellPamfReader> pSelf, u32 stream)
{ {
// TODO: get stream type correctly // TODO: get stream type correctly
verify(HERE), (stream < (u32)pSelf->pAddr->stream_count); verify(HERE), (stream < pSelf->pAddr->stream_count);
auto& header = pSelf->pAddr->stream_headers[stream]; auto& header = pSelf->pAddr->stream_headers[stream];
switch (header.type) switch (header.type)
@ -138,7 +138,7 @@ u8 pamfGetStreamType(vm::ptr<CellPamfReader> pSelf, u32 stream)
u8 pamfGetStreamChannel(vm::ptr<CellPamfReader> pSelf, u32 stream) u8 pamfGetStreamChannel(vm::ptr<CellPamfReader> pSelf, u32 stream)
{ {
// TODO: get stream channel correctly // TODO: get stream channel correctly
verify(HERE), (stream < (u32)pSelf->pAddr->stream_count); verify(HERE), (stream < pSelf->pAddr->stream_count);
auto& header = pSelf->pAddr->stream_headers[stream]; auto& header = pSelf->pAddr->stream_headers[stream];
switch (header.type) switch (header.type)
@ -184,7 +184,7 @@ s32 cellPamfGetHeaderSize(vm::ptr<PamfHeader> pAddr, u64 fileSize, vm::ptr<u64>
//if ((u32)pAddr->magic != 0x464d4150) return CELL_PAMF_ERROR_UNKNOWN_TYPE; //if ((u32)pAddr->magic != 0x464d4150) return CELL_PAMF_ERROR_UNKNOWN_TYPE;
const u64 offset = (u64)pAddr->data_offset << 11; const u64 offset = u64{pAddr->data_offset} << 11;
*pSize = offset; *pSize = offset;
return CELL_OK; return CELL_OK;
} }
@ -195,7 +195,7 @@ s32 cellPamfGetHeaderSize2(vm::ptr<PamfHeader> pAddr, u64 fileSize, u32 attribut
//if ((u32)pAddr->magic != 0x464d4150) return CELL_PAMF_ERROR_UNKNOWN_TYPE; //if ((u32)pAddr->magic != 0x464d4150) return CELL_PAMF_ERROR_UNKNOWN_TYPE;
const u64 offset = (u64)pAddr->data_offset << 11; const u64 offset = u64{pAddr->data_offset} << 11;
*pSize = offset; *pSize = offset;
return CELL_OK; return CELL_OK;
} }
@ -206,9 +206,9 @@ s32 cellPamfGetStreamOffsetAndSize(vm::ptr<PamfHeader> pAddr, u64 fileSize, vm::
//if ((u32)pAddr->magic != 0x464d4150) return CELL_PAMF_ERROR_UNKNOWN_TYPE; //if ((u32)pAddr->magic != 0x464d4150) return CELL_PAMF_ERROR_UNKNOWN_TYPE;
const u64 offset = (u64)pAddr->data_offset << 11; const u64 offset = u64{pAddr->data_offset} << 11;
*pOffset = offset; *pOffset = offset;
const u64 size = (u64)pAddr->data_size << 11; const u64 size = u64{pAddr->data_size} << 11;
*pSize = size; *pSize = size;
return CELL_OK; return CELL_OK;
} }
@ -231,7 +231,7 @@ s32 cellPamfReaderInitialize(vm::ptr<CellPamfReader> pSelf, vm::cptr<PamfHeader>
} }
else // if fileSize is unknown else // if fileSize is unknown
{ {
pSelf->fileSize = ((u64)pAddr->data_offset << 11) + ((u64)pAddr->data_size << 11); pSelf->fileSize = (u64{pAddr->data_offset} << 11) + (u64{pAddr->data_size} << 11);
} }
pSelf->pAddr = pAddr; pSelf->pAddr = pAddr;
@ -251,7 +251,7 @@ s32 cellPamfReaderGetPresentationStartTime(vm::ptr<CellPamfReader> pSelf, vm::pt
// always returns CELL_OK // always returns CELL_OK
pTimeStamp->upper = (u32)(u16)pSelf->pAddr->start_pts_high; pTimeStamp->upper = pSelf->pAddr->start_pts_high;
pTimeStamp->lower = pSelf->pAddr->start_pts_low; pTimeStamp->lower = pSelf->pAddr->start_pts_low;
return CELL_OK; return CELL_OK;
} }
@ -262,7 +262,7 @@ s32 cellPamfReaderGetPresentationEndTime(vm::ptr<CellPamfReader> pSelf, vm::ptr<
// always returns CELL_OK // always returns CELL_OK
pTimeStamp->upper = (u32)(u16)pSelf->pAddr->end_pts_high; pTimeStamp->upper = pSelf->pAddr->end_pts_high;
pTimeStamp->lower = pSelf->pAddr->end_pts_low; pTimeStamp->lower = pSelf->pAddr->end_pts_low;
return CELL_OK; return CELL_OK;
} }
@ -454,7 +454,7 @@ s32 cellPamfReaderGetEsFilterId(vm::ptr<CellPamfReader> pSelf, vm::ptr<CellCodec
// always returns CELL_OK // always returns CELL_OK
verify(HERE), (u32)pSelf->stream < pSelf->pAddr->stream_count; verify(HERE), static_cast<u32>(pSelf->stream) < pSelf->pAddr->stream_count;
auto& header = pSelf->pAddr->stream_headers[pSelf->stream]; auto& header = pSelf->pAddr->stream_headers[pSelf->stream];
pEsFilterId->filterIdMajor = header.fid_major; pEsFilterId->filterIdMajor = header.fid_major;
pEsFilterId->filterIdMinor = header.fid_minor; pEsFilterId->filterIdMinor = header.fid_minor;
@ -467,7 +467,7 @@ s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, vm::ptr<void> pIn
{ {
cellPamf.warning("cellPamfReaderGetStreamInfo(pSelf=*0x%x, pInfo=*0x%x, size=%d)", pSelf, pInfo, size); cellPamf.warning("cellPamfReaderGetStreamInfo(pSelf=*0x%x, pInfo=*0x%x, size=%d)", pSelf, pInfo, size);
verify(HERE), (u32)pSelf->stream < pSelf->pAddr->stream_count; verify(HERE), static_cast<u32>(pSelf->stream) < pSelf->pAddr->stream_count;
auto& header = pSelf->pAddr->stream_headers[pSelf->stream]; auto& header = pSelf->pAddr->stream_headers[pSelf->stream];
const u8 type = pamfGetStreamType(pSelf, pSelf->stream); const u8 type = pamfGetStreamType(pSelf, pSelf->stream);
const u8 ch = pamfGetStreamChannel(pSelf, pSelf->stream); const u8 ch = pamfGetStreamChannel(pSelf, pSelf->stream);
@ -501,8 +501,8 @@ s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, vm::ptr<void> pIn
info->sarHeight = 0; info->sarHeight = 0;
} }
info->horizontalSize = ((u16)header.AVC.horizontalSize & 0xff) * 16; info->horizontalSize = (header.AVC.horizontalSize & u8{0xff}) * 16;
info->verticalSize = ((u16)header.AVC.verticalSize & 0xff) * 16; info->verticalSize = (header.AVC.verticalSize & u8{0xff}) * 16;
info->frameCropLeftOffset = header.AVC.frameCropLeftOffset; info->frameCropLeftOffset = header.AVC.frameCropLeftOffset;
info->frameCropRightOffset = header.AVC.frameCropRightOffset; info->frameCropRightOffset = header.AVC.frameCropRightOffset;
info->frameCropTopOffset = header.AVC.frameCropTopOffset; info->frameCropTopOffset = header.AVC.frameCropTopOffset;
@ -567,8 +567,8 @@ s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, vm::ptr<void> pIn
info->sarHeight = 0; info->sarHeight = 0;
} }
info->horizontalSize = ((u16)header.M2V.horizontalSize & 0xff) * 16; info->horizontalSize = (header.M2V.horizontalSize & u8{0xff}) * 16;
info->verticalSize = ((u16)header.M2V.verticalSize & 0xff) * 16; info->verticalSize = (header.M2V.verticalSize & u8{0xff}) * 16;
info->horizontalSizeValue = header.M2V.horizontalSizeValue; info->horizontalSizeValue = header.M2V.horizontalSizeValue;
info->verticalSizeValue = header.M2V.verticalSizeValue; info->verticalSizeValue = header.M2V.verticalSizeValue;

14
rpcs3/Emu/Cell/Modules/cellPngDec.cpp
View file

@ -59,7 +59,7 @@ void pngDecReadBuffer(png_structp png_ptr, png_bytep out, png_size_t length)
} }
// Cast the IO pointer to our custom structure // Cast the IO pointer to our custom structure
PngBuffer& buffer = *(PngBuffer*)io_ptr; PngBuffer& buffer = *static_cast<PngBuffer*>(io_ptr);
// Read froma file or a buffer // Read froma file or a buffer
if (buffer.file) if (buffer.file)
@ -85,7 +85,7 @@ void pngDecReadBuffer(png_structp png_ptr, png_bytep out, png_size_t length)
void pngDecRowCallback(png_structp png_ptr, png_bytep new_row, png_uint_32 row_num, int pass) void pngDecRowCallback(png_structp png_ptr, png_bytep new_row, png_uint_32 row_num, int pass)
{ {
PngStream* stream = (PngStream*)png_get_progressive_ptr(png_ptr); PngStream* stream = static_cast<PngStream*>(png_get_progressive_ptr(png_ptr));
if (!stream) if (!stream)
{ {
cellPngDec.error("Failed to obtain streamPtr in rowCallback."); cellPngDec.error("Failed to obtain streamPtr in rowCallback.");
@ -123,7 +123,7 @@ void pngDecRowCallback(png_structp png_ptr, png_bytep new_row, png_uint_32 row_n
void pngDecInfoCallback(png_structp png_ptr, png_infop info) void pngDecInfoCallback(png_structp png_ptr, png_infop info)
{ {
PngStream* stream = (PngStream*)png_get_progressive_ptr(png_ptr); PngStream* stream = static_cast<PngStream*>(png_get_progressive_ptr(png_ptr));
if (!stream) if (!stream)
{ {
cellPngDec.error("Failed to obtain streamPtr in rowCallback."); cellPngDec.error("Failed to obtain streamPtr in rowCallback.");
@ -136,7 +136,7 @@ void pngDecInfoCallback(png_structp png_ptr, png_infop info)
void pngDecEndCallback(png_structp png_ptr, png_infop info) void pngDecEndCallback(png_structp png_ptr, png_infop info)
{ {
PngStream* stream = (PngStream*)png_get_progressive_ptr(png_ptr); PngStream* stream = static_cast<PngStream*>(png_get_progressive_ptr(png_ptr));
if (!stream) if (!stream)
{ {
cellPngDec.error("Failed to obtain streamPtr in endCallback."); cellPngDec.error("Failed to obtain streamPtr in endCallback.");
@ -286,7 +286,7 @@ be_t<u32> pngDecGetChunkInformation(PngStream* stream, bool IDAT = false)
chunk_information |= 1 << 11; // sRGB chunk_information |= 1 << 11; // sRGB
} }
if (png_get_iCCP(stream->png_ptr, stream->info_ptr, &name, &compression_type, &profile, (png_uint_32*)&proflen)) if (png_get_iCCP(stream->png_ptr, stream->info_ptr, &name, &compression_type, &profile, &proflen))
{ {
chunk_information |= 1 << 12; // iCCP chunk_information |= 1 << 12; // iCCP
} }
@ -483,7 +483,7 @@ s32 pngDecOpen(ppu_thread& ppu, PHandle handle, PPStream png_stream, PSrc source
stream->cbCtrlStream.cbCtrlStrmArg = control_stream->cbCtrlStrmArg; stream->cbCtrlStream.cbCtrlStrmArg = control_stream->cbCtrlStrmArg;
stream->cbCtrlStream.cbCtrlStrmFunc = control_stream->cbCtrlStrmFunc; stream->cbCtrlStream.cbCtrlStrmFunc = control_stream->cbCtrlStrmFunc;
png_set_progressive_read_fn(stream->png_ptr, (void *)stream.get_ptr(), pngDecInfoCallback, pngDecRowCallback, pngDecEndCallback); png_set_progressive_read_fn(stream->png_ptr, stream.get_ptr(), pngDecInfoCallback, pngDecRowCallback, pngDecEndCallback);
// push header tag to libpng to keep us in sync // push header tag to libpng to keep us in sync
try try
@ -789,7 +789,7 @@ s32 pngDecodeData(ppu_thread& ppu, PHandle handle, PStream stream, vm::ptr<u8> d
const s32 text_chunks = png_get_text(stream->png_ptr, stream->info_ptr, nullptr, nullptr); const s32 text_chunks = png_get_text(stream->png_ptr, stream->info_ptr, nullptr, nullptr);
// Set the chunk information and the previously obtained number of text chunks // Set the chunk information and the previously obtained number of text chunks
data_out_info->numText = (u32)text_chunks; data_out_info->numText = static_cast<u32>(text_chunks);
data_out_info->chunkInformation = pngDecGetChunkInformation(stream.get_ptr(), true); data_out_info->chunkInformation = pngDecGetChunkInformation(stream.get_ptr(), true);
png_unknown_chunkp unknowns; png_unknown_chunkp unknowns;
const int num_unknowns = png_get_unknown_chunks(stream->png_ptr, stream->info_ptr, &unknowns); const int num_unknowns = png_get_unknown_chunks(stream->png_ptr, stream->info_ptr, &unknowns);

2
rpcs3/Emu/Cell/Modules/cellResc.cpp
View file

@ -146,7 +146,7 @@ void cellRescSetVBlankHandler(vm::ptr<void(u32)> handler)
s32 cellRescCreateInterlaceTable(u32 ea_addr, f32 srcH, CellRescTableElement depth, s32 length) s32 cellRescCreateInterlaceTable(u32 ea_addr, f32 srcH, CellRescTableElement depth, s32 length)
{ {
cellResc.todo("cellRescCreateInterlaceTable(ea_addr=0x%x, srcH=%f, depth=%d, length=%d)", ea_addr, srcH, (s32)depth, length); cellResc.todo("cellRescCreateInterlaceTable(ea_addr=0x%x, srcH=%f, depth=%d, length=%d)", ea_addr, srcH, +depth, length);
return CELL_OK; return CELL_OK;
} }

8
rpcs3/Emu/Cell/Modules/cellRtc.cpp
View file

@ -7,15 +7,15 @@ LOG_CHANNEL(cellRtc);
s64 convertToUNIXTime(u16 seconds, u16 minutes, u16 hours, u16 days, s32 years) s64 convertToUNIXTime(u16 seconds, u16 minutes, u16 hours, u16 days, s32 years)
{ {
return (s64)seconds + (s64)minutes * 60 + (s64)hours * 3600 + (s64)days * 86400 + return s64{seconds} + s64{minutes} * 60 + s64{hours} * 3600 + s64{days} * 86400 +
(s64)(years - 70) * 31536000 + (s64)((years - 69) / 4) * 86400 - s64{years - 70} * 31536000 + s64{(years - 69) / 4} * 86400 -
(s64)((years - 1) / 100) * 86400 + (s64)((years + 299) / 400) * 86400; s64{(years - 1) / 100} * 86400 + s64{(years + 299) / 400} * 86400;
} }
u64 convertToWin32FILETIME(u16 seconds, u16 minutes, u16 hours, u16 days, s32 years) u64 convertToWin32FILETIME(u16 seconds, u16 minutes, u16 hours, u16 days, s32 years)
{ {
s64 unixtime = convertToUNIXTime(seconds, minutes, hours, days, years); s64 unixtime = convertToUNIXTime(seconds, minutes, hours, days, years);
u64 win32time = u64(unixtime) * u64(10000000) + u64(116444736000000000); u64 win32time = static_cast<u64>(unixtime) * 10000000 + 116444736000000000;
u64 win32filetime = win32time | win32time >> 32; u64 win32filetime = win32time | win32time >> 32;
return win32filetime; return win32filetime;
} }

2
rpcs3/Emu/Cell/Modules/cellSail.cpp
View file

@ -99,7 +99,7 @@ s32 cellSailDescriptorCreateDatabase(vm::ptr<CellSailDescriptor> pSelf, vm::ptr<
{ {
cellSail.warning("cellSailDescriptorCreateDatabase(pSelf=*0x%x, pDatabase=*0x%x, size=0x%x, arg=0x%llx)", pSelf, pDatabase, size, arg); cellSail.warning("cellSailDescriptorCreateDatabase(pSelf=*0x%x, pDatabase=*0x%x, size=0x%x, arg=0x%llx)", pSelf, pDatabase, size, arg);
switch ((s32)pSelf->streamType) switch (pSelf->streamType)
{ {
case CELL_SAIL_STREAM_PAMF: case CELL_SAIL_STREAM_PAMF:
{ {

14
rpcs3/Emu/Cell/Modules/cellSearch.cpp
View file

@ -59,7 +59,7 @@ struct search_object_t
error_code cellSearchInitialize(CellSearchMode mode, u32 container, vm::ptr<CellSearchSystemCallback> func, vm::ptr<void> userData) error_code cellSearchInitialize(CellSearchMode mode, u32 container, vm::ptr<CellSearchSystemCallback> func, vm::ptr<void> userData)
{ {
cellSearch.warning("cellSearchInitialize(mode=0x%x, container=0x%x, func=*0x%x, userData=*0x%x)", (u32) mode, container, func, userData); cellSearch.warning("cellSearchInitialize(mode=0x%x, container=0x%x, func=*0x%x, userData=*0x%x)", +mode, container, func, userData);
const auto search = g_fxo->get<search_info>(); const auto search = g_fxo->get<search_info>();
search->func = func; search->func = func;
@ -91,7 +91,7 @@ error_code cellSearchFinalize()
error_code cellSearchStartListSearch(CellSearchListSearchType type, CellSearchSortOrder sortOrder, vm::ptr<CellSearchId> outSearchId) error_code cellSearchStartListSearch(CellSearchListSearchType type, CellSearchSortOrder sortOrder, vm::ptr<CellSearchId> outSearchId)
{ {
cellSearch.todo("cellSearchStartListSearch(type=0x%x, sortOrder=0x%x, outSearchId=*0x%x)", (u32) type, (u32) sortOrder, outSearchId); cellSearch.todo("cellSearchStartListSearch(type=0x%x, sortOrder=0x%x, outSearchId=*0x%x)", +type, +sortOrder, outSearchId);
if (!outSearchId) if (!outSearchId)
{ {
@ -117,7 +117,7 @@ error_code cellSearchStartListSearch(CellSearchListSearchType type, CellSearchSo
error_code cellSearchStartContentSearchInList(vm::cptr<CellSearchContentId> listId, CellSearchSortKey sortKey, CellSearchSortOrder sortOrder, vm::ptr<CellSearchId> outSearchId) error_code cellSearchStartContentSearchInList(vm::cptr<CellSearchContentId> listId, CellSearchSortKey sortKey, CellSearchSortOrder sortOrder, vm::ptr<CellSearchId> outSearchId)
{ {
cellSearch.todo("cellSearchStartContentSearchInList(listId=*0x%x, sortKey=0x%x, sortOrder=0x%x, outSearchId=*0x%x)", listId, (u32) sortKey, (u32) sortOrder, outSearchId); cellSearch.todo("cellSearchStartContentSearchInList(listId=*0x%x, sortKey=0x%x, sortOrder=0x%x, outSearchId=*0x%x)", listId, +sortKey, +sortOrder, outSearchId);
if (!listId || !outSearchId) if (!listId || !outSearchId)
{ {
@ -143,7 +143,7 @@ error_code cellSearchStartContentSearchInList(vm::cptr<CellSearchContentId> list
error_code cellSearchStartContentSearch(CellSearchContentSearchType type, CellSearchSortKey sortKey, CellSearchSortOrder sortOrder, vm::ptr<CellSearchId> outSearchId) error_code cellSearchStartContentSearch(CellSearchContentSearchType type, CellSearchSortKey sortKey, CellSearchSortOrder sortOrder, vm::ptr<CellSearchId> outSearchId)
{ {
cellSearch.todo("cellSearchStartContentSearch(type=0x%x, sortKey=0x%x, sortOrder=0x%x, outSearchId=*0x%x)", (u32) type, (u32) sortKey, (u32) sortOrder, outSearchId); cellSearch.todo("cellSearchStartContentSearch(type=0x%x, sortKey=0x%x, sortOrder=0x%x, outSearchId=*0x%x)", +type, +sortKey, +sortOrder, outSearchId);
if (!outSearchId) if (!outSearchId)
{ {
@ -169,7 +169,7 @@ error_code cellSearchStartContentSearch(CellSearchContentSearchType type, CellSe
error_code cellSearchStartSceneSearchInVideo(vm::cptr<CellSearchContentId> videoId, CellSearchSceneSearchType searchType, CellSearchSortOrder sortOrder, vm::ptr<CellSearchId> outSearchId) error_code cellSearchStartSceneSearchInVideo(vm::cptr<CellSearchContentId> videoId, CellSearchSceneSearchType searchType, CellSearchSortOrder sortOrder, vm::ptr<CellSearchId> outSearchId)
{ {
cellSearch.todo("cellSearchStartSceneSearchInVideo(videoId=*0x%x, searchType=0x%x, sortOrder=0x%x, outSearchId=*0x%x)", videoId, (u32) searchType, (u32) sortOrder, outSearchId); cellSearch.todo("cellSearchStartSceneSearchInVideo(videoId=*0x%x, searchType=0x%x, sortOrder=0x%x, outSearchId=*0x%x)", videoId, +searchType, +sortOrder, outSearchId);
if (!videoId || !outSearchId) if (!videoId || !outSearchId)
{ {
@ -195,7 +195,7 @@ error_code cellSearchStartSceneSearchInVideo(vm::cptr<CellSearchContentId> video
error_code cellSearchStartSceneSearch(CellSearchSceneSearchType searchType, vm::cptr<char> gameTitle, vm::cpptr<char> tags, u32 tagNum, CellSearchSortKey sortKey, CellSearchSortOrder sortOrder, vm::ptr<CellSearchId> outSearchId) error_code cellSearchStartSceneSearch(CellSearchSceneSearchType searchType, vm::cptr<char> gameTitle, vm::cpptr<char> tags, u32 tagNum, CellSearchSortKey sortKey, CellSearchSortOrder sortOrder, vm::ptr<CellSearchId> outSearchId)
{ {
cellSearch.todo("cellSearchStartSceneSearch(searchType=0x%x, gameTitle=%s, tags=**0x%x, tagNum=0x%x, sortKey=0x%x, sortOrder=0x%x, outSearchId=*0x%x)", (u32) searchType, gameTitle, tags, tagNum, (u32) sortKey, (u32) sortOrder, outSearchId); cellSearch.todo("cellSearchStartSceneSearch(searchType=0x%x, gameTitle=%s, tags=**0x%x, tagNum=0x%x, sortKey=0x%x, sortOrder=0x%x, outSearchId=*0x%x)", +searchType, gameTitle, tags, tagNum, +sortKey, +sortOrder, outSearchId);
if (!gameTitle || !outSearchId) if (!gameTitle || !outSearchId)
{ {
@ -302,7 +302,7 @@ error_code cellSearchGetContentInfoGameComment(vm::cptr<CellSearchContentId> con
error_code cellSearchGetMusicSelectionContext(CellSearchId searchId, vm::cptr<CellSearchContentId> contentId, CellSearchRepeatMode repeatMode, CellSearchContextOption option, vm::ptr<CellMusicSelectionContext> outContext) error_code cellSearchGetMusicSelectionContext(CellSearchId searchId, vm::cptr<CellSearchContentId> contentId, CellSearchRepeatMode repeatMode, CellSearchContextOption option, vm::ptr<CellMusicSelectionContext> outContext)
{ {
cellSearch.todo("cellSearchGetMusicSelectionContext(searchId=0x%x, contentId=*0x%x, repeatMode=0x%x, option=0x%x, outContext=*0x%x)", searchId, contentId, (u32) repeatMode, (u32) option, outContext); cellSearch.todo("cellSearchGetMusicSelectionContext(searchId=0x%x, contentId=*0x%x, repeatMode=0x%x, option=0x%x, outContext=*0x%x)", searchId, contentId, +repeatMode, +option, outContext);
if (!outContext) if (!outContext)
{ {

102
rpcs3/Emu/Cell/Modules/cellSpurs.cpp
View file

@ -168,7 +168,7 @@ namespace _spurs
namespace _spurs namespace _spurs
{ {
// Add workload // Add workload
s32 add_workload(vm::ptr<CellSpurs> spurs, vm::ptr<u32> wid, vm::cptr<void> pm, u32 size, u64 data, const u8 priorityTable[], u32 minContention, u32 maxContention, vm::cptr<char> nameClass, vm::cptr<char> nameInstance, vm::ptr<CellSpursShutdownCompletionEventHook> hook, vm::ptr<void> hookArg); s32 add_workload(vm::ptr<CellSpurs> spurs, vm::ptr<u32> wid, vm::cptr<void> pm, u32 size, u64 data, const u8(&priorityTable)[8], u32 minContention, u32 maxContention, vm::cptr<char> nameClass, vm::cptr<char> nameInstance, vm::ptr<CellSpursShutdownCompletionEventHook> hook, vm::ptr<void> hookArg);
} }
//s32 _cellSpursWorkloadAttributeInitialize(vm::ptr<CellSpursWorkloadAttribute> attr, u32 revision, u32 sdkVersion, vm::cptr<void> pm, u32 size, u64 data, vm::cptr<u8[8]> priority, u32 minCnt, u32 maxCnt); //s32 _cellSpursWorkloadAttributeInitialize(vm::ptr<CellSpursWorkloadAttribute> attr, u32 revision, u32 sdkVersion, vm::cptr<void> pm, u32 size, u64 data, vm::cptr<u8[8]> priority, u32 minCnt, u32 maxCnt);
@ -506,13 +506,13 @@ void _spurs::handler_wait_ready(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
for (u32 i = 0; i < 16; i++) for (u32 i = 0; i < 16; i++)
{ {
if (spurs->wklState1[i] == SPURS_WKL_STATE_RUNNABLE && if (spurs->wklState1[i] == SPURS_WKL_STATE_RUNNABLE &&
*((u64*)spurs->wklInfo1[i].priority) != 0 && std::bit_cast<u64>(spurs->wklInfo1[i].priority) != 0 &&
spurs->wklMaxContention[i] & 0x0F) spurs->wklMaxContention[i] & 0x0F)
{ {
if (spurs->wklReadyCount1[i] || if (spurs->wklReadyCount1[i] ||
spurs->wklSignal1.load() & (0x8000u >> i) || spurs->wklSignal1.load() & (0x8000u >> i) ||
(spurs->wklFlag.flag.load() == 0 && (spurs->wklFlag.flag.load() == 0 &&
spurs->wklFlagReceiver == (u8)i)) spurs->wklFlagReceiver == static_cast<u8>(i)))
{ {
foundRunnableWorkload = true; foundRunnableWorkload = true;
break; break;
@ -525,13 +525,13 @@ void _spurs::handler_wait_ready(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
for (u32 i = 0; i < 16; i++) for (u32 i = 0; i < 16; i++)
{ {
if (spurs->wklState2[i] == SPURS_WKL_STATE_RUNNABLE && if (spurs->wklState2[i] == SPURS_WKL_STATE_RUNNABLE &&
*((u64*)spurs->wklInfo2[i].priority) != 0 && std::bit_cast<u64>(spurs->wklInfo2[i].priority) != 0 &&
spurs->wklMaxContention[i] & 0xF0) spurs->wklMaxContention[i] & 0xF0)
{ {
if (spurs->wklIdleSpuCountOrReadyCount2[i] || if (spurs->wklIdleSpuCountOrReadyCount2[i] ||
spurs->wklSignal2.load() & (0x8000u >> i) || spurs->wklSignal2.load() & (0x8000u >> i) ||
(spurs->wklFlag.flag.load() == 0 && (spurs->wklFlag.flag.load() == 0 &&
spurs->wklFlagReceiver == (u8)i + 0x10)) spurs->wklFlagReceiver == static_cast<u8>(i) + 0x10))
{ {
foundRunnableWorkload = true; foundRunnableWorkload = true;
break; break;
@ -642,7 +642,7 @@ s32 _spurs::wakeup_shutdown_completion_waiter(ppu_thread& ppu, vm::ptr<CellSpurs
return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN; return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
} }
if (wid >= (u32)(spurs->flags1 & SF1_32_WORKLOADS ? CELL_SPURS_MAX_WORKLOAD2 : CELL_SPURS_MAX_WORKLOAD)) if (wid >= (spurs->flags1 & SF1_32_WORKLOADS ? CELL_SPURS_MAX_WORKLOAD2 : CELL_SPURS_MAX_WORKLOAD))
{ {
return CELL_SPURS_POLICY_MODULE_ERROR_INVAL; return CELL_SPURS_POLICY_MODULE_ERROR_INVAL;
} }
@ -676,7 +676,7 @@ s32 _spurs::wakeup_shutdown_completion_waiter(ppu_thread& ppu, vm::ptr<CellSpurs
if (!wklF->hook || wklEvent->load() & 0x10) if (!wklF->hook || wklEvent->load() & 0x10)
{ {
verify(HERE), (wklF->x28 == 2); verify(HERE), (wklF->x28 == 2);
rc = sys_semaphore_post(ppu, (u32)wklF->sem, 1); rc = sys_semaphore_post(ppu, static_cast<u32>(wklF->sem), 1);
} }
return rc; return rc;
@ -714,11 +714,11 @@ void _spurs::event_helper_entry(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
for (u32 i = 0; i < CELL_SPURS_MAX_WORKLOAD; i++) for (u32 i = 0; i < CELL_SPURS_MAX_WORKLOAD; i++)
{ {
sys_semaphore_post(ppu, (u32)spurs->wklF1[i].sem, 1); sys_semaphore_post(ppu, static_cast<u32>(spurs->wklF1[i].sem), 1);
if (spurs->flags1 & SF1_32_WORKLOADS) if (spurs->flags1 & SF1_32_WORKLOADS)
{ {
sys_semaphore_post(ppu, (u32)spurs->wklF2[i].sem, 1); sys_semaphore_post(ppu, static_cast<u32>(spurs->wklF2[i].sem), 1);
} }
} }
} }
@ -732,7 +732,7 @@ void _spurs::event_helper_entry(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
} }
else if (data0 < 1) else if (data0 < 1)
{ {
const u32 shutdownMask = (u32)event_data3; const u32 shutdownMask = static_cast<u32>(event_data3);
for (u32 wid = 0; wid < CELL_SPURS_MAX_WORKLOAD; wid++) for (u32 wid = 0; wid < CELL_SPURS_MAX_WORKLOAD; wid++)
{ {
@ -749,7 +749,7 @@ void _spurs::event_helper_entry(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
} }
else if (data0 == 2) else if (data0 == 2)
{ {
CHECK_SUCCESS(sys_semaphore_post(ppu, (u32)spurs->semPrv, 1)); CHECK_SUCCESS(sys_semaphore_post(ppu, static_cast<u32>(spurs->semPrv), 1));
} }
else if (data0 == 3) else if (data0 == 3)
{ {
@ -887,7 +887,7 @@ s32 _spurs::stop_event_helper(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
return CELL_SPURS_CORE_ERROR_STAT; return CELL_SPURS_CORE_ERROR_STAT;
} }
if (sys_ppu_thread_join(ppu, (u32)spurs->ppu1, vm::var<u64>{}) != CELL_OK) if (sys_ppu_thread_join(ppu, static_cast<u32>(spurs->ppu1), vm::var<u64>{}) != CELL_OK)
{ {
return CELL_SPURS_CORE_ERROR_STAT; return CELL_SPURS_CORE_ERROR_STAT;
} }
@ -918,7 +918,7 @@ s32 _spurs::join_handler_thread(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
return CELL_SPURS_CORE_ERROR_STAT; return CELL_SPURS_CORE_ERROR_STAT;
} }
CHECK_SUCCESS(sys_ppu_thread_join(ppu, (u32)spurs->ppu0, vm::var<u64>{})); CHECK_SUCCESS(sys_ppu_thread_join(ppu, static_cast<u32>(spurs->ppu0), vm::var<u64>{}));
spurs->ppu0 = 0xFFFFFFFF; spurs->ppu0 = 0xFFFFFFFF;
return CELL_OK; return CELL_OK;
@ -987,7 +987,7 @@ s32 _spurs::initialize(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 revision,
spurs->ppu0 = 0xffffffffull; spurs->ppu0 = 0xffffffffull;
spurs->ppu1 = 0xffffffffull; spurs->ppu1 = 0xffffffffull;
spurs->flags = flags; spurs->flags = flags;
spurs->prefixSize = (u8)prefixSize; spurs->prefixSize = static_cast<u8>(prefixSize);
std::memcpy(spurs->prefix, prefix.get_ptr(), prefixSize); std::memcpy(spurs->prefix, prefix.get_ptr(), prefixSize);
if (!isSecond) if (!isSecond)
@ -1063,7 +1063,7 @@ s32 _spurs::initialize(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 revision,
std::strcat(spuTgName.get_ptr(), "CellSpursKernelGroup"); std::strcat(spuTgName.get_ptr(), "CellSpursKernelGroup");
spuTgAttr->name = spuTgName; spuTgAttr->name = spuTgName;
spuTgAttr->nsize = (u32)strlen(spuTgAttr->name.get_ptr()) + 1; spuTgAttr->nsize = static_cast<u32>(std::strlen(spuTgAttr->name.get_ptr())) + 1;
spuTgAttr->type = SYS_SPU_THREAD_GROUP_TYPE_NORMAL; spuTgAttr->type = SYS_SPU_THREAD_GROUP_TYPE_NORMAL;
if (spurs->flags & SAF_UNKNOWN_FLAG_0) if (spurs->flags & SAF_UNKNOWN_FLAG_0)
@ -1102,15 +1102,15 @@ s32 _spurs::initialize(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 revision,
std::strcat(spuThName.get_ptr(), "CellSpursKernel"); std::strcat(spuThName.get_ptr(), "CellSpursKernel");
spuThAttr->name = spuThName; spuThAttr->name = spuThName;
spuThAttr->name_len = (u32)strlen(spuThName.get_ptr()) + 2; spuThAttr->name_len = static_cast<u32>(std::strlen(spuThName.get_ptr())) + 2;
spuThAttr->option = SYS_SPU_THREAD_OPTION_DEC_SYNC_TB_ENABLE; spuThAttr->option = SYS_SPU_THREAD_OPTION_DEC_SYNC_TB_ENABLE;
spuThName[spuThAttr->name_len - 1] = '\0'; spuThName[spuThAttr->name_len - 1] = '\0';
for (s32 num = 0; num < nSpus; num++) for (s32 num = 0; num < nSpus; num++)
{ {
spuThName[spuThAttr->name_len - 2] = '0' + num; spuThName[spuThAttr->name_len - 2] = '0' + num;
spuThArgs->arg1 = (u64)num << 32; spuThArgs->arg1 = static_cast<u64>(num) << 32;
spuThArgs->arg2 = (u64)spurs.addr(); spuThArgs->arg2 = spurs.addr();
if (s32 rc = sys_spu_thread_initialize(ppu, spurs.ptr(&CellSpurs::spus, num), spurs->spuTG, num, spurs.ptr(&CellSpurs::spuImg), spuThAttr, spuThArgs)) if (s32 rc = sys_spu_thread_initialize(ppu, spurs.ptr(&CellSpurs::spus, num), spurs->spuTG, num, spurs.ptr(&CellSpurs::spuImg), spuThAttr, spuThArgs))
{ {
@ -1469,7 +1469,7 @@ s32 cellSpursAttributeEnableSystemWorkload(vm::ptr<CellSpursAttribute> attr, vm:
} }
attr->flags |= SAF_SYSTEM_WORKLOAD_ENABLED; // set flag attr->flags |= SAF_SYSTEM_WORKLOAD_ENABLED; // set flag
*(u64*)attr->swlPriority = *(u64*)*priority; // copy system workload priorities std::memcpy(attr->swlPriority, priority.get_ptr(), 8);
u32 isPreem = 0; // generate mask from isPreemptible values u32 isPreem = 0; // generate mask from isPreemptible values
for (u32 j = 0; j < nSpus; j++) for (u32 j = 0; j < nSpus; j++)
@ -1633,7 +1633,7 @@ s32 cellSpursSetMaxContention(vm::ptr<CellSpurs> spurs, u32 wid, u32 maxContenti
} }
/// Set the priority of a workload on each SPU /// Set the priority of a workload on each SPU
s32 cellSpursSetPriorities(vm::ptr<CellSpurs> spurs, u32 wid, vm::cptr<u8> priorities) s32 cellSpursSetPriorities(vm::ptr<CellSpurs> spurs, u32 wid, vm::cptr<u8[8]> priorities)
{ {
cellSpurs.warning("cellSpursSetPriorities(spurs=*0x%x, wid=%d, priorities=*0x%x)", spurs, wid, priorities); cellSpurs.warning("cellSpursSetPriorities(spurs=*0x%x, wid=%d, priorities=*0x%x)", spurs, wid, priorities);
@ -1667,20 +1667,16 @@ s32 cellSpursSetPriorities(vm::ptr<CellSpurs> spurs, u32 wid, vm::cptr<u8> prior
// TODO: Implement this // TODO: Implement this
} }
u64 prio = 0; const u64 prio = std::bit_cast<u64>(*priorities);
for (s32 i = 0; i < CELL_SPURS_MAX_SPU; i++)
{
if (priorities[i] >= CELL_SPURS_MAX_PRIORITY)
{
return CELL_SPURS_CORE_ERROR_INVAL;
}
prio |= priorities[i]; // Test if any of the value >= CELL_SPURS_MAX_PRIORITY
prio <<= 8; if (prio & 0xf0f0f0f0f0f0f0f0)
{
return CELL_SPURS_CORE_ERROR_INVAL;
} }
const auto wklInfo = wid < CELL_SPURS_MAX_WORKLOAD ? &spurs->wklInfo1[wid] : &spurs->wklInfo2[wid]; const auto wklInfo = wid < CELL_SPURS_MAX_WORKLOAD ? &spurs->wklInfo1[wid] : &spurs->wklInfo2[wid];
*((be_t<u64>*)wklInfo->priority) = prio; std::memcpy(wklInfo->priority, &prio, 8);
spurs->sysSrvMsgUpdateWorkload = 0xff; spurs->sysSrvMsgUpdateWorkload = 0xff;
spurs->sysSrvMessage = 0xff; spurs->sysSrvMessage = 0xff;
@ -1831,7 +1827,7 @@ void _spurs::trace_status_update(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
if (init) if (init)
{ {
spurs->sysSrvMessage = 0xff; spurs->sysSrvMessage = 0xff;
CHECK_SUCCESS(sys_semaphore_wait(ppu, (u32)spurs->semPrv, 0)); CHECK_SUCCESS(sys_semaphore_wait(ppu, static_cast<u32>(spurs->semPrv), 0));
} }
} }
@ -2045,18 +2041,22 @@ s32 _cellSpursWorkloadAttributeInitialize(vm::ptr<CellSpursWorkloadAttribute> at
return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN; return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
} }
if (minCnt == 0 || *(u64*)*priority & 0xf0f0f0f0f0f0f0f0ull) // check if some priority > 15 // Load packed priorities (endian-agnostic)
const u64 prio = std::bit_cast<u64>(*priority);
// check if some priority > 15
if (minCnt == 0 || prio & 0xf0f0f0f0f0f0f0f0)
{ {
return CELL_SPURS_POLICY_MODULE_ERROR_INVAL; return CELL_SPURS_POLICY_MODULE_ERROR_INVAL;
} }
memset(attr.get_ptr(), 0, sizeof(CellSpursWorkloadAttribute)); std::memset(attr.get_ptr(), 0, sizeof(CellSpursWorkloadAttribute));
attr->revision = revision; attr->revision = revision;
attr->sdkVersion = sdkVersion; attr->sdkVersion = sdkVersion;
attr->pm = pm; attr->pm = pm;
attr->size = size; attr->size = size;
attr->data = data; attr->data = data;
*(u64*)attr->priority = *(u64*)*priority; std::memcpy(attr->priority, &prio, 8);
attr->minContention = minCnt; attr->minContention = minCnt;
attr->maxContention = maxCnt; attr->maxContention = maxCnt;
return CELL_OK; return CELL_OK;
@ -2102,7 +2102,7 @@ s32 cellSpursWorkloadAttributeSetShutdownCompletionEventHook(vm::ptr<CellSpursWo
return CELL_OK; return CELL_OK;
} }
s32 _spurs::add_workload(vm::ptr<CellSpurs> spurs, vm::ptr<u32> wid, vm::cptr<void> pm, u32 size, u64 data, const u8 priorityTable[], u32 minContention, u32 maxContention, vm::cptr<char> nameClass, vm::cptr<char> nameInstance, vm::ptr<CellSpursShutdownCompletionEventHook> hook, vm::ptr<void> hookArg) s32 _spurs::add_workload(vm::ptr<CellSpurs> spurs, vm::ptr<u32> wid, vm::cptr<void> pm, u32 size, u64 data, const u8(&priorityTable)[8], u32 minContention, u32 maxContention, vm::cptr<char> nameClass, vm::cptr<char> nameInstance, vm::ptr<CellSpursShutdownCompletionEventHook> hook, vm::ptr<void> hookArg)
{ {
if (!spurs || !wid || !pm) if (!spurs || !wid || !pm)
{ {
@ -2114,7 +2114,7 @@ s32 _spurs::add_workload(vm::ptr<CellSpurs> spurs, vm::ptr<u32> wid, vm::cptr<vo
return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN; return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
} }
if (minContention == 0 || *(u64*)priorityTable & 0xf0f0f0f0f0f0f0f0ull) // check if some priority > 15 if (minContention == 0 || std::bit_cast<u64>(priorityTable) & 0xf0f0f0f0f0f0f0f0ull) // check if some priority > 15
{ {
return CELL_SPURS_POLICY_MODULE_ERROR_INVAL; return CELL_SPURS_POLICY_MODULE_ERROR_INVAL;
} }
@ -2128,10 +2128,10 @@ s32 _spurs::add_workload(vm::ptr<CellSpurs> spurs, vm::ptr<u32> wid, vm::cptr<vo
const u32 wmax = spurs->flags1 & SF1_32_WORKLOADS ? 0x20u : 0x10u; // TODO: check if can be changed const u32 wmax = spurs->flags1 & SF1_32_WORKLOADS ? 0x20u : 0x10u; // TODO: check if can be changed
spurs->wklEnabled.atomic_op([spurs, wmax, &wnum](be_t<u32>& value) spurs->wklEnabled.atomic_op([spurs, wmax, &wnum](be_t<u32>& value)
{ {
wnum = utils::cntlz32(~(u32)value); // found empty position wnum = utils::cntlz32(~value); // found empty position
if (wnum < wmax) if (wnum < wmax)
{ {
value |= (u32)(0x80000000ull >> wnum); // set workload bit value |= (0x80000000 >> wnum); // set workload bit
} }
}); });
@ -2256,7 +2256,7 @@ s32 _spurs::add_workload(vm::ptr<CellSpurs> spurs, vm::ptr<u32> wid, vm::cptr<vo
} }
} }
wkl->uniqueId.exchange((u8)res_wkl); wkl->uniqueId.exchange(static_cast<u8>(res_wkl));
v = mask | (0x80000000u >> wnum); v = mask | (0x80000000u >> wnum);
}); });
@ -2453,11 +2453,11 @@ s32 cellSpursReadyCountStore(vm::ptr<CellSpurs> spurs, u32 wid, u32 value)
if (wid < CELL_SPURS_MAX_WORKLOAD) if (wid < CELL_SPURS_MAX_WORKLOAD)
{ {
spurs->wklReadyCount1[wid].exchange((u8)value); spurs->wklReadyCount1[wid].exchange(static_cast<u8>(value));
} }
else else
{ {
spurs->wklIdleSpuCountOrReadyCount2[wid].exchange((u8)value); spurs->wklIdleSpuCountOrReadyCount2[wid].exchange(static_cast<u8>(value));
} }
return CELL_OK; return CELL_OK;
@ -2608,7 +2608,7 @@ s32 _cellSpursWorkloadFlagReceiver(vm::ptr<CellSpurs> spurs, u32 wid, u32 is_set
{ {
if (FR == 0xff) if (FR == 0xff)
{ {
FR = (u8)wid; FR = static_cast<u8>(wid);
} }
} }
else else
@ -2810,11 +2810,11 @@ s32 cellSpursEventFlagSet(ppu_thread& ppu, vm::ptr<CellSpursEventFlag> eventFlag
vm::var<vm::ptr<CellSpursTaskset>> taskset; vm::var<vm::ptr<CellSpursTaskset>> taskset;
if (eventFlag->isIwl) if (eventFlag->isIwl)
{ {
cellSpursLookUpTasksetAddress(ppu, vm::ptr<CellSpurs>::make((u32)eventFlag->addr), taskset, eventFlag->waitingTaskWklId[i]); cellSpursLookUpTasksetAddress(ppu, vm::cast(eventFlag->addr, HERE), taskset, eventFlag->waitingTaskWklId[i]);
} }
else else
{ {
taskset->set((u32)eventFlag->addr); *taskset = vm::cast(eventFlag->addr, HERE);
} }
auto rc = _cellSpursSendSignal(ppu, *taskset, eventFlag->waitingTaskId[i]); auto rc = _cellSpursSendSignal(ppu, *taskset, eventFlag->waitingTaskId[i]);
@ -2978,7 +2978,7 @@ s32 _spurs::event_flag_wait(ppu_thread& ppu, vm::ptr<CellSpursEventFlag> eventFl
} }
*mask = eventFlag->pendingRecvTaskEvents[i]; *mask = eventFlag->pendingRecvTaskEvents[i];
((CellSpursEventFlag::ControlSyncVar&)eventFlag->ctrl).ppuPendingRecv = 0; eventFlag->ctrl.atomic_op([](auto& ctrl) { ctrl.ppuPendingRecv = 0; });
} }
*mask = receivedEvents; *mask = receivedEvents;
@ -3029,11 +3029,11 @@ s32 cellSpursEventFlagAttachLv2EventQueue(ppu_thread& ppu, vm::ptr<CellSpursEven
vm::ptr<CellSpurs> spurs; vm::ptr<CellSpurs> spurs;
if (eventFlag->isIwl == 1) if (eventFlag->isIwl == 1)
{ {
spurs.set((u32)eventFlag->addr); spurs = vm::cast(eventFlag->addr, HERE);
} }
else else
{ {
auto taskset = vm::ptr<CellSpursTaskset>::make((u32)eventFlag->addr); auto taskset = vm::ptr<CellSpursTaskset>::make(vm::cast(eventFlag->addr, HERE));
spurs = taskset->spurs; spurs = taskset->spurs;
} }
@ -3122,11 +3122,11 @@ s32 cellSpursEventFlagDetachLv2EventQueue(ppu_thread& ppu, vm::ptr<CellSpursEven
vm::ptr<CellSpurs> spurs; vm::ptr<CellSpurs> spurs;
if (eventFlag->isIwl == 1) if (eventFlag->isIwl == 1)
{ {
spurs.set((u32)eventFlag->addr); spurs = vm::cast(eventFlag->addr, HERE);
} }
else else
{ {
auto taskset = vm::ptr<CellSpursTaskset>::make((u32)eventFlag->addr); auto taskset = vm::ptr<CellSpursTaskset>::make(vm::cast(eventFlag->addr, HERE));
spurs = taskset->spurs; spurs = taskset->spurs;
} }
@ -3904,7 +3904,7 @@ s32 cellSpursLookUpTasksetAddress(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm:
return rc ^ 0x100; return rc ^ 0x100;
} }
taskset->set((u32)*data); *taskset = vm::cast(*data, HERE);
return CELL_OK; return CELL_OK;
} }
@ -3927,7 +3927,7 @@ s32 cellSpursTasksetGetSpursAddress(vm::cptr<CellSpursTaskset> taskset, vm::ptr<
return CELL_SPURS_TASK_ERROR_INVAL; return CELL_SPURS_TASK_ERROR_INVAL;
} }
*spurs = (u32)taskset->spurs.addr(); *spurs = vm::cast(taskset->spurs.addr(), HERE);
return CELL_OK; return CELL_OK;
} }

22
rpcs3/Emu/Cell/Modules/cellSpursSpu.cpp
View file

@ -107,7 +107,7 @@ u32 cellSpursModulePollStatus(spu_thread& spu, u32* status)
auto result = spu.gpr[3]._u64[1]; auto result = spu.gpr[3]._u64[1];
if (status) if (status)
{ {
*status = (u32)result; *status = static_cast<u32>(result);
} }
u32 wklId = result >> 32; u32 wklId = result >> 32;
@ -126,8 +126,8 @@ void cellSpursModuleExit(spu_thread& spu)
bool spursDma(spu_thread& spu, u32 cmd, u64 ea, u32 lsa, u32 size, u32 tag) bool spursDma(spu_thread& spu, u32 cmd, u64 ea, u32 lsa, u32 size, u32 tag)
{ {
spu.set_ch_value(MFC_LSA, lsa); spu.set_ch_value(MFC_LSA, lsa);
spu.set_ch_value(MFC_EAH, (u32)(ea >> 32)); spu.set_ch_value(MFC_EAH, static_cast<u32>(ea >> 32));
spu.set_ch_value(MFC_EAL, (u32)(ea)); spu.set_ch_value(MFC_EAL, static_cast<u32>(ea));
spu.set_ch_value(MFC_Size, size); spu.set_ch_value(MFC_Size, size);
spu.set_ch_value(MFC_TagID, tag); spu.set_ch_value(MFC_TagID, tag);
spu.set_ch_value(MFC_Cmd, cmd); spu.set_ch_value(MFC_Cmd, cmd);
@ -330,7 +330,7 @@ bool spursKernel1SelectWorkload(spu_thread& spu)
// 6. Is the workload executable same as the currently loaded executable // 6. Is the workload executable same as the currently loaded executable
// 7. The workload id (lesser the number, more the weight) // 7. The workload id (lesser the number, more the weight)
u16 weight = (wklFlag || wklSignal || (readyCount > contention[i])) ? 0x8000 : 0; u16 weight = (wklFlag || wklSignal || (readyCount > contention[i])) ? 0x8000 : 0;
weight |= (u16)(ctxt->priority[i] & 0x7F) << 16; weight |= (ctxt->priority[i] & 0x7F) << 8; // TODO: was shifted << 16
weight |= i == ctxt->wklCurrentId ? 0x80 : 0x00; weight |= i == ctxt->wklCurrentId ? 0x80 : 0x00;
weight |= (contention[i] > 0 && spurs->wklMinContention[i] > contention[i]) ? 0x40 : 0x00; weight |= (contention[i] > 0 && spurs->wklMinContention[i] > contention[i]) ? 0x40 : 0x00;
weight |= ((CELL_SPURS_MAX_SPU - contention[i]) & 0x0F) << 2; weight |= ((CELL_SPURS_MAX_SPU - contention[i]) & 0x0F) << 2;
@ -424,7 +424,7 @@ bool spursKernel1SelectWorkload(spu_thread& spu)
std::memcpy(vm::base(spu.offset + 0x100), spurs, 128); std::memcpy(vm::base(spu.offset + 0x100), spurs, 128);
}//); }//);
u64 result = (u64)wklSelectedId << 32; u64 result = u64{wklSelectedId} << 32;
result |= pollStatus; result |= pollStatus;
spu.gpr[3]._u64[1] = result; spu.gpr[3]._u64[1] = result;
return true; return true;
@ -597,7 +597,7 @@ bool spursKernel2SelectWorkload(spu_thread& spu)
std::memcpy(vm::base(spu.offset + 0x100), spurs, 128); std::memcpy(vm::base(spu.offset + 0x100), spurs, 128);
}//); }//);
u64 result = (u64)wklSelectedId << 32; u64 result = u64{wklSelectedId} << 32;
result |= pollStatus; result |= pollStatus;
spu.gpr[3]._u64[1] = result; spu.gpr[3]._u64[1] = result;
return true; return true;
@ -609,8 +609,8 @@ void spursKernelDispatchWorkload(spu_thread& spu, u64 widAndPollStatus)
auto ctxt = vm::_ptr<SpursKernelContext>(spu.offset + 0x100); auto ctxt = vm::_ptr<SpursKernelContext>(spu.offset + 0x100);
auto isKernel2 = ctxt->spurs->flags1 & SF1_32_WORKLOADS ? true : false; auto isKernel2 = ctxt->spurs->flags1 & SF1_32_WORKLOADS ? true : false;
auto pollStatus = (u32)widAndPollStatus; auto pollStatus = static_cast<u32>(widAndPollStatus);
auto wid = (u32)(widAndPollStatus >> 32); auto wid = static_cast<u32>(widAndPollStatus >> 32);
// DMA in the workload info for the selected workload // DMA in the workload info for the selected workload
auto wklInfoOffset = wid < CELL_SPURS_MAX_WORKLOAD ? &ctxt->spurs->wklInfo1[wid] : auto wklInfoOffset = wid < CELL_SPURS_MAX_WORKLOAD ? &ctxt->spurs->wklInfo1[wid] :
@ -718,7 +718,7 @@ bool spursKernelEntry(spu_thread& spu)
//spu.RegisterHleFunction(ctxt->selectWorkloadAddr, isKernel2 ? spursKernel2SelectWorkload : spursKernel1SelectWorkload); //spu.RegisterHleFunction(ctxt->selectWorkloadAddr, isKernel2 ? spursKernel2SelectWorkload : spursKernel1SelectWorkload);
// Start the system service // Start the system service
spursKernelDispatchWorkload(spu, ((u64)CELL_SPURS_SYS_SERVICE_WORKLOAD_ID) << 32); spursKernelDispatchWorkload(spu, u64{CELL_SPURS_SYS_SERVICE_WORKLOAD_ID} << 32);
return false; return false;
} }
@ -1167,7 +1167,7 @@ void spursSysServiceTraceSaveCount(spu_thread& spu, SpursKernelContext* ctxt)
{ {
if (ctxt->traceBuffer) if (ctxt->traceBuffer)
{ {
auto traceInfo = vm::ptr<CellSpursTraceInfo>::make((u32)(ctxt->traceBuffer - (ctxt->spurs->traceStartIndex[ctxt->spuNum] << 4))); auto traceInfo = vm::ptr<CellSpursTraceInfo>::make(vm::cast(ctxt->traceBuffer - (ctxt->spurs->traceStartIndex[ctxt->spuNum] << 4)));
traceInfo->count[ctxt->spuNum] = ctxt->traceMsgCount; traceInfo->count[ctxt->spuNum] = ctxt->traceMsgCount;
} }
} }
@ -1787,7 +1787,7 @@ void spursTasksetDispatch(spu_thread& spu)
if ((elfAddr & 5) == 1) if ((elfAddr & 5) == 1)
{ {
std::memcpy(vm::base(spu.offset + 0x2FC0), &((CellSpursTaskset2*)(ctxt->taskset.get_ptr()))->task_exit_code[taskId], 0x10); std::memcpy(vm::base(spu.offset + 0x2FC0), &vm::_ptr<CellSpursTaskset2>(vm::cast(ctxt->taskset.addr()))->task_exit_code[taskId], 0x10);
} }
// Trace - GUID // Trace - GUID

2
rpcs3/Emu/Cell/Modules/cellSsl.cpp
View file

@ -117,7 +117,7 @@ error_code cellSslCertificateLoader(u64 flag, vm::ptr<char> buffer, u32 size, vm
if (!flagBits[i-1]) if (!flagBits[i-1])
continue; continue;
// If we're loading cert 6 (the baltimore cert), then we need set that we're loading the 'normal' set of certs. // If we're loading cert 6 (the baltimore cert), then we need set that we're loading the 'normal' set of certs.
*required += (u32)(getCert(certPath, i, flagBits[BaltimoreCert-1]).size()); *required += ::size32(getCert(certPath, i, flagBits[BaltimoreCert-1]));
} }
} }
else else

80
rpcs3/Emu/Cell/Modules/cellSync.cpp
View file

@ -902,20 +902,20 @@ error_code _cellSyncLFQueueGetPushPointer(ppu_thread& ppu, vm::ptr<CellSyncLFQue
{ {
push.m_h7 = 0; push.m_h7 = 0;
} }
if (isBlocking && useEventQueue && *(u32*)queue->m_bs == -1) if (isBlocking && useEventQueue && std::bit_cast<s32>(queue->m_bs) == -1)
{ {
return CELL_SYNC_ERROR_STAT; return CELL_SYNC_ERROR_STAT;
} }
s32 var2 = (s16)push.m_h8; s32 var2 = static_cast<s16>(push.m_h8);
s32 res; s32 res;
if (useEventQueue && ((s32)push.m_h5 != var2 || push.m_h7)) if (useEventQueue && (+push.m_h5 != var2 || push.m_h7))
{ {
res = CELL_SYNC_ERROR_BUSY; res = CELL_SYNC_ERROR_BUSY;
} }
else else
{ {
var2 -= (s32)(u16)queue->pop1.load().m_h1; var2 -= queue->pop1.load().m_h1;
if (var2 < 0) if (var2 < 0)
{ {
var2 += depth * 2; var2 += depth * 2;
@ -923,7 +923,7 @@ error_code _cellSyncLFQueueGetPushPointer(ppu_thread& ppu, vm::ptr<CellSyncLFQue
if (var2 < depth) if (var2 < depth)
{ {
const s32 _pointer = (s16)push.m_h8; const s32 _pointer = static_cast<s16>(push.m_h8);
*pointer = _pointer; *pointer = _pointer;
if (_pointer + 1 >= depth * 2) if (_pointer + 1 >= depth * 2)
{ {
@ -997,13 +997,13 @@ error_code _cellSyncLFQueueCompletePushPointer(ppu_thread& ppu, vm::ptr<CellSync
const auto old2 = queue->push3.load(); const auto old2 = queue->push3.load();
auto push3 = old2; auto push3 = old2;
s32 var1 = pointer - (u16)push3.m_h5; s32 var1 = pointer - push3.m_h5;
if (var1 < 0) if (var1 < 0)
{ {
var1 += depth * 2; var1 += depth * 2;
} }
s32 var2 = (s32)(s16)queue->pop1.load().m_h4 - (s32)(u16)queue->pop1.load().m_h1; s32 var2 = static_cast<s16>(queue->pop1.load().m_h4) - queue->pop1.load().m_h1;
if (var2 < 0) if (var2 < 0)
{ {
var2 += depth * 2; var2 += depth * 2;
@ -1019,9 +1019,9 @@ error_code _cellSyncLFQueueCompletePushPointer(ppu_thread& ppu, vm::ptr<CellSync
{ {
var9_ = 1 << var9_; var9_ = 1 << var9_;
} }
s32 var9 = utils::cntlz32((u32)(u16)~(var9_ | (u16)push3.m_h6)) - 16; // count leading zeros in u16 s32 var9 = utils::cntlz32(static_cast<u16>(~(var9_ | push3.m_h6))) - 16; // count leading zeros in u16
s32 var5 = (s32)(u16)push3.m_h6 | var9_; s32 var5 = push3.m_h6 | var9_;
if (var9 & 0x30) if (var9 & 0x30)
{ {
var5 = 0; var5 = 0;
@ -1031,7 +1031,7 @@ error_code _cellSyncLFQueueCompletePushPointer(ppu_thread& ppu, vm::ptr<CellSync
var5 <<= var9; var5 <<= var9;
} }
s32 var3 = (u16)push3.m_h5 + var9; s32 var3 = push3.m_h5 + var9;
if (var3 >= depth * 2) if (var3 >= depth * 2)
{ {
var3 -= depth * 2; var3 -= depth * 2;
@ -1054,7 +1054,7 @@ error_code _cellSyncLFQueueCompletePushPointer(ppu_thread& ppu, vm::ptr<CellSync
var8 += 0x1e; var8 += 0x1e;
} }
if (var9 > 1 && (u32)var8 > 1) if (var9 > 1 && static_cast<u32>(var8) > 1)
{ {
verify(HERE), (16 - var2 <= 1); verify(HERE), (16 - var2 <= 1);
} }
@ -1076,15 +1076,15 @@ error_code _cellSyncLFQueueCompletePushPointer(ppu_thread& ppu, vm::ptr<CellSync
} }
push2.pack = (pack & 0x83ff) | var12; push2.pack = (pack & 0x83ff) | var12;
var6 = (u16)queue->m_hs1[var11]; var6 = queue->m_hs1[var11];
} }
else else
{ {
var6 = -1; var6 = -1;
} }
push3.m_h5 = (u16)var3; push3.m_h5 = static_cast<u16>(var3);
push3.m_h6 = (u16)var5; push3.m_h6 = static_cast<u16>(var5);
if (queue->push2.compare_and_swap_test(old, push2)) if (queue->push2.compare_and_swap_test(old, push2))
{ {
@ -1093,7 +1093,7 @@ error_code _cellSyncLFQueueCompletePushPointer(ppu_thread& ppu, vm::ptr<CellSync
{ {
verify(HERE), (queue->push3.compare_and_swap_test(old2, push3)); verify(HERE), (queue->push3.compare_and_swap_test(old2, push3));
verify(HERE), (fpSendSignal); verify(HERE), (fpSendSignal);
return not_an_error(fpSendSignal(ppu, (u32)queue->m_eaSignal.addr(), var6)); return not_an_error(fpSendSignal(ppu, queue->m_eaSignal.addr(), var6));
} }
else else
{ {
@ -1164,7 +1164,7 @@ error_code _cellSyncLFQueuePushBody(ppu_thread& ppu, vm::ptr<CellSyncLFQueue> qu
const s32 depth = queue->m_depth; const s32 depth = queue->m_depth;
const s32 size = queue->m_size; const s32 size = queue->m_size;
const s32 pos = *position; const s32 pos = *position;
const u32 addr = vm::cast((u64)((queue->m_buffer.addr() & ~1ull) + size * (pos >= depth ? pos - depth : pos)), HERE); const u32 addr = vm::cast<u64>((queue->m_buffer.addr() & ~1ull) + size * (pos >= depth ? pos - depth : pos), HERE);
std::memcpy(vm::base(addr), buffer.get_ptr(), size); std::memcpy(vm::base(addr), buffer.get_ptr(), size);
if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY) if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY)
@ -1201,20 +1201,20 @@ error_code _cellSyncLFQueueGetPopPointer(ppu_thread& ppu, vm::ptr<CellSyncLFQueu
{ {
pop.m_h3 = 0; pop.m_h3 = 0;
} }
if (isBlocking && useEventQueue && *(u32*)queue->m_bs == -1) if (isBlocking && useEventQueue && std::bit_cast<s32>(queue->m_bs) == -1)
{ {
return CELL_SYNC_ERROR_STAT; return CELL_SYNC_ERROR_STAT;
} }
s32 var2 = (s32)(s16)pop.m_h4; s32 var2 = static_cast<s16>(pop.m_h4);
s32 res; s32 res;
if (useEventQueue && ((s32)(u16)pop.m_h1 != var2 || pop.m_h3)) if (useEventQueue && (static_cast<s32>(pop.m_h1) != var2 || pop.m_h3))
{ {
res = CELL_SYNC_ERROR_BUSY; res = CELL_SYNC_ERROR_BUSY;
} }
else else
{ {
var2 = (s32)(u16)queue->push1.load().m_h5 - var2; var2 = queue->push1.load().m_h5 - var2;
if (var2 < 0) if (var2 < 0)
{ {
var2 += depth * 2; var2 += depth * 2;
@ -1222,7 +1222,7 @@ error_code _cellSyncLFQueueGetPopPointer(ppu_thread& ppu, vm::ptr<CellSyncLFQueu
if (var2 > 0) if (var2 > 0)
{ {
const s32 _pointer = (s16)pop.m_h4; const s32 _pointer = static_cast<s16>(pop.m_h4);
*pointer = _pointer; *pointer = _pointer;
if (_pointer + 1 >= depth * 2) if (_pointer + 1 >= depth * 2)
{ {
@ -1297,13 +1297,13 @@ error_code _cellSyncLFQueueCompletePopPointer(ppu_thread& ppu, vm::ptr<CellSyncL
const auto old2 = queue->pop3.load(); const auto old2 = queue->pop3.load();
auto pop3 = old2; auto pop3 = old2;
s32 var1 = pointer - (u16)pop3.m_h1; s32 var1 = pointer - pop3.m_h1;
if (var1 < 0) if (var1 < 0)
{ {
var1 += depth * 2; var1 += depth * 2;
} }
s32 var2 = (s32)(s16)queue->push1.load().m_h8 - (s32)(u16)queue->push1.load().m_h5; s32 var2 = static_cast<s16>(queue->push1.load().m_h8) - queue->push1.load().m_h5;
if (var2 < 0) if (var2 < 0)
{ {
var2 += depth * 2; var2 += depth * 2;
@ -1319,9 +1319,9 @@ error_code _cellSyncLFQueueCompletePopPointer(ppu_thread& ppu, vm::ptr<CellSyncL
{ {
var9_ = 1 << var9_; var9_ = 1 << var9_;
} }
s32 var9 = utils::cntlz32((u32)(u16)~(var9_ | (u16)pop3.m_h2)) - 16; // count leading zeros in u16 s32 var9 = utils::cntlz32(static_cast<u16>(~(var9_ | pop3.m_h2))) - 16; // count leading zeros in u16
s32 var5 = (s32)(u16)pop3.m_h2 | var9_; s32 var5 = pop3.m_h2 | var9_;
if (var9 & 0x30) if (var9 & 0x30)
{ {
var5 = 0; var5 = 0;
@ -1331,7 +1331,7 @@ error_code _cellSyncLFQueueCompletePopPointer(ppu_thread& ppu, vm::ptr<CellSyncL
var5 <<= var9; var5 <<= var9;
} }
s32 var3 = (u16)pop3.m_h1 + var9; s32 var3 = pop3.m_h1 + var9;
if (var3 >= depth * 2) if (var3 >= depth * 2)
{ {
var3 -= depth * 2; var3 -= depth * 2;
@ -1358,7 +1358,7 @@ error_code _cellSyncLFQueueCompletePopPointer(ppu_thread& ppu, vm::ptr<CellSyncL
var8 += 0x1e; var8 += 0x1e;
} }
if (var9 > 1 && (u32)var8 > 1) if (var9 > 1 && static_cast<u32>(var8) > 1)
{ {
verify(HERE), (16 - var2 <= 1); verify(HERE), (16 - var2 <= 1);
} }
@ -1380,11 +1380,11 @@ error_code _cellSyncLFQueueCompletePopPointer(ppu_thread& ppu, vm::ptr<CellSyncL
} }
pop2.pack = (pack & 0x83ff) | var12; pop2.pack = (pack & 0x83ff) | var12;
var6 = (u16)queue->m_hs2[var11]; var6 = queue->m_hs2[var11];
} }
pop3.m_h1 = (u16)var3; pop3.m_h1 = static_cast<u16>(var3);
pop3.m_h2 = (u16)var5; pop3.m_h2 = static_cast<u16>(var5);
if (queue->pop2.compare_and_swap_test(old, pop2)) if (queue->pop2.compare_and_swap_test(old, pop2))
{ {
@ -1392,7 +1392,7 @@ error_code _cellSyncLFQueueCompletePopPointer(ppu_thread& ppu, vm::ptr<CellSyncL
{ {
verify(HERE), (queue->pop3.compare_and_swap_test(old2, pop3)); verify(HERE), (queue->pop3.compare_and_swap_test(old2, pop3));
verify(HERE), (fpSendSignal); verify(HERE), (fpSendSignal);
return not_an_error(fpSendSignal(ppu, (u32)queue->m_eaSignal.addr(), var6)); return not_an_error(fpSendSignal(ppu, queue->m_eaSignal.addr(), var6));
} }
else else
{ {
@ -1463,7 +1463,7 @@ error_code _cellSyncLFQueuePopBody(ppu_thread& ppu, vm::ptr<CellSyncLFQueue> que
const s32 depth = queue->m_depth; const s32 depth = queue->m_depth;
const s32 size = queue->m_size; const s32 size = queue->m_size;
const s32 pos = *position; const s32 pos = *position;
const u32 addr = vm::cast((u64)((queue->m_buffer.addr() & ~1) + size * (pos >= depth ? pos - depth : pos)), HERE); const u32 addr = vm::cast<u64>((queue->m_buffer.addr() & ~1) + size * (pos >= depth ? pos - depth : pos), HERE);
std::memcpy(buffer.get_ptr(), vm::base(addr), size); std::memcpy(buffer.get_ptr(), vm::base(addr), size);
if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY) if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY)
@ -1501,16 +1501,16 @@ error_code cellSyncLFQueueClear(vm::ptr<CellSyncLFQueue> queue)
s32 var1, var2; s32 var1, var2;
if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY) if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY)
{ {
var1 = var2 = (u16)queue->pop2.load().pack; var1 = var2 = queue->pop2.load().pack;
} }
else else
{ {
var1 = (u16)push.m_h7; var1 = push.m_h7;
var2 = (u16)pop.m_h3; var2 = pop.m_h3;
} }
if ((s32)(s16)pop.m_h4 != (s32)(u16)pop.m_h1 || if (static_cast<s16>(pop.m_h4) != +pop.m_h1 ||
(s32)(s16)push.m_h8 != (s32)(u16)push.m_h5 || static_cast<s16>(push.m_h8) != +push.m_h5 ||
((var2 >> 10) & 0x1f) != (var2 & 0x1f) || ((var2 >> 10) & 0x1f) != (var2 & 0x1f) ||
((var1 >> 10) & 0x1f) != (var1 & 0x1f)) ((var1 >> 10) & 0x1f) != (var1 & 0x1f))
{ {
@ -1547,8 +1547,8 @@ error_code cellSyncLFQueueSize(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u32> size
const auto old = queue->pop3.load(); const auto old = queue->pop3.load();
// Loads must be in this order // Loads must be in this order
u32 var1 = (u16)queue->pop1.load().m_h1; u32 var1 = queue->pop1.load().m_h1;
u32 var2 = (u16)queue->push1.load().m_h5; u32 var2 = queue->push1.load().m_h5;
if (queue->pop3.compare_and_swap_test(old, old)) if (queue->pop3.compare_and_swap_test(old, old))
{ {
@ -1558,7 +1558,7 @@ error_code cellSyncLFQueueSize(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u32> size
} }
else else
{ {
*size = var2 - var1 + (u32)queue->m_depth * 2; *size = var2 - var1 + queue->m_depth * 2;
} }
return CELL_OK; return CELL_OK;

20
rpcs3/Emu/Cell/Modules/cellVdec.cpp
View file

@ -557,7 +557,7 @@ error_code cellVdecEndSeq(u32 handle)
error_code cellVdecDecodeAu(u32 handle, CellVdecDecodeMode mode, vm::cptr<CellVdecAuInfo> auInfo) error_code cellVdecDecodeAu(u32 handle, CellVdecDecodeMode mode, vm::cptr<CellVdecAuInfo> auInfo)
{ {
cellVdec.trace("cellVdecDecodeAu(handle=0x%x, mode=%d, auInfo=*0x%x)", handle, (s32)mode, auInfo); cellVdec.trace("cellVdecDecodeAu(handle=0x%x, mode=%d, auInfo=*0x%x)", handle, +mode, auInfo);
const auto vdec = idm::get<vdec_context>(handle); const auto vdec = idm::get<vdec_context>(handle);
@ -758,14 +758,14 @@ error_code cellVdecGetPicItem(u32 handle, vm::pptr<CellVdecPicItem> picItem)
info->startAddr = 0x00000123; // invalid value (no address for picture) info->startAddr = 0x00000123; // invalid value (no address for picture)
info->size = align(av_image_get_buffer_size(vdec->ctx->pix_fmt, vdec->ctx->width, vdec->ctx->height, 1), 128); info->size = align(av_image_get_buffer_size(vdec->ctx->pix_fmt, vdec->ctx->width, vdec->ctx->height, 1), 128);
info->auNum = 1; info->auNum = 1;
info->auPts[0].lower = (u32)(pts); info->auPts[0].lower = static_cast<u32>(pts);
info->auPts[0].upper = (u32)(pts >> 32); info->auPts[0].upper = static_cast<u32>(pts >> 32);
info->auPts[1].lower = (u32)CODEC_TS_INVALID; info->auPts[1].lower = -1;
info->auPts[1].upper = (u32)CODEC_TS_INVALID; info->auPts[1].upper = -1;
info->auDts[0].lower = (u32)(dts); info->auDts[0].lower = static_cast<u32>(dts);
info->auDts[0].upper = (u32)(dts >> 32); info->auDts[0].upper = static_cast<u32>(dts >> 32);
info->auDts[1].lower = (u32)CODEC_TS_INVALID; info->auDts[1].lower = -1;
info->auDts[1].upper = (u32)CODEC_TS_INVALID; info->auDts[1].upper = -1;
info->auUserData[0] = usrd; info->auUserData[0] = usrd;
info->auUserData[1] = 0; info->auUserData[1] = 0;
info->status = CELL_OK; info->status = CELL_OK;
@ -912,7 +912,7 @@ error_code cellVdecGetPicItem(u32 handle, vm::pptr<CellVdecPicItem> picItem)
error_code cellVdecSetFrameRate(u32 handle, CellVdecFrameRate frc) error_code cellVdecSetFrameRate(u32 handle, CellVdecFrameRate frc)
{ {
cellVdec.trace("cellVdecSetFrameRate(handle=0x%x, frc=0x%x)", handle, (s32)frc); cellVdec.trace("cellVdecSetFrameRate(handle=0x%x, frc=0x%x)", handle, +frc);
const auto vdec = idm::get<vdec_context>(handle); const auto vdec = idm::get<vdec_context>(handle);

8
rpcs3/Emu/Cell/Modules/cellVoice.cpp
View file

@ -178,7 +178,7 @@ error_code cellVoiceCreatePort(vm::ptr<u32> portId, vm::cptr<CellVoicePortParam>
{ {
verify(HERE), ctr2 < CELLVOICE_MAX_PORT + 1; verify(HERE), ctr2 < CELLVOICE_MAX_PORT + 1;
std::tie(port, success) = manager->ports.try_emplace(::narrow<u16>((ctr2 << 8) | manager->id_ctr)); std::tie(port, success) = manager->ports.try_emplace(::narrow<u16>((ctr2 << 8) | manager->id_ctr));
} }
port->second.info = *pArg; port->second.info = *pArg;
@ -197,7 +197,7 @@ error_code cellVoiceDeletePort(u32 portId)
if (!manager->is_init) if (!manager->is_init)
return CELL_VOICE_ERROR_LIBVOICE_NOT_INIT; return CELL_VOICE_ERROR_LIBVOICE_NOT_INIT;
if (manager->ports.erase((u16)portId) == 0) if (manager->ports.erase(static_cast<u16>(portId)) == 0)
return CELL_VOICE_ERROR_TOPOLOGY; return CELL_VOICE_ERROR_TOPOLOGY;
return CELL_OK; return CELL_OK;
@ -601,7 +601,7 @@ error_code cellVoiceSetMuteFlagAll(u16 bMuted)
if (!manager->is_init) if (!manager->is_init)
return CELL_VOICE_ERROR_LIBVOICE_NOT_INIT; return CELL_VOICE_ERROR_LIBVOICE_NOT_INIT;
// Doesn't change port->bMute value // Doesn't change port->bMute value
return CELL_OK; return CELL_OK;
} }
@ -796,7 +796,7 @@ error_code cellVoiceWriteToIPort(u32 ips, vm::cptr<void> data, vm::ptr<u32> size
if (!manager->is_init) if (!manager->is_init)
return CELL_VOICE_ERROR_LIBVOICE_NOT_INIT; return CELL_VOICE_ERROR_LIBVOICE_NOT_INIT;
auto iport = manager->access_port(ips); auto iport = manager->access_port(ips);
if (!iport || iport->info.portType >= CELLVOICE_PORTTYPE_OUT_PCMAUDIO) if (!iport || iport->info.portType >= CELLVOICE_PORTTYPE_OUT_PCMAUDIO)

2
rpcs3/Emu/Cell/Modules/cellVoice.h
View file

@ -197,7 +197,7 @@ struct voice_manager
port_t* access_port(u32 id) port_t* access_port(u32 id)
{ {
// Upper 16 bits are ignored // Upper 16 bits are ignored
auto pos = ports.find((u16)id); auto pos = ports.find(static_cast<u16>(id));
if (pos == ports.end()) if (pos == ports.end())
{ {

16
rpcs3/Emu/Cell/Modules/cellVpost.cpp
View file

@ -76,15 +76,15 @@ s32 cellVpostExec(u32 handle, vm::cptr<u8> inPicBuff, vm::cptr<CellVpostCtrlPara
u32 oh = ctrlParam->outHeight; u32 oh = ctrlParam->outHeight;
//ctrlParam->inWindow; // ignored //ctrlParam->inWindow; // ignored
if (ctrlParam->inWindow.x) cellVpost.notice("*** inWindow.x = %d", (u32)ctrlParam->inWindow.x); if (ctrlParam->inWindow.x) cellVpost.notice("*** inWindow.x = %d", ctrlParam->inWindow.x);
if (ctrlParam->inWindow.y) cellVpost.notice("*** inWindow.y = %d", (u32)ctrlParam->inWindow.y); if (ctrlParam->inWindow.y) cellVpost.notice("*** inWindow.y = %d", ctrlParam->inWindow.y);
if (ctrlParam->inWindow.width != w) cellVpost.notice("*** inWindow.width = %d", (u32)ctrlParam->inWindow.width); if (ctrlParam->inWindow.width != w) cellVpost.notice("*** inWindow.width = %d", ctrlParam->inWindow.width);
if (ctrlParam->inWindow.height != h) cellVpost.notice("*** inWindow.height = %d", (u32)ctrlParam->inWindow.height); if (ctrlParam->inWindow.height != h) cellVpost.notice("*** inWindow.height = %d", ctrlParam->inWindow.height);
//ctrlParam->outWindow; // ignored //ctrlParam->outWindow; // ignored
if (ctrlParam->outWindow.x) cellVpost.notice("*** outWindow.x = %d", (u32)ctrlParam->outWindow.x); if (ctrlParam->outWindow.x) cellVpost.notice("*** outWindow.x = %d", ctrlParam->outWindow.x);
if (ctrlParam->outWindow.y) cellVpost.notice("*** outWindow.y = %d", (u32)ctrlParam->outWindow.y); if (ctrlParam->outWindow.y) cellVpost.notice("*** outWindow.y = %d", ctrlParam->outWindow.y);
if (ctrlParam->outWindow.width != ow) cellVpost.notice("*** outWindow.width = %d", (u32)ctrlParam->outWindow.width); if (ctrlParam->outWindow.width != ow) cellVpost.notice("*** outWindow.width = %d", ctrlParam->outWindow.width);
if (ctrlParam->outWindow.height != oh) cellVpost.notice("*** outWindow.height = %d", (u32)ctrlParam->outWindow.height); if (ctrlParam->outWindow.height != oh) cellVpost.notice("*** outWindow.height = %d", ctrlParam->outWindow.height);
//ctrlParam->execType; // ignored //ctrlParam->execType; // ignored
//ctrlParam->scalerType; // ignored //ctrlParam->scalerType; // ignored
//ctrlParam->ipcType; // ignored //ctrlParam->ipcType; // ignored

18
rpcs3/Emu/Cell/Modules/libmixer.cpp
View file

@ -194,7 +194,7 @@ s32 cellSSPlayerCreate(vm::ptr<u32> handle, vm::ptr<CellSSPlayerConfig> config)
p.m_channels = config->channels; p.m_channels = config->channels;
g_ssp.push_back(p); g_ssp.push_back(p);
*handle = (u32)g_ssp.size() - 1; *handle = ::size32(g_ssp) - 1;
return CELL_OK; return CELL_OK;
} }
@ -234,7 +234,7 @@ s32 cellSSPlayerSetWave(u32 handle, vm::ptr<CellSSPlayerWaveParam> waveInfo, vm:
g_ssp[handle].m_addr = waveInfo->addr; g_ssp[handle].m_addr = waveInfo->addr;
g_ssp[handle].m_samples = waveInfo->samples; g_ssp[handle].m_samples = waveInfo->samples;
g_ssp[handle].m_loop_start = waveInfo->loopStartOffset - 1; g_ssp[handle].m_loop_start = waveInfo->loopStartOffset - 1;
g_ssp[handle].m_loop_mode = commonInfo ? (u32)commonInfo->loopMode : CELL_SSPLAYER_ONESHOT; g_ssp[handle].m_loop_mode = commonInfo ? +commonInfo->loopMode : CELL_SSPLAYER_ONESHOT;
g_ssp[handle].m_position = waveInfo->startOffset - 1; g_ssp[handle].m_position = waveInfo->startOffset - 1;
return CELL_OK; return CELL_OK;
@ -351,7 +351,7 @@ struct surmixer_thread : ppu_thread
memset(g_surmx.mixdata, 0, sizeof(g_surmx.mixdata)); memset(g_surmx.mixdata, 0, sizeof(g_surmx.mixdata));
if (g_surmx.cb) if (g_surmx.cb)
{ {
g_surmx.cb(*this, g_surmx.cb_arg, (u32)g_surmx.mixcount, 256); g_surmx.cb(*this, g_surmx.cb_arg, static_cast<u32>(g_surmx.mixcount), 256);
lv2_obj::sleep(*this); lv2_obj::sleep(*this);
} }
@ -379,7 +379,7 @@ struct surmixer_thread : ppu_thread
{ {
pos_inc = -1; pos_inc = -1;
} }
s32 shift = i - (int)fpos; // change playback speed (simple and rough) s32 shift = i - static_cast<s32>(fpos); // change playback speed (simple and rough)
if (shift > 0) if (shift > 0)
{ {
// slow playback // slow playback
@ -397,15 +397,15 @@ struct surmixer_thread : ppu_thread
{ {
fpos += speed; fpos += speed;
} }
p.m_position += (u32)pos_inc; p.m_position += pos_inc;
if (p.m_channels == 1) // get mono data if (p.m_channels == 1) // get mono data
{ {
left = right = (float)v[pos] / 0x8000 * p.m_level; left = right = v[pos] / 32768.f * p.m_level;
} }
else if (p.m_channels == 2) // get stereo data else if (p.m_channels == 2) // get stereo data
{ {
left = (float)v[pos * 2 + 0] / 0x8000 * p.m_level; left = v[pos * 2 + 0] / 32768.f * p.m_level;
right = (float)v[pos * 2 + 1] / 0x8000 * p.m_level; right = v[pos * 2 + 1] / 32768.f * p.m_level;
} }
if (p.m_connected) // mix if (p.m_connected) // mix
{ {
@ -422,7 +422,7 @@ struct surmixer_thread : ppu_thread
} }
else if (p.m_loop_mode == CELL_SSPLAYER_ONESHOT_CONT) else if (p.m_loop_mode == CELL_SSPLAYER_ONESHOT_CONT)
{ {
p.m_position -= (u32)pos_inc; // restore position p.m_position -= pos_inc; // restore position
} }
else // oneshot else // oneshot
{ {

4
rpcs3/Emu/Cell/Modules/sceNp.h
View file

@ -480,7 +480,7 @@ enum SceNpCustomMenuActionMask : u32
enum enum
{ {
SCE_NP_CUSTOM_MENU_INDEX_BITS = (sizeof(SceNpCustomMenuIndexMask) * 8), SCE_NP_CUSTOM_MENU_INDEX_BITS = (sizeof(SceNpCustomMenuIndexMask) * 8),
SCE_NP_CUSTOM_MENU_INDEX_BITS_ALL = ((SceNpCustomMenuIndexMask) - 1), SCE_NP_CUSTOM_MENU_INDEX_BITS_ALL = (static_cast<SceNpCustomMenuIndexMask>(-1)),
SCE_NP_CUSTOM_MENU_INDEX_BITS_SHIFT = 5, SCE_NP_CUSTOM_MENU_INDEX_BITS_SHIFT = 5,
SCE_NP_CUSTOM_MENU_INDEX_BITS_MASK = (SCE_NP_CUSTOM_MENU_INDEX_BITS - 1), SCE_NP_CUSTOM_MENU_INDEX_BITS_MASK = (SCE_NP_CUSTOM_MENU_INDEX_BITS - 1),
SCE_NP_CUSTOM_MENU_INDEX_BITS_MAX = 127, SCE_NP_CUSTOM_MENU_INDEX_BITS_MAX = 127,
@ -587,7 +587,7 @@ enum SceNpBasicMessageSubType : u16
}; };
// Applicable features of messages // Applicable features of messages
#define SCE_NP_BASIC_MESSAGE_FEATURES_EXP_MIN(min) ((((u32)min << 16) | (0 << 15)) & 0xFFFF8000) #define SCE_NP_BASIC_MESSAGE_FEATURES_EXP_MIN(min) (((static_cast<u32>(min) << 16) | (0 << 15)) & 0xFFFF8000)
enum SceNpBasicMessageFeatures : u32 enum SceNpBasicMessageFeatures : u32
{ {
SCE_NP_BASIC_MESSAGE_FEATURES_MULTI_RECEIPIENTS = 0x00000001, SCE_NP_BASIC_MESSAGE_FEATURES_MULTI_RECEIPIENTS = 0x00000001,

10
rpcs3/Emu/Cell/Modules/sceNpTrophy.cpp
View file

@ -362,7 +362,7 @@ error_code sceNpTrophyRegisterContext(ppu_thread& ppu, u32 context, u32 handle,
} }
else if (!trp.ContainsEntry("TROPCONF.SFM")) else if (!trp.ContainsEntry("TROPCONF.SFM"))
{ {
sceNpTrophy.error("sceNpTrophyRegisterContext(): Invalid/Incomplete trophy config"); sceNpTrophy.error("sceNpTrophyRegisterContext(): Invalid/Incomplete trophy config");
return SCE_NP_TROPHY_ERROR_ILLEGAL_UPDATE; return SCE_NP_TROPHY_ERROR_ILLEGAL_UPDATE;
} }
@ -379,7 +379,7 @@ error_code sceNpTrophyRegisterContext(ppu_thread& ppu, u32 context, u32 handle,
std::string trophyPath = "/dev_hdd0/home/" + Emu.GetUsr() + "/trophy/" + ctxt->trp_name; std::string trophyPath = "/dev_hdd0/home/" + Emu.GetUsr() + "/trophy/" + ctxt->trp_name;
if (!trp.Install(trophyPath)) if (!trp.Install(trophyPath))
{ {
sceNpTrophy.error("sceNpTrophyRegisterContext(): Failed to install trophy context '%s' (%s)", trophyPath, fs::g_tls_error); sceNpTrophy.error("sceNpTrophyRegisterContext(): Failed to install trophy context '%s' (%s)", trophyPath, fs::g_tls_error);
return SCE_NP_TROPHY_ERROR_ILLEGAL_UPDATE; return SCE_NP_TROPHY_ERROR_ILLEGAL_UPDATE;
} }
@ -673,7 +673,7 @@ error_code sceNpTrophyUnlockTrophy(u32 context, u32 handle, s32 trophyId, vm::pt
return SCE_NP_TROPHY_ERROR_UNKNOWN_HANDLE; return SCE_NP_TROPHY_ERROR_UNKNOWN_HANDLE;
} }
if (trophyId < 0 || trophyId >= (s32)ctxt->tropusr->GetTrophiesCount()) if (trophyId < 0 || trophyId >= static_cast<s32>(ctxt->tropusr->GetTrophiesCount()))
return SCE_NP_TROPHY_ERROR_INVALID_TROPHY_ID; return SCE_NP_TROPHY_ERROR_INVALID_TROPHY_ID;
if (ctxt->tropusr->GetTrophyUnlockState(trophyId)) if (ctxt->tropusr->GetTrophyUnlockState(trophyId))
return SCE_NP_TROPHY_ERROR_ALREADY_UNLOCKED; return SCE_NP_TROPHY_ERROR_ALREADY_UNLOCKED;
@ -931,7 +931,7 @@ error_code sceNpTrophyGetGameProgress(u32 context, u32 handle, vm::ptr<s32> perc
} }
} }
*percentage = (s32)(accuratePercentage / ctxt->tropusr->GetTrophiesCount()); *percentage = static_cast<s32>(accuratePercentage / ctxt->tropusr->GetTrophiesCount());
return CELL_OK; return CELL_OK;
} }
@ -1017,7 +1017,7 @@ error_code sceNpTrophyGetTrophyIcon(u32 context, u32 handle, s32 trophyId, vm::p
return SCE_NP_TROPHY_ERROR_INVALID_ARGUMENT; return SCE_NP_TROPHY_ERROR_INVALID_ARGUMENT;
} }
if (ctxt->tropusr->GetTrophiesCount() <= (u32)trophyId) if (ctxt->tropusr->GetTrophiesCount() <= static_cast<u32>(trophyId))
{ {
return SCE_NP_TROPHY_ERROR_INVALID_TROPHY_ID; return SCE_NP_TROPHY_ERROR_INVALID_TROPHY_ID;
} }

8
rpcs3/Emu/Cell/Modules/sys_game.cpp
View file

@ -21,7 +21,7 @@ static u32 get_string_array_size(vm::cpptr<char> list, u32& out_count)
if (const vm::cptr<char> str = list[i]) if (const vm::cptr<char> str = list[i])
{ {
out_count++; out_count++;
result += (((u32)std::strlen(str.get_ptr()) + 0x10) & -0x10) + 8; result += ((static_cast<u32>(std::strlen(str.get_ptr())) + 0x10) & -0x10) + 8;
continue; continue;
} }
break; break;
@ -35,7 +35,7 @@ static u32 get_exitspawn_size(vm::cptr<char> path, vm::cpptr<char> argv, vm::cpp
arg_count = 1; arg_count = 1;
env_count = 0; env_count = 0;
u32 result = (((u32)std::strlen(path.get_ptr()) + 0x10) & -0x10) + 8; u32 result = ((static_cast<u32>(std::strlen(path.get_ptr())) + 0x10) & -0x10) + 8;
result += get_string_array_size(argv, arg_count); result += get_string_array_size(argv, arg_count);
result += get_string_array_size(envp, env_count); result += get_string_array_size(envp, env_count);
@ -51,7 +51,7 @@ static void put_string_array(vm::pptr<char, u32, u64> pstr, vm::ptr<char>& str,
{ {
for (u32 i = 0; i < count; i++) for (u32 i = 0; i < count; i++)
{ {
const u32 len = (u32)std::strlen(list[i].get_ptr()); const u32 len = static_cast<u32>(std::strlen(list[i].get_ptr()));
std::memcpy(str.get_ptr(), list[i].get_ptr(), len + 1); std::memcpy(str.get_ptr(), list[i].get_ptr(), len + 1);
pstr[i] = str; pstr[i] = str;
str += (len + 0x10) & -0x10; str += (len + 0x10) & -0x10;
@ -65,7 +65,7 @@ static void put_exitspawn(vm::ptr<void> out, vm::cptr<char> path, u32 argc, vm::
vm::pptr<char, u32, u64> pstr = vm::cast(out.addr()); vm::pptr<char, u32, u64> pstr = vm::cast(out.addr());
vm::ptr<char> str = vm::static_ptr_cast<char>(out) + (argc + envc + (argc + envc) % 2) * 8 + 0x10; vm::ptr<char> str = vm::static_ptr_cast<char>(out) + (argc + envc + (argc + envc) % 2) * 8 + 0x10;
const u32 len = (u32)std::strlen(path.get_ptr()); const u32 len = static_cast<u32>(std::strlen(path.get_ptr()));
std::memcpy(str.get_ptr(), path.get_ptr(), len + 1); std::memcpy(str.get_ptr(), path.get_ptr(), len + 1);
*pstr++ = str; *pstr++ = str;
str += (len + 0x10) & -0x10; str += (len + 0x10) & -0x10;

6
rpcs3/Emu/Cell/Modules/sys_libc_.cpp
View file

@ -24,13 +24,13 @@ struct ps3_fmt_src
template <typename T> template <typename T>
T get(std::size_t index) const T get(std::size_t index) const
{ {
const u32 i = (u32)index + g_count; const u32 i = static_cast<u32>(index) + g_count;
return ppu_gpr_cast<T>(i < 8 ? ctx->gpr[3 + i] : +*ctx->get_stack_arg(i)); return ppu_gpr_cast<T>(i < 8 ? ctx->gpr[3 + i] : +*ctx->get_stack_arg(i));
} }
void skip(std::size_t extra) void skip(std::size_t extra)
{ {
g_count += (u32)extra + 1; g_count += static_cast<u32>(extra) + 1;
} }
std::size_t fmt_string(std::string& out, std::size_t extra) const std::size_t fmt_string(std::string& out, std::size_t extra) const
@ -404,7 +404,7 @@ s32 _sys_snprintf(ppu_thread& ppu, vm::ptr<char> dst, u32 count, vm::cptr<char>
} }
else else
{ {
count = (u32)std::min<size_t>(count - 1, result.size()); count = static_cast<u32>(std::min<size_t>(count - 1, result.size()));
std::memcpy(dst.get_ptr(), result.c_str(), count); std::memcpy(dst.get_ptr(), result.c_str(), count);
dst[count] = 0; dst[count] = 0;

82
rpcs3/Emu/Cell/PPUThread.cpp
View file

@ -170,7 +170,7 @@ extern void ppu_execute_syscall(ppu_thread& ppu, u64 code);
template<typename T = u64> template<typename T = u64>
static T& ppu_ref(u32 addr) static T& ppu_ref(u32 addr)
{ {
return *reinterpret_cast<T*>(vm::g_exec_addr + (u64)addr * 2); return *reinterpret_cast<T*>(vm::g_exec_addr + u64{addr} * 2);
} }
// Get interpreter cache value // Get interpreter cache value
@ -183,7 +183,7 @@ static u64 ppu_cache(u32 addr)
(fmt::throw_exception("Invalid PPU decoder"), nullptr)); (fmt::throw_exception("Invalid PPU decoder"), nullptr));
const u32 value = vm::read32(addr); const u32 value = vm::read32(addr);
return (u64)value << 32 | ::narrow<u32>(reinterpret_cast<std::uintptr_t>(table[ppu_decode(value)])); return u64{value} << 32 | ::narrow<u32>(reinterpret_cast<std::uintptr_t>(table[ppu_decode(value)]));
} }
static bool ppu_fallback(ppu_thread& ppu, ppu_opcode_t op) static bool ppu_fallback(ppu_thread& ppu, ppu_opcode_t op)
@ -212,14 +212,14 @@ void ppu_recompiler_fallback(ppu_thread& ppu)
while (true) while (true)
{ {
// Run instructions in interpreter // Run instructions in interpreter
if (const u32 op = *reinterpret_cast<u32*>(cache + (u64)ppu.cia * 2 + 4); if (const u32 op = *reinterpret_cast<u32*>(cache + u64{ppu.cia} * 2 + 4);
LIKELY(table[ppu_decode(op)](ppu, { op }))) LIKELY(table[ppu_decode(op)](ppu, { op })))
{ {
ppu.cia += 4; ppu.cia += 4;
continue; continue;
} }
if (uptr func = *reinterpret_cast<u32*>(cache + (u64)ppu.cia * 2); if (uptr func = *reinterpret_cast<u32*>(cache + u64{ppu.cia} * 2);
func != reinterpret_cast<uptr>(ppu_recompiler_fallback)) func != reinterpret_cast<uptr>(ppu_recompiler_fallback))
{ {
// We found a recompiler function at cia, return // We found a recompiler function at cia, return
@ -251,7 +251,7 @@ static bool ppu_check_toc(ppu_thread& ppu, ppu_opcode_t op)
} }
// Fallback to the interpreter function // Fallback to the interpreter function
if (reinterpret_cast<decltype(&ppu_interpreter::UNK)>(std::uintptr_t{(u32)ppu_cache(ppu.cia)})(ppu, op)) if (reinterpret_cast<decltype(&ppu_interpreter::UNK)>(ppu_cache(ppu.cia) & 0xffffffff)(ppu, op))
{ {
ppu.cia += 4; ppu.cia += 4;
} }
@ -277,7 +277,7 @@ extern void ppu_register_range(u32 addr, u32 size)
size &= ~3; // Loop assumes `size = n * 4`, enforce that by rounding down size &= ~3; // Loop assumes `size = n * 4`, enforce that by rounding down
while (size) while (size)
{ {
ppu_ref(addr) = (u64)vm::read32(addr) << 32 | fallback; ppu_ref(addr) = u64{vm::read32(addr)} << 32 | fallback;
addr += 4; addr += 4;
size -= 4; size -= 4;
} }
@ -336,7 +336,7 @@ static bool ppu_break(ppu_thread& ppu, ppu_opcode_t op)
} }
// Fallback to the interpreter function // Fallback to the interpreter function
if (reinterpret_cast<decltype(&ppu_interpreter::UNK)>(std::uintptr_t{(u32)ppu_cache(ppu.cia)})(ppu, op)) if (reinterpret_cast<decltype(&ppu_interpreter::UNK)>(ppu_cache(ppu.cia) & 0xffffffff)(ppu, op))
{ {
ppu.cia += 4; ppu.cia += 4;
} }
@ -604,7 +604,7 @@ void ppu_thread::cpu_task()
} }
default: default:
{ {
fmt::throw_exception("Unknown ppu_cmd(0x%x)" HERE, (u32)type); fmt::throw_exception("Unknown ppu_cmd(0x%x)" HERE, static_cast<u32>(type));
} }
} }
} }
@ -645,7 +645,7 @@ void ppu_thread::exec_task()
{ {
const auto exec_op = [this](u64 op) const auto exec_op = [this](u64 op)
{ {
return reinterpret_cast<func_t>((uptr)(u32)op)(*this, {u32(op >> 32)}); return reinterpret_cast<func_t>(op & 0xffffffff)(*this, {static_cast<u32>(op >> 32)});
}; };
if (cia % 8 || UNLIKELY(state)) if (cia % 8 || UNLIKELY(state))
@ -653,12 +653,12 @@ void ppu_thread::exec_task()
if (test_stopped()) return; if (test_stopped()) return;
// Decode single instruction (may be step) // Decode single instruction (may be step)
if (exec_op(*reinterpret_cast<u64*>(cache + (u64)cia * 2))) { cia += 4; } if (exec_op(*reinterpret_cast<u64*>(cache + u64{cia} * 2))) { cia += 4; }
continue; continue;
} }
u64 op0, op1, op2, op3; u64 op0, op1, op2, op3;
u64 _pos = (u64)cia * 2; u64 _pos = u64{cia} * 2;
// Reinitialize // Reinitialize
{ {
@ -887,7 +887,7 @@ u32 ppu_thread::stack_push(u32 size, u32 align_v)
const u32 old_pos = vm::cast(context.gpr[1], HERE); const u32 old_pos = vm::cast(context.gpr[1], HERE);
context.gpr[1] -= align(size + 4, 8); // room minimal possible size context.gpr[1] -= align(size + 4, 8); // room minimal possible size
context.gpr[1] &= ~((u64)align_v - 1); // fix stack alignment context.gpr[1] &= ~(u64{align_v} - 1); // fix stack alignment
if (old_pos >= context.stack_addr && old_pos < context.stack_addr + context.stack_size && context.gpr[1] < context.stack_addr) if (old_pos >= context.stack_addr && old_pos < context.stack_addr + context.stack_size && context.gpr[1] < context.stack_addr)
{ {
@ -1352,37 +1352,37 @@ extern void ppu_initialize(const ppu_module& info)
{ {
std::unordered_map<std::string, u64> link_table std::unordered_map<std::string, u64> link_table
{ {
{ "__mptr", (u64)&vm::g_base_addr }, { "__mptr", reinterpret_cast<u64>(&vm::g_base_addr) },
{ "__cptr", (u64)&vm::g_exec_addr }, { "__cptr", reinterpret_cast<u64>(&vm::g_exec_addr) },
{ "__trap", (u64)&ppu_trap }, { "__trap", reinterpret_cast<u64>(&ppu_trap) },
{ "__error", (u64)&ppu_error }, { "__error", reinterpret_cast<u64>(&ppu_error) },
{ "__check", (u64)&ppu_check }, { "__check", reinterpret_cast<u64>(&ppu_check) },
{ "__trace", (u64)&ppu_trace }, { "__trace", reinterpret_cast<u64>(&ppu_trace) },
{ "__syscall", (u64)&ppu_execute_syscall }, { "__syscall", reinterpret_cast<u64>(ppu_execute_syscall) },
{ "__get_tb", (u64)&get_timebased_time }, { "__get_tb", reinterpret_cast<u64>(get_timebased_time) },
{ "__lwarx", (u64)&ppu_lwarx }, { "__lwarx", reinterpret_cast<u64>(ppu_lwarx) },
{ "__ldarx", (u64)&ppu_ldarx }, { "__ldarx", reinterpret_cast<u64>(ppu_ldarx) },
{ "__stwcx", (u64)&ppu_stwcx }, { "__stwcx", reinterpret_cast<u64>(ppu_stwcx) },
{ "__stdcx", (u64)&ppu_stdcx }, { "__stdcx", reinterpret_cast<u64>(ppu_stdcx) },
{ "__vexptefp", (u64)&sse_exp2_ps }, { "__vexptefp", reinterpret_cast<u64>(sse_exp2_ps) },
{ "__vlogefp", (u64)&sse_log2_ps }, { "__vlogefp", reinterpret_cast<u64>(sse_log2_ps) },
{ "__vperm", s_use_ssse3 ? (u64)&sse_altivec_vperm : (u64)&sse_altivec_vperm_v0 }, // Obsolete { "__vperm", s_use_ssse3 ? reinterpret_cast<u64>(sse_altivec_vperm) : reinterpret_cast<u64>(sse_altivec_vperm_v0) }, // Obsolete
{ "__lvsl", (u64)&sse_altivec_lvsl }, { "__lvsl", reinterpret_cast<u64>(sse_altivec_lvsl) },
{ "__lvsr", (u64)&sse_altivec_lvsr }, { "__lvsr", reinterpret_cast<u64>(sse_altivec_lvsr) },
{ "__lvlx", s_use_ssse3 ? (u64)&sse_cellbe_lvlx : (u64)&sse_cellbe_lvlx_v0 }, { "__lvlx", s_use_ssse3 ? reinterpret_cast<u64>(sse_cellbe_lvlx) : reinterpret_cast<u64>(sse_cellbe_lvlx_v0) },
{ "__lvrx", s_use_ssse3 ? (u64)&sse_cellbe_lvrx : (u64)&sse_cellbe_lvrx_v0 }, { "__lvrx", s_use_ssse3 ? reinterpret_cast<u64>(sse_cellbe_lvrx) : reinterpret_cast<u64>(sse_cellbe_lvrx_v0) },
{ "__stvlx", s_use_ssse3 ? (u64)&sse_cellbe_stvlx : (u64)&sse_cellbe_stvlx_v0 }, { "__stvlx", s_use_ssse3 ? reinterpret_cast<u64>(sse_cellbe_stvlx) : reinterpret_cast<u64>(sse_cellbe_stvlx_v0) },
{ "__stvrx", s_use_ssse3 ? (u64)&sse_cellbe_stvrx : (u64)&sse_cellbe_stvrx_v0 }, { "__stvrx", s_use_ssse3 ? reinterpret_cast<u64>(sse_cellbe_stvrx) : reinterpret_cast<u64>(sse_cellbe_stvrx_v0) },
{ "__resupdate", (u64)&vm::reservation_update }, { "__resupdate", reinterpret_cast<u64>(vm::reservation_update) },
{ "sys_config_io_event", (u64)ppu_get_syscall(523) }, { "sys_config_io_event", reinterpret_cast<u64>(ppu_get_syscall(523)) },
}; };
for (u64 index = 0; index < 1024; index++) for (u64 index = 0; index < 1024; index++)
{ {
if (auto sc = ppu_get_syscall(index)) if (auto sc = ppu_get_syscall(index))
{ {
link_table.emplace(fmt::format("%s", ppu_syscall_code(index)), (u64)sc); link_table.emplace(fmt::format("%s", ppu_syscall_code(index)), reinterpret_cast<u64>(sc));
link_table.emplace(fmt::format("syscall_%u", index), (u64)sc); link_table.emplace(fmt::format("syscall_%u", index), reinterpret_cast<u64>(sc));
} }
} }
@ -1607,8 +1607,8 @@ extern void ppu_initialize(const ppu_module& info)
break; break;
} }
globals.emplace_back(fmt::format("__mptr%x", suffix), (u64)vm::g_base_addr); globals.emplace_back(fmt::format("__mptr%x", suffix), reinterpret_cast<u64>(vm::g_base_addr));
globals.emplace_back(fmt::format("__cptr%x", suffix), (u64)vm::g_exec_addr); globals.emplace_back(fmt::format("__cptr%x", suffix), reinterpret_cast<u64>(vm::g_exec_addr));
// Initialize segments for relocations // Initialize segments for relocations
for (u32 i = 0; i < info.segs.size(); i++) for (u32 i = 0; i < info.segs.size(); i++)
@ -1739,8 +1739,8 @@ extern void ppu_initialize(const ppu_module& info)
// Rewrite global variables // Rewrite global variables
while (index < jit_mod.vars.size()) while (index < jit_mod.vars.size())
{ {
*jit_mod.vars[index++] = (u64)vm::g_base_addr; *jit_mod.vars[index++] = reinterpret_cast<u64>(vm::g_base_addr);
*jit_mod.vars[index++] = (u64)vm::g_exec_addr; *jit_mod.vars[index++] = reinterpret_cast<u64>(vm::g_exec_addr);
for (const auto& seg : info.segs) for (const auto& seg : info.segs)
{ {

4
rpcs3/Emu/Cell/PPUTranslator.cpp
View file

@ -2794,7 +2794,7 @@ void PPUTranslator::LHZUX(ppu_opcode_t op)
void PPUTranslator::XOR(ppu_opcode_t op) void PPUTranslator::XOR(ppu_opcode_t op)
{ {
const auto result = op.rs == op.rb ? (Value*)m_ir->getInt64(0) : m_ir->CreateXor(GetGpr(op.rs), GetGpr(op.rb)); const auto result = op.rs == op.rb ? static_cast<Value*>(m_ir->getInt64(0)) : m_ir->CreateXor(GetGpr(op.rs), GetGpr(op.rb));
SetGpr(op.ra, result); SetGpr(op.ra, result);
if (op.rc) SetCrFieldSignedCmp(0, result, m_ir->getInt64(0)); if (op.rc) SetCrFieldSignedCmp(0, result, m_ir->getInt64(0));
} }
@ -2896,7 +2896,7 @@ void PPUTranslator::STHX(ppu_opcode_t op)
void PPUTranslator::ORC(ppu_opcode_t op) void PPUTranslator::ORC(ppu_opcode_t op)
{ {
const auto result = op.rs == op.rb ? (Value*)m_ir->getInt64(-1) : m_ir->CreateOr(GetGpr(op.rs), m_ir->CreateNot(GetGpr(op.rb))); const auto result = op.rs == op.rb ? static_cast<Value*>(m_ir->getInt64(-1)) : m_ir->CreateOr(GetGpr(op.rs), m_ir->CreateNot(GetGpr(op.rb)));
SetGpr(op.ra, result); SetGpr(op.ra, result);
if (op.rc) SetCrFieldSignedCmp(0, result, m_ir->getInt64(0)); if (op.rc) SetCrFieldSignedCmp(0, result, m_ir->getInt64(0));
} }

12
rpcs3/Emu/Cell/SPUASMJITRecompiler.cpp
View file

@ -2928,7 +2928,7 @@ void spu_recompiler::ROTQBYBI(spu_opcode_t op)
} }
const XmmLink& va = XmmGet(op.ra, XmmType::Int); const XmmLink& va = XmmGet(op.ra, XmmType::Int);
c->mov(*qw0, asmjit::imm_ptr((void*)g_spu_imm.rldq_pshufb)); c->mov(*qw0, asmjit::imm_ptr(+g_spu_imm.rldq_pshufb));
c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3)); c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
c->and_(*addr, 0xf << 3); c->and_(*addr, 0xf << 3);
c->pshufb(va, asmjit::x86::oword_ptr(*qw0, addr->r64(), 1)); c->pshufb(va, asmjit::x86::oword_ptr(*qw0, addr->r64(), 1));
@ -2943,7 +2943,7 @@ void spu_recompiler::ROTQMBYBI(spu_opcode_t op)
} }
const XmmLink& va = XmmGet(op.ra, XmmType::Int); const XmmLink& va = XmmGet(op.ra, XmmType::Int);
c->mov(*qw0, asmjit::imm_ptr((void*)g_spu_imm.srdq_pshufb)); c->mov(*qw0, asmjit::imm_ptr(+g_spu_imm.srdq_pshufb));
c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3)); c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
c->and_(*addr, 0x1f << 3); c->and_(*addr, 0x1f << 3);
c->pshufb(va, asmjit::x86::oword_ptr(*qw0, addr->r64(), 1)); c->pshufb(va, asmjit::x86::oword_ptr(*qw0, addr->r64(), 1));
@ -2958,7 +2958,7 @@ void spu_recompiler::SHLQBYBI(spu_opcode_t op)
} }
const XmmLink& va = XmmGet(op.ra, XmmType::Int); const XmmLink& va = XmmGet(op.ra, XmmType::Int);
c->mov(*qw0, asmjit::imm_ptr((void*)g_spu_imm.sldq_pshufb)); c->mov(*qw0, asmjit::imm_ptr(+g_spu_imm.sldq_pshufb));
c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3)); c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
c->and_(*addr, 0x1f << 3); c->and_(*addr, 0x1f << 3);
c->pshufb(va, asmjit::x86::oword_ptr(*qw0, addr->r64(), 1)); c->pshufb(va, asmjit::x86::oword_ptr(*qw0, addr->r64(), 1));
@ -3081,7 +3081,7 @@ void spu_recompiler::ROTQBY(spu_opcode_t op)
} }
const XmmLink& va = XmmGet(op.ra, XmmType::Int); const XmmLink& va = XmmGet(op.ra, XmmType::Int);
c->mov(*qw0, asmjit::imm_ptr((void*)g_spu_imm.rldq_pshufb)); c->mov(*qw0, asmjit::imm_ptr(+g_spu_imm.rldq_pshufb));
c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3)); c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
c->and_(*addr, 0xf); c->and_(*addr, 0xf);
c->shl(*addr, 4); c->shl(*addr, 4);
@ -3097,7 +3097,7 @@ void spu_recompiler::ROTQMBY(spu_opcode_t op)
} }
const XmmLink& va = XmmGet(op.ra, XmmType::Int); const XmmLink& va = XmmGet(op.ra, XmmType::Int);
c->mov(*qw0, asmjit::imm_ptr((void*)g_spu_imm.srdq_pshufb)); c->mov(*qw0, asmjit::imm_ptr(+g_spu_imm.srdq_pshufb));
c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3)); c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
c->and_(*addr, 0x1f); c->and_(*addr, 0x1f);
c->shl(*addr, 4); c->shl(*addr, 4);
@ -3113,7 +3113,7 @@ void spu_recompiler::SHLQBY(spu_opcode_t op)
} }
const XmmLink& va = XmmGet(op.ra, XmmType::Int); const XmmLink& va = XmmGet(op.ra, XmmType::Int);
c->mov(*qw0, asmjit::imm_ptr((void*)g_spu_imm.sldq_pshufb)); c->mov(*qw0, asmjit::imm_ptr(+g_spu_imm.sldq_pshufb));
c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3)); c->mov(*addr, SPU_OFF_32(gpr, op.rb, &v128::_u32, 3));
c->and_(*addr, 0x1f); c->and_(*addr, 0x1f);
c->shl(*addr, 4); c->shl(*addr, 4);

36
rpcs3/Emu/Cell/SPUInterpreter.cpp
View file

@ -600,7 +600,7 @@ bool spu_interpreter::ROTQBYBI(spu_thread& spu, spu_opcode_t op)
{ {
const auto a = spu.gpr[op.ra].vi; const auto a = spu.gpr[op.ra].vi;
alignas(32) const __m128i buf[2]{a, a}; alignas(32) const __m128i buf[2]{a, a};
spu.gpr[op.rt].vi = _mm_loadu_si128((__m128i*)((u8*)buf + (16 - (spu.gpr[op.rb]._u32[3] >> 3 & 0xf)))); spu.gpr[op.rt].vi = _mm_loadu_si128(reinterpret_cast<const __m128i*>(reinterpret_cast<const u8*>(buf) + (16 - (spu.gpr[op.rb]._u32[3] >> 3 & 0xf))));
return true; return true;
} }
@ -608,7 +608,7 @@ bool spu_interpreter::ROTQMBYBI(spu_thread& spu, spu_opcode_t op)
{ {
const auto a = spu.gpr[op.ra].vi; const auto a = spu.gpr[op.ra].vi;
alignas(64) const __m128i buf[3]{a, _mm_setzero_si128(), _mm_setzero_si128()}; alignas(64) const __m128i buf[3]{a, _mm_setzero_si128(), _mm_setzero_si128()};
spu.gpr[op.rt].vi = _mm_loadu_si128((__m128i*)((u8*)buf + ((0 - (spu.gpr[op.rb]._u32[3] >> 3)) & 0x1f))); spu.gpr[op.rt].vi = _mm_loadu_si128(reinterpret_cast<const __m128i*>(reinterpret_cast<const u8*>(buf) + ((0 - (spu.gpr[op.rb]._u32[3] >> 3)) & 0x1f)));
return true; return true;
} }
@ -616,7 +616,7 @@ bool spu_interpreter::SHLQBYBI(spu_thread& spu, spu_opcode_t op)
{ {
const auto a = spu.gpr[op.ra].vi; const auto a = spu.gpr[op.ra].vi;
alignas(64) const __m128i buf[3]{_mm_setzero_si128(), _mm_setzero_si128(), a}; alignas(64) const __m128i buf[3]{_mm_setzero_si128(), _mm_setzero_si128(), a};
spu.gpr[op.rt].vi = _mm_loadu_si128((__m128i*)((u8*)buf + (32 - (spu.gpr[op.rb]._u32[3] >> 3 & 0x1f)))); spu.gpr[op.rt].vi = _mm_loadu_si128(reinterpret_cast<const __m128i*>(reinterpret_cast<const u8*>(buf) + (32 - (spu.gpr[op.rb]._u32[3] >> 3 & 0x1f))));
return true; return true;
} }
@ -700,7 +700,7 @@ bool spu_interpreter::ROTQBY(spu_thread& spu, spu_opcode_t op)
{ {
const auto a = spu.gpr[op.ra].vi; const auto a = spu.gpr[op.ra].vi;
alignas(32) const __m128i buf[2]{a, a}; alignas(32) const __m128i buf[2]{a, a};
spu.gpr[op.rt].vi = _mm_loadu_si128((__m128i*)((u8*)buf + (16 - (spu.gpr[op.rb]._u32[3] & 0xf)))); spu.gpr[op.rt].vi = _mm_loadu_si128(reinterpret_cast<const __m128i*>(reinterpret_cast<const u8*>(buf) + (16 - (spu.gpr[op.rb]._u32[3] & 0xf))));
return true; return true;
} }
@ -708,7 +708,7 @@ bool spu_interpreter::ROTQMBY(spu_thread& spu, spu_opcode_t op)
{ {
const auto a = spu.gpr[op.ra].vi; const auto a = spu.gpr[op.ra].vi;
alignas(64) const __m128i buf[3]{a, _mm_setzero_si128(), _mm_setzero_si128()}; alignas(64) const __m128i buf[3]{a, _mm_setzero_si128(), _mm_setzero_si128()};
spu.gpr[op.rt].vi = _mm_loadu_si128((__m128i*)((u8*)buf + ((0 - spu.gpr[op.rb]._u32[3]) & 0x1f))); spu.gpr[op.rt].vi = _mm_loadu_si128(reinterpret_cast<const __m128i*>(reinterpret_cast<const u8*>(buf) + ((0 - spu.gpr[op.rb]._u32[3]) & 0x1f)));
return true; return true;
} }
@ -716,7 +716,7 @@ bool spu_interpreter::SHLQBY(spu_thread& spu, spu_opcode_t op)
{ {
const auto a = spu.gpr[op.ra].vi; const auto a = spu.gpr[op.ra].vi;
alignas(64) const __m128i buf[3]{_mm_setzero_si128(), _mm_setzero_si128(), a}; alignas(64) const __m128i buf[3]{_mm_setzero_si128(), _mm_setzero_si128(), a};
spu.gpr[op.rt].vi = _mm_loadu_si128((__m128i*)((u8*)buf + (32 - (spu.gpr[op.rb]._u32[3] & 0x1f)))); spu.gpr[op.rt].vi = _mm_loadu_si128(reinterpret_cast<const __m128i*>(reinterpret_cast<const u8*>(buf) + (32 - (spu.gpr[op.rb]._u32[3] & 0x1f))));
return true; return true;
} }
@ -806,7 +806,7 @@ bool spu_interpreter::ROTQBYI(spu_thread& spu, spu_opcode_t op)
{ {
const auto a = spu.gpr[op.ra].vi; const auto a = spu.gpr[op.ra].vi;
alignas(32) const __m128i buf[2]{a, a}; alignas(32) const __m128i buf[2]{a, a};
spu.gpr[op.rt].vi = _mm_loadu_si128((__m128i*)((u8*)buf + (16 - (op.i7 & 0xf)))); spu.gpr[op.rt].vi = _mm_loadu_si128(reinterpret_cast<const __m128i*>(reinterpret_cast<const u8*>(buf) + (16 - (op.i7 & 0xf))));
return true; return true;
} }
@ -814,7 +814,7 @@ bool spu_interpreter::ROTQMBYI(spu_thread& spu, spu_opcode_t op)
{ {
const auto a = spu.gpr[op.ra].vi; const auto a = spu.gpr[op.ra].vi;
alignas(64) const __m128i buf[3]{a, _mm_setzero_si128(), _mm_setzero_si128()}; alignas(64) const __m128i buf[3]{a, _mm_setzero_si128(), _mm_setzero_si128()};
spu.gpr[op.rt].vi = _mm_loadu_si128((__m128i*)((u8*)buf + ((0 - op.i7) & 0x1f))); spu.gpr[op.rt].vi = _mm_loadu_si128(reinterpret_cast<const __m128i*>(reinterpret_cast<const u8*>(buf) + ((0 - op.i7) & 0x1f)));
return true; return true;
} }
@ -822,7 +822,7 @@ bool spu_interpreter::SHLQBYI(spu_thread& spu, spu_opcode_t op)
{ {
const auto a = spu.gpr[op.ra].vi; const auto a = spu.gpr[op.ra].vi;
alignas(64) const __m128i buf[3]{_mm_setzero_si128(), _mm_setzero_si128(), a}; alignas(64) const __m128i buf[3]{_mm_setzero_si128(), _mm_setzero_si128(), a};
spu.gpr[op.rt].vi = _mm_loadu_si128((__m128i*)((u8*)buf + (32 - (op.i7 & 0x1f)))); spu.gpr[op.rt].vi = _mm_loadu_si128(reinterpret_cast<const __m128i*>(reinterpret_cast<const u8*>(buf) + (32 - (op.i7 & 0x1f))));
return true; return true;
} }
@ -1172,7 +1172,7 @@ bool spu_interpreter::BGX(spu_thread& spu, spu_opcode_t op)
{ {
for (s32 i = 0; i < 4; i++) for (s32 i = 0; i < 4; i++)
{ {
const s64 result = (u64)spu.gpr[op.rb]._u32[i] - (u64)spu.gpr[op.ra]._u32[i] - (u64)(1 - (spu.gpr[op.rt]._u32[i] & 1)); const s64 result = u64{spu.gpr[op.rb]._u32[i]} - spu.gpr[op.ra]._u32[i] - (1 - (spu.gpr[op.rt]._u32[i] & 1));
spu.gpr[op.rt]._u32[i] = result >= 0; spu.gpr[op.rt]._u32[i] = result >= 0;
} }
return true; return true;
@ -1692,7 +1692,7 @@ static bool SHUFB_(spu_thread& spu, spu_opcode_t op)
// Select bytes // Select bytes
for (int i = 0; i < 16; i++) for (int i = 0; i < 16; i++)
{ {
res._u8[i] = ((u8*)+ab)[x._u8[i]]; res._u8[i] = reinterpret_cast<u8*>(ab)[x._u8[i]];
} }
// Select special values // Select special values
@ -1956,7 +1956,7 @@ bool spu_interpreter_precise::FCGT(spu_thread& spu, spu_opcode_t op)
if (a_zero) if (a_zero)
pass = b >= 0x80800000; pass = b >= 0x80800000;
else if (b_zero) else if (b_zero)
pass = (s32)a >= 0x00800000; pass = static_cast<s32>(a) >= 0x00800000;
else if (a >= 0x80000000) else if (a >= 0x80000000)
pass = (b >= 0x80000000 && a < b); pass = (b >= 0x80000000 && a < b);
else else
@ -2307,7 +2307,7 @@ bool spu_interpreter_precise::FESD(spu_thread& spu, spu_opcode_t op)
} }
else else
{ {
spu.gpr[op.rt]._d[i] = (double)a; spu.gpr[op.rt]._d[i] = a;
} }
} }
return true; return true;
@ -2329,7 +2329,7 @@ bool spu_interpreter_precise::FRDS(spu_thread& spu, spu_opcode_t op)
else else
{ {
feclearexcept(FE_ALL_EXCEPT); feclearexcept(FE_ALL_EXCEPT);
spu.gpr[op.rt]._f[i * 2 + 1] = (float)a; spu.gpr[op.rt]._f[i * 2 + 1] = static_cast<float>(a);
const u32 e = _mm_getcsr(); const u32 e = _mm_getcsr();
if (e & _MM_EXCEPT_OVERFLOW) if (e & _MM_EXCEPT_OVERFLOW)
spu.fpscr.setDoublePrecisionExceptionFlags(i, FPSCR_DOVF); spu.fpscr.setDoublePrecisionExceptionFlags(i, FPSCR_DOVF);
@ -2405,7 +2405,7 @@ bool spu_interpreter_precise::CFLTS(spu_thread& spu, spu_opcode_t op)
else if (scaled < -2147483648.0f) else if (scaled < -2147483648.0f)
result = 0x80000000; result = 0x80000000;
else else
result = (s32)scaled; result = static_cast<s32>(scaled);
spu.gpr[op.rt]._s32[i] = result; spu.gpr[op.rt]._s32[i] = result;
} }
return true; return true;
@ -2428,7 +2428,7 @@ bool spu_interpreter_precise::CFLTU(spu_thread& spu, spu_opcode_t op)
else if (scaled < 0.0f) else if (scaled < 0.0f)
result = 0; result = 0;
else else
result = (u32)scaled; result = static_cast<u32>(scaled);
spu.gpr[op.rt]._u32[i] = result; spu.gpr[op.rt]._u32[i] = result;
} }
return true; return true;
@ -2441,7 +2441,7 @@ bool spu_interpreter_precise::CSFLT(spu_thread& spu, spu_opcode_t op)
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
{ {
const s32 a = spu.gpr[op.ra]._s32[i]; const s32 a = spu.gpr[op.ra]._s32[i];
spu.gpr[op.rt]._f[i] = (float)a; spu.gpr[op.rt]._f[i] = static_cast<float>(a);
u32 exp = ((spu.gpr[op.rt]._u32[i] >> 23) & 0xff) - scale; u32 exp = ((spu.gpr[op.rt]._u32[i] >> 23) & 0xff) - scale;
@ -2465,7 +2465,7 @@ bool spu_interpreter_precise::CUFLT(spu_thread& spu, spu_opcode_t op)
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
{ {
const u32 a = spu.gpr[op.ra]._u32[i]; const u32 a = spu.gpr[op.ra]._u32[i];
spu.gpr[op.rt]._f[i] = (float)a; spu.gpr[op.rt]._f[i] = static_cast<float>(a);
u32 exp = ((spu.gpr[op.rt]._u32[i] >> 23) & 0xff) - scale; u32 exp = ((spu.gpr[op.rt]._u32[i] >> 23) & 0xff) - scale;

16
rpcs3/Emu/Cell/SPUThread.cpp
View file

@ -115,7 +115,7 @@ namespace spu
void acquire_pc_address(spu_thread& spu, u32 pc, u32 timeout_ms = 3) void acquire_pc_address(spu_thread& spu, u32 pc, u32 timeout_ms = 3)
{ {
const u8 max_concurrent_instructions = (u8)g_cfg.core.preferred_spu_threads; const u32 max_concurrent_instructions = g_cfg.core.preferred_spu_threads;
const u32 pc_offset = pc >> 2; const u32 pc_offset = pc >> 2;
if (atomic_instruction_table[pc_offset].load(std::memory_order_consume) >= max_concurrent_instructions) if (atomic_instruction_table[pc_offset].load(std::memory_order_consume) >= max_concurrent_instructions)
@ -175,7 +175,7 @@ namespace spu
{ {
if (g_cfg.core.preferred_spu_threads > 0) if (g_cfg.core.preferred_spu_threads > 0)
{ {
acquire_pc_address(spu, pc, (u32)g_cfg.core.spu_delay_penalty); acquire_pc_address(spu, pc, g_cfg.core.spu_delay_penalty);
active = true; active = true;
} }
} }
@ -1546,9 +1546,9 @@ bool spu_thread::do_list_transfer(spu_mfc_cmd& args)
const v128 data1 = v128::fromV(_mm_loadu_si128(src + 1)); const v128 data1 = v128::fromV(_mm_loadu_si128(src + 1));
const v128 data2 = v128::fromV(_mm_loadu_si128(src + 2)); const v128 data2 = v128::fromV(_mm_loadu_si128(src + 2));
((v128*)+bufitems)[0] = data0; reinterpret_cast<v128*>(bufitems)[0] = data0;
((v128*)+bufitems)[1] = data1; reinterpret_cast<v128*>(bufitems)[1] = data1;
((v128*)+bufitems)[2] = data2; reinterpret_cast<v128*>(bufitems)[2] = data2;
} }
const u32 size = items[index].ts & 0x7fff; const u32 size = items[index].ts & 0x7fff;
@ -2360,7 +2360,7 @@ s64 spu_thread::get_ch_value(u32 ch)
case SPU_RdDec: case SPU_RdDec:
{ {
u32 out = ch_dec_value - (u32)(get_timebased_time() - ch_dec_start_timestamp); u32 out = ch_dec_value - static_cast<u32>(get_timebased_time() - ch_dec_start_timestamp);
//Polling: We might as well hint to the scheduler to slot in another thread since this one is counting down //Polling: We might as well hint to the scheduler to slot in another thread since this one is counting down
if (g_cfg.core.spu_loop_detection && out > spu::scheduler::native_jiffy_duration_us) if (g_cfg.core.spu_loop_detection && out > spu::scheduler::native_jiffy_duration_us)
@ -2506,7 +2506,7 @@ bool spu_thread::set_ch_value(u32 ch, u32 value)
ch_in_mbox.set_values(1, CELL_OK); ch_in_mbox.set_values(1, CELL_OK);
if (!queue->send(SYS_SPU_THREAD_EVENT_USER_KEY, id, ((u64)spup << 32) | (value & 0x00ffffff), data)) if (!queue->send(SYS_SPU_THREAD_EVENT_USER_KEY, id, (u64{spup} << 32) | (value & 0x00ffffff), data))
{ {
ch_in_mbox.set_values(1, CELL_EBUSY); ch_in_mbox.set_values(1, CELL_EBUSY);
} }
@ -2536,7 +2536,7 @@ bool spu_thread::set_ch_value(u32 ch, u32 value)
} }
// TODO: check passing spup value // TODO: check passing spup value
if (!queue->send(SYS_SPU_THREAD_EVENT_USER_KEY, id, ((u64)spup << 32) | (value & 0x00ffffff), data)) if (!queue->send(SYS_SPU_THREAD_EVENT_USER_KEY, id, (u64{spup} << 32) | (value & 0x00ffffff), data))
{ {
LOG_WARNING(SPU, "sys_spu_thread_throw_event(spup=%d, data0=0x%x, data1=0x%x) failed (queue is full)", spup, (value & 0x00ffffff), data); LOG_WARNING(SPU, "sys_spu_thread_throw_event(spup=%d, data0=0x%x, data1=0x%x) failed (queue is full)", spup, (value & 0x00ffffff), data);
} }

2
rpcs3/Emu/Io/KeyboardHandler.cpp
View file

@ -111,7 +111,7 @@ void KeyboardHandlerBase::Key(u32 code, bool pressed)
} }
} }
data.len = std::min(data.len + 1, (int)CELL_KB_MAX_KEYCODES); data.len = std::min<s32>(data.len + 1, CELL_KB_MAX_KEYCODES);
} }
else else
{ {

18
rpcs3/Emu/Io/PadHandler.cpp
View file

@ -99,7 +99,7 @@ long PadHandlerBase::FindKeyCodeByString(const std::unordered_map<u64, std::stri
float PadHandlerBase::ScaleStickInput(s32 raw_value, int minimum, int maximum) float PadHandlerBase::ScaleStickInput(s32 raw_value, int minimum, int maximum)
{ {
// value based on max range converted to [0, 1] // value based on max range converted to [0, 1]
float val = float(std::clamp(raw_value, minimum, maximum) - minimum) / float(abs(maximum) + abs(minimum)); float val = static_cast<float>(std::clamp(raw_value, minimum, maximum) - minimum) / (abs(maximum) + abs(minimum));
return 255.0f * val; return 255.0f * val;
} }
@ -107,7 +107,7 @@ float PadHandlerBase::ScaleStickInput(s32 raw_value, int minimum, int maximum)
float PadHandlerBase::ScaleStickInput2(s32 raw_value, int minimum, int maximum) float PadHandlerBase::ScaleStickInput2(s32 raw_value, int minimum, int maximum)
{ {
// value based on max range converted to [0, 1] // value based on max range converted to [0, 1]
float val = float(std::clamp(raw_value, minimum, maximum) - minimum) / float(abs(maximum) + abs(minimum)); float val = static_cast<float>(std::clamp(raw_value, minimum, maximum) - minimum) / (abs(maximum) + abs(minimum));
return (510.0f * val) - 255.0f; return (510.0f * val) - 255.0f;
} }
@ -124,7 +124,7 @@ u16 PadHandlerBase::NormalizeTriggerInput(u16 value, int threshold)
} }
else else
{ {
return (u16)(float(trigger_max) * float(value - threshold) / float(trigger_max - threshold)); return static_cast<u16>(static_cast<float>(trigger_max) * (value - threshold) / (trigger_max - threshold));
} }
} }
@ -137,7 +137,7 @@ u16 PadHandlerBase::NormalizeDirectedInput(s32 raw_value, s32 threshold, s32 max
return static_cast<u16>(0); return static_cast<u16>(0);
} }
float val = float(std::clamp(raw_value, 0, maximum)) / float(maximum); // value based on max range converted to [0, 1] float val = static_cast<float>(std::clamp(raw_value, 0, maximum)) / maximum; // value based on max range converted to [0, 1]
if (threshold <= 0) if (threshold <= 0)
{ {
@ -145,7 +145,7 @@ u16 PadHandlerBase::NormalizeDirectedInput(s32 raw_value, s32 threshold, s32 max
} }
else else
{ {
float thresh = float(threshold) / float(maximum); // threshold converted to [0, 1] float thresh = static_cast<float>(threshold) / maximum; // threshold converted to [0, 1]
return static_cast<u16>(255.0f * std::min(1.0f, (val - thresh) / (1.0f - thresh))); return static_cast<u16>(255.0f * std::min(1.0f, (val - thresh) / (1.0f - thresh)));
} }
} }
@ -169,7 +169,7 @@ u16 PadHandlerBase::NormalizeStickInput(u16 raw_value, int threshold, int multip
// return is new x and y values in 0-255 range // return is new x and y values in 0-255 range
std::tuple<u16, u16> PadHandlerBase::NormalizeStickDeadzone(s32 inX, s32 inY, u32 deadzone) std::tuple<u16, u16> PadHandlerBase::NormalizeStickDeadzone(s32 inX, s32 inY, u32 deadzone)
{ {
const float dzRange = deadzone / float((std::abs(thumb_max) + std::abs(thumb_min))); const float dzRange = deadzone / static_cast<float>((std::abs(thumb_max) + std::abs(thumb_min)));
float X = inX / 255.0f; float X = inX / 255.0f;
float Y = inY / 255.0f; float Y = inY / 255.0f;
@ -224,8 +224,8 @@ u16 PadHandlerBase::ConvertAxis(float value)
std::tuple<u16, u16> PadHandlerBase::ConvertToSquirclePoint(u16 inX, u16 inY, int squircle_factor) std::tuple<u16, u16> PadHandlerBase::ConvertToSquirclePoint(u16 inX, u16 inY, int squircle_factor)
{ {
// convert inX and Y to a (-1, 1) vector; // convert inX and Y to a (-1, 1) vector;
const f32 x = ((f32)inX - 127.5f) / 127.5f; const f32 x = (inX - 127.5f) / 127.5f;
const f32 y = ((f32)inY - 127.5f) / 127.5f; const f32 y = (inY - 127.5f) / 127.5f;
// compute angle and len of given point to be used for squircle radius // compute angle and len of given point to be used for squircle radius
const f32 angle = std::atan2(y, x); const f32 angle = std::atan2(y, x);
@ -233,7 +233,7 @@ std::tuple<u16, u16> PadHandlerBase::ConvertToSquirclePoint(u16 inX, u16 inY, in
// now find len/point on the given squircle from our current angle and radius in polar coords // now find len/point on the given squircle from our current angle and radius in polar coords
// https://thatsmaths.com/2016/07/14/squircles/ // https://thatsmaths.com/2016/07/14/squircles/
const f32 newLen = (1 + std::pow(std::sin(2 * angle), 2.f) / (float(squircle_factor) / 1000.f)) * r; const f32 newLen = (1 + std::pow(std::sin(2 * angle), 2.f) / (squircle_factor / 1000.f)) * r;
// we now have len and angle, convert to cartesian // we now have len and angle, convert to cartesian
const int newX = Clamp0To255(((newLen * std::cos(angle)) + 1) * 127.5f); const int newX = Clamp0To255(((newLen * std::cos(angle)) + 1) * 127.5f);

10
rpcs3/Emu/Io/usb_device.cpp
View file

@ -111,13 +111,13 @@ void usb_device_passthrough::control_transfer(u8 bmRequestType, u8 bRequest, u16
libusb_fill_control_setup(transfer->setup_buf.data(), bmRequestType, bRequest, wValue, wIndex, buf_size); libusb_fill_control_setup(transfer->setup_buf.data(), bmRequestType, bRequest, wValue, wIndex, buf_size);
memcpy(transfer->setup_buf.data() + 8, buf, buf_size); memcpy(transfer->setup_buf.data() + 8, buf, buf_size);
libusb_fill_control_transfer(transfer->transfer, lusb_handle, transfer->setup_buf.data(), callback_transfer, (void*)transfer, 0); libusb_fill_control_transfer(transfer->transfer, lusb_handle, transfer->setup_buf.data(), callback_transfer, transfer, 0);
libusb_submit_transfer(transfer->transfer); libusb_submit_transfer(transfer->transfer);
} }
void usb_device_passthrough::interrupt_transfer(u32 buf_size, u8* buf, u32 endpoint, UsbTransfer* transfer) void usb_device_passthrough::interrupt_transfer(u32 buf_size, u8* buf, u32 endpoint, UsbTransfer* transfer)
{ {
libusb_fill_interrupt_transfer(transfer->transfer, lusb_handle, endpoint, buf, buf_size, callback_transfer, (void*)transfer, 0); libusb_fill_interrupt_transfer(transfer->transfer, lusb_handle, endpoint, buf, buf_size, callback_transfer, transfer, 0);
libusb_submit_transfer(transfer->transfer); libusb_submit_transfer(transfer->transfer);
} }
@ -125,7 +125,7 @@ void usb_device_passthrough::isochronous_transfer(UsbTransfer* transfer)
{ {
// TODO actual endpoint // TODO actual endpoint
// TODO actual size? // TODO actual size?
libusb_fill_iso_transfer(transfer->transfer, lusb_handle, 0x81, (u8*)transfer->iso_request.buf.get_ptr(), 0xFFFF, transfer->iso_request.num_packets, callback_transfer, (void*)transfer, 0); libusb_fill_iso_transfer(transfer->transfer, lusb_handle, 0x81, static_cast<u8*>(transfer->iso_request.buf.get_ptr()), 0xFFFF, transfer->iso_request.num_packets, callback_transfer, transfer, 0);
for (u32 index = 0; index < transfer->iso_request.num_packets; index++) for (u32 index = 0; index < transfer->iso_request.num_packets; index++)
{ {
@ -158,7 +158,7 @@ s32 usb_device_emulated::get_descriptor(u8 type, u8 index, u8* ptr, u32 max_size
{ {
if (index < strings.size()) if (index < strings.size())
{ {
u8 string_len = (u8)strings[index].size(); u8 string_len = ::narrow<u8>(strings[index].size());
ptr[0] = (string_len * 2) + 2; ptr[0] = (string_len * 2) + 2;
ptr[1] = USB_DESCRIPTOR_STRING; ptr[1] = USB_DESCRIPTOR_STRING;
for (u32 i = 0; i < string_len; i++) for (u32 i = 0; i < string_len; i++)
@ -166,7 +166,7 @@ s32 usb_device_emulated::get_descriptor(u8 type, u8 index, u8* ptr, u32 max_size
ptr[2 + (i * 2)] = strings[index].data()[i]; ptr[2 + (i * 2)] = strings[index].data()[i];
ptr[3 + (i * 2)] = 0; ptr[3 + (i * 2)] = 0;
} }
return (s32)ptr[0]; return ptr[0];
} }
} }
else else

30
rpcs3/Emu/Memory/vm.cpp
View file

@ -19,34 +19,34 @@
namespace vm namespace vm
{ {
static u8* memory_reserve_4GiB(std::uintptr_t _addr = 0) static u8* memory_reserve_4GiB(void* _addr, u64 size = 0x100000000)
{ {
for (u64 addr = _addr + 0x100000000;; addr += 0x100000000) for (u64 addr = reinterpret_cast<u64>(_addr) + 0x100000000;; addr += 0x100000000)
{ {
if (auto ptr = utils::memory_reserve(0x100000000, (void*)addr)) if (auto ptr = utils::memory_reserve(size, reinterpret_cast<void*>(addr)))
{ {
return static_cast<u8*>(ptr); return static_cast<u8*>(ptr);
} }
} }
// TODO: a condition to break loop // TODO: a condition to break loop
return static_cast<u8*>(utils::memory_reserve(0x100000000)); return static_cast<u8*>(utils::memory_reserve(size));
} }
// Emulated virtual memory // Emulated virtual memory
u8* const g_base_addr = memory_reserve_4GiB(0x2'0000'0000); u8* const g_base_addr = memory_reserve_4GiB(reinterpret_cast<void*>(0x2'0000'0000));
// Unprotected virtual memory mirror // Unprotected virtual memory mirror
u8* const g_sudo_addr = memory_reserve_4GiB((std::uintptr_t)g_base_addr); u8* const g_sudo_addr = memory_reserve_4GiB(g_base_addr);
// Auxiliary virtual memory for executable areas // Auxiliary virtual memory for executable areas
u8* const g_exec_addr = memory_reserve_4GiB((std::uintptr_t)g_sudo_addr); u8* const g_exec_addr = memory_reserve_4GiB(g_sudo_addr, 0x200000000);
// Stats for debugging // Stats for debugging
u8* const g_stat_addr = memory_reserve_4GiB((std::uintptr_t)g_exec_addr); u8* const g_stat_addr = memory_reserve_4GiB(g_exec_addr);
// Reservation stats (compressed x16) // Reservation stats (compressed x16)
u8* const g_reservations = memory_reserve_4GiB((std::uintptr_t)g_stat_addr); u8* const g_reservations = memory_reserve_4GiB(g_stat_addr);
// Memory locations // Memory locations
std::vector<std::shared_ptr<block_t>> g_locations; std::vector<std::shared_ptr<block_t>> g_locations;
@ -128,7 +128,7 @@ namespace vm
if (LIKELY(test_addr(g_addr_lock.load(), addr, end))) if (LIKELY(test_addr(g_addr_lock.load(), addr, end)))
{ {
// Optimistic path (hope that address range is not locked) // Optimistic path (hope that address range is not locked)
_ret = _register_range_lock((u64)end << 32 | addr); _ret = _register_range_lock(u64{end} << 32 | addr);
if (LIKELY(test_addr(g_addr_lock.load(), addr, end))) if (LIKELY(test_addr(g_addr_lock.load(), addr, end)))
{ {
@ -140,7 +140,7 @@ namespace vm
{ {
::reader_lock lock(g_mutex); ::reader_lock lock(g_mutex);
_ret = _register_range_lock((u64)end << 32 | addr); _ret = _register_range_lock(u64{end} << 32 | addr);
} }
return _ret; return _ret;
@ -540,7 +540,7 @@ namespace vm
if (!block) if (!block)
{ {
fmt::throw_exception("Invalid memory location (%u)" HERE, (uint)location); fmt::throw_exception("Invalid memory location (%u)" HERE, +location);
} }
return block->alloc(size, align); return block->alloc(size, align);
@ -552,7 +552,7 @@ namespace vm
if (!block) if (!block)
{ {
fmt::throw_exception("Invalid memory location (%u, addr=0x%x)" HERE, (uint)location, addr); fmt::throw_exception("Invalid memory location (%u, addr=0x%x)" HERE, +location, addr);
} }
return block->falloc(addr, size); return block->falloc(addr, size);
@ -564,7 +564,7 @@ namespace vm
if (!block) if (!block)
{ {
fmt::throw_exception("Invalid memory location (%u, addr=0x%x)" HERE, (uint)location, addr); fmt::throw_exception("Invalid memory location (%u, addr=0x%x)" HERE, +location, addr);
} }
return block->dealloc(addr); return block->dealloc(addr);
@ -576,7 +576,7 @@ namespace vm
if (!block) if (!block)
{ {
LOG_ERROR(MEMORY, "vm::dealloc(): invalid memory location (%u, addr=0x%x)\n", (uint)location, addr); LOG_ERROR(MEMORY, "vm::dealloc(): invalid memory location (%u, addr=0x%x)\n", +location, addr);
return; return;
} }

4
rpcs3/Emu/RSX/CgBinaryFragmentProgram.cpp
View file

@ -69,7 +69,7 @@ std::string CgBinaryDisasm::AddRegDisAsm(u32 index, int fp16)
std::string CgBinaryDisasm::AddConstDisAsm() std::string CgBinaryDisasm::AddConstDisAsm()
{ {
u32* data = (u32*)&m_buffer[m_offset + m_size + 4 * sizeof(u32)]; u32* data = reinterpret_cast<u32*>(&m_buffer[m_offset + m_size + 4 * sizeof(u32)]);
m_step = 2 * 4 * sizeof(u32); m_step = 2 * 4 * sizeof(u32);
const u32 x = GetData(data[0]); const u32 x = GetData(data[0]);
@ -224,7 +224,7 @@ template<typename T> std::string CgBinaryDisasm::GetSrcDisAsm(T src)
void CgBinaryDisasm::TaskFP() void CgBinaryDisasm::TaskFP()
{ {
m_size = 0; m_size = 0;
u32* data = (u32*)&m_buffer[m_offset]; u32* data = reinterpret_cast<u32*>(&m_buffer[m_offset]);
verify(HERE), ((m_buffer_size - m_offset) % sizeof(u32) == 0); verify(HERE), ((m_buffer_size - m_offset) % sizeof(u32) == 0);
for (u32 i = 0; i < (m_buffer_size - m_offset) / sizeof(u32); i++) for (u32 i = 0; i < (m_buffer_size - m_offset) / sizeof(u32); i++)
{ {

28
rpcs3/Emu/RSX/CgBinaryProgram.h
View file

@ -288,15 +288,15 @@ public:
{ {
auto& fprog = GetCgRef<CgBinaryFragmentProgram>(prog.program); auto& fprog = GetCgRef<CgBinaryFragmentProgram>(prog.program);
m_arb_shader += "\n"; m_arb_shader += "\n";
m_arb_shader += fmt::format("# binaryFormatRevision 0x%x\n", (u32)prog.binaryFormatRevision); m_arb_shader += fmt::format("# binaryFormatRevision 0x%x\n", prog.binaryFormatRevision);
m_arb_shader += fmt::format("# profile sce_fp_rsx\n"); m_arb_shader += fmt::format("# profile sce_fp_rsx\n");
m_arb_shader += fmt::format("# parameterCount %d\n", (u32)prog.parameterCount); m_arb_shader += fmt::format("# parameterCount %d\n", prog.parameterCount);
m_arb_shader += fmt::format("# instructionCount %d\n", (u32)fprog.instructionCount); m_arb_shader += fmt::format("# instructionCount %d\n", fprog.instructionCount);
m_arb_shader += fmt::format("# attributeInputMask 0x%x\n", (u32)fprog.attributeInputMask); m_arb_shader += fmt::format("# attributeInputMask 0x%x\n", fprog.attributeInputMask);
m_arb_shader += fmt::format("# registerCount %d\n\n", (u32)fprog.registerCount); m_arb_shader += fmt::format("# registerCount %d\n\n", fprog.registerCount);
CgBinaryParameterOffset offset = prog.parameterArray; CgBinaryParameterOffset offset = prog.parameterArray;
for (u32 i = 0; i < (u32)prog.parameterCount; i++) for (u32 i = 0; i < prog.parameterCount; i++)
{ {
auto& fparam = GetCgRef<CgBinaryParameter>(offset); auto& fparam = GetCgRef<CgBinaryParameter>(offset);
@ -344,16 +344,16 @@ public:
{ {
auto& vprog = GetCgRef<CgBinaryVertexProgram>(prog.program); auto& vprog = GetCgRef<CgBinaryVertexProgram>(prog.program);
m_arb_shader += "\n"; m_arb_shader += "\n";
m_arb_shader += fmt::format("# binaryFormatRevision 0x%x\n", (u32)prog.binaryFormatRevision); m_arb_shader += fmt::format("# binaryFormatRevision 0x%x\n", prog.binaryFormatRevision);
m_arb_shader += fmt::format("# profile sce_vp_rsx\n"); m_arb_shader += fmt::format("# profile sce_vp_rsx\n");
m_arb_shader += fmt::format("# parameterCount %d\n", (u32)prog.parameterCount); m_arb_shader += fmt::format("# parameterCount %d\n", prog.parameterCount);
m_arb_shader += fmt::format("# instructionCount %d\n", (u32)vprog.instructionCount); m_arb_shader += fmt::format("# instructionCount %d\n", vprog.instructionCount);
m_arb_shader += fmt::format("# registerCount %d\n", (u32)vprog.registerCount); m_arb_shader += fmt::format("# registerCount %d\n", vprog.registerCount);
m_arb_shader += fmt::format("# attributeInputMask 0x%x\n", (u32)vprog.attributeInputMask); m_arb_shader += fmt::format("# attributeInputMask 0x%x\n", vprog.attributeInputMask);
m_arb_shader += fmt::format("# attributeOutputMask 0x%x\n\n", (u32)vprog.attributeOutputMask); m_arb_shader += fmt::format("# attributeOutputMask 0x%x\n\n", vprog.attributeOutputMask);
CgBinaryParameterOffset offset = prog.parameterArray; CgBinaryParameterOffset offset = prog.parameterArray;
for (u32 i = 0; i < (u32)prog.parameterCount; i++) for (u32 i = 0; i < prog.parameterCount; i++)
{ {
auto& vparam = GetCgRef<CgBinaryParameter>(offset); auto& vparam = GetCgRef<CgBinaryParameter>(offset);
@ -371,7 +371,7 @@ public:
m_arb_shader += "\n"; m_arb_shader += "\n";
m_offset = prog.ucode; m_offset = prog.ucode;
u32* vdata = (u32*)&m_buffer[m_offset]; u32* vdata = reinterpret_cast<u32*>(&m_buffer[m_offset]);
verify(HERE), (m_buffer_size - m_offset) % sizeof(u32) == 0; verify(HERE), (m_buffer_size - m_offset) % sizeof(u32) == 0;
for (u32 i = 0; i < (m_buffer_size - m_offset) / sizeof(u32); i++) for (u32 i = 0; i < (m_buffer_size - m_offset) / sizeof(u32); i++)
{ {

136
rpcs3/Emu/RSX/Common/BufferUtils.cpp
View file

@ -44,13 +44,13 @@ namespace
template <typename T> template <typename T>
gsl::span<T> as_span_workaround(gsl::span<std::byte> unformated_span) gsl::span<T> as_span_workaround(gsl::span<std::byte> unformated_span)
{ {
return{ (T*)unformated_span.data(), unformated_span.size_bytes() / sizeof(T) }; return{ reinterpret_cast<T*>(unformated_span.data()), unformated_span.size_bytes() / sizeof(T) };
} }
template <typename T> template <typename T>
gsl::span<T> as_const_span(gsl::span<const std::byte> unformated_span) gsl::span<T> as_const_span(gsl::span<const std::byte> unformated_span)
{ {
return{ (T*)unformated_span.data(), unformated_span.size_bytes() / sizeof(T) }; return{ reinterpret_cast<T*>(unformated_span.data()), unformated_span.size_bytes() / sizeof(T) };
} }
} }
@ -81,8 +81,8 @@ namespace
0x4, 0x5, 0x6, 0x7, 0x4, 0x5, 0x6, 0x7,
0x0, 0x1, 0x2, 0x3); 0x0, 0x1, 0x2, 0x3);
__m128i* dst_ptr = (__m128i*)dst; auto dst_ptr = static_cast<__m128i*>(dst);
__m128i* src_ptr = (__m128i*)src; auto src_ptr = static_cast<const __m128i*>(src);
const u32 dword_count = (vertex_count * (stride >> 2)); const u32 dword_count = (vertex_count * (stride >> 2));
const u32 iterations = dword_count >> 2; const u32 iterations = dword_count >> 2;
@ -116,8 +116,8 @@ namespace
if (remaining) if (remaining)
{ {
u32 *src_ptr2 = (u32 *)src_ptr; auto src_ptr2 = reinterpret_cast<const u32*>(src_ptr);
u32 *dst_ptr2 = (u32 *)dst_ptr; auto dst_ptr2 = reinterpret_cast<u32*>(dst_ptr);
for (u32 i = 0; i < remaining; ++i) for (u32 i = 0; i < remaining; ++i)
dst_ptr2[i] = se_storage<u32>::swap(src_ptr2[i]); dst_ptr2[i] = se_storage<u32>::swap(src_ptr2[i]);
@ -132,8 +132,8 @@ namespace
0x6, 0x7, 0x4, 0x5, 0x6, 0x7, 0x4, 0x5,
0x2, 0x3, 0x0, 0x1); 0x2, 0x3, 0x0, 0x1);
__m128i* dst_ptr = (__m128i*)dst; auto dst_ptr = static_cast<__m128i*>(dst);
__m128i* src_ptr = (__m128i*)src; auto src_ptr = static_cast<const __m128i*>(src);
const u32 word_count = (vertex_count * (stride >> 1)); const u32 word_count = (vertex_count * (stride >> 1));
const u32 iterations = word_count >> 3; const u32 iterations = word_count >> 3;
@ -166,8 +166,8 @@ namespace
if (remaining) if (remaining)
{ {
u16 *src_ptr2 = (u16 *)src_ptr; auto src_ptr2 = reinterpret_cast<const u16*>(src_ptr);
u16 *dst_ptr2 = (u16 *)dst_ptr; auto dst_ptr2 = reinterpret_cast<u16*>(dst_ptr);
for (u32 i = 0; i < remaining; ++i) for (u32 i = 0; i < remaining; ++i)
dst_ptr2[i] = se_storage<u16>::swap(src_ptr2[i]); dst_ptr2[i] = se_storage<u16>::swap(src_ptr2[i]);
@ -182,8 +182,8 @@ namespace
0x4, 0x5, 0x6, 0x7, 0x4, 0x5, 0x6, 0x7,
0x0, 0x1, 0x2, 0x3); 0x0, 0x1, 0x2, 0x3);
char *src_ptr = (char *)src; auto src_ptr = static_cast<const char*>(src);
char *dst_ptr = (char *)dst; auto dst_ptr = static_cast<char*>(dst);
//Count vertices to copy //Count vertices to copy
const bool is_128_aligned = !((dst_stride | src_stride) & 15); const bool is_128_aligned = !((dst_stride | src_stride) & 15);
@ -203,9 +203,9 @@ namespace
{ {
for (u32 i = 0; i < iterations; ++i) for (u32 i = 0; i < iterations; ++i)
{ {
const __m128i vector = _mm_loadu_si128((__m128i*)src_ptr); const __m128i vector = _mm_loadu_si128(reinterpret_cast<const __m128i*>(src_ptr));
const __m128i shuffled_vector = ssse3_shuffle_epi8(vector, mask); const __m128i shuffled_vector = ssse3_shuffle_epi8(vector, mask);
_mm_storeu_si128((__m128i*)dst_ptr, shuffled_vector); _mm_storeu_si128(reinterpret_cast<__m128i*>(dst_ptr), shuffled_vector);
src_ptr += src_stride; src_ptr += src_stride;
dst_ptr += dst_stride; dst_ptr += dst_stride;
@ -215,10 +215,10 @@ namespace
{ {
for (u32 i = 0; i < iterations; ++i) for (u32 i = 0; i < iterations; ++i)
{ {
const __m128i vec0 = _mm_loadu_si128((__m128i*)src_ptr); const __m128i vec0 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(src_ptr));
const __m128i vec1 = _mm_or_si128(_mm_slli_epi16(vec0, 8), _mm_srli_epi16(vec0, 8)); const __m128i vec1 = _mm_or_si128(_mm_slli_epi16(vec0, 8), _mm_srli_epi16(vec0, 8));
const __m128i vec2 = _mm_or_si128(_mm_slli_epi32(vec1, 16), _mm_srli_epi32(vec1, 16)); const __m128i vec2 = _mm_or_si128(_mm_slli_epi32(vec1, 16), _mm_srli_epi32(vec1, 16));
_mm_storeu_si128((__m128i*)dst_ptr, vec2); _mm_storeu_si128(reinterpret_cast<__m128i*>(dst_ptr), vec2);
src_ptr += src_stride; src_ptr += src_stride;
dst_ptr += dst_stride; dst_ptr += dst_stride;
@ -230,8 +230,11 @@ namespace
const u8 attribute_sz = min_block_size >> 2; const u8 attribute_sz = min_block_size >> 2;
for (u32 n = 0; n < remainder; ++n) for (u32 n = 0; n < remainder; ++n)
{ {
for (u32 v= 0; v < attribute_sz; ++v) auto src_ptr2 = reinterpret_cast<const be_t<u32>*>(src_ptr);
((u32*)dst_ptr)[v] = ((be_t<u32>*)src_ptr)[v]; auto dst_ptr2 = reinterpret_cast<u32*>(dst_ptr);
for (u32 v = 0; v < attribute_sz; ++v)
dst_ptr2[v] = src_ptr[v];
src_ptr += src_stride; src_ptr += src_stride;
dst_ptr += dst_stride; dst_ptr += dst_stride;
@ -247,8 +250,8 @@ namespace
0x6, 0x7, 0x4, 0x5, 0x6, 0x7, 0x4, 0x5,
0x2, 0x3, 0x0, 0x1); 0x2, 0x3, 0x0, 0x1);
char *src_ptr = (char *)src; auto src_ptr = static_cast<const char*>(src);
char *dst_ptr = (char *)dst; auto dst_ptr = static_cast<char*>(dst);
const bool is_128_aligned = !((dst_stride | src_stride) & 15); const bool is_128_aligned = !((dst_stride | src_stride) & 15);
@ -267,9 +270,9 @@ namespace
{ {
for (u32 i = 0; i < iterations; ++i) for (u32 i = 0; i < iterations; ++i)
{ {
const __m128i vector = _mm_loadu_si128((__m128i*)src_ptr); const __m128i vector = _mm_loadu_si128(reinterpret_cast<const __m128i*>(src_ptr));
const __m128i shuffled_vector = ssse3_shuffle_epi8(vector, mask); const __m128i shuffled_vector = ssse3_shuffle_epi8(vector, mask);
_mm_storeu_si128((__m128i*)dst_ptr, shuffled_vector); _mm_storeu_si128(reinterpret_cast<__m128i*>(dst_ptr), shuffled_vector);
src_ptr += src_stride; src_ptr += src_stride;
dst_ptr += dst_stride; dst_ptr += dst_stride;
@ -279,9 +282,9 @@ namespace
{ {
for (u32 i = 0; i < iterations; ++i) for (u32 i = 0; i < iterations; ++i)
{ {
const __m128i vec0 = _mm_loadu_si128((__m128i*)src_ptr); const __m128i vec0 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(src_ptr));
const __m128i vec1 = _mm_or_si128(_mm_slli_epi16(vec0, 8), _mm_srli_epi16(vec0, 8)); const __m128i vec1 = _mm_or_si128(_mm_slli_epi16(vec0, 8), _mm_srli_epi16(vec0, 8));
_mm_storeu_si128((__m128i*)dst_ptr, vec1); _mm_storeu_si128(reinterpret_cast<__m128i*>(dst_ptr), vec1);
src_ptr += src_stride; src_ptr += src_stride;
dst_ptr += dst_stride; dst_ptr += dst_stride;
@ -293,8 +296,11 @@ namespace
const u8 attribute_sz = min_block_size >> 1; const u8 attribute_sz = min_block_size >> 1;
for (u32 n = 0; n < remainder; ++n) for (u32 n = 0; n < remainder; ++n)
{ {
auto src_ptr2 = reinterpret_cast<const be_t<u16>*>(src_ptr);
auto dst_ptr2 = reinterpret_cast<u16*>(dst_ptr);
for (u32 v = 0; v < attribute_sz; ++v) for (u32 v = 0; v < attribute_sz; ++v)
((u16*)dst_ptr)[v] = ((be_t<u16>*)src_ptr)[v]; dst_ptr[v] = src_ptr[v];
src_ptr += src_stride; src_ptr += src_stride;
dst_ptr += dst_stride; dst_ptr += dst_stride;
@ -304,8 +310,8 @@ namespace
inline void stream_data_to_memory_u8_non_continuous(void *dst, const void *src, u32 vertex_count, u8 attribute_size, u8 dst_stride, u8 src_stride) inline void stream_data_to_memory_u8_non_continuous(void *dst, const void *src, u32 vertex_count, u8 attribute_size, u8 dst_stride, u8 src_stride)
{ {
char *src_ptr = (char *)src; auto src_ptr = static_cast<const char*>(src);
char *dst_ptr = (char *)dst; auto dst_ptr = static_cast<char*>(dst);
switch (attribute_size) switch (attribute_size)
{ {
@ -314,7 +320,7 @@ namespace
//Read one dword every iteration //Read one dword every iteration
for (u32 vertex = 0; vertex < vertex_count; ++vertex) for (u32 vertex = 0; vertex < vertex_count; ++vertex)
{ {
*(u32*)dst_ptr = *(u32*)src_ptr; *reinterpret_cast<u32*>(dst_ptr) = *reinterpret_cast<const u32*>(src_ptr);
dst_ptr += dst_stride; dst_ptr += dst_stride;
src_ptr += src_stride; src_ptr += src_stride;
@ -327,7 +333,7 @@ namespace
//Read one word and one byte //Read one word and one byte
for (u32 vertex = 0; vertex < vertex_count; ++vertex) for (u32 vertex = 0; vertex < vertex_count; ++vertex)
{ {
*(u16*)dst_ptr = *(u16*)src_ptr; *reinterpret_cast<u16*>(dst_ptr) = *reinterpret_cast<const u16*>(src_ptr);
dst_ptr[2] = src_ptr[2]; dst_ptr[2] = src_ptr[2];
dst_ptr += dst_stride; dst_ptr += dst_stride;
@ -341,7 +347,7 @@ namespace
//Copy u16 blocks //Copy u16 blocks
for (u32 vertex = 0; vertex < vertex_count; ++vertex) for (u32 vertex = 0; vertex < vertex_count; ++vertex)
{ {
*(u16*)dst_ptr = *(u16*)src_ptr; *reinterpret_cast<u16*>(dst_ptr) = *reinterpret_cast<const u16*>(src_ptr);
dst_ptr += dst_stride; dst_ptr += dst_stride;
src_ptr += src_stride; src_ptr += src_stride;
@ -365,15 +371,15 @@ namespace
} }
template <typename T, typename U, int N> template <typename T, typename U, int N>
void copy_whole_attribute_array_impl(void *raw_dst, void *raw_src, u8 dst_stride, u32 src_stride, u32 vertex_count) void copy_whole_attribute_array_impl(void* raw_dst, const void* raw_src, u8 dst_stride, u32 src_stride, u32 vertex_count)
{ {
char *src_ptr = (char *)raw_src; auto src_ptr = static_cast<const char*>(raw_src);
char *dst_ptr = (char *)raw_dst; auto dst_ptr = static_cast<char*>(raw_dst);
for (u32 vertex = 0; vertex < vertex_count; ++vertex) for (u32 vertex = 0; vertex < vertex_count; ++vertex)
{ {
T* typed_dst = (T*)dst_ptr; auto typed_dst = reinterpret_cast<T*>(dst_ptr);
U* typed_src = (U*)src_ptr; auto typed_src = reinterpret_cast<const U*>(src_ptr);
for (u32 i = 0; i < N; ++i) for (u32 i = 0; i < N; ++i)
{ {
@ -390,18 +396,18 @@ namespace
* e.g repeat 2 vertices over a range of 16 verts, so 8 reps * e.g repeat 2 vertices over a range of 16 verts, so 8 reps
*/ */
template <typename T, typename U, int N> template <typename T, typename U, int N>
void copy_whole_attribute_array_repeating_impl(void *raw_dst, void *raw_src, const u8 dst_stride, const u32 src_stride, const u32 vertex_count, const u32 src_vertex_count) void copy_whole_attribute_array_repeating_impl(void* raw_dst, const void* raw_src, const u8 dst_stride, const u32 src_stride, const u32 vertex_count, const u32 src_vertex_count)
{ {
char *src_ptr = (char *)raw_src; auto src_ptr = static_cast<const char*>(raw_src);
char *dst_ptr = (char *)raw_dst; auto dst_ptr = static_cast<char*>(raw_dst);
u32 src_offset = 0; u32 src_offset = 0;
u32 src_limit = src_stride * src_vertex_count; u32 src_limit = src_stride * src_vertex_count;
for (u32 vertex = 0; vertex < vertex_count; ++vertex) for (u32 vertex = 0; vertex < vertex_count; ++vertex)
{ {
T* typed_dst = (T*)dst_ptr; auto typed_dst = reinterpret_cast<T*>(dst_ptr);
U* typed_src = (U*)(src_ptr + src_offset); auto typed_src = reinterpret_cast<const U*>(src_ptr + src_offset);
for (u32 i = 0; i < N; ++i) for (u32 i = 0; i < N; ++i)
{ {
@ -414,7 +420,7 @@ namespace
} }
template <typename U, typename T> template <typename U, typename T>
void copy_whole_attribute_array(void *raw_dst, void *raw_src, const u8 attribute_size, const u8 dst_stride, const u32 src_stride, const u32 vertex_count, const u32 src_vertex_count) void copy_whole_attribute_array(void* raw_dst, const void* raw_src, const u8 attribute_size, const u8 dst_stride, const u32 src_stride, const u32 vertex_count, const u32 src_vertex_count)
{ {
//Eliminate the inner loop by templating the inner loop counter N //Eliminate the inner loop by templating the inner loop counter N
@ -471,13 +477,13 @@ void write_vertex_array_data_to_buffer(gsl::span<std::byte> raw_dst_span, gsl::s
//Sometimes, we get a vertex attribute to be repeated. Just copy the supplied vertices only //Sometimes, we get a vertex attribute to be repeated. Just copy the supplied vertices only
//TODO: Stop these requests from getting here in the first place! //TODO: Stop these requests from getting here in the first place!
//TODO: Check if it is possible to have a repeating array with more than one attribute instance //TODO: Check if it is possible to have a repeating array with more than one attribute instance
const u32 real_count = (u32)src_ptr.size_bytes() / attribute_src_stride; const u32 real_count = static_cast<u32>(src_ptr.size_bytes()) / attribute_src_stride;
if (real_count == 1) attribute_src_stride = 0; //Always fetch src[0] if (real_count == 1) attribute_src_stride = 0; //Always fetch src[0]
//TODO: Determine favourable vertex threshold where vector setup costs become negligible //TODO: Determine favourable vertex threshold where vector setup costs become negligible
//Tests show that even with 4 vertices, using traditional bswap is significantly slower over a large number of calls //Tests show that even with 4 vertices, using traditional bswap is significantly slower over a large number of calls
const u64 src_address = (u64)src_ptr.data(); const u64 src_address = reinterpret_cast<u64>(src_ptr.data());
const bool sse_aligned = ((src_address & 15) == 0); const bool sse_aligned = ((src_address & 15) == 0);
#if !DEBUG_VERTEX_STREAMING #if !DEBUG_VERTEX_STREAMING
@ -505,7 +511,7 @@ void write_vertex_array_data_to_buffer(gsl::span<std::byte> raw_dst_span, gsl::s
else if (use_stream_with_stride) else if (use_stream_with_stride)
stream_data_to_memory_u8_non_continuous(raw_dst_span.data(), src_ptr.data(), count, vector_element_count, dst_stride, attribute_src_stride); stream_data_to_memory_u8_non_continuous(raw_dst_span.data(), src_ptr.data(), count, vector_element_count, dst_stride, attribute_src_stride);
else else
copy_whole_attribute_array<u8, u8>((void *)raw_dst_span.data(), (void *)src_ptr.data(), vector_element_count, dst_stride, attribute_src_stride, count, real_count); copy_whole_attribute_array<u8, u8>(raw_dst_span.data(), src_ptr.data(), vector_element_count, dst_stride, attribute_src_stride, count, real_count);
return; return;
} }
@ -518,9 +524,9 @@ void write_vertex_array_data_to_buffer(gsl::span<std::byte> raw_dst_span, gsl::s
else if (use_stream_with_stride) else if (use_stream_with_stride)
stream_data_to_memory_swapped_u16_non_continuous(raw_dst_span.data(), src_ptr.data(), count, dst_stride, attribute_src_stride); stream_data_to_memory_swapped_u16_non_continuous(raw_dst_span.data(), src_ptr.data(), count, dst_stride, attribute_src_stride);
else if (swap_endianness) else if (swap_endianness)
copy_whole_attribute_array<be_t<u16>, u16>((void *)raw_dst_span.data(), (void *)src_ptr.data(), vector_element_count, dst_stride, attribute_src_stride, count, real_count); copy_whole_attribute_array<be_t<u16>, u16>(raw_dst_span.data(), src_ptr.data(), vector_element_count, dst_stride, attribute_src_stride, count, real_count);
else else
copy_whole_attribute_array<u16, u16>((void *)raw_dst_span.data(), (void *)src_ptr.data(), vector_element_count, dst_stride, attribute_src_stride, count, real_count); copy_whole_attribute_array<u16, u16>(raw_dst_span.data(), src_ptr.data(), vector_element_count, dst_stride, attribute_src_stride, count, real_count);
return; return;
} }
@ -531,9 +537,9 @@ void write_vertex_array_data_to_buffer(gsl::span<std::byte> raw_dst_span, gsl::s
else if (use_stream_with_stride) else if (use_stream_with_stride)
stream_data_to_memory_swapped_u32_non_continuous(raw_dst_span.data(), src_ptr.data(), count, dst_stride, attribute_src_stride); stream_data_to_memory_swapped_u32_non_continuous(raw_dst_span.data(), src_ptr.data(), count, dst_stride, attribute_src_stride);
else if (swap_endianness) else if (swap_endianness)
copy_whole_attribute_array<be_t<u32>, u32>((void *)raw_dst_span.data(), (void *)src_ptr.data(), vector_element_count, dst_stride, attribute_src_stride, count, real_count); copy_whole_attribute_array<be_t<u32>, u32>(raw_dst_span.data(), src_ptr.data(), vector_element_count, dst_stride, attribute_src_stride, count, real_count);
else else
copy_whole_attribute_array<u32, u32>((void *)raw_dst_span.data(), (void *)src_ptr.data(), vector_element_count, dst_stride, attribute_src_stride, count, real_count); copy_whole_attribute_array<u32, u32>(raw_dst_span.data(), src_ptr.data(), vector_element_count, dst_stride, attribute_src_stride, count, real_count);
return; return;
} }
@ -590,8 +596,8 @@ namespace
0x6, 0x7, 0x4, 0x5, 0x6, 0x7, 0x4, 0x5,
0x2, 0x3, 0x0, 0x1); 0x2, 0x3, 0x0, 0x1);
auto src_stream = (const __m128i*)src; auto src_stream = static_cast<const __m128i*>(src);
auto dst_stream = (__m128i*)dst; auto dst_stream = static_cast<__m128i*>(dst);
__m128i min = _mm_set1_epi16(0xFFFF); __m128i min = _mm_set1_epi16(0xFFFF);
__m128i max = _mm_set1_epi16(0); __m128i max = _mm_set1_epi16(0);
@ -622,8 +628,8 @@ namespace
0x4, 0x5, 0x6, 0x7, 0x4, 0x5, 0x6, 0x7,
0x0, 0x1, 0x2, 0x3); 0x0, 0x1, 0x2, 0x3);
auto src_stream = (const __m128i*)src; auto src_stream = static_cast<const __m128i*>(src);
auto dst_stream = (__m128i*)dst; auto dst_stream = static_cast<__m128i*>(dst);
__m128i min = _mm_set1_epi32(~0u); __m128i min = _mm_set1_epi32(~0u);
__m128i max = _mm_set1_epi32(0); __m128i max = _mm_set1_epi32(0);
@ -714,8 +720,8 @@ namespace
0x6, 0x7, 0x4, 0x5, 0x6, 0x7, 0x4, 0x5,
0x2, 0x3, 0x0, 0x1); 0x2, 0x3, 0x0, 0x1);
auto src_stream = (const __m256i*)src; auto src_stream = static_cast<const __m256i*>(src);
auto dst_stream = (__m256i*)dst; auto dst_stream = static_cast<__m256i*>(dst);
__m256i restart = _mm256_set1_epi16(restart_index); __m256i restart = _mm256_set1_epi16(restart_index);
__m256i min = _mm256_set1_epi16(0xffff); __m256i min = _mm256_set1_epi16(0xffff);
@ -757,8 +763,8 @@ namespace
0x6, 0x7, 0x4, 0x5, 0x6, 0x7, 0x4, 0x5,
0x2, 0x3, 0x0, 0x1); 0x2, 0x3, 0x0, 0x1);
auto src_stream = (const __m128i*)src; auto src_stream = static_cast<const __m128i*>(src);
auto dst_stream = (__m128i*)dst; auto dst_stream = static_cast<__m128i*>(dst);
__m128i restart = _mm_set1_epi16(restart_index); __m128i restart = _mm_set1_epi16(restart_index);
__m128i min = _mm_set1_epi16(0xffff); __m128i min = _mm_set1_epi16(0xffff);
@ -792,8 +798,8 @@ namespace
0x4, 0x5, 0x6, 0x7, 0x4, 0x5, 0x6, 0x7,
0x0, 0x1, 0x2, 0x3); 0x0, 0x1, 0x2, 0x3);
auto src_stream = (const __m128i*)src; auto src_stream = static_cast<const __m128i*>(src);
auto dst_stream = (__m128i*)dst; auto dst_stream = static_cast<__m128i*>(dst);
__m128i restart = _mm_set1_epi32(restart_index); __m128i restart = _mm_set1_epi32(restart_index);
__m128i min = _mm_set1_epi32(0xffffffff); __m128i min = _mm_set1_epi32(0xffffffff);
@ -903,7 +909,7 @@ namespace
} }
else else
{ {
return primitive_restart_impl::upload_untouched(src, dst, (u16)primitive_restart_index, is_primitive_disjointed(draw_mode)); return primitive_restart_impl::upload_untouched(src, dst, static_cast<u16>(primitive_restart_index), is_primitive_disjointed(draw_mode));
} }
} }
else else
@ -1079,7 +1085,7 @@ u32 get_index_type_size(rsx::index_array_type type)
void write_index_array_for_non_indexed_non_native_primitive_to_buffer(char* dst, rsx::primitive_type draw_mode, unsigned count) void write_index_array_for_non_indexed_non_native_primitive_to_buffer(char* dst, rsx::primitive_type draw_mode, unsigned count)
{ {
unsigned short *typedDst = (unsigned short *)(dst); auto typedDst = reinterpret_cast<u16*>(dst);
switch (draw_mode) switch (draw_mode)
{ {
case rsx::primitive_type::line_loop: case rsx::primitive_type::line_loop:
@ -1166,7 +1172,7 @@ namespace
return expand_indexed_quads<T>(src, dst, restart_index_enabled, restart_index); return expand_indexed_quads<T>(src, dst, restart_index_enabled, restart_index);
} }
default: default:
fmt::throw_exception("Unknown draw mode (0x%x)" HERE, (u32)draw_mode); fmt::throw_exception("Unknown draw mode (0x%x)" HERE, static_cast<u8>(draw_mode));
} }
} }
} }
@ -1195,8 +1201,8 @@ std::tuple<u32, u32, u32> write_index_array_data_to_buffer(gsl::span<std::byte>
void stream_vector(void *dst, u32 x, u32 y, u32 z, u32 w) void stream_vector(void *dst, u32 x, u32 y, u32 z, u32 w)
{ {
__m128i vector = _mm_set_epi32(w, z, y, x); const __m128i vector = _mm_set_epi32(w, z, y, x);
_mm_stream_si128((__m128i*)dst, vector); _mm_stream_si128(reinterpret_cast<__m128i*>(dst), vector);
} }
void stream_vector(void *dst, f32 x, f32 y, f32 z, f32 w) void stream_vector(void *dst, f32 x, f32 y, f32 z, f32 w)
@ -1205,6 +1211,6 @@ void stream_vector(void *dst, f32 x, f32 y, f32 z, f32 w)
} }
void stream_vector_from_memory(void *dst, void *src) void stream_vector_from_memory(void *dst, void *src)
{ {
const __m128i &vector = _mm_loadu_si128((__m128i*)src); const __m128i vector = _mm_loadu_si128(reinterpret_cast<__m128i*>(src));
_mm_stream_si128((__m128i*)dst, vector); _mm_stream_si128(reinterpret_cast<__m128i*>(dst), vector);
} }

24
rpcs3/Emu/RSX/Common/ProgramStateCache.cpp
View file

@ -10,7 +10,7 @@ size_t vertex_program_utils::get_vertex_program_ucode_hash(const RSXVertexProgra
{ {
// 64-bit Fowler/Noll/Vo FNV-1a hash code // 64-bit Fowler/Noll/Vo FNV-1a hash code
size_t hash = 0xCBF29CE484222325ULL; size_t hash = 0xCBF29CE484222325ULL;
const qword *instbuffer = (const qword*)program.data.data(); const qword* instbuffer = reinterpret_cast<const qword*>(program.data.data());
size_t instIndex = 0; size_t instIndex = 0;
bool end = false; bool end = false;
for (unsigned i = 0; i < program.data.size() / 4; i++) for (unsigned i = 0; i < program.data.size() / 4; i++)
@ -70,7 +70,7 @@ vertex_program_utils::vertex_program_metadata vertex_program_utils::analyse_vert
} }
} }
const qword* instruction = (const qword*)&data[current_instrution * 4]; const qword* instruction = reinterpret_cast<const qword*>(&data[current_instrution * 4]);
d1.HEX = instruction->word[1]; d1.HEX = instruction->word[1];
d3.HEX = instruction->word[3]; d3.HEX = instruction->word[3];
@ -200,8 +200,8 @@ vertex_program_utils::vertex_program_metadata vertex_program_utils::analyse_vert
{ {
for (u32 i = instruction_range.first, count = 0; i <= instruction_range.second; ++i, ++count) for (u32 i = instruction_range.first, count = 0; i <= instruction_range.second; ++i, ++count)
{ {
const qword* instruction = (const qword*)&data[i * 4]; const qword* instruction = reinterpret_cast<const qword*>(&data[i * 4]);
qword* dst = (qword*)&dst_prog.data[count * 4]; qword* dst = reinterpret_cast<qword*>(&dst_prog.data[count * 4]);
if (result.instruction_mask[i]) if (result.instruction_mask[i])
{ {
@ -265,8 +265,8 @@ bool vertex_program_compare::operator()(const RSXVertexProgram &binary1, const R
if (!binary1.skip_vertex_input_check && !binary2.skip_vertex_input_check && binary1.rsx_vertex_inputs != binary2.rsx_vertex_inputs) if (!binary1.skip_vertex_input_check && !binary2.skip_vertex_input_check && binary1.rsx_vertex_inputs != binary2.rsx_vertex_inputs)
return false; return false;
const qword *instBuffer1 = (const qword*)binary1.data.data(); const qword* instBuffer1 = reinterpret_cast<const qword*>(binary1.data.data());
const qword *instBuffer2 = (const qword*)binary2.data.data(); const qword* instBuffer2 = reinterpret_cast<const qword*>(binary2.data.data());
size_t instIndex = 0; size_t instIndex = 0;
for (unsigned i = 0; i < binary1.data.size() / 4; i++) for (unsigned i = 0; i < binary1.data.size() / 4; i++)
{ {
@ -300,7 +300,7 @@ bool fragment_program_utils::is_constant(u32 sourceOperand)
size_t fragment_program_utils::get_fragment_program_ucode_size(void *ptr) size_t fragment_program_utils::get_fragment_program_ucode_size(void *ptr)
{ {
const qword *instBuffer = (const qword*)ptr; const qword* instBuffer = reinterpret_cast<const qword*>(ptr);
size_t instIndex = 0; size_t instIndex = 0;
while (true) while (true)
{ {
@ -325,7 +325,7 @@ size_t fragment_program_utils::get_fragment_program_ucode_size(void *ptr)
fragment_program_utils::fragment_program_metadata fragment_program_utils::analyse_fragment_program(void *ptr) fragment_program_utils::fragment_program_metadata fragment_program_utils::analyse_fragment_program(void *ptr)
{ {
const qword *instBuffer = (const qword*)ptr; const qword* instBuffer = reinterpret_cast<const qword*>(ptr);
s32 index = 0; s32 index = 0;
s32 program_offset = -1; s32 program_offset = -1;
u32 ucode_size = 0; u32 ucode_size = 0;
@ -388,14 +388,14 @@ fragment_program_utils::fragment_program_metadata fragment_program_utils::analys
index++; index++;
} }
return{ (u32)program_offset, ucode_size, constants_size, textures_mask }; return{ static_cast<u32>(program_offset), ucode_size, constants_size, textures_mask };
} }
size_t fragment_program_utils::get_fragment_program_ucode_hash(const RSXFragmentProgram& program) size_t fragment_program_utils::get_fragment_program_ucode_hash(const RSXFragmentProgram& program)
{ {
// 64-bit Fowler/Noll/Vo FNV-1a hash code // 64-bit Fowler/Noll/Vo FNV-1a hash code
size_t hash = 0xCBF29CE484222325ULL; size_t hash = 0xCBF29CE484222325ULL;
const qword *instbuffer = (const qword*)program.addr; const qword* instbuffer = reinterpret_cast<const qword*>(program.addr);
size_t instIndex = 0; size_t instIndex = 0;
while (true) while (true)
{ {
@ -447,8 +447,8 @@ bool fragment_program_compare::operator()(const RSXFragmentProgram& binary1, con
return false; return false;
} }
const qword *instBuffer1 = (const qword*)binary1.addr; const qword* instBuffer1 = reinterpret_cast<const qword*>(binary1.addr);
const qword *instBuffer2 = (const qword*)binary2.addr; const qword* instBuffer2 = reinterpret_cast<const qword*>(binary2.addr);
size_t instIndex = 0; size_t instIndex = 0;
while (true) while (true)
{ {

6
rpcs3/Emu/RSX/Common/surface_store.h
View file

@ -12,7 +12,7 @@ namespace
template <typename T> template <typename T>
gsl::span<T> as_const_span(gsl::span<const std::byte> unformated_span) gsl::span<T> as_const_span(gsl::span<const std::byte> unformated_span)
{ {
return{ (T*)unformated_span.data(), unformated_span.size_bytes() / sizeof(T) }; return{ reinterpret_cast<T*>(unformated_span.data()), unformated_span.size_bytes() / sizeof(T) };
} }
} }
@ -428,7 +428,7 @@ namespace rsx
if (pitch_compatible) if (pitch_compatible)
{ {
// Preserve memory outside the area to be inherited if needed // Preserve memory outside the area to be inherited if needed
split_surface_region<depth>(command_list, address, Traits::get(surface), (u16)width, (u16)height, bpp, antialias); split_surface_region<depth>(command_list, address, Traits::get(surface), static_cast<u16>(width), static_cast<u16>(height), bpp, antialias);
old_surface = Traits::get(surface); old_surface = Traits::get(surface);
} }
@ -444,7 +444,7 @@ namespace rsx
{ {
// Range test // Range test
const auto aa_factor_v = get_aa_factor_v(antialias); const auto aa_factor_v = get_aa_factor_v(antialias);
rsx::address_range range = rsx::address_range::start_length(address, u32(pitch * height * aa_factor_v)); rsx::address_range range = rsx::address_range::start_length(address, static_cast<u32>(pitch * height * aa_factor_v));
*storage_bounds = range.get_min_max(*storage_bounds); *storage_bounds = range.get_min_max(*storage_bounds);
// Search invalidated resources for a suitable surface // Search invalidated resources for a suitable surface

6
rpcs3/Emu/RSX/Common/surface_utils.h
View file

@ -56,8 +56,8 @@ namespace rsx
ret.height = height; ret.height = height;
ret.transfer_scale_x = transfer_scale_x; ret.transfer_scale_x = transfer_scale_x;
ret.transfer_scale_y = transfer_scale_y; ret.transfer_scale_y = transfer_scale_y;
ret.target = (T)(target); ret.target = static_cast<T>(target);
ret.source = (T)(source); ret.source = static_cast<T>(source);
return ret; return ret;
} }
@ -233,7 +233,7 @@ namespace rsx
spp = 4; spp = 4;
break; break;
default: default:
fmt::throw_exception("Unknown AA mode 0x%x", (u32)aa); fmt::throw_exception("Unknown AA mode 0x%x", static_cast<u8>(aa));
} }
} }

2
rpcs3/Emu/RSX/Overlays/overlay_font.cpp
View file

@ -99,7 +99,7 @@ namespace rsx
stbtt_PackSetOversampling(&context, oversample, oversample); stbtt_PackSetOversampling(&context, oversample, oversample);
// Convert pt to px // Convert pt to px
size_px = ceilf((f32)size * 96.f / 72.f); size_px = ceilf(size * 96.f / 72.f);
size_pt = size; size_pt = size;
if (!stbtt_PackFontRange(&context, bytes.data(), 0, size_px, 0, 256, pack_info.data())) if (!stbtt_PackFontRange(&context, bytes.data(), 0, size_px, 0, 256, pack_info.data()))

48
rpcs3/Emu/RSX/rsx_utils.cpp
View file

@ -26,7 +26,7 @@ namespace rsx
void clip_image(u8 *dst, const u8 *src, int clip_x, int clip_y, int clip_w, int clip_h, int bpp, int src_pitch, int dst_pitch) void clip_image(u8 *dst, const u8 *src, int clip_x, int clip_y, int clip_w, int clip_h, int bpp, int src_pitch, int dst_pitch)
{ {
u8 *pixels_src = (u8*)src + clip_y * src_pitch + clip_x * bpp; const u8* pixels_src = src + clip_y * src_pitch + clip_x * bpp;
u8 *pixels_dst = dst; u8 *pixels_dst = dst;
const u32 row_length = clip_w * bpp; const u32 row_length = clip_w * bpp;
@ -130,13 +130,13 @@ namespace rsx
switch (element_size) switch (element_size)
{ {
case 1: case 1:
scale_image_fallback_impl<u8, u8>((u8*)dst, (const u8*)src, src_width, src_height, dst_pitch, src_pitch, element_size, samples_u, samples_v); scale_image_fallback_impl<u8, u8>(static_cast<u8*>(dst), static_cast<const u8*>(src), src_width, src_height, dst_pitch, src_pitch, element_size, samples_u, samples_v);
break; break;
case 2: case 2:
scale_image_fallback_impl<u16, u16>((u16*)dst, (const u16*)src, src_width, src_height, dst_pitch, src_pitch, element_size, samples_u, samples_v); scale_image_fallback_impl<u16, u16>(static_cast<u16*>(dst), static_cast<const u16*>(src), src_width, src_height, dst_pitch, src_pitch, element_size, samples_u, samples_v);
break; break;
case 4: case 4:
scale_image_fallback_impl<u32, u32>((u32*)dst, (const u32*)src, src_width, src_height, dst_pitch, src_pitch, element_size, samples_u, samples_v); scale_image_fallback_impl<u32, u32>(static_cast<u32*>(dst), static_cast<const u32*>(src), src_width, src_height, dst_pitch, src_pitch, element_size, samples_u, samples_v);
break; break;
default: default:
fmt::throw_exception("unsupported element size %d" HERE, element_size); fmt::throw_exception("unsupported element size %d" HERE, element_size);
@ -148,13 +148,13 @@ namespace rsx
switch (element_size) switch (element_size)
{ {
case 1: case 1:
scale_image_fallback_impl<u8, u8>((u8*)dst, (const u8*)src, src_width, src_height, dst_pitch, src_pitch, element_size, samples_u, samples_v); scale_image_fallback_impl<u8, u8>(static_cast<u8*>(dst), static_cast<const u8*>(src), src_width, src_height, dst_pitch, src_pitch, element_size, samples_u, samples_v);
break; break;
case 2: case 2:
scale_image_fallback_impl<u16, be_t<u16>>((u16*)dst, (const be_t<u16>*)src, src_width, src_height, dst_pitch, src_pitch, element_size, samples_u, samples_v); scale_image_fallback_impl<u16, be_t<u16>>(static_cast<u16*>(dst), static_cast<const be_t<u16>*>(src), src_width, src_height, dst_pitch, src_pitch, element_size, samples_u, samples_v);
break; break;
case 4: case 4:
scale_image_fallback_impl<u32, be_t<u32>>((u32*)dst, (const be_t<u32>*)src, src_width, src_height, dst_pitch, src_pitch, element_size, samples_u, samples_v); scale_image_fallback_impl<u32, be_t<u32>>(static_cast<u32*>(dst), static_cast<const be_t<u32>*>(src), src_width, src_height, dst_pitch, src_pitch, element_size, samples_u, samples_v);
break; break;
default: default:
fmt::throw_exception("unsupported element size %d" HERE, element_size); fmt::throw_exception("unsupported element size %d" HERE, element_size);
@ -191,16 +191,16 @@ namespace rsx
switch (element_size) switch (element_size)
{ {
case 1: case 1:
scale_image_impl<u8, u8, N>((u8*)dst, (const u8*)src, src_width, src_height, padding); scale_image_impl<u8, u8, N>(static_cast<u8*>(dst), static_cast<const u8*>(src), src_width, src_height, padding);
break; break;
case 2: case 2:
scale_image_impl<u16, u16, N>((u16*)dst, (const u16*)src, src_width, src_height, padding); scale_image_impl<u16, u16, N>(static_cast<u16*>(dst), static_cast<const u16*>(src), src_width, src_height, padding);
break; break;
case 4: case 4:
scale_image_impl<u32, u32, N>((u32*)dst, (const u32*)src, src_width, src_height, padding); scale_image_impl<u32, u32, N>(static_cast<u32*>(dst), static_cast<const u32*>(src), src_width, src_height, padding);
break; break;
case 8: case 8:
scale_image_impl<u64, u64, N>((u64*)dst, (const u64*)src, src_width, src_height, padding); scale_image_impl<u64, u64, N>(static_cast<u64*>(dst), static_cast<const u64*>(src), src_width, src_height, padding);
break; break;
default: default:
fmt::throw_exception("unsupported pixel size %d" HERE, element_size); fmt::throw_exception("unsupported pixel size %d" HERE, element_size);
@ -213,16 +213,16 @@ namespace rsx
switch (element_size) switch (element_size)
{ {
case 1: case 1:
scale_image_impl<u8, u8, N>((u8*)dst, (const u8*)src, src_width, src_height, padding); scale_image_impl<u8, u8, N>(static_cast<u8*>(dst), static_cast<const u8*>(src), src_width, src_height, padding);
break; break;
case 2: case 2:
scale_image_impl<u16, be_t<u16>, N>((u16*)dst, (const be_t<u16>*)src, src_width, src_height, padding); scale_image_impl<u16, be_t<u16>, N>(static_cast<u16*>(dst), static_cast<const be_t<u16>*>(src), src_width, src_height, padding);
break; break;
case 4: case 4:
scale_image_impl<u32, be_t<u32>, N>((u32*)dst, (const be_t<u32>*)src, src_width, src_height, padding); scale_image_impl<u32, be_t<u32>, N>(static_cast<u32*>(dst), static_cast<const be_t<u32>*>(src), src_width, src_height, padding);
break; break;
case 8: case 8:
scale_image_impl<u64, be_t<u64>, N>((u64*)dst, (const be_t<u64>*)src, src_width, src_height, padding); scale_image_impl<u64, be_t<u64>, N>(static_cast<u64*>(dst), static_cast<const be_t<u64>*>(src), src_width, src_height, padding);
break; break;
default: default:
fmt::throw_exception("unsupported pixel size %d" HERE, element_size); fmt::throw_exception("unsupported pixel size %d" HERE, element_size);
@ -313,8 +313,8 @@ namespace rsx
const auto num_iterations = (num_pixels >> 2); const auto num_iterations = (num_pixels >> 2);
__m128i* dst_ptr = (__m128i*)dst; __m128i* dst_ptr = static_cast<__m128i*>(dst);
__m128i* src_ptr = (__m128i*)src; __m128i* src_ptr = static_cast<__m128i*>(src);
const __m128 scale_vector = _mm_set1_ps(16777214.f); const __m128 scale_vector = _mm_set1_ps(16777214.f);
@ -332,7 +332,7 @@ namespace rsx
for (u32 n = 0; n < num_iterations; ++n) for (u32 n = 0; n < num_iterations; ++n)
{ {
const __m128i src_vector = _mm_loadu_si128(src_ptr); const __m128i src_vector = _mm_loadu_si128(src_ptr);
const __m128i result = _mm_cvtps_epi32(_mm_mul_ps((__m128&)src_vector, scale_vector)); const __m128i result = _mm_cvtps_epi32(_mm_mul_ps(_mm_castsi128_ps(src_vector), scale_vector));
const __m128i shuffled_vector = _mm_shuffle_epi8(result, swap_mask); const __m128i shuffled_vector = _mm_shuffle_epi8(result, swap_mask);
_mm_stream_si128(dst_ptr, shuffled_vector); _mm_stream_si128(dst_ptr, shuffled_vector);
++dst_ptr; ++dst_ptr;
@ -350,7 +350,7 @@ namespace rsx
for (u32 n = 0; n < num_iterations; ++n) for (u32 n = 0; n < num_iterations; ++n)
{ {
const __m128i src_vector = _mm_loadu_si128(src_ptr); const __m128i src_vector = _mm_loadu_si128(src_ptr);
const __m128i result = _mm_cvtps_epi32(_mm_mul_ps((__m128&)src_vector, scale_vector)); const __m128i result = _mm_cvtps_epi32(_mm_mul_ps(_mm_castsi128_ps(src_vector), scale_vector));
const __m128i v1 = _mm_and_si128(result, mask1); const __m128i v1 = _mm_and_si128(result, mask1);
const __m128i v2 = _mm_and_si128(_mm_slli_epi32(result, 16), mask2); const __m128i v2 = _mm_and_si128(_mm_slli_epi32(result, 16), mask2);
@ -370,8 +370,8 @@ namespace rsx
const auto num_iterations = (num_pixels >> 2); const auto num_iterations = (num_pixels >> 2);
__m128i* dst_ptr = (__m128i*)dst; __m128i* dst_ptr = static_cast<__m128i*>(dst);
__m128i* src_ptr = (__m128i*)src; __m128i* src_ptr = static_cast<__m128i*>(src);
#if defined (_MSC_VER) || defined (__SSSE3__) #if defined (_MSC_VER) || defined (__SSSE3__)
if (LIKELY(utils::has_ssse3())) if (LIKELY(utils::has_ssse3()))
@ -422,8 +422,8 @@ namespace rsx
const auto num_iterations = (num_pixels >> 2); const auto num_iterations = (num_pixels >> 2);
__m128i* dst_ptr = (__m128i*)dst; __m128i* dst_ptr = static_cast<__m128i*>(dst);
__m128i* src_ptr = (__m128i*)src; __m128i* src_ptr = static_cast<__m128i*>(src);
const __m128 scale_vector = _mm_set1_ps(1.f / 16777214.f); const __m128 scale_vector = _mm_set1_ps(1.f / 16777214.f);
const __m128i mask = _mm_set1_epi32(0x00FFFFFF); const __m128i mask = _mm_set1_epi32(0x00FFFFFF);
@ -431,7 +431,7 @@ namespace rsx
{ {
const __m128 src_vector = _mm_cvtepi32_ps(_mm_and_si128(mask, _mm_loadu_si128(src_ptr))); const __m128 src_vector = _mm_cvtepi32_ps(_mm_and_si128(mask, _mm_loadu_si128(src_ptr)));
const __m128 normalized_vector = _mm_mul_ps(src_vector, scale_vector); const __m128 normalized_vector = _mm_mul_ps(src_vector, scale_vector);
_mm_stream_si128(dst_ptr, (__m128i&)normalized_vector); _mm_stream_si128(dst_ptr, _mm_castps_si128(normalized_vector));
++dst_ptr; ++dst_ptr;
++src_ptr; ++src_ptr;
} }

2
rpcs3/Emu/System.cpp
View file

@ -1726,7 +1726,7 @@ void Emulator::Resume()
{ {
if (vm::check_addr(i)) if (vm::check_addr(i))
{ {
if (auto& data = *(be_t<u32>*)(vm::g_stat_addr + i)) if (auto& data = *reinterpret_cast<be_t<u32>*>(vm::g_stat_addr + i))
{ {
dis_asm.dump_pc = i; dis_asm.dump_pc = i;
dis_asm.disasm(i); dis_asm.disasm(i);