diff --git a/Utilities/Config.h b/Utilities/Config.h
index f88d19af84..77b71d33db 100644
--- a/Utilities/Config.h
+++ b/Utilities/Config.h
@@ -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;
diff --git a/Utilities/File.cpp b/Utilities/File.cpp
index 66a40d3546..53172a3909 100644
--- a/Utilities/File.cpp
+++ b/Utilities/File.cpp
@@ -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))
diff --git a/Utilities/Thread.cpp b/Utilities/Thread.cpp
index 5bc5d61181..d8adfb8bd6 100644
--- a/Utilities/Thread.cpp
+++ b/Utilities/Thread.cpp
@@ -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);
diff --git a/Utilities/types.h b/Utilities/types.h
index 27c4acaf58..f82798e597 100644
--- a/Utilities/types.h
+++ b/Utilities/types.h
@@ -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)
 
diff --git a/rpcs3/Emu/Audio/AudioDumper.cpp b/rpcs3/Emu/Audio/AudioDumper.cpp
index a61e62c4be..6bb7283286 100644
--- a/rpcs3/Emu/Audio/AudioDumper.cpp
+++ b/rpcs3/Emu/Audio/AudioDumper.cpp
@@ -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;
 	}
diff --git a/rpcs3/Emu/CPU/CPUThread.cpp b/rpcs3/Emu/CPU/CPUThread.cpp
index f73dc2c6ca..ebb8c2f2a4 100644
--- a/rpcs3/Emu/CPU/CPUThread.cpp
+++ b/rpcs3/Emu/CPU/CPUThread.cpp
@@ -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());
diff --git a/rpcs3/Emu/CPU/CPUThread.h b/rpcs3/Emu/CPU/CPUThread.h
index cef0c19563..4bbed40d3a 100644
--- a/rpcs3/Emu/CPU/CPUThread.h
+++ b/rpcs3/Emu/CPU/CPUThread.h
@@ -47,6 +47,9 @@ public:
 	// Run thread
 	void run();
 
+	// Set cpu_flag::signal
+	void set_signal();
+
 	// Print CPU state
 	virtual std::string dump() const;
 
diff --git a/rpcs3/Emu/Cell/Modules/cellDmux.cpp b/rpcs3/Emu/Cell/Modules/cellDmux.cpp
index c0d3559d2b..155b07e872 100644
--- a/rpcs3/Emu/Cell/Modules/cellDmux.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellDmux.cpp
@@ -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)
diff --git a/rpcs3/Emu/Cell/Modules/cellGcmSys.cpp b/rpcs3/Emu/Cell/Modules/cellGcmSys.cpp
index 155467f30a..96232fefab 100644
--- a/rpcs3/Emu/Cell/Modules/cellGcmSys.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellGcmSys.cpp
@@ -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);
 }
diff --git a/rpcs3/Emu/Cell/Modules/cellMsgDialog.cpp b/rpcs3/Emu/Cell/Modules/cellMsgDialog.cpp
index 622d9a936e..99f78b0e10 100644
--- a/rpcs3/Emu/Cell/Modules/cellMsgDialog.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellMsgDialog.cpp
@@ -249,8 +249,7 @@ s32 cellMsgDialogAbort()
 		return CELL_SYSUTIL_ERROR_BUSY;
 	}
 
-	VERIFY(fxm::remove<MsgDialogBase>());
-
+	verify(HERE), fxm::remove<MsgDialogBase>();
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/Cell/Modules/cellSail.cpp b/rpcs3/Emu/Cell/Modules/cellSail.cpp
index 5a1bcd771d..b96bd1dc9d 100644
--- a/rpcs3/Emu/Cell/Modules/cellSail.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellSail.cpp
@@ -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);
diff --git a/rpcs3/Emu/Cell/Modules/cellSpurs.cpp b/rpcs3/Emu/Cell/Modules/cellSpurs.cpp
index 2c9975e6f5..b8c6392e69 100644
--- a/rpcs3/Emu/Cell/Modules/cellSpurs.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellSpurs.cpp
@@ -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);
diff --git a/rpcs3/Emu/Cell/Modules/cellSync.cpp b/rpcs3/Emu/Cell/Modules/cellSync.cpp
index defe374f1f..eaa0a76f70 100644
--- a/rpcs3/Emu/Cell/Modules/cellSync.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellSync.cpp
@@ -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
diff --git a/rpcs3/Emu/Cell/Modules/cellSysutil.cpp b/rpcs3/Emu/Cell/Modules/cellSysutil.cpp
index 4a61922c90..ea4dcff2cf 100644
--- a/rpcs3/Emu/Cell/Modules/cellSysutil.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellSysutil.cpp
@@ -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);
diff --git a/rpcs3/Emu/Cell/Modules/sceNpTrophy.cpp b/rpcs3/Emu/Cell/Modules/sceNpTrophy.cpp
index a743a953cb..36c90f3a3c 100644
--- a/rpcs3/Emu/Cell/Modules/sceNpTrophy.cpp
+++ b/rpcs3/Emu/Cell/Modules/sceNpTrophy.cpp
@@ -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);
 
