mirror/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-02-10 21:40:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

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
Show Stats 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))
{
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->CreateShuffleVector(data0, zeros, result.value);
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;
data = crc;
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)

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)
{
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;
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;
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;
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)
{
case 4: *(u32*)dst = *(be_t<u32>*)src; break;
case 2: *(u16*)dst = *(be_t<u16>*)src; break;
case 4: *static_cast<u32*>(dst) = *static_cast<const be_t<u32>*>(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)
{
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))
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)
{
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 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)
{
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;
}
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;
}
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 std::lock_guard lock(mic_thr->mutex);
if (!mic_thr->init)
return CELL_MIC_ERROR_NOT_INIT;
be_t<u32>* ival = (be_t<u32>*)value.get_ptr();
be_t<f32>* fval = (be_t<f32>*)value.get_ptr();
be_t<u32>* ival = vm::_ptr<u32>(value.addr());
be_t<f32>* fval = vm::_ptr<f32>(value.addr());
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))
return CELL_MIC_ERROR_NOT_OPEN;
u8* res_buf = (u8*)data.get_ptr();
return mic.read_raw(res_buf, maxBytes);
return mic.read_raw(vm::_ptr<u8>(data.addr()), 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))
return CELL_MIC_ERROR_NOT_OPEN;
u8* res_buf = (u8*)data.get_ptr();
return mic.read_dsp(res_buf, maxBytes);
return mic.read_dsp(vm::_ptr<u8>(data.addr()), maxBytes);
}
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>())
{
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
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;
// 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
{
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);
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;
// 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
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)
{
// 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];
switch (header.type)
@ -138,7 +138,7 @@ u8 pamfGetStreamType(vm::ptr<CellPamfReader> pSelf, u32 stream)
u8 pamfGetStreamChannel(vm::ptr<CellPamfReader> pSelf, u32 stream)
{
// 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];
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;
const u64 offset = (u64)pAddr->data_offset << 11;
const u64 offset = u64{pAddr->data_offset} << 11;
*pSize = offset;
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;
const u64 offset = (u64)pAddr->data_offset << 11;
const u64 offset = u64{pAddr->data_offset} << 11;
*pSize = offset;
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;
const u64 offset = (u64)pAddr->data_offset << 11;
const u64 offset = u64{pAddr->data_offset} << 11;
*pOffset = offset;
const u64 size = (u64)pAddr->data_size << 11;
const u64 size = u64{pAddr->data_size} << 11;
*pSize = size;
return CELL_OK;
}
@ -231,7 +231,7 @@ s32 cellPamfReaderInitialize(vm::ptr<CellPamfReader> pSelf, vm::cptr<PamfHeader>
}
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;
@ -251,7 +251,7 @@ s32 cellPamfReaderGetPresentationStartTime(vm::ptr<CellPamfReader> pSelf, vm::pt
// 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;
return CELL_OK;
}
@ -262,7 +262,7 @@ s32 cellPamfReaderGetPresentationEndTime(vm::ptr<CellPamfReader> pSelf, vm::ptr<
// 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;
return CELL_OK;
}
@ -454,7 +454,7 @@ s32 cellPamfReaderGetEsFilterId(vm::ptr<CellPamfReader> pSelf, vm::ptr<CellCodec
// 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];
pEsFilterId->filterIdMajor = header.fid_major;
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);
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];
const u8 type = pamfGetStreamType(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->horizontalSize = ((u16)header.AVC.horizontalSize & 0xff) * 16;
info->verticalSize = ((u16)header.AVC.verticalSize & 0xff) * 16;
info->horizontalSize = (header.AVC.horizontalSize & u8{0xff}) * 16;
info->verticalSize = (header.AVC.verticalSize & u8{0xff}) * 16;
info->frameCropLeftOffset = header.AVC.frameCropLeftOffset;
info->frameCropRightOffset = header.AVC.frameCropRightOffset;
info->frameCropTopOffset = header.AVC.frameCropTopOffset;
@ -567,8 +567,8 @@ s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, vm::ptr<void> pIn
info->sarHeight = 0;
}
info->horizontalSize = ((u16)header.M2V.horizontalSize & 0xff) * 16;
info->verticalSize = ((u16)header.M2V.verticalSize & 0xff) * 16;
info->horizontalSize = (header.M2V.horizontalSize & u8{0xff}) * 16;
info->verticalSize = (header.M2V.verticalSize & u8{0xff}) * 16;
info->horizontalSizeValue = header.M2V.horizontalSizeValue;
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
PngBuffer& buffer = *(PngBuffer*)io_ptr;
PngBuffer& buffer = *static_cast<PngBuffer*>(io_ptr);
// Read froma file or a buffer
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)
{
PngStream* stream = (PngStream*)png_get_progressive_ptr(png_ptr);
PngStream* stream = static_cast<PngStream*>(png_get_progressive_ptr(png_ptr));
if (!stream)
{
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)
{
PngStream* stream = (PngStream*)png_get_progressive_ptr(png_ptr);
PngStream* stream = static_cast<PngStream*>(png_get_progressive_ptr(png_ptr));
if (!stream)
{
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)
{
PngStream* stream = (PngStream*)png_get_progressive_ptr(png_ptr);
PngStream* stream = static_cast<PngStream*>(png_get_progressive_ptr(png_ptr));
if (!stream)
{
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
}
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
}
@ -483,7 +483,7 @@ s32 pngDecOpen(ppu_thread& ppu, PHandle handle, PPStream png_stream, PSrc source
stream->cbCtrlStream.cbCtrlStrmArg = control_stream->cbCtrlStrmArg;
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
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);
// 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);
png_unknown_chunkp 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)
{
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;
}

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)
{
return (s64)seconds + (s64)minutes * 60 + (s64)hours * 3600 + (s64)days * 86400 +
(s64)(years - 70) * 31536000 + (s64)((years - 69) / 4) * 86400 -
(s64)((years - 1) / 100) * 86400 + (s64)((years + 299) / 400) * 86400;
return s64{seconds} + s64{minutes} * 60 + s64{hours} * 3600 + s64{days} * 86400 +
s64{years - 70} * 31536000 + s64{(years - 69) / 4} * 86400 -
s64{(years - 1) / 100} * 86400 + s64{(years + 299) / 400} * 86400;
}
u64 convertToWin32FILETIME(u16 seconds, u16 minutes, u16 hours, u16 days, s32 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;
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);
switch ((s32)pSelf->streamType)
switch (pSelf->streamType)
{
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)
{
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>();
search->func = func;
@ -91,7 +91,7 @@ error_code cellSearchFinalize()
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)
{
@ -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)
{
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)
{
@ -143,7 +143,7 @@ error_code cellSearchStartContentSearchInList(vm::cptr<CellSearchContentId> list
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)
{
@ -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)
{
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)
{
@ -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)
{
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)
{
@ -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)
{
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)
{

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

@ -168,7 +168,7 @@ namespace _spurs
namespace _spurs
{
// 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);
@ -506,13 +506,13 @@ void _spurs::handler_wait_ready(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
for (u32 i = 0; i < 16; i++)
{
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)
{
if (spurs->wklReadyCount1[i] ||
spurs->wklSignal1.load() & (0x8000u >> i) ||
(spurs->wklFlag.flag.load() == 0 &&
spurs->wklFlagReceiver == (u8)i))
spurs->wklFlagReceiver == static_cast<u8>(i)))
{
foundRunnableWorkload = true;
break;
@ -525,13 +525,13 @@ void _spurs::handler_wait_ready(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
for (u32 i = 0; i < 16; i++)
{
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)
{
if (spurs->wklIdleSpuCountOrReadyCount2[i] ||
spurs->wklSignal2.load() & (0x8000u >> i) ||
(spurs->wklFlag.flag.load() == 0 &&
spurs->wklFlagReceiver == (u8)i + 0x10))
spurs->wklFlagReceiver == static_cast<u8>(i) + 0x10))
{
foundRunnableWorkload = true;
break;
@ -642,7 +642,7 @@ s32 _spurs::wakeup_shutdown_completion_waiter(ppu_thread& ppu, vm::ptr<CellSpurs
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;
}
@ -676,7 +676,7 @@ s32 _spurs::wakeup_shutdown_completion_waiter(ppu_thread& ppu, vm::ptr<CellSpurs
if (!wklF->hook || wklEvent->load() & 0x10)
{
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;
@ -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++)
{
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)
{
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)
{
const u32 shutdownMask = (u32)event_data3;
const u32 shutdownMask = static_cast<u32>(event_data3);
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)
{
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)
{
@ -887,7 +887,7 @@ s32 _spurs::stop_event_helper(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
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;
}
@ -918,7 +918,7 @@ s32 _spurs::join_handler_thread(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
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;
return CELL_OK;
@ -987,7 +987,7 @@ s32 _spurs::initialize(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 revision,
spurs->ppu0 = 0xffffffffull;
spurs->ppu1 = 0xffffffffull;
spurs->flags = flags;
spurs->prefixSize = (u8)prefixSize;
spurs->prefixSize = static_cast<u8>(prefixSize);
std::memcpy(spurs->prefix, prefix.get_ptr(), prefixSize);
if (!isSecond)
@ -1063,7 +1063,7 @@ s32 _spurs::initialize(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 revision,
std::strcat(spuTgName.get_ptr(), "CellSpursKernelGroup");
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;
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");
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;
spuThName[spuThAttr->name_len - 1] = '\0';
for (s32 num = 0; num < nSpus; num++)
{
spuThName[spuThAttr->name_len - 2] = '0' + num;
spuThArgs->arg1 = (u64)num << 32;
spuThArgs->arg2 = (u64)spurs.addr();
spuThArgs->arg1 = static_cast<u64>(num) << 32;
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))
{
@ -1469,7 +1469,7 @@ s32 cellSpursAttributeEnableSystemWorkload(vm::ptr<CellSpursAttribute> attr, vm:
}
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
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
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);
@ -1667,20 +1667,16 @@ s32 cellSpursSetPriorities(vm::ptr<CellSpurs> spurs, u32 wid, vm::cptr<u8> prior
// TODO: Implement this
}
u64 prio = 0;
for (s32 i = 0; i < CELL_SPURS_MAX_SPU; i++)
{
if (priorities[i] >= CELL_SPURS_MAX_PRIORITY)
{
return CELL_SPURS_CORE_ERROR_INVAL;
}
const u64 prio = std::bit_cast<u64>(*priorities);
prio |= priorities[i];
prio <<= 8;
// Test if any of the value >= CELL_SPURS_MAX_PRIORITY
if (prio & 0xf0f0f0f0f0f0f0f0)
{
return CELL_SPURS_CORE_ERROR_INVAL;
}
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->sysSrvMessage = 0xff;
@ -1831,7 +1827,7 @@ void _spurs::trace_status_update(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
if (init)
{
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;
}
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;
}
memset(attr.get_ptr(), 0, sizeof(CellSpursWorkloadAttribute));
std::memset(attr.get_ptr(), 0, sizeof(CellSpursWorkloadAttribute));
attr->revision = revision;
attr->sdkVersion = sdkVersion;
attr->pm = pm;
attr->size = size;
attr->data = data;
*(u64*)attr->priority = *(u64*)*priority;
std::memcpy(attr->priority, &prio, 8);
attr->minContention = minCnt;
attr->maxContention = maxCnt;
return CELL_OK;
@ -2102,7 +2102,7 @@ s32 cellSpursWorkloadAttributeSetShutdownCompletionEventHook(vm::ptr<CellSpursWo
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)
{
@ -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;
}
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;
}
@ -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
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)
{
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);
});
@ -2453,11 +2453,11 @@ s32 cellSpursReadyCountStore(vm::ptr<CellSpurs> spurs, u32 wid, u32 value)
if (wid < CELL_SPURS_MAX_WORKLOAD)
{
spurs->wklReadyCount1[wid].exchange((u8)value);
spurs->wklReadyCount1[wid].exchange(static_cast<u8>(value));
}
else
{
spurs->wklIdleSpuCountOrReadyCount2[wid].exchange((u8)value);
spurs->wklIdleSpuCountOrReadyCount2[wid].exchange(static_cast<u8>(value));
}
return CELL_OK;
@ -2608,7 +2608,7 @@ s32 _cellSpursWorkloadFlagReceiver(vm::ptr<CellSpurs> spurs, u32 wid, u32 is_set
{
if (FR == 0xff)
{
FR = (u8)wid;
FR = static_cast<u8>(wid);
}
}
else
@ -2810,11 +2810,11 @@ s32 cellSpursEventFlagSet(ppu_thread& ppu, vm::ptr<CellSpursEventFlag> eventFlag
vm::var<vm::ptr<CellSpursTaskset>> taskset;
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
{
taskset->set((u32)eventFlag->addr);
*taskset = vm::cast(eventFlag->addr, HERE);
}
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];
((CellSpursEventFlag::ControlSyncVar&)eventFlag->ctrl).ppuPendingRecv = 0;
eventFlag->ctrl.atomic_op([](auto& ctrl) { ctrl.ppuPendingRecv = 0; });
}
*mask = receivedEvents;
@ -3029,11 +3029,11 @@ s32 cellSpursEventFlagAttachLv2EventQueue(ppu_thread& ppu, vm::ptr<CellSpursEven
vm::ptr<CellSpurs> spurs;
if (eventFlag->isIwl == 1)
{
spurs.set((u32)eventFlag->addr);
spurs = vm::cast(eventFlag->addr, HERE);
}
else
{
auto taskset = vm::ptr<CellSpursTaskset>::make((u32)eventFlag->addr);
auto taskset = vm::ptr<CellSpursTaskset>::make(vm::cast(eventFlag->addr, HERE));
spurs = taskset->spurs;
}
@ -3122,11 +3122,11 @@ s32 cellSpursEventFlagDetachLv2EventQueue(ppu_thread& ppu, vm::ptr<CellSpursEven
vm::ptr<CellSpurs> spurs;
if (eventFlag->isIwl == 1)
{
spurs.set((u32)eventFlag->addr);
spurs = vm::cast(eventFlag->addr, HERE);
}
else
{
auto taskset = vm::ptr<CellSpursTaskset>::make((u32)eventFlag->addr);
auto taskset = vm::ptr<CellSpursTaskset>::make(vm::cast(eventFlag->addr, HERE));
spurs = taskset->spurs;
}
@ -3904,7 +3904,7 @@ s32 cellSpursLookUpTasksetAddress(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm:
return rc ^ 0x100;
}
taskset->set((u32)*data);
*taskset = vm::cast(*data, HERE);
return CELL_OK;
}
@ -3927,7 +3927,7 @@ s32 cellSpursTasksetGetSpursAddress(vm::cptr<CellSpursTaskset> taskset, vm::ptr<
return CELL_SPURS_TASK_ERROR_INVAL;
}
*spurs = (u32)taskset->spurs.addr();
*spurs = vm::cast(taskset->spurs.addr(), HERE);
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];
if (status)
{
*status = (u32)result;
*status = static_cast<u32>(result);
}
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)
{
spu.set_ch_value(MFC_LSA, lsa);
spu.set_ch_value(MFC_EAH, (u32)(ea >> 32));
spu.set_ch_value(MFC_EAL, (u32)(ea));
spu.set_ch_value(MFC_EAH, static_cast<u32>(ea >> 32));
spu.set_ch_value(MFC_EAL, static_cast<u32>(ea));
spu.set_ch_value(MFC_Size, size);
spu.set_ch_value(MFC_TagID, tag);
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
// 7. The workload id (lesser the number, more the weight)
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 |= (contention[i] > 0 && spurs->wklMinContention[i] > contention[i]) ? 0x40 : 0x00;
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);
}//);
u64 result = (u64)wklSelectedId << 32;
u64 result = u64{wklSelectedId} << 32;
result |= pollStatus;
spu.gpr[3]._u64[1] = result;
return true;
@ -597,7 +597,7 @@ bool spursKernel2SelectWorkload(spu_thread& spu)
std::memcpy(vm::base(spu.offset + 0x100), spurs, 128);
}//);
u64 result = (u64)wklSelectedId << 32;
u64 result = u64{wklSelectedId} << 32;
result |= pollStatus;
spu.gpr[3]._u64[1] = result;
return true;
@ -609,8 +609,8 @@ void spursKernelDispatchWorkload(spu_thread& spu, u64 widAndPollStatus)
auto ctxt = vm::_ptr<SpursKernelContext>(spu.offset + 0x100);
auto isKernel2 = ctxt->spurs->flags1 & SF1_32_WORKLOADS ? true : false;
auto pollStatus = (u32)widAndPollStatus;
auto wid = (u32)(widAndPollStatus >> 32);
auto pollStatus = static_cast<u32>(widAndPollStatus);
auto wid = static_cast<u32>(widAndPollStatus >> 32);
// DMA in the workload info for the selected workload
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);
// 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;
}
@ -1167,7 +1167,7 @@ void spursSysServiceTraceSaveCount(spu_thread& spu, SpursKernelContext* ctxt)
{
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;
}
}
@ -1787,7 +1787,7 @@ void spursTasksetDispatch(spu_thread& spu)
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

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])
continue;
// 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

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;
}
if (isBlocking && useEventQueue && *(u32*)queue->m_bs == -1)
if (isBlocking && useEventQueue && std::bit_cast<s32>(queue->m_bs) == -1)
{
return CELL_SYNC_ERROR_STAT;
}
s32 var2 = (s16)push.m_h8;
s32 var2 = static_cast<s16>(push.m_h8);
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;
}
else
{
var2 -= (s32)(u16)queue->pop1.load().m_h1;
var2 -= queue->pop1.load().m_h1;
if (var2 < 0)
{
var2 += depth * 2;
@ -923,7 +923,7 @@ error_code _cellSyncLFQueueGetPushPointer(ppu_thread& ppu, vm::ptr<CellSyncLFQue
if (var2 < depth)
{
const s32 _pointer = (s16)push.m_h8;
const s32 _pointer = static_cast<s16>(push.m_h8);
*pointer = _pointer;
if (_pointer + 1 >= depth * 2)
{
@ -997,13 +997,13 @@ error_code _cellSyncLFQueueCompletePushPointer(ppu_thread& ppu, vm::ptr<CellSync
const auto old2 = queue->push3.load();
auto push3 = old2;
s32 var1 = pointer - (u16)push3.m_h5;
s32 var1 = pointer - push3.m_h5;
if (var1 < 0)
{
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)
{
var2 += depth * 2;
@ -1019,9 +1019,9 @@ error_code _cellSyncLFQueueCompletePushPointer(ppu_thread& ppu, vm::ptr<CellSync
{
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)
{
var5 = 0;
@ -1031,7 +1031,7 @@ error_code _cellSyncLFQueueCompletePushPointer(ppu_thread& ppu, vm::ptr<CellSync
var5 <<= var9;
}
s32 var3 = (u16)push3.m_h5 + var9;
s32 var3 = push3.m_h5 + var9;
if (var3 >= depth * 2)
{
var3 -= depth * 2;
@ -1054,7 +1054,7 @@ error_code _cellSyncLFQueueCompletePushPointer(ppu_thread& ppu, vm::ptr<CellSync
var8 += 0x1e;
}
if (var9 > 1 && (u32)var8 > 1)
if (var9 > 1 && static_cast<u32>(var8) > 1)
{
verify(HERE), (16 - var2 <= 1);
}
@ -1076,15 +1076,15 @@ error_code _cellSyncLFQueueCompletePushPointer(ppu_thread& ppu, vm::ptr<CellSync
}
push2.pack = (pack & 0x83ff) | var12;
var6 = (u16)queue->m_hs1[var11];
var6 = queue->m_hs1[var11];
}
else
{
var6 = -1;
}
push3.m_h5 = (u16)var3;
push3.m_h6 = (u16)var5;
push3.m_h5 = static_cast<u16>(var3);
push3.m_h6 = static_cast<u16>(var5);
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), (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
{
@ -1164,7 +1164,7 @@ error_code _cellSyncLFQueuePushBody(ppu_thread& ppu, vm::ptr<CellSyncLFQueue> qu
const s32 depth = queue->m_depth;
const s32 size = queue->m_size;
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);
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;
}
if (isBlocking && useEventQueue && *(u32*)queue->m_bs == -1)
if (isBlocking && useEventQueue && std::bit_cast<s32>(queue->m_bs) == -1)
{
return CELL_SYNC_ERROR_STAT;
}
s32 var2 = (s32)(s16)pop.m_h4;
s32 var2 = static_cast<s16>(pop.m_h4);
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;
}
else
{
var2 = (s32)(u16)queue->push1.load().m_h5 - var2;
var2 = queue->push1.load().m_h5 - var2;
if (var2 < 0)
{
var2 += depth * 2;
@ -1222,7 +1222,7 @@ error_code _cellSyncLFQueueGetPopPointer(ppu_thread& ppu, vm::ptr<CellSyncLFQueu
if (var2 > 0)
{
const s32 _pointer = (s16)pop.m_h4;
const s32 _pointer = static_cast<s16>(pop.m_h4);
*pointer = _pointer;
if (_pointer + 1 >= depth * 2)
{
@ -1297,13 +1297,13 @@ error_code _cellSyncLFQueueCompletePopPointer(ppu_thread& ppu, vm::ptr<CellSyncL
const auto old2 = queue->pop3.load();
auto pop3 = old2;
s32 var1 = pointer - (u16)pop3.m_h1;
s32 var1 = pointer - pop3.m_h1;
if (var1 < 0)
{
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)
{
var2 += depth * 2;
@ -1319,9 +1319,9 @@ error_code _cellSyncLFQueueCompletePopPointer(ppu_thread& ppu, vm::ptr<CellSyncL
{
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)
{
var5 = 0;
@ -1331,7 +1331,7 @@ error_code _cellSyncLFQueueCompletePopPointer(ppu_thread& ppu, vm::ptr<CellSyncL
var5 <<= var9;
}
s32 var3 = (u16)pop3.m_h1 + var9;
s32 var3 = pop3.m_h1 + var9;
if (var3 >= depth * 2)
{
var3 -= depth * 2;
@ -1358,7 +1358,7 @@ error_code _cellSyncLFQueueCompletePopPointer(ppu_thread& ppu, vm::ptr<CellSyncL
var8 += 0x1e;
}
if (var9 > 1 && (u32)var8 > 1)
if (var9 > 1 && static_cast<u32>(var8) > 1)
{
verify(HERE), (16 - var2 <= 1);
}
@ -1380,11 +1380,11 @@ error_code _cellSyncLFQueueCompletePopPointer(ppu_thread& ppu, vm::ptr<CellSyncL
}
pop2.pack = (pack & 0x83ff) | var12;
var6 = (u16)queue->m_hs2[var11];
var6 = queue->m_hs2[var11];
}
pop3.m_h1 = (u16)var3;
pop3.m_h2 = (u16)var5;
pop3.m_h1 = static_cast<u16>(var3);
pop3.m_h2 = static_cast<u16>(var5);
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), (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
{
@ -1463,7 +1463,7 @@ error_code _cellSyncLFQueuePopBody(ppu_thread& ppu, vm::ptr<CellSyncLFQueue> que
const s32 depth = queue->m_depth;
const s32 size = queue->m_size;
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);
if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY)
@ -1501,16 +1501,16 @@ error_code cellSyncLFQueueClear(vm::ptr<CellSyncLFQueue> queue)
s32 var1, var2;
if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY)
{
var1 = var2 = (u16)queue->pop2.load().pack;
var1 = var2 = queue->pop2.load().pack;
}
else
{
var1 = (u16)push.m_h7;
var2 = (u16)pop.m_h3;
var1 = push.m_h7;
var2 = pop.m_h3;
}
if ((s32)(s16)pop.m_h4 != (s32)(u16)pop.m_h1 ||
(s32)(s16)push.m_h8 != (s32)(u16)push.m_h5 ||
if (static_cast<s16>(pop.m_h4) != +pop.m_h1 ||
static_cast<s16>(push.m_h8) != +push.m_h5 ||
((var2 >> 10) & 0x1f) != (var2 & 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();
// Loads must be in this order
u32 var1 = (u16)queue->pop1.load().m_h1;
u32 var2 = (u16)queue->push1.load().m_h5;
u32 var1 = queue->pop1.load().m_h1;
u32 var2 = queue->push1.load().m_h5;
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
{
*size = var2 - var1 + (u32)queue->m_depth * 2;
*size = var2 - var1 + queue->m_depth * 2;
}
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)
{
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);
@ -758,14 +758,14 @@ error_code cellVdecGetPicItem(u32 handle, vm::pptr<CellVdecPicItem> picItem)
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->auNum = 1;
info->auPts[0].lower = (u32)(pts);
info->auPts[0].upper = (u32)(pts >> 32);
info->auPts[1].lower = (u32)CODEC_TS_INVALID;
info->auPts[1].upper = (u32)CODEC_TS_INVALID;
info->auDts[0].lower = (u32)(dts);
info->auDts[0].upper = (u32)(dts >> 32);
info->auDts[1].lower = (u32)CODEC_TS_INVALID;
info->auDts[1].upper = (u32)CODEC_TS_INVALID;
info->auPts[0].lower = static_cast<u32>(pts);
info->auPts[0].upper = static_cast<u32>(pts >> 32);
info->auPts[1].lower = -1;
info->auPts[1].upper = -1;
info->auDts[0].lower = static_cast<u32>(dts);
info->auDts[0].upper = static_cast<u32>(dts >> 32);
info->auDts[1].lower = -1;
info->auDts[1].upper = -1;
info->auUserData[0] = usrd;
info->auUserData[1] = 0;
info->status = CELL_OK;
@ -912,7 +912,7 @@ error_code cellVdecGetPicItem(u32 handle, vm::pptr<CellVdecPicItem> picItem)
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);

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;
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;
@ -197,7 +197,7 @@ error_code cellVoiceDeletePort(u32 portId)
if (!manager->is_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_OK;
@ -601,7 +601,7 @@ error_code cellVoiceSetMuteFlagAll(u16 bMuted)
if (!manager->is_init)
return CELL_VOICE_ERROR_LIBVOICE_NOT_INIT;
// Doesn't change port->bMute value
// Doesn't change port->bMute value
return CELL_OK;
}
@ -796,7 +796,7 @@ error_code cellVoiceWriteToIPort(u32 ips, vm::cptr<void> data, vm::ptr<u32> size
if (!manager->is_init)
return CELL_VOICE_ERROR_LIBVOICE_NOT_INIT;
auto iport = manager->access_port(ips);
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)
{
// Upper 16 bits are ignored
auto pos = ports.find((u16)id);
auto pos = ports.find(static_cast<u16>(id));
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;
//ctrlParam->inWindow; // ignored
if (ctrlParam->inWindow.x) cellVpost.notice("*** inWindow.x = %d", (u32)ctrlParam->inWindow.x);
if (ctrlParam->inWindow.y) cellVpost.notice("*** inWindow.y = %d", (u32)ctrlParam->inWindow.y);
if (ctrlParam->inWindow.width != w) cellVpost.notice("*** inWindow.width = %d", (u32)ctrlParam->inWindow.width);
if (ctrlParam->inWindow.height != h) cellVpost.notice("*** inWindow.height = %d", (u32)ctrlParam->inWindow.height);
if (ctrlParam->inWindow.x) cellVpost.notice("*** inWindow.x = %d", ctrlParam->inWindow.x);
if (ctrlParam->inWindow.y) cellVpost.notice("*** inWindow.y = %d", ctrlParam->inWindow.y);
if (ctrlParam->inWindow.width != w) cellVpost.notice("*** inWindow.width = %d", ctrlParam->inWindow.width);
if (ctrlParam->inWindow.height != h) cellVpost.notice("*** inWindow.height = %d", ctrlParam->inWindow.height);
//ctrlParam->outWindow; // ignored
if (ctrlParam->outWindow.x) cellVpost.notice("*** outWindow.x = %d", (u32)ctrlParam->outWindow.x);
if (ctrlParam->outWindow.y) cellVpost.notice("*** outWindow.y = %d", (u32)ctrlParam->outWindow.y);
if (ctrlParam->outWindow.width != ow) cellVpost.notice("*** outWindow.width = %d", (u32)ctrlParam->outWindow.width);
if (ctrlParam->outWindow.height != oh) cellVpost.notice("*** outWindow.height = %d", (u32)ctrlParam->outWindow.height);
if (ctrlParam->outWindow.x) cellVpost.notice("*** outWindow.x = %d", ctrlParam->outWindow.x);
if (ctrlParam->outWindow.y) cellVpost.notice("*** outWindow.y = %d", ctrlParam->outWindow.y);
if (ctrlParam->outWindow.width != ow) cellVpost.notice("*** outWindow.width = %d", ctrlParam->outWindow.width);
if (ctrlParam->outWindow.height != oh) cellVpost.notice("*** outWindow.height = %d", ctrlParam->outWindow.height);
//ctrlParam->execType; // ignored
//ctrlParam->scalerType; // 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;
g_ssp.push_back(p);
*handle = (u32)g_ssp.size() - 1;
*handle = ::size32(g_ssp) - 1;
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_samples = waveInfo->samples;
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;
return CELL_OK;
@ -351,7 +351,7 @@ struct surmixer_thread : ppu_thread
memset(g_surmx.mixdata, 0, sizeof(g_surmx.mixdata));
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);
}
@ -379,7 +379,7 @@ struct surmixer_thread : ppu_thread
{
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)
{
// slow playback
@ -397,15 +397,15 @@ struct surmixer_thread : ppu_thread
{
fpos += speed;
}
p.m_position += (u32)pos_inc;
p.m_position += pos_inc;
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
{
left = (float)v[pos * 2 + 0] / 0x8000 * p.m_level;
right = (float)v[pos * 2 + 1] / 0x8000 * p.m_level;
left = v[pos * 2 + 0] / 32768.f * p.m_level;
right = v[pos * 2 + 1] / 32768.f * p.m_level;
}
if (p.m_connected) // mix
{
@ -422,7 +422,7 @@ struct surmixer_thread : ppu_thread
}
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
{

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

@ -480,7 +480,7 @@ enum SceNpCustomMenuActionMask : u32
enum
{
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_MASK = (SCE_NP_CUSTOM_MENU_INDEX_BITS - 1),
SCE_NP_CUSTOM_MENU_INDEX_BITS_MAX = 127,
@ -587,7 +587,7 @@ enum SceNpBasicMessageSubType : u16
};
// 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
{
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"))
{
sceNpTrophy.error("sceNpTrophyRegisterContext(): Invalid/Incomplete trophy config");
sceNpTrophy.error("sceNpTrophyRegisterContext(): Invalid/Incomplete trophy config");
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;
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;
}
@ -673,7 +673,7 @@ error_code sceNpTrophyUnlockTrophy(u32 context, u32 handle, s32 trophyId, vm::pt
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;
if (ctxt->tropusr->GetTrophyUnlockState(trophyId))
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;
}
@ -1017,7 +1017,7 @@ error_code sceNpTrophyGetTrophyIcon(u32 context, u32 handle, s32 trophyId, vm::p
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;
}

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])
{
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;
}
break;
@ -35,7 +35,7 @@ static u32 get_exitspawn_size(vm::cptr<char> path, vm::cpptr<char> argv, vm::cpp
arg_count = 1;
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(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++)
{
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);
pstr[i] = str;
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::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);
*pstr++ = str;
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>
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));
}
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
@ -404,7 +404,7 @@ s32 _sys_snprintf(ppu_thread& ppu, vm::ptr<char> dst, u32 count, vm::cptr<char>
}
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);
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>
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
@ -183,7 +183,7 @@ static u64 ppu_cache(u32 addr)
(fmt::throw_exception("Invalid PPU decoder"), nullptr));
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)
@ -212,14 +212,14 @@ void ppu_recompiler_fallback(ppu_thread& ppu)
while (true)
{
// 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 })))
{
ppu.cia += 4;
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))
{
// 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
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;
}
@ -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
while (size)
{
ppu_ref(addr) = (u64)vm::read32(addr) << 32 | fallback;
ppu_ref(addr) = u64{vm::read32(addr)} << 32 | fallback;
addr += 4;
size -= 4;
}
@ -336,7 +336,7 @@ static bool ppu_break(ppu_thread& ppu, ppu_opcode_t op)
}
// 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;
}
@ -604,7 +604,7 @@ void ppu_thread::cpu_task()
}
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)
{
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))
@ -653,12 +653,12 @@ void ppu_thread::exec_task()
if (test_stopped()) return;
// 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;
}
u64 op0, op1, op2, op3;
u64 _pos = (u64)cia * 2;
u64 _pos = u64{cia} * 2;
// 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);
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)
{
@ -1352,37 +1352,37 @@ extern void ppu_initialize(const ppu_module& info)
{
std::unordered_map<std::string, u64> link_table
{
{ "__mptr", (u64)&vm::g_base_addr },
{ "__cptr", (u64)&vm::g_exec_addr },
{ "__trap", (u64)&ppu_trap },
{ "__error", (u64)&ppu_error },
{ "__check", (u64)&ppu_check },
{ "__trace", (u64)&ppu_trace },
{ "__syscall", (u64)&ppu_execute_syscall },
{ "__get_tb", (u64)&get_timebased_time },
{ "__lwarx", (u64)&ppu_lwarx },
{ "__ldarx", (u64)&ppu_ldarx },
{ "__stwcx", (u64)&ppu_stwcx },
{ "__stdcx", (u64)&ppu_stdcx },
{ "__vexptefp", (u64)&sse_exp2_ps },
{ "__vlogefp", (u64)&sse_log2_ps },
{ "__vperm", s_use_ssse3 ? (u64)&sse_altivec_vperm : (u64)&sse_altivec_vperm_v0 }, // Obsolete
{ "__lvsl", (u64)&sse_altivec_lvsl },
{ "__lvsr", (u64)&sse_altivec_lvsr },
{ "__lvlx", s_use_ssse3 ? (u64)&sse_cellbe_lvlx : (u64)&sse_cellbe_lvlx_v0 },
{ "__lvrx", s_use_ssse3 ? (u64)&sse_cellbe_lvrx : (u64)&sse_cellbe_lvrx_v0 },
{ "__stvlx", s_use_ssse3 ? (u64)&sse_cellbe_stvlx : (u64)&sse_cellbe_stvlx_v0 },
{ "__stvrx", s_use_ssse3 ? (u64)&sse_cellbe_stvrx : (u64)&sse_cellbe_stvrx_v0 },
{ "__resupdate", (u64)&vm::reservation_update },
{ "sys_config_io_event", (u64)ppu_get_syscall(523) },
{ "__mptr", reinterpret_cast<u64>(&vm::g_base_addr) },
{ "__cptr", reinterpret_cast<u64>(&vm::g_exec_addr) },
{ "__trap", reinterpret_cast<u64>(&ppu_trap) },
{ "__error", reinterpret_cast<u64>(&ppu_error) },
{ "__check", reinterpret_cast<u64>(&ppu_check) },
{ "__trace", reinterpret_cast<u64>(&ppu_trace) },
{ "__syscall", reinterpret_cast<u64>(ppu_execute_syscall) },
{ "__get_tb", reinterpret_cast<u64>(get_timebased_time) },
{ "__lwarx", reinterpret_cast<u64>(ppu_lwarx) },
{ "__ldarx", reinterpret_cast<u64>(ppu_ldarx) },
{ "__stwcx", reinterpret_cast<u64>(ppu_stwcx) },
{ "__stdcx", reinterpret_cast<u64>(ppu_stdcx) },
{ "__vexptefp", reinterpret_cast<u64>(sse_exp2_ps) },
{ "__vlogefp", reinterpret_cast<u64>(sse_log2_ps) },
{ "__vperm", s_use_ssse3 ? reinterpret_cast<u64>(sse_altivec_vperm) : reinterpret_cast<u64>(sse_altivec_vperm_v0) }, // Obsolete
{ "__lvsl", reinterpret_cast<u64>(sse_altivec_lvsl) },
{ "__lvsr", reinterpret_cast<u64>(sse_altivec_lvsr) },
{ "__lvlx", s_use_ssse3 ? reinterpret_cast<u64>(sse_cellbe_lvlx) : reinterpret_cast<u64>(sse_cellbe_lvlx_v0) },
{ "__lvrx", s_use_ssse3 ? reinterpret_cast<u64>(sse_cellbe_lvrx) : reinterpret_cast<u64>(sse_cellbe_lvrx_v0) },
{ "__stvlx", s_use_ssse3 ? reinterpret_cast<u64>(sse_cellbe_stvlx) : reinterpret_cast<u64>(sse_cellbe_stvlx_v0) },
{ "__stvrx", s_use_ssse3 ? reinterpret_cast<u64>(sse_cellbe_stvrx) : reinterpret_cast<u64>(sse_cellbe_stvrx_v0) },
{ "__resupdate", reinterpret_cast<u64>(vm::reservation_update) },
{ "sys_config_io_event", reinterpret_cast<u64>(ppu_get_syscall(523)) },
};
for (u64 index = 0; index < 1024; 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("syscall_%u", 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), reinterpret_cast<u64>(sc));
}
}
@ -1607,8 +1607,8 @@ extern void ppu_initialize(const ppu_module& info)
break;
}
globals.emplace_back(fmt::format("__mptr%x", suffix), (u64)vm::g_base_addr);
globals.emplace_back(fmt::format("__cptr%x", suffix), (u64)vm::g_exec_addr);
globals.emplace_back(fmt::format("__mptr%x", suffix), reinterpret_cast<u64>(vm::g_base_addr));
globals.emplace_back(fmt::format("__cptr%x", suffix), reinterpret_cast<u64>(vm::g_exec_addr));
// Initialize segments for relocations
for (u32 i = 0; i < info.segs.size(); i++)
@ -1739,8 +1739,8 @@ extern void ppu_initialize(const ppu_module& info)
// Rewrite global variables
while (index < jit_mod.vars.size())
{
*jit_mod.vars[index++] = (u64)vm::g_base_addr;
*jit_mod.vars[index++] = (u64)vm::g_exec_addr;
*jit_mod.vars[index++] = reinterpret_cast<u64>(vm::g_base_addr);
*jit_mod.vars[index++] = reinterpret_cast<u64>(vm::g_exec_addr);
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)
{
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);
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)
{
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);
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);
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->and_(*addr, 0xf << 3);
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);
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->and_(*addr, 0x1f << 3);
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);
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->and_(*addr, 0x1f << 3);
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);
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->and_(*addr, 0xf);
c->shl(*addr, 4);
@ -3097,7 +3097,7 @@ void spu_recompiler::ROTQMBY(spu_opcode_t op)
}
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->and_(*addr, 0x1f);
c->shl(*addr, 4);
@ -3113,7 +3113,7 @@ void spu_recompiler::SHLQBY(spu_opcode_t op)
}
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->and_(*addr, 0x1f);
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;
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;
}
@ -608,7 +608,7 @@ bool spu_interpreter::ROTQMBYBI(spu_thread& spu, spu_opcode_t op)
{
const auto a = spu.gpr[op.ra].vi;
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;
}
@ -616,7 +616,7 @@ bool spu_interpreter::SHLQBYBI(spu_thread& spu, spu_opcode_t op)
{
const auto a = spu.gpr[op.ra].vi;
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;
}
@ -700,7 +700,7 @@ bool spu_interpreter::ROTQBY(spu_thread& spu, spu_opcode_t op)
{
const auto a = spu.gpr[op.ra].vi;
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;
}
@ -708,7 +708,7 @@ bool spu_interpreter::ROTQMBY(spu_thread& spu, spu_opcode_t op)
{
const auto a = spu.gpr[op.ra].vi;
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;
}
@ -716,7 +716,7 @@ bool spu_interpreter::SHLQBY(spu_thread& spu, spu_opcode_t op)
{
const auto a = spu.gpr[op.ra].vi;
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;
}
@ -806,7 +806,7 @@ bool spu_interpreter::ROTQBYI(spu_thread& spu, spu_opcode_t op)
{
const auto a = spu.gpr[op.ra].vi;
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;
}
@ -814,7 +814,7 @@ bool spu_interpreter::ROTQMBYI(spu_thread& spu, spu_opcode_t op)
{
const auto a = spu.gpr[op.ra].vi;
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;
}
@ -822,7 +822,7 @@ bool spu_interpreter::SHLQBYI(spu_thread& spu, spu_opcode_t op)
{
const auto a = spu.gpr[op.ra].vi;
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;
}
@ -1172,7 +1172,7 @@ bool spu_interpreter::BGX(spu_thread& spu, spu_opcode_t op)
{
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;
}
return true;
@ -1692,7 +1692,7 @@ static bool SHUFB_(spu_thread& spu, spu_opcode_t op)
// Select bytes
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
@ -1956,7 +1956,7 @@ bool spu_interpreter_precise::FCGT(spu_thread& spu, spu_opcode_t op)
if (a_zero)
pass = b >= 0x80800000;
else if (b_zero)
pass = (s32)a >= 0x00800000;
pass = static_cast<s32>(a) >= 0x00800000;
else if (a >= 0x80000000)
pass = (b >= 0x80000000 && a < b);
else
@ -2307,7 +2307,7 @@ bool spu_interpreter_precise::FESD(spu_thread& spu, spu_opcode_t op)
}
else
{
spu.gpr[op.rt]._d[i] = (double)a;
spu.gpr[op.rt]._d[i] = a;
}
}
return true;
@ -2329,7 +2329,7 @@ bool spu_interpreter_precise::FRDS(spu_thread& spu, spu_opcode_t op)
else
{
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();
if (e & _MM_EXCEPT_OVERFLOW)
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)
result = 0x80000000;
else
result = (s32)scaled;
result = static_cast<s32>(scaled);
spu.gpr[op.rt]._s32[i] = result;
}
return true;
@ -2428,7 +2428,7 @@ bool spu_interpreter_precise::CFLTU(spu_thread& spu, spu_opcode_t op)
else if (scaled < 0.0f)
result = 0;
else
result = (u32)scaled;
result = static_cast<u32>(scaled);
spu.gpr[op.rt]._u32[i] = result;
}
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++)
{
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;
@ -2465,7 +2465,7 @@ bool spu_interpreter_precise::CUFLT(spu_thread& spu, spu_opcode_t op)
for (int i = 0; i < 4; 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;

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)
{
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;
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)
{
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;
}
}
@ -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 data2 = v128::fromV(_mm_loadu_si128(src + 2));
((v128*)+bufitems)[0] = data0;
((v128*)+bufitems)[1] = data1;
((v128*)+bufitems)[2] = data2;
reinterpret_cast<v128*>(bufitems)[0] = data0;
reinterpret_cast<v128*>(bufitems)[1] = data1;
reinterpret_cast<v128*>(bufitems)[2] = data2;
}
const u32 size = items[index].ts & 0x7fff;
@ -2360,7 +2360,7 @@ s64 spu_thread::get_ch_value(u32 ch)
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
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);
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);
}
@ -2536,7 +2536,7 @@ bool spu_thread::set_ch_value(u32 ch, u32 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);
}

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
{

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)
{
// 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;
}
@ -107,7 +107,7 @@ float PadHandlerBase::ScaleStickInput(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]
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;
}
@ -124,7 +124,7 @@ u16 PadHandlerBase::NormalizeTriggerInput(u16 value, int threshold)
}
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);
}
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)
{
@ -145,7 +145,7 @@ u16 PadHandlerBase::NormalizeDirectedInput(s32 raw_value, s32 threshold, s32 max
}
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)));
}
}
@ -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
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 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)
{
// convert inX and Y to a (-1, 1) vector;
const f32 x = ((f32)inX - 127.5f) / 127.5f;
const f32 y = ((f32)inY - 127.5f) / 127.5f;
const f32 x = (inX - 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
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
// 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
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);
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);
}
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);
}
@ -125,7 +125,7 @@ void usb_device_passthrough::isochronous_transfer(UsbTransfer* transfer)
{
// TODO actual endpoint
// 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++)
{
@ -158,7 +158,7 @@ s32 usb_device_emulated::get_descriptor(u8 type, u8 index, u8* ptr, u32 max_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[1] = USB_DESCRIPTOR_STRING;
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[3 + (i * 2)] = 0;
}
return (s32)ptr[0];
return ptr[0];
}
}
else

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

