mirror/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-02-28 03:39:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

VERIFY macro removed

Browse Source
This commit is contained in:
Nekotekina 2016-08-15 03:11:49 +03:00
parent cc46f2d7e6
commit 05fb57baff
36 changed files with 108 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Utilities/Config.h
View File

@ -180,7 +180,7 @@ namespace cfg
for (const auto& v : init)
{
// Ensure elements are unique
VERIFY(map.emplace(v.first, v.second).second);
verify(HERE), map.emplace(v.first, v.second).second;
}
return map;

27
Utilities/File.cpp
View File

@ -201,33 +201,6 @@ std::string fs::get_parent_dir(const std::string& path)
}
}
static const auto test_get_parent_dir = []() -> bool
{
// Success:
VERIFY(fs::get_parent_dir("/x/y///") == "/x");
VERIFY(fs::get_parent_dir("/x/y/") == "/x");
VERIFY(fs::get_parent_dir("/x/y") == "/x");
VERIFY(fs::get_parent_dir("x:/y") == "x:");
VERIFY(fs::get_parent_dir("//x/y") == "//x");
// Failure:
VERIFY(fs::get_parent_dir("").empty());
VERIFY(fs::get_parent_dir("x/").empty());
VERIFY(fs::get_parent_dir("x").empty());
VERIFY(fs::get_parent_dir("x///").empty());
VERIFY(fs::get_parent_dir("/x/").empty());
VERIFY(fs::get_parent_dir("/x").empty());
VERIFY(fs::get_parent_dir("/").empty());
VERIFY(fs::get_parent_dir("//").empty());
VERIFY(fs::get_parent_dir("//x").empty());
VERIFY(fs::get_parent_dir("//x/").empty());
VERIFY(fs::get_parent_dir("///").empty());
VERIFY(fs::get_parent_dir("///x").empty());
VERIFY(fs::get_parent_dir("///x/").empty());
return false;
}();
bool fs::stat(const std::string& path, stat_t& info)
{
if (auto device = get_virtual_device(path))

14
Utilities/Thread.cpp
View File

@ -2200,26 +2200,26 @@ void thread_ctrl::handle_interrupt()
void thread_ctrl::interrupt(void(*handler)())
{
VERIFY(this != g_tls_this_thread); // TODO: self-interrupt
VERIFY(m_data->interrupt.compare_and_swap_test(nullptr, handler)); // TODO: multiple interrupts
verify(HERE), this != g_tls_this_thread; // TODO: self-interrupt
verify(HERE), m_data->interrupt.compare_and_swap_test(nullptr, handler); // TODO: multiple interrupts
#ifdef _WIN32
const auto ctx = m_data->thread_ctx;
const HANDLE nt = OpenThread(THREAD_ALL_ACCESS, FALSE, m_data->thread_id);
VERIFY(nt);
VERIFY(SuspendThread(nt) != -1);
verify(HERE), nt;
verify(HERE), SuspendThread(nt) != -1;
ctx->ContextFlags = CONTEXT_FULL;
VERIFY(GetThreadContext(nt, ctx));
verify(HERE), GetThreadContext(nt, ctx);
ctx->ContextFlags = CONTEXT_FULL;
const u64 _rip = RIP(ctx);
RIP(ctx) = (u64)std::addressof(thread_ctrl::handle_interrupt);
VERIFY(SetThreadContext(nt, ctx));
verify(HERE), SetThreadContext(nt, ctx);
RIP(ctx) = _rip;
VERIFY(ResumeThread(nt) != -1);
verify(HERE), ResumeThread(nt) != -1;
CloseHandle(nt);
#else
pthread_kill(reinterpret_cast<std::thread&>(m_thread).native_handle(), SIGUSR1);

4
Utilities/types.h
View File

@ -61,9 +61,7 @@
// Wrap an expression into lambda. Obsolete.
#define WRAP_EXPR(...) [&] { return __VA_ARGS__; }
// Ensure that the expression is evaluated to true. Obsolete.
#define VERIFY(...) do { if (!(__VA_ARGS__)) fmt::raw_error("Verification failed: " #__VA_ARGS__ HERE); } while (0)
// Ensure that the expression evaluates to true. Obsolete.
#define EXPECTS(...) do { if (!(__VA_ARGS__)) fmt::raw_error("Precondition failed: " #__VA_ARGS__ HERE); } while (0)
#define ENSURES(...) do { if (!(__VA_ARGS__)) fmt::raw_error("Postcondition failed: " #__VA_ARGS__ HERE); } while (0)

2
rpcs3/Emu/Audio/AudioDumper.cpp
View File

@ -24,7 +24,7 @@ void AudioDumper::WriteData(const void* buffer, u32 size)
{
if (GetCh())
{
VERIFY(m_output.write(buffer, size) == size);
verify(HERE), size, m_output.write(buffer, size) == size;
m_header.Size += size;
m_header.RIFF.Size += size;
}

6
rpcs3/Emu/CPU/CPUThread.cpp
View File

@ -146,6 +146,12 @@ void cpu_thread::run()
lock_notify();
}
void cpu_thread::set_signal()
{
verify("cpu_flag::signal" HERE), !state.test_and_set(cpu_flag::signal);
notify(); // TODO: lock_notify?
}
std::string cpu_thread::dump() const
{
return fmt::format("Type: %s\n" "State: %s\n", typeid(*this).name(), state.load());

3
rpcs3/Emu/CPU/CPUThread.h
View File

@ -47,6 +47,9 @@ public:
// Run thread
void run();
// Set cpu_flag::signal
void set_signal();
// Print CPU state
virtual std::string dump() const;

4
rpcs3/Emu/Cell/Modules/cellDmux.cpp
View File

@ -792,7 +792,7 @@ void ElementaryStream::push_au(u32 size, u64 dts, u64 pts, u64 userdata, bool ra
u32 addr;
{
std::lock_guard<std::mutex> lock(m_mutex);
VERIFY(!is_full(size));
verify(HERE), !is_full(size);
if (put + size + 128 > memAddr + memSize)
{
@ -833,7 +833,7 @@ void ElementaryStream::push_au(u32 size, u64 dts, u64 pts, u64 userdata, bool ra
put_count++;
}
VERIFY(entries.push(addr, &dmux->is_closed));
verify(HERE), entries.push(addr, &dmux->is_closed);
}
void ElementaryStream::push(DemuxerStream& stream, u32 size)

2
rpcs3/Emu/Cell/Modules/cellGcmSys.cpp
View File

@ -939,7 +939,7 @@ s32 cellGcmMapEaIoAddressWithFlags(u32 ea, u32 io, u32 size, u32 flags)
{
cellGcmSys.warning("cellGcmMapEaIoAddressWithFlags(ea=0x%x, io=0x%x, size=0x%x, flags=0x%x)", ea, io, size, flags);
VERIFY(flags == 2 /*CELL_GCM_IOMAP_FLAG_STRICT_ORDERING*/);
verify(HERE), flags == 2 /*CELL_GCM_IOMAP_FLAG_STRICT_ORDERING*/;
return gcmMapEaIoAddress(ea, io, size, true);
}

3
rpcs3/Emu/Cell/Modules/cellMsgDialog.cpp
View File

@ -249,8 +249,7 @@ s32 cellMsgDialogAbort()
return CELL_SYSUTIL_ERROR_BUSY;
}
VERIFY(fxm::remove<MsgDialogBase>());
verify(HERE), fxm::remove<MsgDialogBase>();
return CELL_OK;
}

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

@ -810,7 +810,7 @@ s32 cellSailPlayerCreateDescriptor(vm::ptr<CellSailPlayer> pSelf, s32 streamType
u32 buffer = vm::alloc(size, vm::main);
auto bufPtr = vm::cptr<PamfHeader>::make(buffer);
PamfHeader *buf = const_cast<PamfHeader*>(bufPtr.get_ptr());
VERIFY(f.read(buf, size) == size);
verify(HERE), f.read(buf, size) == size;
u32 sp_ = vm::alloc(sizeof(CellPamfReader), vm::main);
auto sp = vm::ptr<CellPamfReader>::make(sp_);
u32 reader = cellPamfReaderInitialize(sp, bufPtr, size, 0);

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

@ -588,7 +588,7 @@ void _spurs::handler_entry(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
if ((spurs->flags1 & SF1_EXIT_IF_NO_WORK) == 0)
{
VERIFY(spurs->handlerExiting == 1);
verify(HERE), (spurs->handlerExiting == 1);
return sys_ppu_thread_exit(ppu, 0);
}
@ -666,16 +666,16 @@ s32 _spurs::wakeup_shutdown_completion_waiter(ppu_thread& ppu, vm::ptr<CellSpurs
{
wklF->hook(ppu, spurs, wid, wklF->hookArg);
VERIFY(wklEvent->load() & 0x01);
VERIFY(wklEvent->load() & 0x02);
VERIFY((wklEvent->load() & 0x20) == 0);
verify(HERE), (wklEvent->load() & 0x01);
verify(HERE), (wklEvent->load() & 0x02);
verify(HERE), (wklEvent->load() & 0x20) == 0;
wklEvent->fetch_or(0x20);
}
s32 rc = CELL_OK;
if (!wklF->hook || wklEvent->load() & 0x10)
{
VERIFY(wklF->x28 == 2);
verify(HERE), (wklF->x28 == 2);
rc = sys_semaphore_post((u32)wklF->sem, 1);
}
@ -2143,8 +2143,8 @@ s32 _spurs::add_workload(vm::ptr<CellSpurs> spurs, vm::ptr<u32> wid, vm::cptr<vo
u32 index = wnum & 0xf;
if (wnum <= 15)
{
VERIFY((spurs->wklCurrentContention[wnum] & 0xf) == 0);
VERIFY((spurs->wklPendingContention[wnum] & 0xf) == 0);
verify(HERE), (spurs->wklCurrentContention[wnum] & 0xf) == 0;
verify(HERE), (spurs->wklPendingContention[wnum] & 0xf) == 0;
spurs->wklState1[wnum] = 1;
spurs->wklStatus1[wnum] = 0;
spurs->wklEvent1[wnum] = 0;
@ -2179,8 +2179,8 @@ s32 _spurs::add_workload(vm::ptr<CellSpurs> spurs, vm::ptr<u32> wid, vm::cptr<vo
}
else
{
VERIFY((spurs->wklCurrentContention[index] & 0xf0) == 0);
VERIFY((spurs->wklPendingContention[index] & 0xf0) == 0);
verify(HERE), (spurs->wklCurrentContention[index] & 0xf0) == 0;
verify(HERE), (spurs->wklPendingContention[index] & 0xf0) == 0;
spurs->wklState2[index] = 1;
spurs->wklStatus2[index] = 0;
spurs->wklEvent2[index] = 0;
@ -2259,7 +2259,7 @@ s32 _spurs::add_workload(vm::ptr<CellSpurs> spurs, vm::ptr<u32> wid, vm::cptr<vo
v = mask | (0x80000000u >> wnum);
});
VERIFY(res_wkl <= 31);
verify(HERE), (res_wkl <= 31);
spurs->wklState(wnum).exchange(2);
spurs->sysSrvMsgUpdateWorkload.exchange(0xff);
spurs->sysSrvMessage.exchange(0xff);

18
rpcs3/Emu/Cell/Modules/cellSync.cpp
View File

@ -908,7 +908,7 @@ ppu_error_code _cellSyncLFQueueGetPushPointer(ppu_thread& ppu, vm::ptr<CellSyncL
}
}
VERIFY(sys_event_queue_receive(ppu, queue->m_eq_id, vm::null, 0) == CELL_OK);
verify(HERE), sys_event_queue_receive(ppu, queue->m_eq_id, vm::null, 0) == CELL_OK;
var1 = 1;
}
}
@ -999,7 +999,7 @@ ppu_error_code _cellSyncLFQueueCompletePushPointer(ppu_thread& ppu, vm::ptr<Cell
if (var9 > 1 && (u32)var8 > 1)
{
VERIFY(16 - var2 <= 1);
verify(HERE), (16 - var2 <= 1);
}
s32 var11 = (pack >> 10) & 0x1f;
@ -1031,11 +1031,11 @@ ppu_error_code _cellSyncLFQueueCompletePushPointer(ppu_thread& ppu, vm::ptr<Cell
if (queue->push2.compare_and_swap_test(old, push2))
{
VERIFY(var2 + var4 < 16);
verify(HERE), (var2 + var4 < 16);
if (var6 != -1)
{
VERIFY(queue->push3.compare_and_swap_test(old2, push3));
VERIFY(fpSendSignal);
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));
}
else
@ -1207,7 +1207,7 @@ ppu_error_code _cellSyncLFQueueGetPopPointer(ppu_thread& ppu, vm::ptr<CellSyncLF
}
}
VERIFY(sys_event_queue_receive(ppu, queue->m_eq_id, vm::null, 0) == CELL_OK);
verify(HERE), (sys_event_queue_receive(ppu, queue->m_eq_id, vm::null, 0) == CELL_OK);
var1 = 1;
}
}
@ -1303,7 +1303,7 @@ ppu_error_code _cellSyncLFQueueCompletePopPointer(ppu_thread& ppu, vm::ptr<CellS
if (var9 > 1 && (u32)var8 > 1)
{
VERIFY(16 - var2 <= 1);
verify(HERE), (16 - var2 <= 1);
}
s32 var11 = (pack >> 10) & 0x1f;
@ -1333,8 +1333,8 @@ ppu_error_code _cellSyncLFQueueCompletePopPointer(ppu_thread& ppu, vm::ptr<CellS
{
if (var6 != -1)
{
VERIFY(queue->pop3.compare_and_swap_test(old2, pop3));
VERIFY(fpSendSignal);
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));
}
else

2
rpcs3/Emu/Cell/Modules/cellSysutil.cpp
View File

@ -293,7 +293,7 @@ s32 cellSysCacheMount(vm::ptr<CellSysCacheParam> param)
cellSysutil.warning("cellSysCacheMount(param=*0x%x)", param);
const std::string& cache_id = param->cacheId;
VERIFY(cache_id.size() < sizeof(param->cacheId));
verify(HERE), cache_id.size() < sizeof(param->cacheId);
const std::string& cache_path = "/dev_hdd1/cache/" + cache_id + '/';
strcpy_trunc(param->getCachePath, cache_path);

4
rpcs3/Emu/Cell/Modules/sceNpTrophy.cpp
View File

@ -269,7 +269,7 @@ s32 sceNpTrophyGetGameInfo(u32 context, u32 handle, vm::ptr<SceNpTrophyGameDetai
const std::string& path = vfs::get("/dev_hdd0/home/00000001/trophy/" + ctxt->trp_name + "/TROPCONF.SFM");
// TODO: rXmlDocument can open only real file
VERIFY(!fs::get_virtual_device(path));
verify(HERE), !fs::get_virtual_device(path);
rXmlDocument doc;
doc.Load(path);
@ -399,7 +399,7 @@ s32 sceNpTrophyGetTrophyInfo(u32 context, u32 handle, s32 trophyId, vm::ptr<SceN
const std::string& path = vfs::get("/dev_hdd0/home/00000001/trophy/" + ctxt->trp_name + "/TROPCONF.SFM");
// TODO: rXmlDocument can open only real file
VERIFY(!fs::get_virtual_device(path));
verify(HERE), !fs::get_virtual_device(path);
rXmlDocument doc;
doc.Load(path);

8
rpcs3/Emu/Cell/Modules/sys_libc_.cpp
View File

@ -213,7 +213,7 @@ vm::ptr<char> _sys_strcat(vm::ptr<char> dest, vm::cptr<char> source)
{
sysPrxForUser.trace("_sys_strcat(dest=*0x%x, source=%s)", dest, source);
VERIFY(std::strcat(dest.get_ptr(), source.get_ptr()) == dest.get_ptr());
verify(HERE), std::strcat(dest.get_ptr(), source.get_ptr()) == dest.get_ptr();
return dest;
}
@ -229,7 +229,7 @@ vm::ptr<char> _sys_strncat(vm::ptr<char> dest, vm::cptr<char> source, u32 len)
{
sysPrxForUser.trace("_sys_strncat(dest=*0x%x, source=%s, len=%d)", dest, source, len);
VERIFY(std::strncat(dest.get_ptr(), source.get_ptr(), len) == dest.get_ptr());
verify(HERE), std::strncat(dest.get_ptr(), source.get_ptr(), len) == dest.get_ptr();
return dest;
}
@ -238,7 +238,7 @@ vm::ptr<char> _sys_strcpy(vm::ptr<char> dest, vm::cptr<char> source)
{
sysPrxForUser.trace("_sys_strcpy(dest=*0x%x, source=%s)", dest, source);
VERIFY(std::strcpy(dest.get_ptr(), source.get_ptr()) == dest.get_ptr());
verify(HERE), std::strcpy(dest.get_ptr(), source.get_ptr()) == dest.get_ptr();
return dest;
}
@ -252,7 +252,7 @@ vm::ptr<char> _sys_strncpy(vm::ptr<char> dest, vm::cptr<char> source, u32 len)
return vm::null;
}
VERIFY(std::strncpy(dest.get_ptr(), source.get_ptr(), len) == dest.get_ptr());
verify(HERE), std::strncpy(dest.get_ptr(), source.get_ptr(), len) == dest.get_ptr();
return dest;
}

2
rpcs3/Emu/Cell/Modules/sys_spu_.cpp
View File

@ -59,7 +59,7 @@ s32 sys_spu_image_close(vm::ptr<sys_spu_image_t> img)
return CELL_EINVAL;
}
VERIFY(vm::dealloc(img->segs.addr(), vm::main)); // Current rough implementation
verify(HERE), vm::dealloc(img->segs.addr(), vm::main); // Current rough implementation
return CELL_OK;
}

52
rpcs3/Emu/Cell/PPUInterpreter.cpp
View File

@ -3569,28 +3569,28 @@ bool ppu_interpreter::STDU(ppu_thread& ppu, ppu_opcode_t op)
bool ppu_interpreter::FDIVS(ppu_thread& ppu, ppu_opcode_t op)
{
ppu.fpr[op.frd] = f32(ppu.fpr[op.fra] / ppu.fpr[op.frb]);
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
bool ppu_interpreter::FSUBS(ppu_thread& ppu, ppu_opcode_t op)
{
ppu.fpr[op.frd] = f32(ppu.fpr[op.fra] - ppu.fpr[op.frb]);
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
bool ppu_interpreter::FADDS(ppu_thread& ppu, ppu_opcode_t op)
{
ppu.fpr[op.frd] = f32(ppu.fpr[op.fra] + ppu.fpr[op.frb]);
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
bool ppu_interpreter::FSQRTS(ppu_thread& ppu, ppu_opcode_t op)
{
ppu.fpr[op.frd] = f32(std::sqrt(ppu.fpr[op.frb]));
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
@ -3599,42 +3599,42 @@ bool ppu_interpreter::FRES(ppu_thread& ppu, ppu_opcode_t op)
f32 value = f32(ppu.fpr[op.frb]);
_mm_store_ss(&value, _mm_rcp_ss(_mm_load_ss(&value)));
ppu.fpr[op.frd] = value;
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
bool ppu_interpreter::FMULS(ppu_thread& ppu, ppu_opcode_t op)
{
ppu.fpr[op.frd] = f32(ppu.fpr[op.fra] * ppu.fpr[op.frc]);
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
bool ppu_interpreter::FMADDS(ppu_thread& ppu, ppu_opcode_t op)
{
ppu.fpr[op.frd] = f32(ppu.fpr[op.fra] * ppu.fpr[op.frc] + ppu.fpr[op.frb]);
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
bool ppu_interpreter::FMSUBS(ppu_thread& ppu, ppu_opcode_t op)
{
ppu.fpr[op.frd] = f32(ppu.fpr[op.fra] * ppu.fpr[op.frc] - ppu.fpr[op.frb]);
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
bool ppu_interpreter::FNMSUBS(ppu_thread& ppu, ppu_opcode_t op)
{
ppu.fpr[op.frd] = f32(-(ppu.fpr[op.fra] * ppu.fpr[op.frc]) + ppu.fpr[op.frb]);
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
bool ppu_interpreter::FNMADDS(ppu_thread& ppu, ppu_opcode_t op)
{
ppu.fpr[op.frd] = f32(-(ppu.fpr[op.fra] * ppu.fpr[op.frc]) - ppu.fpr[op.frb]);
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
@ -3696,49 +3696,49 @@ bool ppu_interpreter::FCMPU(ppu_thread& ppu, ppu_opcode_t op)
bool ppu_interpreter::FRSP(ppu_thread& ppu, ppu_opcode_t op)
{
ppu.fpr[op.frd] = f32(ppu.fpr[op.frb]);
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
bool ppu_interpreter::FCTIW(ppu_thread& ppu, ppu_opcode_t op)
{
(s32&)ppu.fpr[op.frd] = s32(ppu.fpr[op.frb]);
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
bool ppu_interpreter::FCTIWZ(ppu_thread& ppu, ppu_opcode_t op)
{
(s32&)ppu.fpr[op.frd] = _mm_cvttsd_si32(_mm_load_sd(&ppu.fpr[op.frb]));
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
bool ppu_interpreter::FDIV(ppu_thread& ppu, ppu_opcode_t op)
{
ppu.fpr[op.frd] = ppu.fpr[op.fra] / ppu.fpr[op.frb];
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
bool ppu_interpreter::FSUB(ppu_thread& ppu, ppu_opcode_t op)
{
ppu.fpr[op.frd] = ppu.fpr[op.fra] - ppu.fpr[op.frb];
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
bool ppu_interpreter::FADD(ppu_thread& ppu, ppu_opcode_t op)
{
ppu.fpr[op.frd] = ppu.fpr[op.fra] + ppu.fpr[op.frb];
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
bool ppu_interpreter::FSQRT(ppu_thread& ppu, ppu_opcode_t op)
{
ppu.fpr[op.frd] = std::sqrt(ppu.fpr[op.frb]);
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
@ -3752,7 +3752,7 @@ bool ppu_interpreter::FSEL(ppu_thread& ppu, ppu_opcode_t op)
bool ppu_interpreter::FMUL(ppu_thread& ppu, ppu_opcode_t op)
{
ppu.fpr[op.frd] = ppu.fpr[op.fra] * ppu.fpr[op.frc];
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
@ -3761,35 +3761,35 @@ bool ppu_interpreter::FRSQRTE(ppu_thread& ppu, ppu_opcode_t op)
f32 value = f32(ppu.fpr[op.frb]);
_mm_store_ss(&value, _mm_rsqrt_ss(_mm_load_ss(&value)));
ppu.fpr[op.frd] = value;
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
bool ppu_interpreter::FMSUB(ppu_thread& ppu, ppu_opcode_t op)
{
ppu.fpr[op.frd] = ppu.fpr[op.fra] * ppu.fpr[op.frc] - ppu.fpr[op.frb];
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
bool ppu_interpreter::FMADD(ppu_thread& ppu, ppu_opcode_t op)
{
ppu.fpr[op.frd] = ppu.fpr[op.fra] * ppu.fpr[op.frc] + ppu.fpr[op.frb];
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
bool ppu_interpreter::FNMSUB(ppu_thread& ppu, ppu_opcode_t op)
{
ppu.fpr[op.frd] = -(ppu.fpr[op.fra] * ppu.fpr[op.frc]) + ppu.fpr[op.frb];
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
bool ppu_interpreter::FNMADD(ppu_thread& ppu, ppu_opcode_t op)
{
ppu.fpr[op.frd] = -(ppu.fpr[op.fra] * ppu.fpr[op.frc]) - ppu.fpr[op.frb];
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
@ -3830,21 +3830,21 @@ bool ppu_interpreter::FABS(ppu_thread& ppu, ppu_opcode_t op)
bool ppu_interpreter::FCTID(ppu_thread& ppu, ppu_opcode_t op)
{
(s64&)ppu.fpr[op.frd] = s64(ppu.fpr[op.frb]);
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
bool ppu_interpreter::FCTIDZ(ppu_thread& ppu, ppu_opcode_t op)
{
(s64&)ppu.fpr[op.frd] = _mm_cvttsd_si64(_mm_load_sd(&ppu.fpr[op.frb]));
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}
bool ppu_interpreter::FCFID(ppu_thread& ppu, ppu_opcode_t op)
{
ppu.fpr[op.frd] = static_cast<double>((s64&)ppu.fpr[op.frb]);
VERIFY(!op.rc); //if (UNLIKELY(op.rc)) ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
if (UNLIKELY(op.rc)) fmt::throw_exception("%s: op.rc", __func__); //ppu_cr_set(ppu, 1, ppu.fpscr.fg, ppu.fpscr.fl, ppu.fpscr.fe, ppu.fpscr.fu);
return true;
}

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

@ -1355,7 +1355,7 @@ void ppu_load_exec(const ppu_exec_object& elf)
if (prog.p_type == 0x1 /* LOAD */ && prog.p_memsz && (prog.p_flags & 0x2) == 0 /* W */)
{
// Set memory protection to read-only when necessary
VERIFY(vm::page_protect(addr, ::align(size, 0x1000), 0, 0, vm::page_writable));
verify(HERE), vm::page_protect(addr, ::align(size, 0x1000), 0, 0, vm::page_writable);
}
}
}

3
rpcs3/Emu/Cell/RawSPUThread.cpp
View File

@ -30,8 +30,7 @@ void RawSPUThread::on_init(const std::shared_ptr<void>& _this)
{
// Install correct SPU index and LS address
const_cast<u32&>(index) = id;
const_cast<u32&>(offset) = vm::falloc(RAW_SPU_BASE_ADDR + RAW_SPU_OFFSET * index, 0x40000);
VERIFY(offset);
const_cast<u32&>(offset) = verify(vm::falloc(RAW_SPU_BASE_ADDR + RAW_SPU_OFFSET * index, 0x40000), HERE);
SPUThread::on_init(_this);
}

4
rpcs3/Emu/Cell/lv2/sys_cond.cpp
View File

@ -24,9 +24,7 @@ void lv2_cond_t::notify(lv2_lock_t, cpu_thread* thread)
else
{
mutex->owner = idm::get<ppu_thread>(thread->id);
VERIFY(!thread->state.test_and_set(cpu_flag::signal));
thread->notify();
thread->set_signal();
}
}

3
rpcs3/Emu/Cell/lv2/sys_event.cpp
View File

@ -83,8 +83,7 @@ void lv2_event_queue_t::push(lv2_lock_t, u64 source, u64 data1, u64 data2, u64 d
fmt::throw_exception("Unexpected (queue type=%d, tid=%s)" HERE, type, thread->id);
}
VERIFY(!thread->state.test_and_set(cpu_flag::signal));
thread->notify();
thread->set_signal();
return m_sq.pop_front();
}

6
rpcs3/Emu/Cell/lv2/sys_event_flag.cpp
View File

@ -29,8 +29,7 @@ void lv2_event_flag_t::notify_all(lv2_lock_t)
// save pattern
ppu.gpr[4] = clear_pattern(bitptn, mode);
VERIFY(!thread->state.test_and_set(cpu_flag::signal));
thread->notify();
thread->set_signal();
return true;
}
@ -292,8 +291,7 @@ s32 sys_event_flag_cancel(u32 id, vm::ptr<u32> num)
// clear "mode" as a sign of cancellation
ppu.gpr[5] = 0;
VERIFY(!thread->state.test_and_set(cpu_flag::signal));
thread->notify();
thread->set_signal();
}
eflag->sq.clear();

2
rpcs3/Emu/Cell/lv2/sys_fs.cpp
View File

@ -474,7 +474,7 @@ ppu_error_code sys_fs_fcntl(u32 fd, u32 op, vm::ptr<void> _arg, u32 _size)
? file->op_read(arg->buf, arg->size)
: file->op_write(arg->buf, arg->size);
VERIFY(old_pos == file->file.seek(old_pos));
verify(HERE), old_pos == file->file.seek(old_pos);
arg->out_code = CELL_OK;

3
rpcs3/Emu/Cell/lv2/sys_lwcond.cpp
View File

@ -30,8 +30,7 @@ void lv2_lwcond_t::notify(lv2_lock_t, cpu_thread* thread, const std::shared_ptr<
mutex->signaled--;
}
VERIFY(!thread->state.test_and_set(cpu_flag::signal));
thread->notify();
thread->set_signal();
}
s32 _sys_lwcond_create(vm::ptr<u32> lwcond_id, u32 lwmutex_id, vm::ptr<sys_lwcond_t> control, u64 name, u32 arg5)

5
rpcs3/Emu/Cell/lv2/sys_lwmutex.cpp
View File

@ -20,9 +20,8 @@ void lv2_lwmutex_t::unlock(lv2_lock_t)
if (sq.size())
{
auto& thread = sq.front();
VERIFY(!thread->state.test_and_set(cpu_flag::signal));
thread->notify();
const auto thread = sq.front();
thread->set_signal();
sq.pop_front();
}

6
rpcs3/Emu/Cell/lv2/sys_memory.cpp
View File

@ -48,7 +48,7 @@ ppu_error_code sys_memory_allocate(u32 size, u64 flags, vm::ptr<u32> alloc_addr)
}
// Allocate memory, write back the start address of the allocated area
VERIFY(*alloc_addr = vm::alloc(size, vm::user_space, flags == SYS_MEMORY_PAGE_SIZE_1M ? 0x100000 : 0x10000));
*alloc_addr = verify(vm::alloc(size, vm::user_space, flags == SYS_MEMORY_PAGE_SIZE_1M ? 0x100000 : 0x10000), HERE);
return CELL_OK;
}
@ -111,7 +111,7 @@ ppu_error_code sys_memory_allocate_from_container(u32 size, u32 cid, u64 flags,
}
// Allocate memory, write back the start address of the allocated area, use cid as the supplementary info
VERIFY(*alloc_addr = vm::alloc(size, vm::user_space, flags == SYS_MEMORY_PAGE_SIZE_1M ? 0x100000 : 0x10000, cid));
*alloc_addr = verify(vm::alloc(size, vm::user_space, flags == SYS_MEMORY_PAGE_SIZE_1M ? 0x100000 : 0x10000, cid), HERE);
return CELL_OK;
}
@ -122,7 +122,7 @@ ppu_error_code sys_memory_free(u32 addr)
const auto area = vm::get(vm::user_space);
VERIFY(area);
verify(HERE), area;
// Deallocate memory
u32 cid, size = area->dealloc(addr, &cid);

4
rpcs3/Emu/Cell/lv2/sys_mmapper.cpp
View File

@ -334,9 +334,7 @@ ppu_error_code sys_mmapper_unmap_shared_memory(u32 addr, vm::ptr<u32> mem_id)
return CELL_EINVAL;
}
VERIFY(area->dealloc(addr));
VERIFY(mem->addr.exchange(0) == addr);
verify(HERE), area->dealloc(addr), mem->addr.exchange(0) == addr;
return CELL_OK;
}

4
rpcs3/Emu/Cell/lv2/sys_mutex.cpp
View File

@ -19,9 +19,7 @@ void lv2_mutex_t::unlock(lv2_lock_t)
{
// pick new owner; protocol is ignored in current implementation
owner = idm::get<ppu_thread>(sq.front()->id);
VERIFY(!owner->state.test_and_set(cpu_flag::signal));
owner->notify();
owner->set_signal();
}
}

7
rpcs3/Emu/Cell/lv2/sys_rwlock.cpp
View File

@ -17,9 +17,7 @@ void lv2_rwlock_t::notify_all(lv2_lock_t)
if (!readers && !writer && wsq.size())
{
writer = idm::get<ppu_thread>(wsq.front()->id);
VERIFY(!writer->state.test_and_set(cpu_flag::signal));
writer->notify();
writer->set_signal();
return wsq.pop_front();
}
@ -31,8 +29,7 @@ void lv2_rwlock_t::notify_all(lv2_lock_t)
for (auto& thread : rsq)
{
VERIFY(!thread->state.test_and_set(cpu_flag::signal));
thread->notify();
thread->set_signal();
}
return rsq.clear();

5
rpcs3/Emu/Cell/lv2/sys_semaphore.cpp
View File

@ -172,9 +172,8 @@ s32 sys_semaphore_post(u32 sem_id, s32 count)
{
count--;
auto& thread = sem->sq.front();
VERIFY(!thread->state.test_and_set(cpu_flag::signal));
thread->notify();
const auto thread = sem->sq.front();
thread->set_signal();
sem->sq.pop_front();
}

2
rpcs3/Emu/Cell/lv2/sys_vm.cpp
View File

@ -27,7 +27,7 @@ ppu_error_code sys_vm_memory_map(u32 vsize, u32 psize, u32 cid, u64 flag, u64 po
if (const auto area = vm::map(found, vsize, flag))
{
// Alloc all memory (shall not fail)
VERIFY(area->alloc(vsize));
verify(HERE), area->alloc(vsize);
// Write a pointer for the allocated memory
*addr = found;

8
rpcs3/Emu/PSP2/ARMv7Module.cpp
View File

@ -465,7 +465,7 @@ void arm_load_exec(const arm_exec_object& elf)
case 0x6c2224ba: // __sce_moduleinfo
{
VERIFY(addr == module_info.addr());
verify(HERE), addr == module_info.addr();
break;
}
@ -601,8 +601,8 @@ void arm_load_exec(const arm_exec_object& elf)
LOG_NOTICE(LOADER, "__sce_process_param(*0x%x) analysis...", proc_param);
VERIFY(proc_param->size >= sizeof(psv_process_param_t));
VERIFY(proc_param->ver == "PSP2"_u32);
verify(HERE), proc_param->size >= sizeof(psv_process_param_t);
verify(HERE), proc_param->ver == "PSP2"_u32;
LOG_NOTICE(LOADER, "*** size=0x%x; 0x%x, 0x%x, 0x%x", proc_param->size, proc_param->ver, proc_param->unk0, proc_param->unk1);
@ -618,7 +618,7 @@ void arm_load_exec(const arm_exec_object& elf)
LOG_NOTICE(LOADER, "__sce_libcparam(*0x%x) analysis...", libc_param);
VERIFY(libc_param->size >= 0x1c);
verify(HERE), libc_param->size >= 0x1c;
LOG_NOTICE(LOADER, "*** size=0x%x; 0x%x, 0x%x, 0x%x", libc_param->size, libc_param->unk0, libc_param->unk1, libc_param->unk2);

10
rpcs3/Emu/PSP2/Modules/scePerf.cpp
View File

@ -12,7 +12,7 @@ arm_error_code scePerfArmPmonReset(ARMv7Thread& cpu, s32 threadId)
{
scePerf.warning("scePerfArmPmonReset(threadId=0x%x)", threadId);
VERIFY(threadId == SCE_PERF_ARM_PMON_THREAD_ID_SELF);
verify(HERE), threadId == SCE_PERF_ARM_PMON_THREAD_ID_SELF;
cpu.counters = {};
@ -23,7 +23,7 @@ arm_error_code scePerfArmPmonSelectEvent(ARMv7Thread& cpu, s32 threadId, u32 cou
{
scePerf.warning("scePerfArmPmonSelectEvent(threadId=0x%x, counter=0x%x, eventCode=0x%x)", threadId, counter, eventCode);
VERIFY(threadId == SCE_PERF_ARM_PMON_THREAD_ID_SELF);
verify(HERE), threadId == SCE_PERF_ARM_PMON_THREAD_ID_SELF;
if (counter >= 6)
{
@ -72,7 +72,7 @@ arm_error_code scePerfArmPmonStart(ARMv7Thread& cpu, s32 threadId)
{
scePerf.warning("scePerfArmPmonStart(threadId=0x%x)", threadId);
VERIFY(threadId == SCE_PERF_ARM_PMON_THREAD_ID_SELF);
verify(HERE), threadId == SCE_PERF_ARM_PMON_THREAD_ID_SELF;
return SCE_OK;
}
@ -81,7 +81,7 @@ arm_error_code scePerfArmPmonStop(ARMv7Thread& cpu, s32 threadId)
{
scePerf.warning("scePerfArmPmonStop(threadId=0x%x)");
VERIFY(threadId == SCE_PERF_ARM_PMON_THREAD_ID_SELF);
verify(HERE), threadId == SCE_PERF_ARM_PMON_THREAD_ID_SELF;
return SCE_OK;
}
@ -90,7 +90,7 @@ arm_error_code scePerfArmPmonGetCounterValue(ARMv7Thread& cpu, s32 threadId, u32
{
scePerf.warning("scePerfArmPmonGetCounterValue(threadId=0x%x, counter=%d, pValue=*0x%x)", threadId, counter, pValue);
VERIFY(threadId == SCE_PERF_ARM_PMON_THREAD_ID_SELF);
verify(HERE), threadId == SCE_PERF_ARM_PMON_THREAD_ID_SELF;
if (counter >= 6 && counter != SCE_PERF_ARM_PMON_CYCLE_COUNTER)
{

2
rpcs3/Emu/RSX/D3D12/D3D12GSRender.cpp
View File

@ -489,7 +489,7 @@ void D3D12GSRender::flip(int buffer)
if (!is_flip_surface_in_global_memory(rsx::method_registers.surface_color_target()))
{
resource_storage &storage = get_current_resource_storage();
VERIFY(storage.ram_framebuffer == nullptr);
verify(HERE), storage.ram_framebuffer == nullptr;
size_t w = 0, h = 0, row_pitch = 0;

2
rpcs3/Loader/TROPUSR.cpp
View File

@ -138,7 +138,7 @@ bool TROPUSRLoader::Generate(const std::string& filepath, const std::string& con
const std::string& path = vfs::get(configpath);
// TODO: rXmlDocument can open only real file
VERIFY(!fs::get_virtual_device(path));
verify(HERE), !fs::get_virtual_device(path);
rXmlDocument doc;
doc.Load(path);