diff --git a/rpcs3/Emu/Cell/Modules/sys_libc_.cpp b/rpcs3/Emu/Cell/Modules/sys_libc_.cpp
index 2cbca7311d..e95c4f2044 100644
--- a/rpcs3/Emu/Cell/Modules/sys_libc_.cpp
+++ b/rpcs3/Emu/Cell/Modules/sys_libc_.cpp
@@ -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;
 }
diff --git a/rpcs3/Emu/Cell/Modules/sys_spu_.cpp b/rpcs3/Emu/Cell/Modules/sys_spu_.cpp
index 905627bdee..26275824f4 100644
--- a/rpcs3/Emu/Cell/Modules/sys_spu_.cpp
+++ b/rpcs3/Emu/Cell/Modules/sys_spu_.cpp
@@ -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;
 }
 
diff --git a/rpcs3/Emu/Cell/PPUInterpreter.cpp b/rpcs3/Emu/Cell/PPUInterpreter.cpp
index b3e5cfb1ea..6110873dff 100644
--- a/rpcs3/Emu/Cell/PPUInterpreter.cpp
+++ b/rpcs3/Emu/Cell/PPUInterpreter.cpp
@@ -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;
 }
 
diff --git a/rpcs3/Emu/Cell/PPUModule.cpp b/rpcs3/Emu/Cell/PPUModule.cpp
index 3745d8247e..fd7c703ffe 100644
--- a/rpcs3/Emu/Cell/PPUModule.cpp
+++ b/rpcs3/Emu/Cell/PPUModule.cpp
@@ -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);
 		}
 	}
 }
diff --git a/rpcs3/Emu/Cell/RawSPUThread.cpp b/rpcs3/Emu/Cell/RawSPUThread.cpp
index 17d7f12be6..d83d270b4d 100644
--- a/rpcs3/Emu/Cell/RawSPUThread.cpp
+++ b/rpcs3/Emu/Cell/RawSPUThread.cpp
@@ -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);
 	}
diff --git a/rpcs3/Emu/Cell/lv2/sys_cond.cpp b/rpcs3/Emu/Cell/lv2/sys_cond.cpp
index f18a97f5da..902f3bd871 100644
--- a/rpcs3/Emu/Cell/lv2/sys_cond.cpp
+++ b/rpcs3/Emu/Cell/lv2/sys_cond.cpp
@@ -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();
 	}
 }
 
diff --git a/rpcs3/Emu/Cell/lv2/sys_event.cpp b/rpcs3/Emu/Cell/lv2/sys_event.cpp
index 6fc46359e2..234863480d 100644
--- a/rpcs3/Emu/Cell/lv2/sys_event.cpp
+++ b/rpcs3/Emu/Cell/lv2/sys_event.cpp
@@ -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();
 }
diff --git a/rpcs3/Emu/Cell/lv2/sys_event_flag.cpp b/rpcs3/Emu/Cell/lv2/sys_event_flag.cpp
index 9e18658909..e260f99359 100644
--- a/rpcs3/Emu/Cell/lv2/sys_event_flag.cpp
+++ b/rpcs3/Emu/Cell/lv2/sys_event_flag.cpp
@@ -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();
diff --git a/rpcs3/Emu/Cell/lv2/sys_fs.cpp b/rpcs3/Emu/Cell/lv2/sys_fs.cpp
index 3147dfd719..6831cf1b21 100644
--- a/rpcs3/Emu/Cell/lv2/sys_fs.cpp
+++ b/rpcs3/Emu/Cell/lv2/sys_fs.cpp
@@ -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;
 