@ -19,34 +19,34 @@
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);
}
}
// 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
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
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
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
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)
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
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)))
{
// 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)))
{
@ -140,7 +140,7 @@ namespace vm
{
::reader_lock lock(g_mutex);
_ret = _register_range_lock((u64)end << 32 | addr);
_ret = _register_range_lock(u64{end} << 32 | addr);
}
return _ret;
@ -540,7 +540,7 @@ namespace vm
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);
@ -552,7 +552,7 @@ namespace vm
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);
@ -564,7 +564,7 @@ namespace vm
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);
@ -576,7 +576,7 @@ namespace vm
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;
}

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

@ -69,7 +69,7 @@ std::string CgBinaryDisasm::AddRegDisAsm(u32 index, int fp16)
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);
const u32 x = GetData(data[0]);
@ -224,7 +224,7 @@ template<typename T> std::string CgBinaryDisasm::GetSrcDisAsm(T src)
void CgBinaryDisasm::TaskFP()
{
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);
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);
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("# parameterCount %d\n", (u32)prog.parameterCount);
m_arb_shader += fmt::format("# instructionCount %d\n", (u32)fprog.instructionCount);
m_arb_shader += fmt::format("# attributeInputMask 0x%x\n", (u32)fprog.attributeInputMask);
m_arb_shader += fmt::format("# registerCount %d\n\n", (u32)fprog.registerCount);
m_arb_shader += fmt::format("# parameterCount %d\n", prog.parameterCount);
m_arb_shader += fmt::format("# instructionCount %d\n", fprog.instructionCount);
m_arb_shader += fmt::format("# attributeInputMask 0x%x\n", fprog.attributeInputMask);
m_arb_shader += fmt::format("# registerCount %d\n\n", fprog.registerCount);
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);
@ -344,16 +344,16 @@ public:
{
auto& vprog = GetCgRef<CgBinaryVertexProgram>(prog.program);
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("# parameterCount %d\n", (u32)prog.parameterCount);
m_arb_shader += fmt::format("# instructionCount %d\n", (u32)vprog.instructionCount);
m_arb_shader += fmt::format("# registerCount %d\n", (u32)vprog.registerCount);
m_arb_shader += fmt::format("# attributeInputMask 0x%x\n", (u32)vprog.attributeInputMask);
m_arb_shader += fmt::format("# attributeOutputMask 0x%x\n\n", (u32)vprog.attributeOutputMask);
m_arb_shader += fmt::format("# parameterCount %d\n", prog.parameterCount);
m_arb_shader += fmt::format("# instructionCount %d\n", vprog.instructionCount);
m_arb_shader += fmt::format("# registerCount %d\n", vprog.registerCount);
m_arb_shader += fmt::format("# attributeInputMask 0x%x\n", vprog.attributeInputMask);
m_arb_shader += fmt::format("# attributeOutputMask 0x%x\n\n", vprog.attributeOutputMask);
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);
@ -371,7 +371,7 @@ public:
m_arb_shader += "\n";
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;
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>
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>
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,
0x0, 0x1, 0x2, 0x3);
__m128i* dst_ptr = (__m128i*)dst;
__m128i* src_ptr = (__m128i*)src;
auto dst_ptr = static_cast<__m128i*>(dst);
auto src_ptr = static_cast<const __m128i*>(src);
const u32 dword_count = (vertex_count * (stride >> 2));
const u32 iterations = dword_count >> 2;
@ -116,8 +116,8 @@ namespace
if (remaining)
{
u32 *src_ptr2 = (u32 *)src_ptr;
u32 *dst_ptr2 = (u32 *)dst_ptr;
auto src_ptr2 = reinterpret_cast<const u32*>(src_ptr);
auto dst_ptr2 = reinterpret_cast<u32*>(dst_ptr);
for (u32 i = 0; i < remaining; ++i)
dst_ptr2[i] = se_storage<u32>::swap(src_ptr2[i]);
@ -132,8 +132,8 @@ namespace
0x6, 0x7, 0x4, 0x5,
0x2, 0x3, 0x0, 0x1);
__m128i* dst_ptr = (__m128i*)dst;
__m128i* src_ptr = (__m128i*)src;
auto dst_ptr = static_cast<__m128i*>(dst);
auto src_ptr = static_cast<const __m128i*>(src);
const u32 word_count = (vertex_count * (stride >> 1));
const u32 iterations = word_count >> 3;
@ -166,8 +166,8 @@ namespace
if (remaining)
{
u16 *src_ptr2 = (u16 *)src_ptr;
u16 *dst_ptr2 = (u16 *)dst_ptr;
auto src_ptr2 = reinterpret_cast<const u16*>(src_ptr);
auto dst_ptr2 = reinterpret_cast<u16*>(dst_ptr);
for (u32 i = 0; i < remaining; ++i)
dst_ptr2[i] = se_storage<u16>::swap(src_ptr2[i]);
@ -182,8 +182,8 @@ namespace
0x4, 0x5, 0x6, 0x7,
0x0, 0x1, 0x2, 0x3);
char *src_ptr = (char *)src;
char *dst_ptr = (char *)dst;
auto src_ptr = static_cast<const char*>(src);
auto dst_ptr = static_cast<char*>(dst);
//Count vertices to copy
const bool is_128_aligned = !((dst_stride | src_stride) & 15);
@ -203,9 +203,9 @@ namespace
{
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);
_mm_storeu_si128((__m128i*)dst_ptr, shuffled_vector);
_mm_storeu_si128(reinterpret_cast<__m128i*>(dst_ptr), shuffled_vector);
src_ptr += src_stride;
dst_ptr += dst_stride;
@ -215,10 +215,10 @@ namespace
{
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 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;
dst_ptr += dst_stride;
@ -230,8 +230,11 @@ namespace
const u8 attribute_sz = min_block_size >> 2;
for (u32 n = 0; n < remainder; ++n)
{
for (u32 v= 0; v < attribute_sz; ++v)
((u32*)dst_ptr)[v] = ((be_t<u32>*)src_ptr)[v];
auto src_ptr2 = reinterpret_cast<const be_t<u32>*>(src_ptr);
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;
dst_ptr += dst_stride;
@ -247,8 +250,8 @@ namespace
0x6, 0x7, 0x4, 0x5,
0x2, 0x3, 0x0, 0x1);
char *src_ptr = (char *)src;
char *dst_ptr = (char *)dst;
auto src_ptr = static_cast<const char*>(src);
auto dst_ptr = static_cast<char*>(dst);
const bool is_128_aligned = !((dst_stride | src_stride) & 15);
@ -267,9 +270,9 @@ namespace
{
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);
_mm_storeu_si128((__m128i*)dst_ptr, shuffled_vector);
_mm_storeu_si128(reinterpret_cast<__m128i*>(dst_ptr), shuffled_vector);
src_ptr += src_stride;
dst_ptr += dst_stride;
@ -279,9 +282,9 @@ namespace
{
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));
_mm_storeu_si128((__m128i*)dst_ptr, vec1);
_mm_storeu_si128(reinterpret_cast<__m128i*>(dst_ptr), vec1);
src_ptr += src_stride;
dst_ptr += dst_stride;
@ -293,8 +296,11 @@ namespace
const u8 attribute_sz = min_block_size >> 1;
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)
((u16*)dst_ptr)[v] = ((be_t<u16>*)src_ptr)[v];
dst_ptr[v] = src_ptr[v];
src_ptr += src_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)
{
char *src_ptr = (char *)src;
char *dst_ptr = (char *)dst;
auto src_ptr = static_cast<const char*>(src);
auto dst_ptr = static_cast<char*>(dst);
switch (attribute_size)
{
@ -314,7 +320,7 @@ namespace
//Read one dword every iteration
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;
src_ptr += src_stride;
@ -327,7 +333,7 @@ namespace
//Read one word and one byte
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 += dst_stride;
@ -341,7 +347,7 @@ namespace
//Copy u16 blocks
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;
src_ptr += src_stride;
@ -365,15 +371,15 @@ namespace
}
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;
char *dst_ptr = (char *)raw_dst;
auto src_ptr = static_cast<const char*>(raw_src);
auto dst_ptr = static_cast<char*>(raw_dst);
for (u32 vertex = 0; vertex < vertex_count; ++vertex)
{
T* typed_dst = (T*)dst_ptr;
U* typed_src = (U*)src_ptr;
auto typed_dst = reinterpret_cast<T*>(dst_ptr);
auto typed_src = reinterpret_cast<const U*>(src_ptr);
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
*/
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;
char *dst_ptr = (char *)raw_dst;
auto src_ptr = static_cast<const char*>(raw_src);
auto dst_ptr = static_cast<char*>(raw_dst);
u32 src_offset = 0;
u32 src_limit = src_stride * src_vertex_count;
for (u32 vertex = 0; vertex < vertex_count; ++vertex)
{
T* typed_dst = (T*)dst_ptr;
U* typed_src = (U*)(src_ptr + src_offset);
auto typed_dst = reinterpret_cast<T*>(dst_ptr);
auto typed_src = reinterpret_cast<const U*>(src_ptr + src_offset);
for (u32 i = 0; i < N; ++i)
{
@ -414,7 +420,7 @@ namespace
}
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
@ -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
//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
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]
//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
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);
#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)
stream_data_to_memory_u8_non_continuous(raw_dst_span.data(), src_ptr.data(), count, vector_element_count, dst_stride, attribute_src_stride);
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;
}
@ -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)
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)
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
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;
}
@ -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)
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)
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
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;
}
@ -590,8 +596,8 @@ namespace
0x6, 0x7, 0x4, 0x5,
0x2, 0x3, 0x0, 0x1);
auto src_stream = (const __m128i*)src;
auto dst_stream = (__m128i*)dst;
auto src_stream = static_cast<const __m128i*>(src);
auto dst_stream = static_cast<__m128i*>(dst);
__m128i min = _mm_set1_epi16(0xFFFF);
__m128i max = _mm_set1_epi16(0);
@ -622,8 +628,8 @@ namespace
0x4, 0x5, 0x6, 0x7,
0x0, 0x1, 0x2, 0x3);
auto src_stream = (const __m128i*)src;
auto dst_stream = (__m128i*)dst;
auto src_stream = static_cast<const __m128i*>(src);
auto dst_stream = static_cast<__m128i*>(dst);
__m128i min = _mm_set1_epi32(~0u);
__m128i max = _mm_set1_epi32(0);
@ -714,8 +720,8 @@ namespace
0x6, 0x7, 0x4, 0x5,
0x2, 0x3, 0x0, 0x1);
auto src_stream = (const __m256i*)src;
auto dst_stream = (__m256i*)dst;
auto src_stream = static_cast<const __m256i*>(src);
auto dst_stream = static_cast<__m256i*>(dst);
__m256i restart = _mm256_set1_epi16(restart_index);
__m256i min = _mm256_set1_epi16(0xffff);
@ -757,8 +763,8 @@ namespace
0x6, 0x7, 0x4, 0x5,
0x2, 0x3, 0x0, 0x1);
auto src_stream = (const __m128i*)src;
auto dst_stream = (__m128i*)dst;
auto src_stream = static_cast<const __m128i*>(src);
auto dst_stream = static_cast<__m128i*>(dst);
__m128i restart = _mm_set1_epi16(restart_index);
__m128i min = _mm_set1_epi16(0xffff);
@ -792,8 +798,8 @@ namespace
0x4, 0x5, 0x6, 0x7,
0x0, 0x1, 0x2, 0x3);
auto src_stream = (const __m128i*)src;
auto dst_stream = (__m128i*)dst;
auto src_stream = static_cast<const __m128i*>(src);
auto dst_stream = static_cast<__m128i*>(dst);
__m128i restart = _mm_set1_epi32(restart_index);
__m128i min = _mm_set1_epi32(0xffffffff);
@ -903,7 +909,7 @@ namespace
}
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
@ -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)
{
unsigned short *typedDst = (unsigned short *)(dst);
auto typedDst = reinterpret_cast<u16*>(dst);
switch (draw_mode)
{
case rsx::primitive_type::line_loop:
@ -1166,7 +1172,7 @@ namespace
return expand_indexed_quads<T>(src, dst, restart_index_enabled, restart_index);
}
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)
{
__m128i vector = _mm_set_epi32(w, z, y, x);
_mm_stream_si128((__m128i*)dst, vector);
const __m128i vector = _mm_set_epi32(w, z, y, x);
_mm_stream_si128(reinterpret_cast<__m128i*>(dst), vector);
}
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)
{
const __m128i &vector = _mm_loadu_si128((__m128i*)src);
_mm_stream_si128((__m128i*)dst, vector);
const __m128i vector = _mm_loadu_si128(reinterpret_cast<__m128i*>(src));
_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
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;
bool end = false;
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];
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)
{
const qword* instruction = (const qword*)&data[i * 4];
qword* dst = (qword*)&dst_prog.data[count * 4];
const qword* instruction = reinterpret_cast<const qword*>(&data[i * 4]);
qword* dst = reinterpret_cast<qword*>(&dst_prog.data[count * 4]);
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)
return false;
const qword *instBuffer1 = (const qword*)binary1.data.data();
const qword *instBuffer2 = (const qword*)binary2.data.data();
const qword* instBuffer1 = reinterpret_cast<const qword*>(binary1.data.data());
const qword* instBuffer2 = reinterpret_cast<const qword*>(binary2.data.data());
size_t instIndex = 0;
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)
{
const qword *instBuffer = (const qword*)ptr;
const qword* instBuffer = reinterpret_cast<const qword*>(ptr);
size_t instIndex = 0;
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)
{
const qword *instBuffer = (const qword*)ptr;
const qword* instBuffer = reinterpret_cast<const qword*>(ptr);
s32 index = 0;
s32 program_offset = -1;
u32 ucode_size = 0;
@ -388,14 +388,14 @@ fragment_program_utils::fragment_program_metadata fragment_program_utils::analys
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)
{
// 64-bit Fowler/Noll/Vo FNV-1a hash code
size_t hash = 0xCBF29CE484222325ULL;
const qword *instbuffer = (const qword*)program.addr;
const qword* instbuffer = reinterpret_cast<const qword*>(program.addr);
size_t instIndex = 0;
while (true)
{
@ -447,8 +447,8 @@ bool fragment_program_compare::operator()(const RSXFragmentProgram& binary1, con
return false;
}
const qword *instBuffer1 = (const qword*)binary1.addr;
const qword *instBuffer2 = (const qword*)binary2.addr;
const qword* instBuffer1 = reinterpret_cast<const qword*>(binary1.addr);
const qword* instBuffer2 = reinterpret_cast<const qword*>(binary2.addr);
size_t instIndex = 0;
while (true)
{

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

@ -12,7 +12,7 @@ namespace
template <typename T>
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)
{
// 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);
}
@ -444,7 +444,7 @@ namespace rsx
{
// Range test
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);
// 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.transfer_scale_x = transfer_scale_x;
ret.transfer_scale_y = transfer_scale_y;
ret.target = (T)(target);
ret.source = (T)(source);
ret.target = static_cast<T>(target);
ret.source = static_cast<T>(source);
return ret;
}
@ -233,7 +233,7 @@ namespace rsx
spp = 4;
break;
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);
// Convert pt to px
size_px = ceilf((f32)size * 96.f / 72.f);
size_px = ceilf(size * 96.f / 72.f);
size_pt = size;
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)
{
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;
const u32 row_length = clip_w * bpp;
@ -130,13 +130,13 @@ namespace rsx
switch (element_size)
{
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;
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;
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;
default:
fmt::throw_exception("unsupported element size %d" HERE, element_size);
@ -148,13 +148,13 @@ namespace rsx
switch (element_size)
{
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;
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;
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;
default:
fmt::throw_exception("unsupported element size %d" HERE, element_size);
@ -191,16 +191,16 @@ namespace rsx
switch (element_size)
{
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;
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;
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;
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;
default:
fmt::throw_exception("unsupported pixel size %d" HERE, element_size);
@ -213,16 +213,16 @@ namespace rsx
switch (element_size)
{
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;
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;
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;
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;
default:
fmt::throw_exception("unsupported pixel size %d" HERE, element_size);
@ -313,8 +313,8 @@ namespace rsx
const auto num_iterations = (num_pixels >> 2);
__m128i* dst_ptr = (__m128i*)dst;
__m128i* src_ptr = (__m128i*)src;
__m128i* dst_ptr = static_cast<__m128i*>(dst);
__m128i* src_ptr = static_cast<__m128i*>(src);
const __m128 scale_vector = _mm_set1_ps(16777214.f);
@ -332,7 +332,7 @@ namespace rsx
for (u32 n = 0; n < num_iterations; ++n)
{
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);
_mm_stream_si128(dst_ptr, shuffled_vector);
++dst_ptr;
@ -350,7 +350,7 @@ namespace rsx
for (u32 n = 0; n < num_iterations; ++n)
{
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 v2 = _mm_and_si128(_mm_slli_epi32(result, 16), mask2);
@ -370,8 +370,8 @@ namespace rsx
const auto num_iterations = (num_pixels >> 2);
__m128i* dst_ptr = (__m128i*)dst;
__m128i* src_ptr = (__m128i*)src;
__m128i* dst_ptr = static_cast<__m128i*>(dst);
__m128i* src_ptr = static_cast<__m128i*>(src);
#if defined (_MSC_VER) || defined (__SSSE3__)
if (LIKELY(utils::has_ssse3()))
@ -422,8 +422,8 @@ namespace rsx
const auto num_iterations = (num_pixels >> 2);
__m128i* dst_ptr = (__m128i*)dst;
__m128i* src_ptr = (__m128i*)src;
__m128i* dst_ptr = static_cast<__m128i*>(dst);
__m128i* src_ptr = static_cast<__m128i*>(src);
const __m128 scale_vector = _mm_set1_ps(1.f / 16777214.f);
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 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;
++src_ptr;
}

2
rpcs3/Emu/System.cpp
View File

@ -1726,7 +1726,7 @@ void Emulator::Resume()
{
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.disasm(i);