diff --git a/rpcs3/Emu/Cell/lv2/sys_lwcond.cpp b/rpcs3/Emu/Cell/lv2/sys_lwcond.cpp
index 98012eeb25..11454ebe27 100644
--- a/rpcs3/Emu/Cell/lv2/sys_lwcond.cpp
+++ b/rpcs3/Emu/Cell/lv2/sys_lwcond.cpp
@@ -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)
diff --git a/rpcs3/Emu/Cell/lv2/sys_lwmutex.cpp b/rpcs3/Emu/Cell/lv2/sys_lwmutex.cpp
index 980c5d613f..2dc3cc272e 100644
--- a/rpcs3/Emu/Cell/lv2/sys_lwmutex.cpp
+++ b/rpcs3/Emu/Cell/lv2/sys_lwmutex.cpp
@@ -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();
 	}
diff --git a/rpcs3/Emu/Cell/lv2/sys_memory.cpp b/rpcs3/Emu/Cell/lv2/sys_memory.cpp
index 4074af62c4..68e3bdc63f 100644
--- a/rpcs3/Emu/Cell/lv2/sys_memory.cpp
+++ b/rpcs3/Emu/Cell/lv2/sys_memory.cpp
@@ -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);
diff --git a/rpcs3/Emu/Cell/lv2/sys_mmapper.cpp b/rpcs3/Emu/Cell/lv2/sys_mmapper.cpp
index ebd5130a77..74bc73b4dd 100644
--- a/rpcs3/Emu/Cell/lv2/sys_mmapper.cpp
+++ b/rpcs3/Emu/Cell/lv2/sys_mmapper.cpp
@@ -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;
 }
 
diff --git a/rpcs3/Emu/Cell/lv2/sys_mutex.cpp b/rpcs3/Emu/Cell/lv2/sys_mutex.cpp
index 6564611e47..ad0ac4e5c9 100644
--- a/rpcs3/Emu/Cell/lv2/sys_mutex.cpp
+++ b/rpcs3/Emu/Cell/lv2/sys_mutex.cpp
@@ -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();
 	}
 }
 
diff --git a/rpcs3/Emu/Cell/lv2/sys_rwlock.cpp b/rpcs3/Emu/Cell/lv2/sys_rwlock.cpp
index 51b2879d6b..ecfad5d2a7 100644
--- a/rpcs3/Emu/Cell/lv2/sys_rwlock.cpp
+++ b/rpcs3/Emu/Cell/lv2/sys_rwlock.cpp
@@ -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();
diff --git a/rpcs3/Emu/Cell/lv2/sys_semaphore.cpp b/rpcs3/Emu/Cell/lv2/sys_semaphore.cpp
index 17e38689c7..cc375b9516 100644
--- a/rpcs3/Emu/Cell/lv2/sys_semaphore.cpp
+++ b/rpcs3/Emu/Cell/lv2/sys_semaphore.cpp
@@ -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();
 	}
diff --git a/rpcs3/Emu/Cell/lv2/sys_vm.cpp b/rpcs3/Emu/Cell/lv2/sys_vm.cpp
index 7258d73de0..5473bf67ed 100644
--- a/rpcs3/Emu/Cell/lv2/sys_vm.cpp
+++ b/rpcs3/Emu/Cell/lv2/sys_vm.cpp
@@ -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;
diff --git a/rpcs3/Emu/PSP2/ARMv7Module.cpp b/rpcs3/Emu/PSP2/ARMv7Module.cpp
index 93d5eb0d91..17cbb01688 100644
--- a/rpcs3/Emu/PSP2/ARMv7Module.cpp
+++ b/rpcs3/Emu/PSP2/ARMv7Module.cpp
@@ -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);
 
diff --git a/rpcs3/Emu/PSP2/Modules/scePerf.cpp b/rpcs3/Emu/PSP2/Modules/scePerf.cpp
index 4684cee64d..6373646327 100644
--- a/rpcs3/Emu/PSP2/Modules/scePerf.cpp
+++ b/rpcs3/Emu/PSP2/Modules/scePerf.cpp
@@ -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)
 	{
diff --git a/rpcs3/Emu/RSX/D3D12/D3D12GSRender.cpp b/rpcs3/Emu/RSX/D3D12/D3D12GSRender.cpp
index 48c3752719..b5e8bded69 100644
--- a/rpcs3/Emu/RSX/D3D12/D3D12GSRender.cpp
+++ b/rpcs3/Emu/RSX/D3D12/D3D12GSRender.cpp
@@ -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;
 
diff --git a/rpcs3/Loader/TROPUSR.cpp b/rpcs3/Loader/TROPUSR.cpp
index b58b71e122..dee75a46d6 100644
--- a/rpcs3/Loader/TROPUSR.cpp
+++ b/rpcs3/Loader/TROPUSR.cpp
@@ -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);