Some fixes

Utilities/File.cpp

@@ -13,14 +13,13 @@ std::unique_ptr<wchar_t[]> to_wchar(const std::string& source)
 {
 	const auto length = source.size() + 1; // size + null terminator
 
-	const int size = source.size() < INT_MAX ? static_cast<int>(length) : throw std::length_error(__FUNCTION__);
+	const int size = source.size() < INT_MAX ? static_cast<int>(length) : throw EXCEPTION("Invalid source length (0x%llx)", source.size());
 
 	std::unique_ptr<wchar_t[]> buffer(new wchar_t[length]); // allocate buffer assuming that length is the max possible size
 
 	if (!MultiByteToWideChar(CP_UTF8, 0, source.c_str(), size, buffer.get(), size))
 	{
-		LOG_ERROR(GENERAL, "ConvertUTF8ToWChar(source='%s') failed: 0x%llx", source, GET_API_ERROR);
-		throw __FUNCTION__;
+		throw EXCEPTION("Conversion failed (0x%llx)", GET_API_ERROR);
 	}
 
 	return buffer;
@@ -39,15 +38,14 @@ void to_utf8(std::string& result, const wchar_t* source)
 
 	if (size <= 0)
 	{
-		LOG_ERROR(GENERAL, "ConvertWCharToUTF8(length=%d) failed: 0x%llx", length, GET_API_ERROR);
-		throw __FUNCTION__;
+		throw EXCEPTION("Conversion failed (0x%llx)", GET_API_ERROR);
 	}
 
 	result.resize(size);
 
 	if (!WideCharToMultiByte(CP_UTF8, 0, source, length, &result.front(), size, NULL, NULL))
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("Conversion failed (0x%llx)", GET_API_ERROR);
 	}
 }
 
@@ -532,7 +530,7 @@ bool fs::file::close()
 
 u64 fs::file::read(void* buffer, u64 count) const
 {
-	const int size = count <= INT_MAX ? static_cast<int>(count) : throw std::length_error(__FUNCTION__);
+	const int size = count <= INT_MAX ? static_cast<int>(count) : throw EXCEPTION("Invalid count (0x%llx)", count);
 
 #ifdef _WIN32
 	DWORD nread;
@@ -549,7 +547,7 @@ u64 fs::file::read(void* buffer, u64 count) const
 
 u64 fs::file::write(const void* buffer, u64 count) const
 {
-	const int size = count <= INT_MAX ? static_cast<int>(count) : throw std::length_error(__FUNCTION__);
+	const int size = count <= INT_MAX ? static_cast<int>(count) : throw EXCEPTION("Invalid count (0x%llx)", count);
 
 #ifdef _WIN32
 	DWORD nwritten;

Utilities/Thread.cpp

@@ -1222,7 +1222,7 @@ thread_t::~thread_t()
 		}
 		else
 		{
-			m_thread->m_thread.detach();
+			throw EXCEPTION("Deadlock");
 		}
 	}
 }
@@ -1310,11 +1310,7 @@ void thread_t::start(std::function<std::string()> name, std::function<void()> fu
 			error(e);
 		}
 
-		if (Emu.IsStopped())
-		{
-			LOG_NOTICE(GENERAL, "Thread aborted");
-		}
-		else if (Ini.HLELogging.GetValue())
+		if (Ini.HLELogging.GetValue())
 		{
 			LOG_NOTICE(GENERAL, "Thread ended");
 		}

Utilities/Thread.h

@@ -54,8 +54,8 @@ public:
 	// create named thread
 	thread_t(std::function<std::string()> name, std::function<void()> func);
 
-	// destructor, joins automatically
-	virtual ~thread_t();
+	// destructor, joins automatically (questionable, don't rely on this functionality in derived destructors)
+	virtual ~thread_t() noexcept(false);
 
 	thread_t(const thread_t&) = delete;
 

rpcs3/Emu/ARMv7/ARMv7Context.h

@@ -107,7 +107,7 @@ struct ARMv7Context
 
 		operator bool() const
 		{
-			return check_state;
+			return check_state != 0;
 		}
 
 	} ITSTATE;

rpcs3/Emu/ARMv7/ARMv7Thread.cpp

@@ -91,6 +91,7 @@ ARMv7Thread::~ARMv7Thread()
 	cv.notify_one();
 	join();
 
+	CloseStack();
 	armv7_free_tls(GetId());
 }
 
@@ -202,7 +203,7 @@ void ARMv7Thread::Task()
 
 	while (true)
 	{
-		if (m_state.load() && CheckStatus()) return;
+		if (m_state.load() && CheckStatus()) break;
 
 		// decode instruction using specified decoder
 		PC += m_dec->DecodeMemory(PC);
@@ -219,9 +220,11 @@ void ARMv7Thread::FastCall(u32 addr)
 	auto old_PC = PC;
 	auto old_stack = SP;
 	auto old_LR = LR;
+	auto old_task = decltype(custom_task)();
 
 	PC = addr;
 	LR = Emu.GetCPUThreadStop();
+	custom_task.swap(old_task);
 
 	try
 	{
@@ -231,6 +234,8 @@ void ARMv7Thread::FastCall(u32 addr)
 	{
 	}
 
+	m_state &= ~CPU_STATE_RETURN;
+
 	PC = old_PC;
 
 	if (SP != old_stack) // SP shouldn't change
@@ -239,11 +244,12 @@ void ARMv7Thread::FastCall(u32 addr)
 	}
 
 	LR = old_LR;
+	custom_task.swap(old_task);
 }
 
 void ARMv7Thread::FastStop()
 {
-	throw CPUThreadReturn{};
+	m_state |= CPU_STATE_RETURN;
 }
 
 armv7_thread::armv7_thread(u32 entry, const std::string& name, u32 stack_size, s32 prio)

rpcs3/Emu/ARMv7/Modules/sceAppMgr.cpp

@@ -6,22 +6,22 @@
 
 s32 sceAppMgrReceiveEventNum(vm::ptr<s32> eventNum)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAppMgrReceiveEvent(vm::ptr<SceAppMgrEvent> appEvent)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAppMgrAcquireBgmPort()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAppMgrReleaseBgmPort()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceAppUtil.cpp

@@ -6,67 +6,67 @@
 
 s32 sceAppUtilInit(vm::cptr<SceAppUtilInitParam> initParam, vm::ptr<SceAppUtilBootParam> bootParam)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAppUtilShutdown()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAppUtilSaveDataSlotCreate(u32 slotId, vm::cptr<SceAppUtilSaveDataSlotParam> param, vm::cptr<SceAppUtilSaveDataMountPoint> mountPoint)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAppUtilSaveDataSlotDelete(u32 slotId, vm::cptr<SceAppUtilSaveDataMountPoint> mountPoint)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAppUtilSaveDataSlotSetParam(u32 slotId, vm::cptr<SceAppUtilSaveDataSlotParam> param, vm::cptr<SceAppUtilSaveDataMountPoint> mountPoint)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAppUtilSaveDataSlotGetParam(u32 slotId, vm::ptr<SceAppUtilSaveDataSlotParam> param, vm::cptr<SceAppUtilSaveDataMountPoint> mountPoint)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAppUtilSaveDataFileSave(vm::cptr<SceAppUtilSaveDataFileSlot> slot, vm::cptr<SceAppUtilSaveDataFile> files, u32 fileNum, vm::cptr<SceAppUtilSaveDataMountPoint> mountPoint, vm::ptr<u32> requiredSizeKB)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAppUtilPhotoMount()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAppUtilPhotoUmount()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAppUtilSystemParamGetInt(u32 paramId, vm::ptr<s32> value)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAppUtilSystemParamGetString(u32 paramId, vm::ptr<char> buf, u32 bufSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAppUtilSaveSafeMemory(vm::cptr<void> buf, u32 bufSize, s64 offset)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAppUtilLoadSafeMemory(vm::ptr<void> buf, u32 bufSize, s64 offset)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceAudio.cpp

@@ -6,42 +6,42 @@
 
 s32 sceAudioOutOpenPort(s32 portType, s32 len, s32 freq, s32 param)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudioOutReleasePort(s32 port)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudioOutOutput(s32 port, vm::ptr<void> ptr)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudioOutSetVolume(s32 port, s32 flag, vm::ptr<s32> vol)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudioOutSetConfig(s32 port, s32 len, s32 freq, s32 param)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudioOutGetConfig(s32 port, s32 configType)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudioOutGetRestSample(s32 port)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudioOutGetAdopt(s32 portType)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceAudioIn.cpp

@@ -6,17 +6,17 @@
 
 s32 sceAudioInOpenPort(s32 portType, s32 grain, s32 freq, s32 param)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudioInReleasePort(s32 port)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudioInInput(s32 port, vm::ptr<void> destPtr)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceAudiodec.cpp

@@ -6,37 +6,37 @@
 
 s32 sceAudiodecInitLibrary(u32 codecType, vm::ptr<SceAudiodecInitParam> pInitParam)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudiodecTermLibrary(u32 codecType)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudiodecCreateDecoder(vm::ptr<SceAudiodecCtrl> pCtrl, u32 codecType)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudiodecDeleteDecoder(vm::ptr<SceAudiodecCtrl> pCtrl)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudiodecDecode(vm::ptr<SceAudiodecCtrl> pCtrl)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudiodecClearContext(vm::ptr<SceAudiodecCtrl> pCtrl)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudiodecGetInternalError(vm::ptr<SceAudiodecCtrl> pCtrl, vm::ptr<s32> pInternalError)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceAudioenc.cpp

@@ -6,42 +6,42 @@
 
 s32 sceAudioencInitLibrary(u32 codecType, vm::ptr<SceAudioencInitParam> pInitParam)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudioencTermLibrary(u32 codecType)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudioencCreateEncoder(vm::ptr<SceAudioencCtrl> pCtrl, u32 codecType)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudioencDeleteEncoder(vm::ptr<SceAudioencCtrl> pCtrl)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudioencEncode(vm::ptr<SceAudioencCtrl> pCtrl)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudioencClearContext(vm::ptr<SceAudioencCtrl> pCtrl)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudioencGetOptInfo(vm::ptr<SceAudioencCtrl> pCtrl)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAudioencGetInternalError(vm::ptr<SceAudioencCtrl> pCtrl, vm::ptr<s32> pInternalError)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceCamera.cpp

@@ -6,207 +6,207 @@
 
 s32 sceCameraOpen(s32 devnum, vm::ptr<SceCameraInfo> pInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraClose(s32 devnum)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraStart(s32 devnum)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraStop(s32 devnum)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraRead(s32 devnum, vm::ptr<SceCameraRead> pRead)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraIsActive(s32 devnum)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraGetSaturation(s32 devnum, vm::ptr<s32> pLevel)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraSetSaturation(s32 devnum, s32 level)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraGetBrightness(s32 devnum, vm::ptr<s32> pLevel)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraSetBrightness(s32 devnum, s32 level)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraGetContrast(s32 devnum, vm::ptr<s32> pLevel)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraSetContrast(s32 devnum, s32 level)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraGetSharpness(s32 devnum, vm::ptr<s32> pLevel)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraSetSharpness(s32 devnum, s32 level)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraGetReverse(s32 devnum, vm::ptr<s32> pMode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraSetReverse(s32 devnum, s32 mode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraGetEffect(s32 devnum, vm::ptr<s32> pMode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraSetEffect(s32 devnum, s32 mode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraGetEV(s32 devnum, vm::ptr<s32> pLevel)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraSetEV(s32 devnum, s32 level)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraGetZoom(s32 devnum, vm::ptr<s32> pLevel)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraSetZoom(s32 devnum, s32 level)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraGetAntiFlicker(s32 devnum, vm::ptr<s32> pMode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraSetAntiFlicker(s32 devnum, s32 mode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraGetISO(s32 devnum, vm::ptr<s32> pMode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraSetISO(s32 devnum, s32 mode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraGetGain(s32 devnum, vm::ptr<s32> pMode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraSetGain(s32 devnum, s32 mode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraGetWhiteBalance(s32 devnum, vm::ptr<s32> pMode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraSetWhiteBalance(s32 devnum, s32 mode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraGetBacklight(s32 devnum, vm::ptr<s32> pMode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraSetBacklight(s32 devnum, s32 mode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraGetNightmode(s32 devnum, vm::ptr<s32> pMode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraSetNightmode(s32 devnum, s32 mode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraLedSwitch(s32 devnum, s32 iSwitch)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraLedBlink(s32 devnum, s32 iOnCount, s32 iOffCount, s32 iBlinkCount)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraGetNoiseReductionForDebug(s32 devnum, vm::ptr<s32> pLevel)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraSetNoiseReductionForDebug(s32 devnum, s32 level)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraGetSharpnessOffForDebug(s32 devnum, vm::ptr<s32> pLevel)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCameraSetSharpnessOffForDebug(s32 devnum, s32 level)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void sceCameraUseCacheMemoryForTrial(s32 isCache)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceCodecEngine.cpp

@@ -6,22 +6,22 @@
 
 s32 sceCodecEnginePmonStart()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCodecEnginePmonStop()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCodecEnginePmonGetProcessorLoad(vm::ptr<SceCodecEnginePmonProcessorLoad> pProcessorLoad)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCodecEnginePmonReset()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceCommonDialog.cpp

@@ -6,202 +6,202 @@
 
 s32 sceCommonDialogUpdate(vm::cptr<SceCommonDialogUpdateParam> updateParam)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMsgDialogInit(vm::cptr<SceMsgDialogParam> param)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 SceCommonDialogStatus sceMsgDialogGetStatus()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMsgDialogAbort()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMsgDialogGetResult(vm::ptr<SceMsgDialogResult> result)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMsgDialogTerm()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMsgDialogClose()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMsgDialogProgressBarInc(s32 target, u32 delta)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMsgDialogProgressBarSetValue(s32 target, u32 rate)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetCheckDialogInit(vm::ptr<SceNetCheckDialogParam> param)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 SceCommonDialogStatus sceNetCheckDialogGetStatus()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetCheckDialogAbort()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetCheckDialogGetResult(vm::ptr<SceNetCheckDialogResult> result)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetCheckDialogTerm()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSaveDataDialogInit(vm::cptr<SceSaveDataDialogParam> param)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 SceCommonDialogStatus sceSaveDataDialogGetStatus()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSaveDataDialogAbort()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSaveDataDialogGetResult(vm::ptr<SceSaveDataDialogResult> result)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSaveDataDialogTerm()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 SceCommonDialogStatus sceSaveDataDialogGetSubStatus()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSaveDataDialogSubClose()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSaveDataDialogContinue(vm::cptr<SceSaveDataDialogParam> param)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSaveDataDialogFinish(vm::cptr<SceSaveDataDialogFinishParam> param)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSaveDataDialogProgressBarInc(s32 target, u32 delta)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSaveDataDialogProgressBarSetValue(s32 target, u32 rate)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceImeDialogInit(vm::cptr<SceImeDialogParam> param)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 SceCommonDialogStatus sceImeDialogGetStatus()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceImeDialogAbort()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceImeDialogGetResult(vm::ptr<SceImeDialogResult> result)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceImeDialogTerm()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 scePhotoImportDialogInit(vm::cptr<ScePhotoImportDialogParam> param)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 SceCommonDialogStatus scePhotoImportDialogGetStatus()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 scePhotoImportDialogGetResult(vm::ptr<ScePhotoImportDialogResult> result)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 scePhotoImportDialogTerm()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 scePhotoImportDialogAbort()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 scePhotoReviewDialogInit(vm::cptr<ScePhotoReviewDialogParam> param)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 SceCommonDialogStatus scePhotoReviewDialogGetStatus()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 scePhotoReviewDialogGetResult(vm::ptr<ScePhotoReviewDialogResult> result)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 scePhotoReviewDialogTerm()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 scePhotoReviewDialogAbort()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceCtrl.cpp

@@ -6,42 +6,42 @@
 
 s32 sceCtrlSetSamplingMode(u32 uiMode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCtrlGetSamplingMode(vm::ptr<u32> puiMode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCtrlPeekBufferPositive(s32 port, vm::ptr<SceCtrlData> pData, s32 nBufs)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCtrlPeekBufferNegative(s32 port, vm::ptr<SceCtrlData> pData, s32 nBufs)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCtrlReadBufferPositive(s32 port, vm::ptr<SceCtrlData> pData, s32 nBufs)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCtrlReadBufferNegative(s32 port, vm::ptr<SceCtrlData> pData, s32 nBufs)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCtrlSetRapidFire(s32 port, s32 idx, vm::cptr<SceCtrlRapidFireRule> pRule)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceCtrlClearRapidFire(s32 port, s32 idx)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceDbg.cpp

@@ -6,22 +6,22 @@
 
 s32 sceDbgSetMinimumLogLevel(s32 minimumLogLevel)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceDbgSetBreakOnErrorState(SceDbgBreakOnErrorState state)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceDbgAssertionHandler(vm::cptr<char> pFile, s32 line, bool stop, vm::cptr<char> pComponent, vm::cptr<char> pMessage) // va_args...
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceDbgLoggingHandler(vm::cptr<char> pFile, s32 line, s32 severity, vm::cptr<char> pComponent, vm::cptr<char> pMessage) // va_args...
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceDeci4p.cpp

@@ -6,27 +6,27 @@
 
 s32 sceKernelDeci4pOpen(vm::cptr<char> protoname, u32 protonum, u32 bufsize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelDeci4pClose(s32 socketid)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelDeci4pRead(s32 socketid, vm::ptr<void> buffer, u32 size, u32 reserved)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelDeci4pWrite(s32 socketid, vm::cptr<void> buffer, u32 size, u32 reserved)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelDeci4pRegisterCallback(s32 socketid, s32 cbid)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceDeflt.cpp

@@ -6,67 +6,67 @@
 
 s32 sceGzipIsValid(vm::cptr<void> pSrcGzip)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceGzipGetInfo(vm::cptr<void> pSrcGzip, vm::cpptr<void> ppvExtra, vm::cpptr<char> ppszName, vm::cpptr<char> ppszComment, vm::ptr<u16> pusCrc, vm::cpptr<void> ppvData)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<char> sceGzipGetName(vm::cptr<void> pSrcGzip)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<char> sceGzipGetComment(vm::cptr<void> pSrcGzip)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<void> sceGzipGetCompressedData(vm::cptr<void> pSrcGzip)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceGzipDecompress(vm::ptr<void> pDst, u32 uiBufSize, vm::cptr<void> pSrcGzip, vm::ptr<u32> puiCrc32)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceZlibIsValid(vm::cptr<void> pSrcZlib)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceZlibGetInfo(vm::cptr<void> pSrcZlib, vm::ptr<u8> pbCmf, vm::ptr<u8> pbFlg, vm::ptr<u32> puiDictId, vm::cpptr<void> ppvData)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<void> sceZlibGetCompressedData(vm::cptr<void> pSrcZlib)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceZlibDecompress(vm::ptr<void> pDst, u32 uiBufSize, vm::cptr<void> pSrcZlib, vm::ptr<u32> puiAdler32)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u32 sceZlibAdler32(u32 uiAdler, vm::cptr<u8> pSrc, u32 uiSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceDeflateDecompress(vm::ptr<void> pDst, u32 uiBufSize, vm::cptr<void> pSrcDeflate, vm::cpptr<void> ppNext)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceZipGetInfo(vm::cptr<void> pSrc, vm::cpptr<void> ppvExtra, vm::ptr<u32> puiCrc, vm::cpptr<void> ppvData)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceDisplay.cpp

@@ -6,72 +6,72 @@
 
 s32 sceDisplayGetRefreshRate(vm::ptr<float> pFps)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceDisplaySetFrameBuf(vm::cptr<SceDisplayFrameBuf> pFrameBuf, s32 iUpdateTimingMode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceDisplayGetFrameBuf(vm::ptr<SceDisplayFrameBuf> pFrameBuf, s32 iUpdateTimingMode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceDisplayGetVcount()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceDisplayWaitVblankStart()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceDisplayWaitVblankStartCB()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceDisplayWaitVblankStartMulti(u32 vcount)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceDisplayWaitVblankStartMultiCB(u32 vcount)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceDisplayWaitSetFrameBuf()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceDisplayWaitSetFrameBufCB()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceDisplayWaitSetFrameBufMulti(u32 vcount)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceDisplayWaitSetFrameBufMultiCB(u32 vcount)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceDisplayRegisterVblankStartCallback(s32 uid)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceDisplayUnregisterVblankStartCallback(s32 uid)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceFiber.cpp

@@ -6,42 +6,42 @@
 
 s32 _sceFiberInitializeImpl(vm::ptr<SceFiber> fiber, vm::cptr<char> name, vm::ptr<SceFiberEntry> entry, u32 argOnInitialize, vm::ptr<void> addrContext, u32 sizeContext, vm::cptr<SceFiberOptParam> optParam, u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiberOptParamInitialize(vm::ptr<SceFiberOptParam> optParam)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiberFinalize(vm::ptr<SceFiber> fiber)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiberRun(vm::ptr<SceFiber> fiber, u32 argOnRunTo, vm::ptr<u32> argOnReturn)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiberSwitch(vm::ptr<SceFiber> fiber, u32 argOnRunTo, vm::ptr<u32> argOnRun)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiberGetSelf(vm::pptr<SceFiber> fiber)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiberReturnToThread(u32 argOnReturn, vm::ptr<u32> argOnRun)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiberGetInfo(vm::ptr<SceFiber> fiber, vm::ptr<SceFiberInfo> fiberInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceFios.cpp

@@ -6,682 +6,682 @@
 
 s32 sceFiosInitialize(vm::cptr<SceFiosParams> pParameters)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void sceFiosTerminate()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 bool sceFiosIsInitialized(vm::ptr<SceFiosParams> pOutParameters)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void sceFiosUpdateParameters(vm::cptr<SceFiosParams> pParameters)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void sceFiosSetGlobalDefaultOpAttr(vm::cptr<SceFiosOpAttr> pAttr)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 bool sceFiosGetGlobalDefaultOpAttr(vm::ptr<SceFiosOpAttr> pOutAttr)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void sceFiosSetThreadDefaultOpAttr(vm::cptr<SceFiosOpAttr> pAttr)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 bool sceFiosGetThreadDefaultOpAttr(vm::ptr<SceFiosOpAttr> pOutAttr)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void sceFiosGetDefaultOpAttr(vm::ptr<SceFiosOpAttr> pOutAttr)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void sceFiosSuspend()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u32 sceFiosGetSuspendCount()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 bool sceFiosIsSuspended()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void sceFiosResume()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void sceFiosShutdownAndCancelOps()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void sceFiosCancelAllOps()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void sceFiosCloseAllFiles()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 bool sceFiosIsIdle()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u32 sceFiosGetAllFHs(vm::ptr<s32> pOutArray, u32 arraySize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u32 sceFiosGetAllDHs(vm::ptr<s32> pOutArray, u32 arraySize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u32 sceFiosGetAllOps(vm::ptr<s32> pOutArray, u32 arraySize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 bool sceFiosIsValidHandle(s32 h)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosPathcmp(vm::cptr<char> pA, vm::cptr<char> pB)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosPathncmp(vm::cptr<char> pA, vm::cptr<char> pB, u32 n)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosPrintf(vm::cptr<char> pFormat) // va_args...
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosVprintf(vm::cptr<char> pFormat) // va_list
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFileExists(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, vm::ptr<bool> pOutExists)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 bool sceFiosFileExistsSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFileGetSize(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, vm::ptr<s64> pOutSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosFileGetSizeSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFileDelete(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFileDeleteSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosDirectoryExists(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, vm::ptr<bool> pOutExists)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 bool sceFiosDirectoryExistsSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosDirectoryCreate(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosDirectoryCreateSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosDirectoryDelete(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosDirectoryDeleteSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosExists(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, vm::ptr<bool> pOutExists)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 bool sceFiosExistsSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosStat(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, vm::ptr<SceFiosStat> pOutStatus)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosStatSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, vm::ptr<SceFiosStat> pOutStatus)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosDelete(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosDeleteSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosResolve(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<SceFiosTuple> pInTuple, vm::ptr<SceFiosTuple> pOutTuple)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosResolveSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<SceFiosTuple> pInTuple, vm::ptr<SceFiosTuple> pOutTuple)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosRename(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pOldPath, vm::cptr<char> pNewPath)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosRenameSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pOldPath, vm::cptr<char> pNewPath)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFileRead(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, vm::ptr<void> pBuf, s64 length, s64 offset)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosFileReadSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, vm::ptr<void> pBuf, s64 length, s64 offset)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFileWrite(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, vm::cptr<void> pBuf, s64 length, s64 offset)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosFileWriteSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, vm::cptr<void> pBuf, s64 length, s64 offset)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFileTruncate(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, s64 length)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFileTruncateSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, s64 length)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFHOpen(vm::cptr<SceFiosOpAttr> pAttr, vm::ptr<s32> pOutFH, vm::cptr<char> pPath, vm::cptr<SceFiosOpenParams> pOpenParams)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFHOpenSync(vm::cptr<SceFiosOpAttr> pAttr, vm::ptr<s32> pOutFH, vm::cptr<char> pPath, vm::cptr<SceFiosOpenParams> pOpenParams)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFHStat(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::ptr<SceFiosStat> pOutStatus)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFHStatSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::ptr<SceFiosStat> pOutStatus)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFHTruncate(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, s64 length)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFHTruncateSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, s64 length)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFHSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFHSyncSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFHRead(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::ptr<void> pBuf, s64 length)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosFHReadSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::ptr<void> pBuf, s64 length)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFHWrite(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<void> pBuf, s64 length)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosFHWriteSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<void> pBuf, s64 length)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFHReadv(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<SceFiosBuffer> iov, s32 iovcnt)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosFHReadvSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<SceFiosBuffer> iov, s32 iovcnt)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFHWritev(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<SceFiosBuffer> iov, s32 iovcnt)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosFHWritevSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<SceFiosBuffer> iov, s32 iovcnt)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFHPread(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::ptr<void> pBuf, s64 length, s64 offset)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosFHPreadSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::ptr<void> pBuf, s64 length, s64 offset)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFHPwrite(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<void> pBuf, s64 length, s64 offset)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosFHPwriteSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<void> pBuf, s64 length, s64 offset)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFHPreadv(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<SceFiosBuffer> iov, s32 iovcnt, s64 offset)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosFHPreadvSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<SceFiosBuffer> iov, s32 iovcnt, s64 offset)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFHPwritev(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<SceFiosBuffer> iov, s32 iovcnt, s64 offset)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosFHPwritevSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<SceFiosBuffer> iov, s32 iovcnt, s64 offset)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFHClose(vm::cptr<SceFiosOpAttr> pAttr, s32 fh)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosFHCloseSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosFHSeek(s32 fh, s64 offset, SceFiosWhence whence)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosFHTell(s32 fh)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<char> sceFiosFHGetPath(s32 fh)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosFHGetSize(s32 fh)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::ptr<SceFiosOpenParams> sceFiosFHGetOpenParams(s32 fh)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosDHOpen(vm::cptr<SceFiosOpAttr> pAttr, vm::ptr<s32> pOutDH, vm::cptr<char> pPath, SceFiosBuffer buf)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosDHOpenSync(vm::cptr<SceFiosOpAttr> pAttr, vm::ptr<s32> pOutDH, vm::cptr<char> pPath, SceFiosBuffer buf)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosDHRead(vm::cptr<SceFiosOpAttr> pAttr, s32 dh, vm::ptr<SceFiosDirEntry> pOutEntry)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosDHReadSync(vm::cptr<SceFiosOpAttr> pAttr, s32 dh, vm::ptr<SceFiosDirEntry> pOutEntry)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosDHClose(vm::cptr<SceFiosOpAttr> pAttr, s32 dh)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosDHCloseSync(vm::cptr<SceFiosOpAttr> pAttr, s32 dh)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<char> sceFiosDHGetPath(s32 dh)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 bool sceFiosOpIsDone(s32 op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosOpWait(s32 op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosOpWaitUntil(s32 op, s64 deadline)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void sceFiosOpDelete(s32 op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosOpSyncWait(s32 op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosOpSyncWaitForIO(s32 op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosOpGetError(s32 op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void sceFiosOpCancel(s32 op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 bool sceFiosOpIsCancelled(s32 op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<SceFiosOpAttr> sceFiosOpGetAttr(s32 op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<char> sceFiosOpGetPath(s32 op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::ptr<void> sceFiosOpGetBuffer(s32 op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosOpGetOffset(s32 op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosOpGetRequestCount(s32 op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosOpGetActualCount(s32 op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void sceFiosOpReschedule(s32 op, s64 newDeadline)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosTimeGetCurrent()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosTimeIntervalToNanoseconds(s64 interval)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosTimeIntervalFromNanoseconds(s64 ns)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u64 sceFiosDateGetCurrent()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u64 sceFiosDateFromComponents(vm::cptr<tm> pComponents)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::ptr<tm> sceFiosDateToComponents(u64 date, vm::ptr<tm> pOutComponents)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u64 sceFiosDateFromSceDateTime(vm::cptr<SceDateTime> pSceDateTime)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::ptr<SceDateTime> sceFiosDateToSceDateTime(u64 date, vm::ptr<SceDateTime> pSceDateTime)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosOverlayAdd(vm::cptr<SceFiosOverlay> pOverlay, vm::ptr<s32> pOutID)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosOverlayRemove(s32 id)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosOverlayGetInfo(s32 id, vm::ptr<SceFiosOverlay> pOutOverlay)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosOverlayModify(s32 id, vm::cptr<SceFiosOverlay> pNewValue)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosOverlayGetList(vm::ptr<s32> pOutIDs, u32 maxIDs, vm::ptr<u32> pActualIDs)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosOverlayResolveSync(s32 resolveFlag, vm::cptr<char> pInPath, vm::ptr<char> pOutPath, u32 maxPath)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosArchiveGetMountBufferSize(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pArchivePath, vm::cptr<SceFiosOpenParams> pOpenParams)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceFiosArchiveGetMountBufferSizeSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pArchivePath, vm::cptr<SceFiosOpenParams> pOpenParams)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosArchiveMount(vm::cptr<SceFiosOpAttr> pAttr, vm::ptr<s32> pOutFH, vm::cptr<char> pArchivePath, vm::cptr<char> pMountPoint, SceFiosBuffer mountBuffer, vm::cptr<SceFiosOpenParams> pOpenParams)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosArchiveMountSync(vm::cptr<SceFiosOpAttr> pAttr, vm::ptr<s32> pOutFH, vm::cptr<char> pArchivePath, vm::cptr<char> pMountPoint, SceFiosBuffer mountBuffer, vm::cptr<SceFiosOpenParams> pOpenParams)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosArchiveUnmount(vm::cptr<SceFiosOpAttr> pAttr, s32 fh)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosArchiveUnmountSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::ptr<char> sceFiosDebugDumpError(s32 err, vm::ptr<char> pBuffer, u32 bufferSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::ptr<char> sceFiosDebugDumpOp(s32 op, vm::ptr<char> pBuffer, u32 bufferSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::ptr<char> sceFiosDebugDumpFH(s32 fh, vm::ptr<char> pBuffer, u32 bufferSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::ptr<char> sceFiosDebugDumpDH(s32 dh, vm::ptr<char> pBuffer, u32 bufferSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::ptr<char> sceFiosDebugDumpDate(u64 date, vm::ptr<char> pBuffer, u32 bufferSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosIOFilterAdd(s32 index, vm::ptr<SceFiosIOFilterCallback> pFilterCallback, vm::ptr<void> pFilterContext)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosIOFilterGetInfo(s32 index, vm::pptr<SceFiosIOFilterCallback> pOutFilterCallback, vm::pptr<void> pOutFilterContext)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceFiosIOFilterRemove(s32 index)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void sceFiosIOFilterPsarcDearchiver()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceFios, #name, name)

rpcs3/Emu/ARMv7/Modules/sceFpu.cpp

@@ -6,73 +6,73 @@
 
 float sceFpuSinf(float x)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 float sceFpuCosf(float x)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 float sceFpuTanf(float x)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 float sceFpuAtanf(float x)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 float sceFpuAtan2f(float y, float x)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 float sceFpuAsinf(float x)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 float sceFpuAcosf(float x)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 
 float sceFpuLogf(float x)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 float sceFpuLog2f(float fs)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 float sceFpuLog10f(float fs)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 float sceFpuExpf(float x)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 float sceFpuExp2f(float x)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 float sceFpuExp10f(float x)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 float sceFpuPowf(float x, float y)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceHttp.cpp

@@ -6,277 +6,277 @@
 
 s32 sceHttpInit(u32 poolSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpTerm()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpGetMemoryPoolStats(vm::ptr<SceHttpMemoryPoolStats> currentStat)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpCreateTemplate(vm::cptr<char> userAgent, s32 httpVer, s32 autoProxyConf)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpDeleteTemplate(s32 tmplId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpCreateConnection(s32 tmplId, vm::cptr<char> serverName, vm::cptr<char> scheme, u16 port, s32 enableKeepalive)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpCreateConnectionWithURL(s32 tmplId, vm::cptr<char> url, s32 enableKeepalive)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpDeleteConnection(s32 connId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpCreateRequest(s32 connId, s32 method, vm::cptr<char> path, u64 contentLength)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpCreateRequestWithURL(s32 connId, s32 method, vm::cptr<char> url, u64 contentLength)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpDeleteRequest(s32 reqId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpSetResponseHeaderMaxSize(s32 id, u32 headerSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpSetRecvBlockSize(s32 id, u32 blockSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpSetRequestContentLength(s32 id, u64 contentLength)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpSendRequest(s32 reqId, vm::cptr<void> postData, u32 size)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpAbortRequest(s32 reqId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpGetResponseContentLength(s32 reqId, vm::ptr<u64> contentLength)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpGetStatusCode(s32 reqId, vm::ptr<s32> statusCode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpGetAllResponseHeaders(s32 reqId, vm::pptr<char> header, vm::ptr<u32> headerSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpReadData(s32 reqId, vm::ptr<void> data, u32 size)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpAddRequestHeader(s32 id, vm::cptr<char> name, vm::cptr<char> value, u32 mode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpRemoveRequestHeader(s32 id, vm::cptr<char> name)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpParseResponseHeader(vm::cptr<char> header, u32 headerLen, vm::cptr<char> fieldStr, vm::cpptr<char> fieldValue, vm::ptr<u32> valueLen)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpParseStatusLine(vm::cptr<char> statusLine, u32 lineLen, vm::ptr<s32> httpMajorVer, vm::ptr<s32> httpMinorVer, vm::ptr<s32> responseCode, vm::cpptr<char> reasonPhrase, vm::ptr<u32> phraseLen)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpSetAuthInfoCallback(s32 id, vm::ptr<SceHttpAuthInfoCallback> cbfunc, vm::ptr<void> userArg)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpSetAuthEnabled(s32 id, s32 enable)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpGetAuthEnabled(s32 id, vm::ptr<s32> enable)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpSetRedirectCallback(s32 id, vm::ptr<SceHttpRedirectCallback> cbfunc, vm::ptr<void> userArg)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpSetAutoRedirect(s32 id, s32 enable)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpGetAutoRedirect(s32 id, vm::ptr<s32> enable)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpSetResolveTimeOut(s32 id, u32 usec)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpSetResolveRetry(s32 id, s32 retry)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpSetConnectTimeOut(s32 id, u32 usec)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpSetSendTimeOut(s32 id, u32 usec)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpSetRecvTimeOut(s32 id, u32 usec)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpUriEscape(vm::ptr<char> out, vm::ptr<u32> require, u32 prepare, vm::cptr<char> in)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpUriUnescape(vm::ptr<char> out, vm::ptr<u32> require, u32 prepare, vm::cptr<char> in)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpUriParse(vm::ptr<SceHttpUriElement> out, vm::cptr<char> srcUrl, vm::ptr<void> pool, vm::ptr<u32> require, u32 prepare)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpUriBuild(vm::ptr<char> out, vm::ptr<u32> require, u32 prepare, vm::cptr<SceHttpUriElement> srcElement, u32 option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpUriMerge(vm::ptr<char> mergedUrl, vm::cptr<char> url, vm::cptr<char> relativeUrl, vm::ptr<u32> require, u32 prepare, u32 option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpUriSweepPath(vm::ptr<char> dst, vm::cptr<char> src, u32 srcSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpSetCookieEnabled(s32 id, s32 enable)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpGetCookieEnabled(s32 id, vm::ptr<s32> enable)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpGetCookie(vm::cptr<char> url, vm::ptr<char> cookie, vm::ptr<u32> cookieLength, u32 prepare, s32 secure)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpAddCookie(vm::cptr<char> url, vm::cptr<char> cookie, u32 cookieLength)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpSetCookieRecvCallback(s32 id, vm::ptr<SceHttpCookieRecvCallback> cbfunc, vm::ptr<void> userArg)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpSetCookieSendCallback(s32 id, vm::ptr<SceHttpCookieSendCallback> cbfunc, vm::ptr<void> userArg)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpsLoadCert(s32 caCertNum, vm::cpptr<SceHttpsData> caList, vm::cptr<SceHttpsData> cert, vm::cptr<SceHttpsData> privKey)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpsUnloadCert()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpsEnableOption(u32 sslFlags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpsDisableOption(u32 sslFlags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpsGetSslError(s32 id, vm::ptr<s32> errNum, vm::ptr<u32> detail)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpsSetSslCallback(s32 id, vm::ptr<SceHttpsCallback> cbfunc, vm::ptr<void> userArg)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpsGetCaList(vm::ptr<SceHttpsCaList> caList)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceHttpsFreeCaList(vm::ptr<SceHttpsCaList> caList)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceIme.cpp

@@ -6,27 +6,27 @@
 
 s32 sceImeOpen(vm::ptr<SceImeParam> param)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceImeUpdate()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceImeSetCaret(vm::cptr<SceImeCaret> caret)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceImeSetPreeditGeometry(vm::cptr<SceImePreeditGeometry> preedit)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceImeClose()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceJpeg.cpp

@@ -6,12 +6,12 @@
 
 s32 sceJpegInitMJpeg(s32 maxSplitDecoder)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceJpegFinishMJpeg()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceJpegDecodeMJpeg(
@@ -25,7 +25,7 @@ s32 sceJpegDecodeMJpeg(
 	vm::ptr<void> pCoefBuffer,
 	u32 coefBufferSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceJpegDecodeMJpegYCbCr(
@@ -37,7 +37,7 @@ s32 sceJpegDecodeMJpegYCbCr(
 	vm::ptr<void> pCoefBuffer,
 	u32 coefBufferSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceJpegMJpegCsc(
@@ -48,7 +48,7 @@ s32 sceJpegMJpegCsc(
 	s32 colorOption,
 	s32 sampling)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceJpegGetOutputInfo(
@@ -58,22 +58,22 @@ s32 sceJpegGetOutputInfo(
 	s32 decodeMode,
 	vm::ptr<SceJpegOutputInfo> pOutputInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceJpegCreateSplitDecoder(vm::ptr<SceJpegSplitDecodeCtrl> pCtrl)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceJpegDeleteSplitDecoder(vm::ptr<SceJpegSplitDecodeCtrl> pCtrl)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceJpegSplitDecodeMJpeg(vm::ptr<SceJpegSplitDecodeCtrl> pCtrl)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceJpegEnc.cpp

@@ -6,7 +6,7 @@
 
 s32 sceJpegEncoderGetContextSize()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceJpegEncoderInit(
@@ -17,19 +17,19 @@ s32 sceJpegEncoderInit(
 	vm::ptr<void> pJpeg,
 	u32 oJpegbufSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceJpegEncoderEncode(
 	SceJpegEncoderContext context,
 	vm::cptr<void> pYCbCr)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceJpegEncoderEnd(SceJpegEncoderContext context)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceJpegEncoderSetValidRegion(
@@ -37,21 +37,21 @@ s32 sceJpegEncoderSetValidRegion(
 	s32 iFrameWidth,
 	s32 iFrameHeight)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceJpegEncoderSetCompressionRatio(
 	SceJpegEncoderContext context,
 	s32 compratio)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceJpegEncoderSetHeaderMode(
 	SceJpegEncoderContext context,
 	s32 headerMode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceJpegEncoderSetOutputAddr(
@@ -59,7 +59,7 @@ s32 sceJpegEncoderSetOutputAddr(
 	vm::ptr<void> pJpeg,
 	u32 oJpegbufSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceJpegEncoderCsc(
@@ -69,7 +69,7 @@ s32 sceJpegEncoderCsc(
 	s32 iFrameWidth,
 	s32 inputPixelFormat)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceLibKernel.cpp

@@ -16,22 +16,22 @@
 
 s32 sceKernelAllocMemBlock(vm::cptr<char> name, s32 type, u32 vsize, vm::ptr<SceKernelAllocMemBlockOpt> pOpt)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelFreeMemBlock(s32 uid)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetMemBlockBase(s32 uid, vm::pptr<void> ppBase)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetMemBlockInfoByAddr(vm::ptr<void> vbase, vm::ptr<SceKernelMemBlockInfo> pInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelCreateThread(
@@ -140,28 +140,28 @@ s32 sceKernelChangeThreadCpuAffinityMask(s32 threadId, s32 cpuAffinityMask)
 {
 	sceLibKernel.Todo("sceKernelChangeThreadCpuAffinityMask(threadId=0x%x, cpuAffinityMask=0x%x)", threadId, cpuAffinityMask);
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetThreadCpuAffinityMask(s32 threadId)
 {
 	sceLibKernel.Todo("sceKernelGetThreadCpuAffinityMask(threadId=0x%x)", threadId);
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelChangeThreadPriority(s32 threadId, s32 priority)
 {
 	sceLibKernel.Todo("sceKernelChangeThreadPriority(threadId=0x%x, priority=%d)", threadId, priority);
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetThreadCurrentPriority()
 {
 	sceLibKernel.Todo("sceKernelGetThreadCurrentPriority()");
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u32 sceKernelGetThreadId(ARMv7Context& context)
@@ -175,84 +175,84 @@ s32 sceKernelChangeCurrentThreadAttr(u32 clearAttr, u32 setAttr)
 {
 	sceLibKernel.Todo("sceKernelChangeCurrentThreadAttr()");
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetThreadExitStatus(s32 threadId, vm::ptr<s32> pExitStatus)
 {
 	sceLibKernel.Todo("sceKernelGetThreadExitStatus(threadId=0x%x, pExitStatus=*0x%x)", threadId, pExitStatus);
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetProcessId()
 {
 	sceLibKernel.Todo("sceKernelGetProcessId()");
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelCheckWaitableStatus()
 {
 	sceLibKernel.Todo("sceKernelCheckWaitableStatus()");
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetThreadInfo(s32 threadId, vm::ptr<SceKernelThreadInfo> pInfo)
 {
 	sceLibKernel.Todo("sceKernelGetThreadInfo(threadId=0x%x, pInfo=*0x%x)", threadId, pInfo);
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetThreadRunStatus(vm::ptr<SceKernelThreadRunStatus> pStatus)
 {
 	sceLibKernel.Todo("sceKernelGetThreadRunStatus(pStatus=*0x%x)", pStatus);
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetSystemInfo(vm::ptr<SceKernelSystemInfo> pInfo)
 {
 	sceLibKernel.Todo("sceKernelGetSystemInfo(pInfo=*0x%x)", pInfo);
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetThreadmgrUIDClass(s32 uid)
 {
 	sceLibKernel.Todo("sceKernelGetThreadmgrUIDClass(uid=0x%x)", uid);
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelChangeThreadVfpException(s32 clearMask, s32 setMask)
 {
 	sceLibKernel.Todo("sceKernelChangeThreadVfpException(clearMask=0x%x, setMask=0x%x)", clearMask, setMask);
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetCurrentThreadVfpException()
 {
 	sceLibKernel.Todo("sceKernelGetCurrentThreadVfpException()");
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelDelayThread(u32 usec)
 {
 	sceLibKernel.Todo("sceKernelDelayThread()");
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelDelayThreadCB(u32 usec)
 {
 	sceLibKernel.Todo("sceKernelDelayThreadCB()");
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelWaitThreadEnd(s32 threadId, vm::ptr<s32> pExitStatus, vm::ptr<u32> pTimeout)
@@ -289,96 +289,96 @@ s32 sceKernelWaitThreadEndCB(s32 threadId, vm::ptr<s32> pExitStatus, vm::ptr<u32
 {
 	sceLibKernel.Todo("sceKernelWaitThreadEndCB(threadId=0x%x, pExitStatus=*0x%x, pTimeout=*0x%x)", threadId, pExitStatus, pTimeout);
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 // Callback functions
 
 s32 sceKernelCreateCallback(vm::cptr<char> pName, u32 attr, vm::ptr<SceKernelCallbackFunction> callbackFunc, vm::ptr<void> pCommon)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelDeleteCallback(s32 callbackId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelNotifyCallback(s32 callbackId, s32 notifyArg)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelCancelCallback(s32 callbackId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetCallbackCount(s32 callbackId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelCheckCallback()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetCallbackInfo(s32 callbackId, vm::ptr<SceKernelCallbackInfo> pInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelRegisterCallbackToEvent(s32 eventId, s32 callbackId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelUnregisterCallbackFromEvent(s32 eventId, s32 callbackId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelUnregisterCallbackFromEventAll(s32 eventId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 // Event functions
 
 s32 sceKernelWaitEvent(s32 eventId, u32 waitPattern, vm::ptr<u32> pResultPattern, vm::ptr<u64> pUserData, vm::ptr<u32> pTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelWaitEventCB(s32 eventId, u32 waitPattern, vm::ptr<u32> pResultPattern, vm::ptr<u64> pUserData, vm::ptr<u32> pTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelPollEvent(s32 eventId, u32 bitPattern, vm::ptr<u32> pResultPattern, vm::ptr<u64> pUserData)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelCancelEvent(s32 eventId, vm::ptr<s32> pNumWaitThreads)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetEventInfo(s32 eventId, vm::ptr<SceKernelEventInfo> pInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelWaitMultipleEvents(vm::ptr<SceKernelWaitEvent> pWaitEventList, s32 numEvents, u32 waitMode, vm::ptr<SceKernelResultEvent> pResultEventList, vm::ptr<u32> pTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelWaitMultipleEventsCB(vm::ptr<SceKernelWaitEvent> pWaitEventList, s32 numEvents, u32 waitMode, vm::ptr<SceKernelResultEvent> pResultEventList, vm::ptr<u32> pTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 // Event flag functions
@@ -397,52 +397,52 @@ s32 sceKernelCreateEventFlag(vm::cptr<char> pName, u32 attr, u32 initPattern, vm
 
 s32 sceKernelDeleteEventFlag(s32 evfId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelOpenEventFlag(vm::cptr<char> pName)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelCloseEventFlag(s32 evfId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelWaitEventFlag(s32 evfId, u32 bitPattern, u32 waitMode, vm::ptr<u32> pResultPat, vm::ptr<u32> pTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelWaitEventFlagCB(s32 evfId, u32 bitPattern, u32 waitMode, vm::ptr<u32> pResultPat, vm::ptr<u32> pTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelPollEventFlag(s32 evfId, u32 bitPattern, u32 waitMode, vm::ptr<u32> pResultPat)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelSetEventFlag(s32 evfId, u32 bitPattern)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelClearEventFlag(s32 evfId, u32 bitPattern)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelCancelEventFlag(s32 evfId, u32 setPattern, vm::ptr<s32> pNumWaitThreads)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetEventFlagInfo(s32 evfId, vm::ptr<SceKernelEventFlagInfo> pInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 // Semaphore functions
@@ -480,12 +480,12 @@ s32 sceKernelDeleteSema(s32 semaId)
 
 s32 sceKernelOpenSema(vm::cptr<char> pName)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelCloseSema(s32 semaId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelWaitSema(s32 semaId, s32 needCount, vm::ptr<u32> pTimeout)
@@ -506,27 +506,27 @@ s32 sceKernelWaitSema(s32 semaId, s32 needCount, vm::ptr<u32> pTimeout)
 
 s32 sceKernelWaitSemaCB(s32 semaId, s32 needCount, vm::ptr<u32> pTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelPollSema(s32 semaId, s32 needCount)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelSignalSema(s32 semaId, s32 signalCount)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelCancelSema(s32 semaId, s32 setCount, vm::ptr<s32> pNumWaitThreads)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetSemaInfo(s32 semaId, vm::ptr<SceKernelSemaInfo> pInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 // Mutex functions
@@ -545,89 +545,89 @@ s32 sceKernelCreateMutex(vm::cptr<char> pName, u32 attr, s32 initCount, vm::cptr
 
 s32 sceKernelDeleteMutex(s32 mutexId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelOpenMutex(vm::cptr<char> pName)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelCloseMutex(s32 mutexId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelLockMutex(s32 mutexId, s32 lockCount, vm::ptr<u32> pTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelLockMutexCB(s32 mutexId, s32 lockCount, vm::ptr<u32> pTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelTryLockMutex(s32 mutexId, s32 lockCount)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelUnlockMutex(s32 mutexId, s32 unlockCount)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelCancelMutex(s32 mutexId, s32 newCount, vm::ptr<s32> pNumWaitThreads)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetMutexInfo(s32 mutexId, vm::ptr<SceKernelMutexInfo> pInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 // Lightweight mutex functions
 
 s32 sceKernelCreateLwMutex(vm::ptr<SceKernelLwMutexWork> pWork, vm::cptr<char> pName, u32 attr, s32 initCount, vm::cptr<SceKernelLwMutexOptParam> pOptParam)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelDeleteLwMutex(vm::ptr<SceKernelLwMutexWork> pWork)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelLockLwMutex(vm::ptr<SceKernelLwMutexWork> pWork, s32 lockCount, vm::ptr<u32> pTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelLockLwMutexCB(vm::ptr<SceKernelLwMutexWork> pWork, s32 lockCount, vm::ptr<u32> pTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelTryLockLwMutex(vm::ptr<SceKernelLwMutexWork> pWork, s32 lockCount)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelUnlockLwMutex(vm::ptr<SceKernelLwMutexWork> pWork, s32 unlockCount)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetLwMutexInfo(vm::ptr<SceKernelLwMutexWork> pWork, vm::ptr<SceKernelLwMutexInfo> pInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetLwMutexInfoById(s32 lwMutexId, vm::ptr<SceKernelLwMutexInfo> pInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 // Condition variable functions
@@ -646,362 +646,362 @@ s32 sceKernelCreateCond(vm::cptr<char> pName, u32 attr, s32 mutexId, vm::cptr<Sc
 
 s32 sceKernelDeleteCond(s32 condId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelOpenCond(vm::cptr<char> pName)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelCloseCond(s32 condId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelWaitCond(s32 condId, vm::ptr<u32> pTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelWaitCondCB(s32 condId, vm::ptr<u32> pTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelSignalCond(s32 condId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelSignalCondAll(s32 condId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelSignalCondTo(s32 condId, s32 threadId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetCondInfo(s32 condId, vm::ptr<SceKernelCondInfo> pInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 // Lightweight condition variable functions
 
 s32 sceKernelCreateLwCond(vm::ptr<SceKernelLwCondWork> pWork, vm::cptr<char> pName, u32 attr, vm::ptr<SceKernelLwMutexWork> pLwMutex, vm::cptr<SceKernelLwCondOptParam> pOptParam)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelDeleteLwCond(vm::ptr<SceKernelLwCondWork> pWork)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelWaitLwCond(vm::ptr<SceKernelLwCondWork> pWork, vm::ptr<u32> pTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelWaitLwCondCB(vm::ptr<SceKernelLwCondWork> pWork, vm::ptr<u32> pTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelSignalLwCond(vm::ptr<SceKernelLwCondWork> pWork)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelSignalLwCondAll(vm::ptr<SceKernelLwCondWork> pWork)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelSignalLwCondTo(vm::ptr<SceKernelLwCondWork> pWork, s32 threadId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetLwCondInfo(vm::ptr<SceKernelLwCondWork> pWork, vm::ptr<SceKernelLwCondInfo> pInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetLwCondInfoById(s32 lwCondId, vm::ptr<SceKernelLwCondInfo> pInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 // Time functions
 
 s32 sceKernelGetSystemTime(vm::ptr<SceKernelSysClock> pClock)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u64 sceKernelGetSystemTimeWide()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u32 sceKernelGetSystemTimeLow()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 // Timer functions
 
 s32 sceKernelCreateTimer(vm::cptr<char> pName, u32 attr, vm::cptr<SceKernelTimerOptParam> pOptParam)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelDeleteTimer(s32 timerId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelOpenTimer(vm::cptr<char> pName)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelCloseTimer(s32 timerId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelStartTimer(s32 timerId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelStopTimer(s32 timerId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetTimerBase(s32 timerId, vm::ptr<SceKernelSysClock> pBase)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u64 sceKernelGetTimerBaseWide(s32 timerId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetTimerTime(s32 timerId, vm::ptr<SceKernelSysClock> pClock)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u64 sceKernelGetTimerTimeWide(s32 timerId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelSetTimerTime(s32 timerId, vm::ptr<SceKernelSysClock> pClock)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u64 sceKernelSetTimerTimeWide(s32 timerId, u64 clock)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelSetTimerEvent(s32 timerId, s32 type, vm::ptr<SceKernelSysClock> pInterval, s32 fRepeat)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelCancelTimer(s32 timerId, vm::ptr<s32> pNumWaitThreads)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetTimerInfo(s32 timerId, vm::ptr<SceKernelTimerInfo> pInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 // Reader/writer lock functions
 
 s32 sceKernelCreateRWLock(vm::cptr<char> pName, u32 attr, vm::cptr<SceKernelRWLockOptParam> pOptParam)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelDeleteRWLock(s32 rwLockId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelOpenRWLock(vm::cptr<char> pName)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelCloseRWLock(s32 rwLockId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelLockReadRWLock(s32 rwLockId, vm::ptr<u32> pTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelLockReadRWLockCB(s32 rwLockId, vm::ptr<u32> pTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelTryLockReadRWLock(s32 rwLockId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelUnlockReadRWLock(s32 rwLockId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelLockWriteRWLock(s32 rwLockId, vm::ptr<u32> pTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelLockWriteRWLockCB(s32 rwLockId, vm::ptr<u32> pTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelTryLockWriteRWLock(s32 rwLockId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelUnlockWriteRWLock(s32 rwLockId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelCancelRWLock(s32 rwLockId, vm::ptr<s32> pNumReadWaitThreads, vm::ptr<s32> pNumWriteWaitThreads, s32 flag)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceKernelGetRWLockInfo(s32 rwLockId, vm::ptr<SceKernelRWLockInfo> pInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 // IO/File functions
 
 s32 sceIoRemove(vm::cptr<char> filename)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceIoMkdir(vm::cptr<char> dirname, s32 mode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceIoRmdir(vm::cptr<char> dirname)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceIoRename(vm::cptr<char> oldname, vm::cptr<char> newname)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceIoDevctl(vm::cptr<char> devname, s32 cmd, vm::cptr<void> arg, u32 arglen, vm::ptr<void> bufp, u32 buflen)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceIoSync(vm::cptr<char> devname, s32 flag)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceIoOpen(vm::cptr<char> filename, s32 flag, s32 mode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceIoClose(s32 fd)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceIoIoctl(s32 fd, s32 cmd, vm::cptr<void> argp, u32 arglen, vm::ptr<void> bufp, u32 buflen)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s64 sceIoLseek(s32 fd, s64 offset, s32 whence)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceIoLseek32(s32 fd, s32 offset, s32 whence)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceIoRead(s32 fd, vm::ptr<void> buf, u32 nbyte)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceIoWrite(s32 fd, vm::cptr<void> buf, u32 nbyte)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceIoPread(s32 fd, vm::ptr<void> buf, u32 nbyte, s64 offset)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceIoPwrite(s32 fd, vm::cptr<void> buf, u32 nbyte, s64 offset)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceIoDopen(vm::cptr<char> dirname)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceIoDclose(s32 fd)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceIoDread(s32 fd, vm::ptr<SceIoDirent> buf)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceIoChstat(vm::cptr<char> name, vm::cptr<SceIoStat> buf, u32 cbit)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceIoGetstat(vm::cptr<char> name, vm::ptr<SceIoStat> buf)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceLibstdcxx.cpp

@@ -8,17 +8,17 @@ namespace sce_libstdcxx_func
 {
 	void __aeabi_unwind_cpp_pr0()
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("");
 	}
 
 	void __aeabi_unwind_cpp_pr1()
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("");
 	}
 
 	void __aeabi_unwind_cpp_pr2()
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("");
 	}
 }
 

rpcs3/Emu/ARMv7/Modules/sceLiveArea.cpp

@@ -6,12 +6,12 @@
 
 s32 sceLiveAreaResourceReplaceAll(vm::cptr<char> dirpath)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceLiveAreaResourceGetStatus()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceLiveArea, #name, name)

rpcs3/Emu/ARMv7/Modules/sceLocation.cpp

@@ -6,87 +6,87 @@
 
 s32 sceLocationOpen(vm::ptr<u8> handle, SceLocationLocationMethod lmethod, SceLocationHeadingMethod hmethod)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceLocationClose(u8 handle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceLocationReopen(u8 handle, SceLocationLocationMethod lmethod, SceLocationHeadingMethod hmethod)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceLocationGetMethod(u8 handle, vm::ptr<s32> lmethod, vm::ptr<s32> hmethod)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceLocationGetLocation(u8 handle, vm::ptr<SceLocationLocationInfo> linfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceLocationCancelGetLocation(u8 handle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceLocationStartLocationCallback(u8 handle, u32 distance, vm::ptr<SceLocationLocationInfoCallback> callback, vm::ptr<void> userdata)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceLocationStopLocationCallback(u8 handle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceLocationGetHeading(u8 handle, vm::ptr<SceLocationHeadingInfo> hinfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceLocationStartHeadingCallback(u8 handle, u32 difference, vm::ptr<SceLocationHeadingInfoCallback> callback, vm::ptr<void> userdata)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceLocationStopHeadingCallback(u8 handle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceLocationConfirm(u8 handle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceLocationConfirmGetStatus(u8 handle, vm::ptr<s32> status)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceLocationConfirmGetResult(u8 handle, vm::ptr<s32> result)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceLocationConfirmAbort(u8 handle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceLocationGetPermission(u8 handle, vm::ptr<SceLocationPermissionInfo> info)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceLocationSetGpsEmulationFile(vm::ptr<char> filename)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceMd5.cpp

@@ -6,22 +6,22 @@
 
 s32 sceMd5Digest(vm::cptr<void> plain, u32 len, vm::ptr<u8> digest)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMd5BlockInit(vm::ptr<SceMd5Context> pContext)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMd5BlockUpdate(vm::ptr<SceMd5Context> pContext, vm::cptr<void> plain, u32 len)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMd5BlockResult(vm::ptr<SceMd5Context> pContext, vm::ptr<u8> digest)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceMd5, #name, name)

rpcs3/Emu/ARMv7/Modules/sceMotion.cpp

@@ -6,82 +6,82 @@
 
 s32 sceMotionGetState(vm::ptr<SceMotionState> motionState)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMotionGetSensorState(vm::ptr<SceMotionSensorState> sensorState, s32 numRecords)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMotionGetBasicOrientation(vm::ptr<SceFVector3> basicOrientation)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMotionRotateYaw(const float radians)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMotionGetTiltCorrection()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMotionSetTiltCorrection(s32 setValue)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMotionGetDeadband()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMotionSetDeadband(s32 setValue)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMotionSetAngleThreshold(const float angle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 float sceMotionGetAngleThreshold()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMotionReset()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMotionMagnetometerOn()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMotionMagnetometerOff()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMotionGetMagnetometerState()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMotionStartSampling()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceMotionStopSampling()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceMotion, #name, name)

rpcs3/Emu/ARMv7/Modules/sceMt19937.cpp

@@ -6,12 +6,12 @@
 
 s32 sceMt19937Init(vm::ptr<SceMt19937Context> pCtx, u32 seed)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u32 sceMt19937UInt(vm::ptr<SceMt19937Context> pCtx)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceNet.cpp

@@ -6,292 +6,292 @@
 
 s32 sceNetSetDnsInfo(vm::ptr<SceNetDnsInfo> info, s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetClearDnsCache(s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetDumpCreate(vm::cptr<char> name, s32 len, s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetDumpRead(s32 id, vm::ptr<void> buf, s32 len, vm::ptr<s32> pflags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetDumpDestroy(s32 id)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetDumpAbort(s32 id, s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetEpollCreate(vm::cptr<char> name, s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetEpollControl(s32 eid, s32 op, s32 id, vm::ptr<SceNetEpollEvent> event)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetEpollWait(s32 eid, vm::ptr<SceNetEpollEvent> events, s32 maxevents, s32 timeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetEpollWaitCB(s32 eid, vm::ptr<SceNetEpollEvent> events, s32 maxevents, s32 timeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetEpollDestroy(s32 eid)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetEpollAbort(s32 eid, s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::ptr<s32> sceNetErrnoLoc()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetEtherStrton(vm::cptr<char> str, vm::ptr<SceNetEtherAddr> n)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetEtherNtostr(vm::cptr<SceNetEtherAddr> n, vm::ptr<char> str, u32 len)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetGetMacAddress(vm::ptr<SceNetEtherAddr> addr, s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<char> sceNetInetNtop(s32 af, vm::cptr<void> src, vm::ptr<char> dst, SceNetSocklen_t size)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetInetPton(s32 af, vm::cptr<char> src, vm::ptr<void> dst)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u64 sceNetHtonll(u64 host64)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u32 sceNetHtonl(u32 host32)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u16 sceNetHtons(u16 host16)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u64 sceNetNtohll(u64 net64)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u32 sceNetNtohl(u32 net32)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u16 sceNetNtohs(u16 net16)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetInit(vm::ptr<SceNetInitParam> param)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetTerm()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetShowIfconfig()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetShowRoute()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetShowNetstat()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetEmulationSet(vm::ptr<SceNetEmulationParam> param, s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetEmulationGet(vm::ptr<SceNetEmulationParam> param, s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetResolverCreate(vm::cptr<char> name, vm::ptr<SceNetResolverParam> param, s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetResolverStartNtoa(s32 rid, vm::cptr<char> hostname, vm::ptr<SceNetInAddr> addr, s32 timeout, s32 retry, s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetResolverStartAton(s32 rid, vm::cptr<SceNetInAddr> addr, vm::ptr<char> hostname, s32 len, s32 timeout, s32 retry, s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetResolverGetError(s32 rid, vm::ptr<s32> result)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetResolverDestroy(s32 rid)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetResolverAbort(s32 rid, s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetSocket(vm::cptr<char> name, s32 domain, s32 type, s32 protocol)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetAccept(s32 s, vm::ptr<SceNetSockaddr> addr, vm::ptr<SceNetSocklen_t> addrlen)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetBind(s32 s, vm::cptr<SceNetSockaddr> addr, SceNetSocklen_t addrlen)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetConnect(s32 s, vm::cptr<SceNetSockaddr> name, SceNetSocklen_t namelen)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetGetpeername(s32 s, vm::ptr<SceNetSockaddr> name, vm::ptr<SceNetSocklen_t> namelen)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetGetsockname(s32 s, vm::ptr<SceNetSockaddr> name, vm::ptr<SceNetSocklen_t> namelen)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetGetsockopt(s32 s, s32 level, s32 optname, vm::ptr<void> optval, vm::ptr<SceNetSocklen_t> optlen)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetListen(s32 s, s32 backlog)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetRecv(s32 s, vm::ptr<void> buf, u32 len, s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetRecvfrom(s32 s, vm::ptr<void> buf, u32 len, s32 flags, vm::ptr<SceNetSockaddr> from, vm::ptr<SceNetSocklen_t> fromlen)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetRecvmsg(s32 s, vm::ptr<SceNetMsghdr> msg, s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetSend(s32 s, vm::cptr<void> msg, u32 len, s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetSendto(s32 s, vm::cptr<void> msg, u32 len, s32 flags, vm::cptr<SceNetSockaddr> to, SceNetSocklen_t tolen)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetSendmsg(s32 s, vm::cptr<SceNetMsghdr> msg, s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetSetsockopt(s32 s, s32 level, s32 optname, vm::cptr<void> optval, SceNetSocklen_t optlen)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetShutdown(s32 s, s32 how)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetSocketClose(s32 s)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetSocketAbort(s32 s, s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetGetSockInfo(s32 s, vm::ptr<SceNetSockInfo> info, s32 n, s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetGetSockIdInfo(vm::ptr<SceNetFdSet> fds, s32 sockinfoflags, s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetGetStatisticsInfo(vm::ptr<SceNetStatisticsInfo> info, s32 flags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceNetCtl.cpp

@@ -6,82 +6,82 @@
 
 s32 sceNetCtlInit()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void sceNetCtlTerm()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetCtlCheckCallback()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetCtlInetGetResult(s32 eventType, vm::ptr<s32> errorCode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetCtlAdhocGetResult(s32 eventType, vm::ptr<s32> errorCode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetCtlInetGetInfo(s32 code, vm::ptr<SceNetCtlInfo> info)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetCtlInetGetState(vm::ptr<s32> state)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetCtlGetNatInfo(vm::ptr<SceNetCtlNatInfo> natinfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetCtlInetRegisterCallback(vm::ptr<SceNetCtlCallback> func, vm::ptr<void> arg, vm::ptr<s32> cid)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetCtlInetUnregisterCallback(s32 cid)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetCtlAdhocRegisterCallback(vm::ptr<SceNetCtlCallback> func, vm::ptr<void> arg, vm::ptr<s32> cid)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetCtlAdhocUnregisterCallback(s32 cid)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetCtlAdhocGetState(vm::ptr<s32> state)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetCtlAdhocDisconnect()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetCtlAdhocGetPeerList(vm::ptr<u32> buflen, vm::ptr<void> buf)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNetCtlAdhocGetInAddr(vm::ptr<SceNetInAddr> inaddr)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceNetCtl, #name, name)

rpcs3/Emu/ARMv7/Modules/sceNgs.cpp

@@ -6,317 +6,317 @@
 
 s32 sceNgsSystemGetRequiredMemorySize(vm::cptr<SceNgsSystemInitParams> pSynthParams, vm::ptr<u32> pnSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsSystemInit(vm::ptr<void> pSynthSysMemory, const u32 uMemSize, vm::cptr<SceNgsSystemInitParams> pSynthParams, vm::ptr<SceNgsHSynSystem> pSystemHandle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsSystemUpdate(SceNgsHSynSystem hSystemHandle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsSystemRelease(SceNgsHSynSystem hSystemHandle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsSystemLock(SceNgsHSynSystem hSystemHandle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsSystemUnlock(SceNgsHSynSystem hSystemHandle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsSystemSetParamErrorCallback(SceNgsHSynSystem hSystemHandle, vm::ptr<SceNgsCallbackFunc> callbackFuncPtr)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsSystemSetFlags(SceNgsHSynSystem hSystemHandle, const u32 uSystemFlags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsRackGetRequiredMemorySize(SceNgsHSynSystem hSystemHandle, vm::cptr<SceNgsRackDescription> pRackDesc, vm::ptr<u32> pnSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsRackInit(SceNgsHSynSystem hSystemHandle, vm::ptr<SceNgsBufferInfo> pRackBuffer, vm::cptr<SceNgsRackDescription> pRackDesc, vm::ptr<SceNgsHRack> pRackHandle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsRackGetVoiceHandle(SceNgsHRack hRackHandle, const u32 uIndex, vm::ptr<SceNgsHVoice> pVoiceHandle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsRackRelease(SceNgsHRack hRackHandle, vm::ptr<SceNgsCallbackFunc> callbackFuncPtr)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsRackSetParamErrorCallback(SceNgsHRack hRackHandle, vm::ptr<SceNgsCallbackFunc> callbackFuncPtr)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoiceInit(SceNgsHVoice hVoiceHandle, vm::cptr<SceNgsVoicePreset> pPreset, const u32 uInitFlags)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoicePlay(SceNgsHVoice hVoiceHandle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoiceKeyOff(SceNgsHVoice hVoiceHandle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoiceKill(SceNgsHVoice hVoiceHandle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoicePause(SceNgsHVoice hVoiceHandle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoiceResume(SceNgsHVoice hVoiceHandle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoiceSetPreset(SceNgsHVoice hVoiceHandle, vm::cptr<SceNgsVoicePreset> pVoicePreset)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoiceLockParams(SceNgsHVoice hVoiceHandle, const u32 uModule, const u32 uParamsInterfaceId, vm::ptr<SceNgsBufferInfo> pParamsBuffer)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoiceUnlockParams(SceNgsHVoice hVoiceHandle, const u32 uModule)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoiceSetParamsBlock(SceNgsHVoice hVoiceHandle, vm::cptr<SceNgsModuleParamHeader> pParamData, const u32 uSize, vm::ptr<s32> pnErrorCount)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoiceBypassModule(SceNgsHVoice hVoiceHandle, const u32 uModule, const u32 uBypassFlag)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoiceSetModuleCallback(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::ptr<SceNgsCallbackFunc> callbackFuncPtr, vm::ptr<void> pUserData)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoiceSetFinishedCallback(SceNgsHVoice hVoiceHandle, vm::ptr<SceNgsCallbackFunc> callbackFuncPtr, vm::ptr<void> pUserData)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoiceGetStateData(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::ptr<void> pMem, const u32 uMemSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoiceGetInfo(SceNgsHVoice hVoiceHandle, vm::ptr<SceNgsVoiceInfo> pInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoiceGetModuleType(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::ptr<u32> pModuleType)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoiceGetModuleBypass(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::ptr<u32> puBypassFlag)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoiceGetParamsOutOfRange(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::ptr<char> pszMessageBuffer)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsPatchCreateRouting(vm::cptr<SceNgsPatchSetupInfo> pPatchInfo, vm::ptr<SceNgsHPatch> pPatchHandle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsPatchGetInfo(SceNgsHPatch hPatchHandle, vm::ptr<SceNgsPatchRouteInfo> pRouteInfo, vm::ptr<SceNgsPatchSetupInfo> pSetup)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoiceGetOutputPatch(SceNgsHVoice hVoiceHandle, const s32 nOutputIndex, const s32 nSubIndex, vm::ptr<SceNgsHPatch> pPatchHandle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsPatchRemoveRouting(SceNgsHPatch hPatchHandle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoicePatchSetVolume(SceNgsHPatch hPatchHandle, const s32 nOutputChannel, const s32 nInputChannel, const float fVol)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoicePatchSetVolumes(SceNgsHPatch hPatchHandle, const s32 nOutputChannel, vm::cptr<float> pVolumes, const s32 nVols)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsVoicePatchSetVolumesMatrix(SceNgsHPatch hPatchHandle, vm::cptr<SceNgsVolumeMatrix> pMatrix)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsModuleGetNumPresets(SceNgsHSynSystem hSystemHandle, const u32 uModuleID, vm::ptr<u32> puNumPresets)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNgsModuleGetPreset(SceNgsHSynSystem hSystemHandle, const u32 uModuleID, const u32 uPresetIndex, vm::ptr<SceNgsBufferInfo> pParamsBuffer)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetCompressorBuss()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetCompressorSideChainBuss()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetDelayBuss()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetDistortionBuss()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetEnvelopeBuss()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetEqBuss()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetMasterBuss()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetMixerBuss()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetPauserBuss()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetReverbBuss()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetSasEmuVoice()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetSimpleVoice()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetTemplate1()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetAtrac9Voice()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaNgsGetDefaultConfig(vm::ptr<SceSulphaNgsConfig> config)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaNgsGetNeededMemory(vm::cptr<SceSulphaNgsConfig> config, vm::ptr<u32> sizeInBytes)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaNgsInit(vm::cptr<SceSulphaNgsConfig> config, vm::ptr<void> buffer, u32 sizeInBytes)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaNgsShutdown()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaNgsSetSynthName(SceNgsHSynSystem synthHandle, vm::cptr<char> name)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaNgsSetRackName(SceNgsHRack rackHandle, vm::cptr<char> name)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaNgsSetVoiceName(SceNgsHVoice voiceHandle, vm::cptr<char> name)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaNgsSetSampleName(vm::cptr<void> location, u32 length, vm::cptr<char> name)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaNgsTrace(vm::cptr<char> message)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceNpBasic.cpp

@@ -6,92 +6,92 @@
 
 s32 sceNpBasicInit(vm::ptr<void> opt)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBasicTerm(ARMv7Context&)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBasicRegisterHandler(vm::cptr<SceNpBasicEventHandlers> handlers, vm::cptr<SceNpCommunicationId> context, vm::ptr<void> userdata)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBasicUnregisterHandler(ARMv7Context&)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBasicCheckCallback()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBasicGetFriendOnlineStatus(vm::cptr<SceNpId> friendId, vm::ptr<s32> status)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBasicGetGamePresenceOfFriend(vm::cptr<SceNpId> friendId, vm::ptr<SceNpBasicGamePresence> presence)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBasicGetFriendListEntryCount(vm::ptr<u32> count)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBasicGetFriendListEntries(u32 startIndex, vm::ptr<SceNpId> entries, u32 numEntries, vm::ptr<u32> retrieved)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBasicGetBlockListEntryCount(vm::ptr<u32> count)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBasicGetBlockListEntries(u32 startIndex, vm::ptr<SceNpId> entries, u32 numEntries, vm::ptr<u32> retrieved)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBasicCheckIfPlayerIsBlocked(vm::cptr<SceNpId> player, vm::ptr<u8> playerIsBlocked)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBasicSetInGamePresence(vm::cptr<SceNpBasicInGamePresence> presence)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBasicUnsetInGamePresence()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBasicSendInGameDataMessage(vm::cptr<SceNpId> to, vm::cptr<SceNpBasicInGameDataMessage> message)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBasicRecordPlaySessionLog(vm::cptr<SceNpId> withWhom, vm::cptr<SceNpBasicPlaySessionLogDescription> description)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBasicGetPlaySessionLogSize(SceNpBasicPlaySessionLogType type, vm::ptr<u32> size)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBasicGetPlaySessionLog(SceNpBasicPlaySessionLogType type, u32 index, vm::ptr<SceNpBasicPlaySessionLog> log)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpBasic, #name, name)

rpcs3/Emu/ARMv7/Modules/sceNpCommon.cpp

@@ -6,57 +6,57 @@
 
 s32 sceNpAuthInit()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpAuthTerm()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpAuthCreateStartRequest(vm::cptr<SceNpAuthRequestParameter> param)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpAuthDestroyRequest(s32 id)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpAuthAbortRequest(s32 id)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpAuthGetTicket(s32 id, vm::ptr<void> buf, u32 len)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpAuthGetTicketParam(vm::cptr<u8> ticket, u32 ticketSize, s32 paramId, vm::ptr<SceNpTicketParam> param)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpAuthGetEntitlementIdList(vm::cptr<u8> ticket, u32 ticketSize, vm::ptr<SceNpEntitlementId> entIdList, u32 entIdListNum)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpAuthGetEntitlementById(vm::cptr<u8> ticket, u32 ticketSize, vm::cptr<char> entId, vm::ptr<SceNpEntitlement> ent)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpCmpNpId(vm::cptr<SceNpId> npid1, vm::cptr<SceNpId> npid2)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpCmpNpIdInOrder(vm::cptr<SceNpId> npid1, vm::cptr<SceNpId> npid2, vm::ptr<s32> order)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpCommon, #name, name)

rpcs3/Emu/ARMv7/Modules/sceNpManager.cpp

@@ -6,52 +6,52 @@
 
 s32 sceNpInit(vm::cptr<SceNpCommunicationConfig> commConf, vm::ptr<SceNpOptParam> opt)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpTerm(ARMv7Context&)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpCheckCallback()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpGetServiceState(vm::ptr<s32> state)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpRegisterServiceStateCallback(vm::ptr<SceNpServiceStateCallback> callback, vm::ptr<void> userdata)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpUnregisterServiceStateCallback()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpManagerGetNpId(vm::ptr<SceNpId> npId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpManagerGetAccountRegion(vm::ptr<SceNpCountryCode> countryCode, vm::ptr<s32> languageCode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpManagerGetContentRatingFlag(vm::ptr<s32> isRestricted, vm::ptr<s32> age)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpManagerGetChatRestrictionFlag(vm::ptr<s32> isRestricted)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpManager, #name, name)

rpcs3/Emu/ARMv7/Modules/sceNpMatching.cpp

@@ -8,12 +8,12 @@
 
 s32 sceNpMatching2Init(u32 poolSize, s32 threadPriority, s32 cpuAffinityMask, u32 threadStackSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2Term()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2CreateContext(
@@ -22,67 +22,67 @@ s32 sceNpMatching2CreateContext(
 	vm::cptr<SceNpCommunicationPassphrase> passPhrase,
 	vm::ptr<u16> ctxId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2DestroyContext(u16 ctxId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2ContextStart(u16 ctxId, u64 timeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2AbortContextStart(u16 ctxId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2ContextStop(u16 ctxId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2SetDefaultRequestOptParam(u16 ctxId, vm::cptr<SceNpMatching2RequestOptParam> optParam)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2RegisterRoomEventCallback(u16 ctxId, vm::ptr<SceNpMatching2RoomEventCallback> cbFunc, vm::ptr<void> cbFuncArg)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2RegisterRoomMessageCallback(u16 ctxId, vm::ptr<SceNpMatching2RoomMessageCallback> cbFunc, vm::ptr<void> cbFuncArg)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2RegisterSignalingCallback(u16 ctxId, vm::ptr<SceNpMatching2SignalingCallback> cbFunc, vm::ptr<void> cbFuncArg)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2RegisterContextCallback(vm::ptr<SceNpMatching2ContextCallback> cbFunc, vm::ptr<void> cbFuncArg)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2AbortRequest(u16 ctxId, u32 reqId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2GetMemoryInfo(vm::ptr<SceNpMatching2MemoryInfo> memInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2GetServerLocal(u16 ctxId, vm::ptr<SceNpMatching2Server> server)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2GetWorldInfoList(
@@ -91,7 +91,7 @@ s32 sceNpMatching2GetWorldInfoList(
 	vm::cptr<SceNpMatching2RequestOptParam> optParam,
 	vm::ptr<u32> assignedReqId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2CreateJoinRoom(
@@ -100,7 +100,7 @@ s32 sceNpMatching2CreateJoinRoom(
 	vm::cptr<SceNpMatching2RequestOptParam> optParam,
 	vm::ptr<u32> assignedReqId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2SearchRoom(
@@ -109,7 +109,7 @@ s32 sceNpMatching2SearchRoom(
 	vm::cptr<SceNpMatching2RequestOptParam> optParam,
 	vm::ptr<u32> assignedReqId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2JoinRoom(
@@ -118,7 +118,7 @@ s32 sceNpMatching2JoinRoom(
 	vm::cptr<SceNpMatching2RequestOptParam> optParam,
 	vm::ptr<u32> assignedReqId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2LeaveRoom(
@@ -127,7 +127,7 @@ s32 sceNpMatching2LeaveRoom(
 	vm::cptr<SceNpMatching2RequestOptParam> optParam,
 	vm::ptr<u32> assignedReqId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2GetSignalingOptParamLocal(
@@ -135,7 +135,7 @@ s32 sceNpMatching2GetSignalingOptParamLocal(
 	u64 roomId,
 	vm::ptr<SceNpMatching2SignalingOptParam> signalingOptParam)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2SetRoomDataExternal(
@@ -144,7 +144,7 @@ s32 sceNpMatching2SetRoomDataExternal(
 	vm::cptr<SceNpMatching2RequestOptParam> optParam,
 	vm::ptr<u32> assignedReqId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2KickoutRoomMember(
@@ -153,7 +153,7 @@ s32 sceNpMatching2KickoutRoomMember(
 	vm::cptr<SceNpMatching2RequestOptParam> optParam,
 	vm::ptr<u32> assignedReqId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2SendRoomChatMessage(
@@ -162,7 +162,7 @@ s32 sceNpMatching2SendRoomChatMessage(
 	vm::cptr<SceNpMatching2RequestOptParam> optParam,
 	vm::ptr<u32> assignedReqId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2SendRoomMessage(
@@ -171,7 +171,7 @@ s32 sceNpMatching2SendRoomMessage(
 	vm::cptr<SceNpMatching2RequestOptParam> optParam,
 	vm::ptr<u32> assignedReqId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2SignalingGetConnectionStatus(
@@ -182,7 +182,7 @@ s32 sceNpMatching2SignalingGetConnectionStatus(
 	vm::ptr<SceNetInAddr> peerAddr,
 	vm::ptr<u16> peerPort)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2SignalingGetConnectionInfo(
@@ -192,12 +192,12 @@ s32 sceNpMatching2SignalingGetConnectionInfo(
 	s32 code,
 	vm::ptr<SceNpMatching2SignalingConnectionInfo> info)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2SignalingGetLocalNetInfo(vm::ptr<SceNpMatching2SignalingNetInfo> netinfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2SignalingGetPeerNetInfo(
@@ -206,14 +206,14 @@ s32 sceNpMatching2SignalingGetPeerNetInfo(
 	u16 memberId,
 	vm::ptr<u32> reqId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2SignalingCancelPeerNetInfo(
 	u16 ctxId,
 	u32 reqId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpMatching2SignalingGetPeerNetInfoResult(
@@ -221,7 +221,7 @@ s32 sceNpMatching2SignalingGetPeerNetInfoResult(
 	u32 reqId,
 	vm::ptr<SceNpMatching2SignalingNetInfo> netinfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpMatching, #name, name)

rpcs3/Emu/ARMv7/Modules/sceNpScore.cpp

@@ -6,52 +6,52 @@
 
 s32 sceNpScoreInit(s32 threadPriority, s32 cpuAffinityMask, vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreTerm(ARMv7Context&)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreCreateTitleCtx(vm::cptr<SceNpCommunicationId> titleId, vm::cptr<SceNpCommunicationPassphrase> passphrase, vm::cptr<SceNpId> selfNpId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreDeleteTitleCtx(s32 titleCtxId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreCreateRequest(s32 titleCtxId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreDeleteRequest(s32 reqId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreAbortRequest(s32 reqId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreSetTimeout(s32 id, s32 resolveRetry, s32 resolveTimeout, s32 connTimeout, s32 sendTimeout, s32 recvTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreSetPlayerCharacterId(s32 id, s32 pcId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreGetBoardInfo(s32 reqId, u32 boardId, vm::ptr<SceNpScoreBoardInfo> boardInfo, vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreRecordScore(
@@ -64,7 +64,7 @@ s32 sceNpScoreRecordScore(
 	vm::cptr<u64> compareDate,
 	vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreRecordGameData(
@@ -76,7 +76,7 @@ s32 sceNpScoreRecordGameData(
 	vm::cptr<void> data,
 	vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreGetGameData(
@@ -88,7 +88,7 @@ s32 sceNpScoreGetGameData(
 	vm::ptr<void> data,
 	vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreGetRankingByNpId(
@@ -107,7 +107,7 @@ s32 sceNpScoreGetRankingByNpId(
 	vm::ptr<u32> totalRecord,
 	vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreGetRankingByRange(
@@ -125,7 +125,7 @@ s32 sceNpScoreGetRankingByRange(
 	vm::ptr<u32> totalRecord,
 	vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 
@@ -145,32 +145,32 @@ s32 sceNpScoreGetRankingByNpIdPcId(
 	vm::ptr<u32> totalRecord,
 	vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreCensorComment(s32 reqId, vm::cptr<char> comment, vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreSanitizeComment(s32 reqId, vm::cptr<char> comment, vm::ptr<char> sanitizedComment, vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreWaitAsync(s32 id, vm::ptr<s32> result)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScorePollAsync(s32 reqId, vm::ptr<s32> result)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreGetBoardInfoAsync(s32 reqId, u32 boardId, vm::ptr<SceNpScoreBoardInfo> boardInfo, vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreRecordScoreAsync(
@@ -183,7 +183,7 @@ s32 sceNpScoreRecordScoreAsync(
 	vm::cptr<u64> compareDate,
 	vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreRecordGameDataAsync(
@@ -195,7 +195,7 @@ s32 sceNpScoreRecordGameDataAsync(
 	vm::cptr<void> data,
 	vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreGetGameDataAsync(
@@ -207,7 +207,7 @@ s32 sceNpScoreGetGameDataAsync(
 	vm::ptr<void> data,
 	vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreGetRankingByNpIdAsync(
@@ -226,7 +226,7 @@ s32 sceNpScoreGetRankingByNpIdAsync(
 	vm::ptr<u32> totalRecord,
 	vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreGetRankingByRangeAsync(
@@ -244,7 +244,7 @@ s32 sceNpScoreGetRankingByRangeAsync(
 	vm::ptr<u32> totalRecord,
 	vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreGetRankingByNpIdPcIdAsync(
@@ -263,17 +263,17 @@ s32 sceNpScoreGetRankingByNpIdPcIdAsync(
 	vm::ptr<u32> totalRecord,
 	vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreCensorCommentAsync(s32 reqId, vm::cptr<char> comment, vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpScoreSanitizeCommentAsync(s32 reqId, vm::cptr<char> comment, vm::ptr<char> sanitizedComment, vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpScore, #name, name)

rpcs3/Emu/ARMv7/Modules/sceNpUtility.cpp

@@ -6,62 +6,62 @@
 
 s32 sceNpLookupInit(s32 usesAsync, s32 threadPriority, s32 cpuAffinityMask, vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpLookupTerm(ARMv7Context&)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpLookupCreateTitleCtx(vm::cptr<SceNpCommunicationId> titleId, vm::cptr<SceNpId> selfNpId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpLookupDeleteTitleCtx(s32 titleCtxId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpLookupCreateRequest(s32 titleCtxId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpLookupDeleteRequest(s32 reqId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpLookupAbortRequest(s32 reqId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpLookupSetTimeout(s32 id, s32 resolveRetry, u32 resolveTimeout, u32 connTimeout, u32 sendTimeout, u32 recvTimeout)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpLookupWaitAsync(s32 reqId, vm::ptr<s32> result)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpLookupPollAsync(s32 reqId, vm::ptr<s32> result)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpLookupNpId(s32 reqId, vm::cptr<SceNpOnlineId> onlineId, vm::ptr<SceNpId> npId, vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpLookupNpIdAsync(s32 reqId, vm::cptr<SceNpOnlineId> onlineId, vm::ptr<SceNpId> npId, vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpLookupUserProfile(
@@ -77,7 +77,7 @@ s32 sceNpLookupUserProfile(
 	vm::ptr<u32> avatarImageDataSize,
 	vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpLookupUserProfileAsync(
@@ -93,37 +93,37 @@ s32 sceNpLookupUserProfileAsync(
 	vm::ptr<u32> avatarImageDataSize,
 	vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpLookupAvatarImage(s32 reqId, vm::cptr<SceNpAvatarUrl> avatarUrl, vm::ptr<SceNpAvatarImage> avatarImage, vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpLookupAvatarImageAsync(s32 reqId, vm::cptr<SceNpAvatarUrl> avatarUrl, vm::ptr<SceNpAvatarImage> avatarImage, vm::ptr<void> option)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBandwidthTestInitStart(s32 initPriority, s32 cpuAffinityMask)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBandwidthTestGetStatus()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBandwidthTestShutdown(vm::ptr<SceNpBandwidthTestResult> result)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceNpBandwidthTestAbort()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpUtility, #name, name)

rpcs3/Emu/ARMv7/Modules/scePerf.cpp

@@ -12,7 +12,7 @@ s32 scePerfArmPmonReset(ARMv7Context& context, s32 threadId)
 
 	if (threadId != SCE_PERF_ARM_PMON_THREAD_ID_SELF)
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("Unexpected thread");
 	}
 
 	context.counters = {};
@@ -26,7 +26,7 @@ s32 scePerfArmPmonSelectEvent(ARMv7Context& context, s32 threadId, u32 counter,
 
 	if (threadId != SCE_PERF_ARM_PMON_THREAD_ID_SELF)
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("Unexpected thread");
 	}
 
 	if (counter >= 6)
@@ -75,7 +75,7 @@ s32 scePerfArmPmonStart(ARMv7Context& context, s32 threadId)
 
 	if (threadId != SCE_PERF_ARM_PMON_THREAD_ID_SELF)
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("Unexpected thread");
 	}
 
 	return SCE_OK;
@@ -87,7 +87,7 @@ s32 scePerfArmPmonStop(ARMv7Context& context, s32 threadId)
 
 	if (threadId != SCE_PERF_ARM_PMON_THREAD_ID_SELF)
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("Unexpected thread");
 	}
 
 	return SCE_OK;
@@ -99,7 +99,7 @@ s32 scePerfArmPmonGetCounterValue(ARMv7Context& context, s32 threadId, u32 count
 
 	if (threadId != SCE_PERF_ARM_PMON_THREAD_ID_SELF)
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("Unexpected thread");
 	}
 
 	if (counter >= 6 && counter != SCE_PERF_ARM_PMON_CYCLE_COUNTER)
@@ -113,7 +113,7 @@ s32 scePerfArmPmonGetCounterValue(ARMv7Context& context, s32 threadId, u32 count
 	}
 	else
 	{
-		throw "scePerfArmPmonGetCounterValue(): cycle counter requested";
+		throw EXCEPTION("Cycle counter requested");
 	}
 
 	return SCE_OK;
@@ -155,22 +155,22 @@ u32 scePerfGetTimebaseFrequency()
 
 s32 _sceRazorCpuInit(vm::cptr<void> pBufferBase, u32 bufferSize, u32 numPerfCounters, vm::pptr<u32> psceRazorVars)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRazorCpuPushMarker(vm::cptr<char> szLabel)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRazorCpuPopMarker()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRazorCpuSync()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &scePerf, #name, name)

rpcs3/Emu/ARMv7/Modules/scePhotoExport.cpp

@@ -14,7 +14,7 @@ s32 scePhotoExportFromData(
 	vm::ptr<char> exportedPath,
 	s32 exportedPathLength)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 scePhotoExportFromFile(
@@ -26,7 +26,7 @@ s32 scePhotoExportFromFile(
 	vm::ptr<char> exportedPath,
 	s32 exportedPathLength)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &scePhotoExport, #name, name)

rpcs3/Emu/ARMv7/Modules/sceRazorCapture.cpp

@@ -6,17 +6,17 @@
 
 void sceRazorCaptureSetTrigger(u32 frameIndex, vm::cptr<char> captureFilename)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void sceRazorCaptureSetTriggerNextFrame(vm::cptr<char> captureFilename)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 bool sceRazorCaptureIsInProgress()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceRazorCapture, #name, name)

rpcs3/Emu/ARMv7/Modules/sceRtc.cpp

@@ -6,187 +6,187 @@
 
 u32 sceRtcGetTickResolution()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcGetCurrentTick(vm::ptr<u64> pTick)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcGetCurrentClock(vm::ptr<SceDateTime> pTime, s32 iTimeZone)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcGetCurrentClockLocalTime(vm::ptr<SceDateTime> pTime)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcGetCurrentNetworkTick(vm::ptr<u64> pTick)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcConvertUtcToLocalTime(vm::cptr<u64> pUtc, vm::ptr<u64> pLocalTime)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcConvertLocalTimeToUtc(vm::cptr<u64> pLocalTime, vm::ptr<u64> pUtc)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcIsLeapYear(s32 year)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcGetDaysInMonth(s32 year, s32 month)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcGetDayOfWeek(s32 year, s32 month, s32 day)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcCheckValid(vm::cptr<SceDateTime> pTime)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcSetTime_t(vm::ptr<SceDateTime> pTime, u32 iTime)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcSetTime64_t(vm::ptr<SceDateTime> pTime, u64 ullTime)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcGetTime_t(vm::cptr<SceDateTime> pTime, vm::ptr<u32> piTime)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcGetTime64_t(vm::cptr<SceDateTime> pTime, vm::ptr<u64> pullTime)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcSetDosTime(vm::ptr<SceDateTime> pTime, u32 uiDosTime)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcGetDosTime(vm::cptr<SceDateTime> pTime, vm::ptr<u32> puiDosTime)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcSetWin32FileTime(vm::ptr<SceDateTime> pTime, u64 ulWin32Time)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcGetWin32FileTime(vm::cptr<SceDateTime> pTime, vm::ptr<u64> ulWin32Time)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcSetTick(vm::ptr<SceDateTime> pTime, vm::cptr<u64> pTick)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcGetTick(vm::cptr<SceDateTime> pTime, vm::ptr<u64> pTick)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcCompareTick(vm::cptr<u64> pTick1, vm::cptr<u64> pTick2)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcTickAddTicks(vm::ptr<u64> pTick0, vm::cptr<u64> pTick1, u64 lAdd)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcTickAddMicroseconds(vm::ptr<u64> pTick0, vm::cptr<u64> pTick1, u64 lAdd)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcTickAddSeconds(vm::ptr<u64> pTick0, vm::cptr<u64> pTick1, u64 lAdd)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcTickAddMinutes(vm::ptr<u64> pTick0, vm::cptr<u64> pTick1, u64 lAdd)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcTickAddHours(vm::ptr<u64> pTick0, vm::cptr<u64> pTick1, s32 lAdd)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcTickAddDays(vm::ptr<u64> pTick0, vm::cptr<u64> pTick1, s32 lAdd)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcTickAddWeeks(vm::ptr<u64> pTick0, vm::cptr<u64> pTick1, s32 lAdd)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcTickAddMonths(vm::ptr<u64> pTick0, vm::cptr<u64> pTick1, s32 lAdd)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcTickAddYears(vm::ptr<u64> pTick0, vm::cptr<u64> pTick1, s32 lAdd)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcFormatRFC2822(vm::ptr<char> pszDateTime, vm::cptr<u64> pUtc, s32 iTimeZoneMinutes)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcFormatRFC2822LocalTime(vm::ptr<char> pszDateTime, vm::cptr<u64> pUtc)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcFormatRFC3339(vm::ptr<char> pszDateTime, vm::cptr<u64> pUtc, s32 iTimeZoneMinutes)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcFormatRFC3339LocalTime(vm::ptr<char> pszDateTime, vm::cptr<u64> pUtc)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcParseDateTime(vm::ptr<u64> pUtc, vm::cptr<char> pszDateTime)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceRtcParseRFC3339(vm::ptr<u64> pUtc, vm::cptr<char> pszDateTime)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceSas.cpp

@@ -6,147 +6,147 @@
 
 s32 sceSasGetNeededMemorySize(vm::cptr<char> config, vm::ptr<u32> outSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasInit(vm::cptr<char> config, vm::ptr<void> buffer, u32 bufferSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasInitWithGrain(vm::cptr<char> config, u32 grain, vm::ptr<void> buffer, u32 bufferSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasExit(vm::pptr<void> outBuffer, vm::ptr<u32> outBufferSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasSetGrain(u32 grain)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasGetGrain()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasSetOutputmode(u32 outputmode)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasGetOutputmode()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasCore(vm::ptr<s16> out)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasCoreWithMix(vm::ptr<s16> inOut, s32 lvol, s32 rvol)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasSetVoice(s32 iVoiceNum, vm::cptr<void> vagBuf, u32 size, u32 loopflag)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasSetVoicePCM(s32 iVoiceNum, vm::cptr<void> pcmBuf, u32 size, s32 loopsize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasSetNoise(s32 iVoiceNum, u32 uClk)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasSetVolume(s32 iVoiceNum, s32 l, s32 r, s32 wl, s32 wr)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasSetPitch(s32 iVoiceNum, s32 pitch)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasSetADSR(s32 iVoiceNum, u32 flag, u32 ar, u32 dr, u32 sr, u32 rr)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasSetADSRmode(s32 iVoiceNum, u32 flag, u32 am, u32 dm, u32 sm, u32 rm)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasSetSL(s32 iVoiceNum, u32 sl)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasSetSimpleADSR(s32 iVoiceNum, u16 adsr1, u16 adsr2)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasSetKeyOn(s32 iVoiceNum)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasSetKeyOff(s32 iVoiceNum)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasSetPause(s32 iVoiceNum, u32 pauseFlag)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasGetPauseState(s32 iVoiceNum)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasGetEndState(s32 iVoiceNum)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasGetEnvelope(s32 iVoiceNum)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasSetEffect(s32 drySwitch, s32 wetSwitch)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasSetEffectType(s32 type)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasSetEffectVolume(s32 valL, s32 valR)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSasSetEffectParam(u32 delayTime, u32 feedback)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceScreenShot.cpp

@@ -6,22 +6,22 @@
 
 s32 sceScreenShotSetParam(vm::cptr<SceScreenShotParam> param)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceScreenShotSetOverlayImage(vm::cptr<char> filePath, s32 offsetX, s32 offsetY)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceScreenShotDisable()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceScreenShotEnable()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceSsl.cpp

@@ -6,57 +6,57 @@
 
 s32 sceSslInit(u32 poolSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSslTerm()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSslGetMemoryPoolStats(vm::ptr<SceSslMemoryPoolStats> currentStat)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSslGetSerialNumber(vm::ptr<SceSslCert> sslCert, vm::cpptr<u8> sboData, vm::ptr<u32> sboLen)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::ptr<SceSslCertName> sceSslGetSubjectName(vm::ptr<SceSslCert> sslCert)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 vm::ptr<SceSslCertName> sceSslGetIssuerName(vm::ptr<SceSslCert> sslCert)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSslGetNotBefore(vm::ptr<SceSslCert> sslCert, vm::ptr<u64> begin)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSslGetNotAfter(vm::ptr<SceSslCert> sslCert, vm::ptr<u64> limit)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSslGetNameEntryCount(vm::ptr<SceSslCertName> certName)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSslGetNameEntryInfo(vm::ptr<SceSslCertName> certName, s32 entryNum, vm::ptr<char> oidname, u32 maxOidnameLen, vm::ptr<u8> value, u32 maxValueLen, vm::ptr<u32> valueLen)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSslFreeSslCertName(vm::ptr<SceSslCertName> certName)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceSulpha.cpp

@@ -6,67 +6,67 @@
 
 s32 sceSulphaNetworkInit()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaNetworkShutdown()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaGetDefaultConfig(vm::ptr<SceSulphaConfig> config)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaGetNeededMemory(vm::cptr<SceSulphaConfig> config, vm::ptr<u32> sizeInBytes)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaInit(vm::cptr<SceSulphaConfig> config, vm::ptr<void> buffer, u32 sizeInBytes)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaShutdown()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaUpdate()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaFileConnect(vm::cptr<char> filename)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaFileDisconnect()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaSetBookmark(vm::cptr<char> name, s32 id)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaAgentsGetNeededMemory(vm::cptr<SceSulphaAgentsRegister> config, vm::ptr<u32> sizeInBytes)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaAgentsRegister(vm::cptr<SceSulphaAgentsRegister> config, vm::ptr<void> buffer, u32 sizeInBytes, vm::ptr<SceSulphaHandle> handles)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSulphaAgentsUnregister(vm::cptr<SceSulphaHandle> handles, u32 agentCount)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceSystemGesture.cpp

@@ -6,87 +6,87 @@
 
 s32 sceSystemGestureInitializePrimitiveTouchRecognizer(vm::ptr<SceSystemGesturePrimitiveTouchRecognizerParameter> parameter)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSystemGestureFinalizePrimitiveTouchRecognizer()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSystemGestureResetPrimitiveTouchRecognizer()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSystemGestureUpdatePrimitiveTouchRecognizer(vm::cptr<SceTouchData> pFrontData, vm::cptr<SceTouchData> pBackData)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSystemGestureGetPrimitiveTouchEvents(vm::ptr<SceSystemGesturePrimitiveTouchEvent> primitiveEventBuffer, const u32 capacityOfBuffer, vm::ptr<u32> numberOfEvent)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSystemGestureGetPrimitiveTouchEventsCount()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSystemGestureGetPrimitiveTouchEventByIndex(const u32 index, vm::ptr<SceSystemGesturePrimitiveTouchEvent> primitiveTouchEvent)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSystemGestureGetPrimitiveTouchEventByPrimitiveID(const u16 primitiveID, vm::ptr<SceSystemGesturePrimitiveTouchEvent> primitiveTouchEvent)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSystemGestureCreateTouchRecognizer(vm::ptr<SceSystemGestureTouchRecognizer> touchRecognizer, const SceSystemGestureType gestureType, const u8 touchPanelPortID, vm::cptr<SceSystemGestureRectangle> rectangle, vm::cptr<SceSystemGestureTouchRecognizerParameter> touchRecognizerParameter)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSystemGestureGetTouchRecognizerInformation(vm::cptr<SceSystemGestureTouchRecognizer> touchRecognizer, vm::ptr<SceSystemGestureTouchRecognizerInformation> information)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSystemGestureResetTouchRecognizer(vm::ptr<SceSystemGestureTouchRecognizer> touchRecognizer)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSystemGestureUpdateTouchRecognizer(vm::ptr<SceSystemGestureTouchRecognizer> touchRecognizer)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSystemGestureUpdateTouchRecognizerRectangle(vm::ptr<SceSystemGestureTouchRecognizer> touchRecognizer, vm::cptr<SceSystemGestureRectangle> rectangle)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSystemGestureGetTouchEvents(vm::cptr<SceSystemGestureTouchRecognizer> touchRecognizer, vm::ptr<SceSystemGestureTouchEvent> eventBuffer, const u32 capacityOfBuffer, vm::ptr<u32> numberOfEvent)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSystemGestureGetTouchEventsCount(vm::cptr<SceSystemGestureTouchRecognizer> touchRecognizer)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSystemGestureGetTouchEventByIndex(vm::cptr<SceSystemGestureTouchRecognizer> touchRecognizer, const u32 index, vm::ptr<SceSystemGestureTouchEvent> touchEvent)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceSystemGestureGetTouchEventByEventID(vm::cptr<SceSystemGestureTouchRecognizer> touchRecognizer, const u32 eventID, vm::ptr<SceSystemGestureTouchEvent> touchEvent)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceTouch.cpp

@@ -6,27 +6,27 @@
 
 s32 sceTouchGetPanelInfo(u32 port, vm::ptr<SceTouchPanelInfo> pPanelInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceTouchRead(u32 port, vm::ptr<SceTouchData> pData, u32 nBufs)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceTouchPeek(u32 port, vm::ptr<SceTouchData> pData, u32 nBufs)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceTouchSetSamplingState(u32 port, u32 state)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceTouchGetSamplingState(u32 port, vm::ptr<u32> pState)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceUlt.cpp

@@ -8,12 +8,12 @@
 
 s32 _sceUltWaitingQueueResourcePoolOptParamInitialize(vm::ptr<SceUltWaitingQueueResourcePoolOptParam> optParam, u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u32 sceUltWaitingQueueResourcePoolGetWorkAreaSize(u32 numThreads, u32 numSyncObjects)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _sceUltWaitingQueueResourcePoolCreate(
@@ -25,22 +25,22 @@ s32 _sceUltWaitingQueueResourcePoolCreate(
 	vm::cptr<SceUltWaitingQueueResourcePoolOptParam> optParam,
 	u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltWaitingQueueResourcePoolDestroy(vm::ptr<SceUltWaitingQueueResourcePool> pool)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _sceUltQueueDataResourcePoolOptParamInitialize(vm::ptr<SceUltQueueDataResourcePoolOptParam> optParam, u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u32 sceUltQueueDataResourcePoolGetWorkAreaSize(u32 numData, u32 dataSize, u32 numQueueObject)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _sceUltQueueDataResourcePoolCreate(
@@ -54,22 +54,22 @@ s32 _sceUltQueueDataResourcePoolCreate(
 	vm::cptr<SceUltQueueDataResourcePoolOptParam> optParam,
 	u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltQueueDataResourcePoolDestroy(vm::ptr<SceUltQueueDataResourcePool> pool)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u32 sceUltMutexGetStandaloneWorkAreaSize(u32 waitingQueueDepth, u32 numConditionVariable)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _sceUltMutexOptParamInitialize(vm::ptr<SceUltMutexOptParam> optParam, u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _sceUltMutexCreate(
@@ -79,7 +79,7 @@ s32 _sceUltMutexCreate(
 	vm::cptr<SceUltMutexOptParam> optParam,
 	u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _sceUltMutexCreateStandalone(
@@ -91,32 +91,32 @@ s32 _sceUltMutexCreateStandalone(
 	vm::cptr<SceUltMutexOptParam> optParam,
 	u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltMutexLock(vm::ptr<SceUltMutex> mutex)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltMutexTryLock(vm::ptr<SceUltMutex> mutex)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltMutexUnlock(vm::ptr<SceUltMutex> mutex)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltMutexDestroy(vm::ptr<SceUltMutex> mutex)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _sceUltConditionVariableOptParamInitialize(vm::ptr<SceUltConditionVariableOptParam> optParam, u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _sceUltConditionVariableCreate(
@@ -126,39 +126,39 @@ s32 _sceUltConditionVariableCreate(
 	vm::cptr<SceUltConditionVariableOptParam> optParam,
 	u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltConditionVariableSignal(vm::ptr<SceUltConditionVariable> conditionVariable)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltConditionVariableSignalAll(vm::ptr<SceUltConditionVariable> conditionVariable)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltConditionVariableWait(vm::ptr<SceUltConditionVariable> conditionVariable)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltConditionVariableDestroy(vm::ptr<SceUltConditionVariable> conditionVariable)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _sceUltQueueOptParamInitialize(vm::ptr<SceUltQueueOptParam> optParam, u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u32 sceUltQueueGetStandaloneWorkAreaSize(u32 queueDepth,
 	u32 dataSize,
 	u32 waitingQueueLength)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _sceUltQueueCreate(
@@ -170,7 +170,7 @@ s32 _sceUltQueueCreate(
 	vm::cptr<SceUltQueueOptParam> optParam,
 	u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _sceUltQueueCreateStandalone(
@@ -183,37 +183,37 @@ s32 _sceUltQueueCreateStandalone(
 	vm::cptr<SceUltQueueOptParam> optParam,
 	u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltQueuePush(vm::ptr<SceUltQueue> queue, vm::cptr<void> data)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltQueueTryPush(vm::ptr<SceUltQueue> queue, vm::cptr<void> data)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltQueuePop(vm::ptr<SceUltQueue> queue, vm::ptr<void> data)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltQueueTryPop(vm::ptr<SceUltQueue> queue, vm::ptr<void> data)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltQueueDestroy(vm::ptr<SceUltQueue> queue)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _sceUltReaderWriterLockOptParamInitialize(vm::ptr<SceUltReaderWriterLockOptParam> optParam, u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _sceUltReaderWriterLockCreate(
@@ -223,7 +223,7 @@ s32 _sceUltReaderWriterLockCreate(
 	vm::cptr<SceUltReaderWriterLockOptParam> optParam,
 	u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _sceUltReaderWriterLockCreateStandalone(
@@ -234,52 +234,52 @@ s32 _sceUltReaderWriterLockCreateStandalone(
 	vm::cptr<SceUltReaderWriterLockOptParam> optParam,
 	u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u32 sceUltReaderWriterLockGetStandaloneWorkAreaSize(u32 waitingQueueDepth)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltReaderWriterLockLockRead(vm::ptr<SceUltReaderWriterLock> rwlock)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltReaderWriterLockTryLockRead(vm::ptr<SceUltReaderWriterLock> rwlock)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltReaderWriterLockUnlockRead(vm::ptr<SceUltReaderWriterLock> rwlock)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltReaderWriterLockLockWrite(vm::ptr<SceUltReaderWriterLock> rwlock)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltReaderWriterLockTryLockWrite(vm::ptr<SceUltReaderWriterLock> rwlock)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltReaderWriterLockUnlockWrite(vm::ptr<SceUltReaderWriterLock> rwlock)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltReaderWriterLockDestroy(vm::ptr<SceUltReaderWriterLock> rwlock)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _sceUltSemaphoreOptParamInitialize(vm::ptr<SceUltSemaphoreOptParam> optParam, u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _sceUltSemaphoreCreate(
@@ -290,37 +290,37 @@ s32 _sceUltSemaphoreCreate(
 	vm::cptr<SceUltSemaphoreOptParam> optParam,
 	u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltSemaphoreAcquire(vm::ptr<SceUltSemaphore> semaphore, s32 numResource)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltSemaphoreTryAcquire(vm::ptr<SceUltSemaphore> semaphore, s32 numResource)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltSemaphoreRelease(vm::ptr<SceUltSemaphore> semaphore, s32 numResource)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltSemaphoreDestroy(vm::ptr<SceUltSemaphore> semaphore)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _sceUltUlthreadRuntimeOptParamInitialize(vm::ptr<SceUltUlthreadRuntimeOptParam> optParam, u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 u32 sceUltUlthreadRuntimeGetWorkAreaSize(u32 numMaxUlthread, u32 numWorkerThread)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _sceUltUlthreadRuntimeCreate(
@@ -332,17 +332,17 @@ s32 _sceUltUlthreadRuntimeCreate(
 	vm::cptr<SceUltUlthreadRuntimeOptParam> optParam,
 	u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltUlthreadRuntimeDestroy(vm::ptr<SceUltUlthreadRuntime> runtime)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _sceUltUlthreadOptParamInitialize(vm::ptr<SceUltUlthreadOptParam> optParam, u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _sceUltUlthreadCreate(
@@ -356,32 +356,32 @@ s32 _sceUltUlthreadCreate(
 	vm::cptr<SceUltUlthreadOptParam> optParam,
 	u32 buildVersion)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltUlthreadYield()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltUlthreadExit(s32 status)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltUlthreadJoin(vm::ptr<SceUltUlthread> ulthread, vm::ptr<s32> status)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltUlthreadTryJoin(vm::ptr<SceUltUlthread> ulthread, vm::ptr<s32> status)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceUltUlthreadGetSelf(vm::pptr<SceUltUlthread> ulthread)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceUlt, #name, name)

rpcs3/Emu/ARMv7/Modules/sceVideodec.cpp

@@ -6,47 +6,47 @@
 
 s32 sceVideodecInitLibrary(u32 codecType, vm::cptr<SceVideodecQueryInitInfo> pInitInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVideodecTermLibrary(u32 codecType)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAvcdecQueryDecoderMemSize(u32 codecType, vm::cptr<SceAvcdecQueryDecoderInfo> pDecoderInfo, vm::ptr<SceAvcdecDecoderInfo> pMemInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAvcdecCreateDecoder(u32 codecType, vm::ptr<SceAvcdecCtrl> pCtrl, vm::cptr<SceAvcdecQueryDecoderInfo> pDecoderInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAvcdecDeleteDecoder(vm::ptr<SceAvcdecCtrl> pCtrl)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAvcdecDecodeAvailableSize(vm::ptr<SceAvcdecCtrl> pCtrl)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAvcdecDecode(vm::ptr<SceAvcdecCtrl> pCtrl, vm::cptr<SceAvcdecAu> pAu, vm::ptr<SceAvcdecArrayPicture> pArrayPicture)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAvcdecDecodeStop(vm::ptr<SceAvcdecCtrl> pCtrl, vm::ptr<SceAvcdecArrayPicture> pArrayPicture)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceAvcdecDecodeFlush(vm::ptr<SceAvcdecCtrl> pCtrl)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceVoice.cpp

@@ -6,127 +6,127 @@
 
 s32 sceVoiceInit(vm::ptr<SceVoiceInitParam> pArg, SceVoiceVersion version)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceEnd()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceStart(vm::ptr<SceVoiceStartParam> pArg)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceStop()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceResetPort(u32 portId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceCreatePort(vm::ptr<u32> portId, vm::cptr<SceVoicePortParam> pArg)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceUpdatePort(u32 portId, vm::cptr<SceVoicePortParam> pArg)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceConnectIPortToOPort(u32 ips, u32 ops)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceDisconnectIPortFromOPort(u32 ips, u32 ops)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceDeletePort(u32 portId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceWriteToIPort(u32 ips, vm::cptr<void> data, vm::ptr<u32> size, s16 frameGaps)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceReadFromOPort(u32 ops, vm::ptr<void> data, vm::ptr<u32> size)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceSetMuteFlagAll(u16 bMuted)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceSetMuteFlag(u32 portId, u16 bMuted)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceGetMuteFlag(u32 portId, vm::ptr<u16> bMuted)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceSetVolume(u32 portId, float volume)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceGetVolume(u32 portId, vm::ptr<float> volume)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceSetBitRate(u32 portId, SceVoiceBitRate bitrate)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceGetBitRate(u32 portId, vm::ptr<u32> bitrate)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceGetPortInfo(u32 portId, vm::ptr<SceVoiceBasePortInfo> pInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoicePausePort(u32 portId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceResumePort(u32 portId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoicePausePortAll()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceResumePortAll()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceGetResourceInfo(vm::ptr<SceVoiceResourceInfo> pInfo)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/ARMv7/Modules/sceVoiceQoS.cpp

@@ -6,87 +6,87 @@
 
 s32 sceVoiceQoSInit()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceQoSEnd()
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceQoSCreateLocalEndpoint(vm::ptr<s32> pLocalId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceQoSDeleteLocalEndpoint(s32 localId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceQoSCreateRemoteEndpoint(vm::ptr<s32> pRemoteId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceQoSDeleteRemoteEndpoint(s32 remoteId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceQoSConnect(vm::ptr<s32> pConnectionId, s32 localId, s32 remoteId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceQoSDisconnect(s32 connectionId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceQoSGetLocalEndpoint(s32 connectionId, vm::ptr<s32> pLocalId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceQoSGetRemoteEndpoint(s32 connectionId, vm::ptr<s32> pRemoteId)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceQoSSetLocalEndpointAttribute(s32 localId, SceVoiceQoSAttributeId attributeId, vm::cptr<void> pAttributeValue, s32 attributeSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceQoSGetLocalEndpointAttribute(s32 localId, SceVoiceQoSAttributeId attributeId, vm::ptr<void> pAttributeValue, s32 attributeSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceQoSSetConnectionAttribute(s32 connectionId, SceVoiceQoSAttributeId attributeId, vm::cptr<void> pAttributeValue, s32 attributeSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceQoSGetConnectionAttribute(s32 connectionId, SceVoiceQoSAttributeId attributeId, vm::ptr<void> pAttributeValue, s32 attributeSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceQoSGetStatus(s32 connectionId, SceVoiceQoSStatusId statusId, vm::ptr<void> pStatusValue, s32 statusSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceQoSWritePacket(s32 connectionId, vm::cptr<void> pData, vm::ptr<u32> pSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 sceVoiceQoSReadPacket(s32 connectionId, vm::ptr<void> pData, vm::ptr<u32> pSize)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 

rpcs3/Emu/CPU/CPUThread.cpp

@@ -11,13 +11,15 @@
 #include "CPUThread.h"
 
 CPUThread::CPUThread(CPUThreadType type, const std::string& name, std::function<std::string()> thread_name)
-	: m_state({ CPU_STATE_STOP })
+	: m_state({ CPU_STATE_STOPPED })
 	, m_id(Emu.GetIdManager().get_current_id())
 	, m_type(type)
 	, m_name(name)
 {
 	start(thread_name, [this]
 	{
+		SendDbgCommand(DID_CREATE_THREAD, this);
+
 		std::unique_lock<std::mutex> lock(mutex);
 
 		// check thread status
@@ -39,7 +41,7 @@ CPUThread::CPUThread(CPUThreadType type, const std::string& name, std::function<
 				}
 				catch (CPUThreadStop)
 				{
-					m_state |= CPU_STATE_STOP;
+					m_state |= CPU_STATE_STOPPED;
 				}
 				catch (CPUThreadExit)
 				{
@@ -47,6 +49,7 @@ CPUThread::CPUThread(CPUThreadType type, const std::string& name, std::function<
 					break;
 				}
 
+				m_state &= ~CPU_STATE_RETURN;
 				cv.notify_one();
 				continue;
 			}
@@ -58,8 +61,6 @@ CPUThread::CPUThread(CPUThreadType type, const std::string& name, std::function<
 
 		cv.notify_all();
 	});
-
-	SendDbgCommand(DID_CREATE_THREAD, this);
 }
 
 CPUThread::~CPUThread()
@@ -74,7 +75,7 @@ CPUThread::~CPUThread()
 
 bool CPUThread::IsPaused() const
 {
-	return (m_state.load() & CPU_STATE_PAUSE) != 0 || Emu.IsPaused();
+	return (m_state.load() & CPU_STATE_PAUSED) != 0 || Emu.IsPaused();
 }
 
 void CPUThread::DumpInformation() const
@@ -97,7 +98,7 @@ void CPUThread::Resume()
 {
 	SendDbgCommand(DID_RESUME_THREAD, this);
 
-	m_state &= ~CPU_STATE_PAUSE;
+	m_state &= ~CPU_STATE_PAUSED;
 
 	cv.notify_one();
 
@@ -108,7 +109,7 @@ void CPUThread::Pause()
 {
 	SendDbgCommand(DID_PAUSE_THREAD, this);
 
-	m_state |= CPU_STATE_PAUSE;
+	m_state |= CPU_STATE_PAUSED;
 
 	cv.notify_one();
 
@@ -125,7 +126,7 @@ void CPUThread::Stop()
 	}
 	else
 	{
-		m_state |= CPU_STATE_STOP;
+		m_state |= CPU_STATE_STOPPED;
 
 		cv.notify_one();
 	}
@@ -137,7 +138,7 @@ void CPUThread::Exec()
 {
 	SendDbgCommand(DID_EXEC_THREAD, this);
 
-	m_state &= ~CPU_STATE_STOP;
+	m_state &= ~CPU_STATE_STOPPED;
 
 	cv.notify_one();
 }
@@ -159,7 +160,7 @@ void CPUThread::Step()
 	m_state.atomic_op([](u64& state)
 	{
 		state |= CPU_STATE_STEP;
-		state &= ~CPU_STATE_PAUSE;
+		state &= ~CPU_STATE_PAUSED;
 	});
 
 	cv.notify_one();
@@ -194,7 +195,7 @@ bool CPUThread::CheckStatus()
 		cv.wait_for(lock, std::chrono::milliseconds(1));
 	}
 
-	if (IsStopped())
+	if (m_state.load() & CPU_STATE_RETURN || IsStopped())
 	{
 		return true;
 	}
@@ -202,7 +203,7 @@ bool CPUThread::CheckStatus()
 	if (m_state.load() & CPU_STATE_STEP)
 	{
 		// set PAUSE, but allow to execute once
-		m_state |= CPU_STATE_PAUSE;
+		m_state |= CPU_STATE_PAUSED;
 		m_state &= ~CPU_STATE_STEP;
 	}
 

rpcs3/Emu/CPU/CPUThread.h

@@ -13,11 +13,12 @@ enum CPUThreadType
 // CPU Thread State Flags
 enum : u64
 {
-	CPU_STATE_STOP  = (1ull << 0), // basic execution state (stopped by default), removed by Exec()
-	CPU_STATE_PAUSE = (1ull << 1), // paused by debugger (manually or after step execution)
-	CPU_STATE_SLEEP = (1ull << 2),
-	CPU_STATE_STEP  = (1ull << 3),
-	CPU_STATE_DEAD  = (1ull << 4),
+	CPU_STATE_STOPPED = (1ull << 0), // basic execution state (stopped by default), removed by Exec()
+	CPU_STATE_PAUSED  = (1ull << 1), // paused by debugger (manually or after step execution)
+	CPU_STATE_SLEEP   = (1ull << 2),
+	CPU_STATE_STEP    = (1ull << 3),
+	CPU_STATE_DEAD    = (1ull << 4),
+	CPU_STATE_RETURN  = (1ull << 5),
 };
 
 // "HLE return" exception event
@@ -57,7 +58,7 @@ public:
 	std::string GetName() const { return m_name; }
 
 	bool IsActive() const { return (m_state.load() & CPU_STATE_DEAD) == 0; }
-	bool IsStopped() const { return (m_state.load() & CPU_STATE_STOP) != 0; }
+	bool IsStopped() const { return (m_state.load() & CPU_STATE_STOPPED) != 0; }
 	virtual bool IsPaused() const;
 
 	virtual void DumpInformation() const;
@@ -79,7 +80,7 @@ public:
 	void Step(); // set STEP status, don't use
 	void Sleep(); // flip SLEEP status, don't use
 	void Awake(); // flip SLEEP status, don't use
-	bool CheckStatus(); // process m_state flags, returns true if must return from Task()
+	bool CheckStatus(); // process m_state flags, returns true if the checker must return
 
 	std::string GetFName() const
 	{

rpcs3/Emu/Cell/PPUInterpreter.cpp

@@ -53,7 +53,7 @@ void ppu_interpreter::TDI(PPUThread& CPU, ppu_opcode_t op)
 		((op.bo & 0x2) && a_ < b_) ||
 		((op.bo & 0x1) && a_ > b_))
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("");
 	}
 }
 
@@ -68,14 +68,14 @@ void ppu_interpreter::TWI(PPUThread& CPU, ppu_opcode_t op)
 		((op.bo & 0x2) && a_ < b_) ||
 		((op.bo & 0x1) && a_ > b_))
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("");
 	}
 }
 
 
 void ppu_interpreter::MFVSCR(PPUThread& CPU, ppu_opcode_t op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void ppu_interpreter::MTVSCR(PPUThread& CPU, ppu_opcode_t op)
@@ -1478,7 +1478,7 @@ void ppu_interpreter::SC(PPUThread& CPU, ppu_opcode_t op)
 	{
 	case 0x0: SysCalls::DoSyscall(CPU, CPU.GPR[11]); break;
 	case 0x3: CPU.FastStop(); break;
-	default: throw __FUNCTION__;
+	default: throw EXCEPTION("");
 	}
 }
 
@@ -1698,7 +1698,7 @@ void ppu_interpreter::TW(PPUThread& CPU, ppu_opcode_t op)
 		((u32)a < (u32)b && (op.bo & 0x2)) ||
 		((u32)a >(u32)b && (op.bo & 0x1)))
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("");
 	}
 }
 
@@ -1923,7 +1923,7 @@ void ppu_interpreter::ANDC(PPUThread& CPU, ppu_opcode_t op)
 
 void ppu_interpreter::TD(PPUThread& CPU, ppu_opcode_t op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void ppu_interpreter::LVEWX(PPUThread& CPU, ppu_opcode_t op)
@@ -2233,7 +2233,7 @@ void ppu_interpreter::EQV(PPUThread& CPU, ppu_opcode_t op)
 
 void ppu_interpreter::ECIWX(PPUThread& CPU, ppu_opcode_t op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void ppu_interpreter::LHZUX(PPUThread& CPU, ppu_opcode_t op)
@@ -2274,7 +2274,7 @@ void ppu_interpreter::MFSPR(PPUThread& CPU, ppu_opcode_t op)
 	case 0x117: CPU.GPR[op.rd] = CPU.SPRG[n - 0x110]; return;
 	}
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void ppu_interpreter::LWAX(PPUThread& CPU, ppu_opcode_t op)
@@ -2308,7 +2308,7 @@ void ppu_interpreter::MFTB(PPUThread& CPU, ppu_opcode_t op)
 	{
 	case 0x10C: CPU.GPR[op.rd] = CPU.TB; break;
 	case 0x10D: CPU.GPR[op.rd] = CPU.TB >> 32; break;
-	default: throw __FUNCTION__;
+	default: throw EXCEPTION("");
 	}
 }
 
@@ -2344,7 +2344,7 @@ void ppu_interpreter::ORC(PPUThread& CPU, ppu_opcode_t op)
 
 void ppu_interpreter::ECOWX(PPUThread& CPU, ppu_opcode_t op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void ppu_interpreter::STHUX(PPUThread& CPU, ppu_opcode_t op)
@@ -2419,7 +2419,7 @@ void ppu_interpreter::MTSPR(PPUThread& CPU, ppu_opcode_t op)
 	case 0x117: CPU.SPRG[n - 0x110] = CPU.GPR[op.rs]; return;
 	}
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 void ppu_interpreter::DCBI(PPUThread& CPU, ppu_opcode_t op)
@@ -3324,5 +3324,5 @@ void ppu_interpreter::FCFID(PPUThread& CPU, ppu_opcode_t op)
 
 void ppu_interpreter::UNK(PPUThread& CPU, ppu_opcode_t op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }

rpcs3/Emu/Cell/PPUInterpreter.h

@@ -2886,7 +2886,7 @@ private:
 	}
 	void ECIWX(u32 rd, u32 ra, u32 rb)
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("Privileged instruction");
 	}
 	void LHZUX(u32 rd, u32 ra, u32 rb)
 	{
@@ -2960,7 +2960,7 @@ private:
 	}
 	void ECOWX(u32 rs, u32 ra, u32 rb)
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("Privileged instruction");
 	}
 	void STHUX(u32 rs, u32 ra, u32 rb)
 	{

rpcs3/Emu/Cell/PPULLVMRecompiler.cpp

@@ -5596,15 +5596,15 @@ std::mutex                           RecompilationEngine::s_mutex;
 std::shared_ptr<RecompilationEngine> RecompilationEngine::s_the_instance = nullptr;
 
 RecompilationEngine::RecompilationEngine()
-    : ThreadBase("PPU Recompilation Engine")
-    , m_log(nullptr)
+    : m_log(nullptr)
     , m_next_ordinal(0)
     , m_compiler(*this, ExecutionEngine::ExecuteFunction, ExecutionEngine::ExecuteTillReturn, ExecutionEngine::PollStatus) {
     m_compiler.RunAllTests();
 }
 
 RecompilationEngine::~RecompilationEngine() {
-    Stop();
+    cv.notify_one();
+    join();
 }
 
 u32 RecompilationEngine::AllocateOrdinal(u32 address, bool is_function) {
@@ -5648,11 +5648,11 @@ void RecompilationEngine::NotifyTrace(ExecutionTrace * execution_trace) {
         m_pending_execution_traces.push_back(execution_trace);
     }
 
-    if (!IsAlive()) {
-        Start();
+    if (!joinable()) {
+        start(WRAP_EXPR("PPU Recompilation Engine"), WRAP_EXPR(Task()));
     }
 
-    Notify();
+    cv.notify_one();
     // TODO: Increase the priority of the recompilation engine thread
 }
 
@@ -5672,7 +5672,7 @@ void RecompilationEngine::Task() {
     std::chrono::nanoseconds recompiling_time(0);
 
     auto start = std::chrono::high_resolution_clock::now();
-    while (!TestDestroy() && !Emu.IsStopped()) {
+    while (joinable() && !Emu.IsStopped()) {
         bool             work_done_this_iteration = false;
         ExecutionTrace * execution_trace          = nullptr;
 
@@ -5729,7 +5729,8 @@ void RecompilationEngine::Task() {
 
             // Wait a few ms for something to happen
             auto idling_start = std::chrono::high_resolution_clock::now();
-            WaitForAnySignal(250);
+            std::unique_lock<std::mutex> lock(mutex);
+            cv.wait_for(lock, std::chrono::milliseconds(250));
             auto idling_end  = std::chrono::high_resolution_clock::now();
             idling_time     += std::chrono::duration_cast<std::chrono::nanoseconds>(idling_end - idling_start);
         }
@@ -6027,8 +6028,8 @@ u32 ppu_recompiler_llvm::ExecutionEngine::ExecuteTillReturn(PPUThread * ppu_stat
             execution_engine->m_tracer.Trace(Tracer::TraceType::Instruction, ppu_state->PC, 0);
             u32 instruction = vm::ps3::read32(ppu_state->PC);
             execution_engine->m_decoder.Decode(instruction);
-            branch_type = ppu_state->m_is_branch ? GetBranchTypeFromInstruction(instruction) : BranchType::NonBranch;
-            ppu_state->NextPc(4);
+            branch_type = GetBranchTypeFromInstruction(instruction);
+            ppu_state->PC += 4;
 
             switch (branch_type) {
             case BranchType::Return:
@@ -6055,15 +6056,7 @@ u32 ppu_recompiler_llvm::ExecutionEngine::ExecuteTillReturn(PPUThread * ppu_stat
 }
 
 bool ppu_recompiler_llvm::ExecutionEngine::PollStatus(PPUThread * ppu_state) {
-    while (Emu.IsPaused() || ppu_state->IsPaused()) {
-        std::this_thread::sleep_for(std::chrono::milliseconds(50));
-    }
-
-    if (Emu.IsStopped() || ppu_state->IsStopped()) {
-        return true;
-    }
-
-    return false;
+    return ppu_state->CheckStatus();
 }
 
 BranchType ppu_recompiler_llvm::GetBranchTypeFromInstruction(u32 instruction) {

rpcs3/Emu/Cell/PPULLVMRecompiler.h

@@ -948,9 +948,9 @@ namespace ppu_recompiler_llvm {
         static void InitRotateMask();
     };
 
-    class RecompilationEngine : public ThreadBase {
+    class RecompilationEngine final : protected thread_t {
     public:
-        virtual ~RecompilationEngine();
+        virtual ~RecompilationEngine() override;
 
         /// Allocate an ordinal
         u32 AllocateOrdinal(u32 address, bool is_function);
@@ -970,7 +970,7 @@ namespace ppu_recompiler_llvm {
         /// Log
         llvm::raw_fd_ostream & Log();
 
-        void Task() override;
+        void Task();
 
         /// Get a pointer to the instance of this class
         static std::shared_ptr<RecompilationEngine> GetInstance();

rpcs3/Emu/Cell/PPUThread.cpp

@@ -501,6 +501,7 @@ PPUThread::~PPUThread()
 	cv.notify_one();
 	join();
 
+	CloseStack();
 	ppu_free_tls(m_id);
 }
 
@@ -578,7 +579,6 @@ void PPUThread::DoRun()
 	case 2:
 	{
 #ifdef PPU_LLVM_RECOMPILER
-		SetCallStackTracing(false);
 		m_dec.reset(new ppu_recompiler_llvm::ExecutionEngine(*this));
 #else
 		LOG_ERROR(PPU, "This image does not include PPU JIT (LLVM)");
@@ -663,6 +663,8 @@ void PPUThread::FastCall2(u32 addr, u32 rtoc)
 	{
 	}
 
+	m_state &= ~CPU_STATE_RETURN;
+
 	PC = old_PC;
 
 	if (GPR[1] != old_stack) // GPR[1] shouldn't change
@@ -677,7 +679,7 @@ void PPUThread::FastCall2(u32 addr, u32 rtoc)
 
 void PPUThread::FastStop()
 {
-	throw CPUThreadReturn{};
+	m_state |= CPU_STATE_RETURN;
 }
 
 void PPUThread::Task()
@@ -695,7 +697,7 @@ void PPUThread::Task()
 	{
 		while (true)
 		{
-			if (m_state.load() && CheckStatus()) return;
+			if (m_state.load() && CheckStatus()) break;
 
 			// decode instruction using specified decoder
 			m_dec->DecodeMemory(PC);
@@ -708,7 +710,7 @@ void PPUThread::Task()
 	{
 		while (true)
 		{
-			if (m_state.load() && CheckStatus()) return;
+			if (m_state.load() && CheckStatus()) break;
 
 			// get interpreter function
 			const auto func = g_ppu_inter_func_list[*(u32*)((u8*)g_ppu_exec_map + PC)];

rpcs3/Emu/Cell/SPUInterpreter.cpp

@@ -274,7 +274,7 @@ void spu_interpreter::BIZ(SPUThread& CPU, spu_opcode_t op)
 {
 	if (op.d || op.e)
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("Unimplemented interrupt flags (d=%d, e=%d)", op.d, op.e);
 	}
 
 	if (CPU.GPR[op.rt]._u32[3] == 0)
@@ -287,7 +287,7 @@ void spu_interpreter::BINZ(SPUThread& CPU, spu_opcode_t op)
 {
 	if (op.d || op.e)
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("Unimplemented interrupt flags (d=%d, e=%d)", op.d, op.e);
 	}
 
 	if (CPU.GPR[op.rt]._u32[3] != 0)
@@ -300,7 +300,7 @@ void spu_interpreter::BIHZ(SPUThread& CPU, spu_opcode_t op)
 {
 	if (op.d || op.e)
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("Unimplemented interrupt flags (d=%d, e=%d)", op.d, op.e);
 	}
 
 	if (CPU.GPR[op.rt]._u16[6] == 0)
@@ -313,7 +313,7 @@ void spu_interpreter::BIHNZ(SPUThread& CPU, spu_opcode_t op)
 {
 	if (op.d || op.e)
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("Unimplemented interrupt flags (d=%d, e=%d)", op.d, op.e);
 	}
 
 	if (CPU.GPR[op.rt]._u16[6] != 0)
@@ -324,7 +324,7 @@ void spu_interpreter::BIHNZ(SPUThread& CPU, spu_opcode_t op)
 
 void spu_interpreter::STOPD(SPUThread& CPU, spu_opcode_t op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("Unexpected instruction");
 }
 
 void spu_interpreter::STQX(SPUThread& CPU, spu_opcode_t op)
@@ -336,7 +336,7 @@ void spu_interpreter::BI(SPUThread& CPU, spu_opcode_t op)
 {
 	if (op.d || op.e)
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("Unimplemented interrupt flags (d=%d, e=%d)", op.d, op.e);
 	}
 
 	CPU.PC = SPUOpcodes::branchTarget(CPU.GPR[op.ra]._u32[3], 0) - 4;
@@ -346,7 +346,7 @@ void spu_interpreter::BISL(SPUThread& CPU, spu_opcode_t op)
 {
 	if (op.d || op.e)
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("Unimplemented interrupt flags (d=%d, e=%d)", op.d, op.e);
 	}
 
 	const u32 target = SPUOpcodes::branchTarget(CPU.GPR[op.ra]._u32[3], 0);
@@ -356,12 +356,12 @@ void spu_interpreter::BISL(SPUThread& CPU, spu_opcode_t op)
 
 void spu_interpreter::IRET(SPUThread& CPU, spu_opcode_t op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("Unexpected instruction");
 }
 
 void spu_interpreter::BISLED(SPUThread& CPU, spu_opcode_t op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("Unexpected instruction");
 }
 
 void spu_interpreter::HBR(SPUThread& CPU, spu_opcode_t op)
@@ -656,7 +656,7 @@ void spu_interpreter::FCGT(SPUThread& CPU, spu_opcode_t op)
 
 void spu_interpreter::DFCGT(SPUThread& CPU, spu_opcode_t op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("Unexpected instruction");
 }
 
 void spu_interpreter::FA(SPUThread& CPU, spu_opcode_t op)
@@ -692,7 +692,7 @@ void spu_interpreter::FCMGT(SPUThread& CPU, spu_opcode_t op)
 
 void spu_interpreter::DFCMGT(SPUThread& CPU, spu_opcode_t op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("Unexpected instruction");
 }
 
 void spu_interpreter::DFA(SPUThread& CPU, spu_opcode_t op)
@@ -818,7 +818,7 @@ void spu_interpreter::FSCRWR(SPUThread& CPU, spu_opcode_t op)
 
 void spu_interpreter::DFTSV(SPUThread& CPU, spu_opcode_t op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("Unexpected instruction");
 }
 
 void spu_interpreter::FCEQ(SPUThread& CPU, spu_opcode_t op)
@@ -828,7 +828,7 @@ void spu_interpreter::FCEQ(SPUThread& CPU, spu_opcode_t op)
 
 void spu_interpreter::DFCEQ(SPUThread& CPU, spu_opcode_t op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("Unexpected instruction");
 }
 
 void spu_interpreter::MPY(SPUThread& CPU, spu_opcode_t op)
@@ -865,7 +865,7 @@ void spu_interpreter::FCMEQ(SPUThread& CPU, spu_opcode_t op)
 
 void spu_interpreter::DFCMEQ(SPUThread& CPU, spu_opcode_t op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("Unexpected instruction");
 }
 
 void spu_interpreter::MPYU(SPUThread& CPU, spu_opcode_t op)
@@ -1250,5 +1250,5 @@ void spu_interpreter::FMS(SPUThread& CPU, spu_opcode_t op)
 
 void spu_interpreter::UNK(SPUThread& CPU, spu_opcode_t op)
 {
-	throw __FUNCTION__;
+	throw EXCEPTION("Unknown instruction (op=0x%08x)", op.opcode);
 }

rpcs3/Emu/Cell/SPUThread.cpp

@@ -110,14 +110,14 @@ void SPUThread::Task()
 	{
 		if (CheckStatus()) return;
 
-		m_custom_task(*this);
+		return m_custom_task(*this);
 	}
 	
 	if (m_dec)
 	{
 		while (true)
 		{
-			if (m_state.load() && CheckStatus()) return;
+			if (m_state.load() && CheckStatus()) break;
 
 			// decode instruction using specified decoder
 			m_dec->DecodeMemory(PC + offset);
@@ -130,7 +130,7 @@ void SPUThread::Task()
 	{
 		while (true)
 		{
-			if (m_state.load() && CheckStatus()) return;
+			if (m_state.load() && CheckStatus()) break;
 
 			// read opcode
 			const spu_opcode_t opcode = { vm::read32(PC + offset) };
@@ -254,6 +254,8 @@ void SPUThread::FastCall(u32 ls_addr)
 	{
 	}
 
+	m_state &= ~CPU_STATE_RETURN;
+
 	PC = old_PC;
 	GPR[0]._u32[3] = old_LR;
 	GPR[1]._u32[3] = old_stack;
@@ -291,14 +293,12 @@ void SPUThread::do_dma_transfer(u32 cmd, spu_mfc_arg_t args)
 			}
 			else
 			{
-				LOG_ERROR(SPU, "do_dma_transfer(cmd=0x%x, lsa=0x%x, ea=0x%llx, tag=0x%x, size=0x%x): invalid MMIO offset", cmd, args.lsa, args.ea, args.tag, args.size);
-				throw __FUNCTION__;
+				throw EXCEPTION("Invalid MMIO offset (cmd=0x%x, lsa=0x%x, ea=0x%llx, tag=0x%x, size=0x%x)", cmd, args.lsa, args.ea, args.tag, args.size);
 			}
 		}
 		else
 		{
-			LOG_ERROR(SPU, "do_dma_transfer(cmd=0x%x, lsa=0x%x, ea=0x%llx, tag=0x%x, size=0x%x): invalid thread type", cmd, args.lsa, args.ea, args.tag, args.size);
-			throw __FUNCTION__;
+			throw EXCEPTION("Invalid thread type (cmd=0x%x, lsa=0x%x, ea=0x%llx, tag=0x%x, size=0x%x)", cmd, args.lsa, args.ea, args.tag, args.size);
 		}
 	}
 
@@ -318,16 +318,14 @@ void SPUThread::do_dma_transfer(u32 cmd, spu_mfc_arg_t args)
 	}
 	}
 
-	LOG_ERROR(SPU, "do_dma_transfer(cmd=0x%x, lsa=0x%x, ea=0x%llx, tag=0x%x, size=0x%x): invalid cmd (%s)", cmd, args.lsa, args.ea, args.tag, args.size, get_mfc_cmd_name(cmd));
-	throw __FUNCTION__;
+	throw EXCEPTION("Invalid command %s (cmd=0x%x, lsa=0x%x, ea=0x%llx, tag=0x%x, size=0x%x)", get_mfc_cmd_name(cmd), cmd, args.lsa, args.ea, args.tag, args.size);
 }
 
 void SPUThread::do_dma_list_cmd(u32 cmd, spu_mfc_arg_t args)
 {
 	if (!(cmd & MFC_LIST_MASK))
 	{
-		LOG_ERROR(SPU, "do_dma_list_cmd(cmd=0x%x, lsa=0x%x, ea=0x%llx, tag=0x%x, size=0x%x): invalid cmd (%s)", cmd, args.lsa, args.ea, args.tag, args.size, get_mfc_cmd_name(cmd));
-		throw __FUNCTION__;
+		throw EXCEPTION("Invalid command %s (cmd=0x%x, lsa=0x%x, ea=0x%llx, tag=0x%x, size=0x%x)", get_mfc_cmd_name(cmd), cmd, args.lsa, args.ea, args.tag, args.size);
 	}
 
 	const u32 list_addr = args.ea & 0x3ffff;
@@ -476,8 +474,7 @@ void SPUThread::process_mfc_cmd(u32 cmd)
 	}
 	}
 
-	LOG_ERROR(SPU, "Unknown DMA %s: cmd=0x%x, lsa=0x%x, ea=0x%llx, tag=0x%x, size=0x%x", get_mfc_cmd_name(cmd), cmd, ch_mfc_args.lsa, ch_mfc_args.ea, ch_mfc_args.tag, ch_mfc_args.size);
-	throw __FUNCTION__;
+	throw EXCEPTION("Unknown command %s (cmd=0x%x, lsa=0x%x, ea=0x%llx, tag=0x%x, size=0x%x)", get_mfc_cmd_name(cmd), cmd, ch_mfc_args.lsa, ch_mfc_args.ea, ch_mfc_args.tag, ch_mfc_args.size);
 }
 
 u32 SPUThread::get_ch_count(u32 ch)
@@ -504,8 +501,7 @@ u32 SPUThread::get_ch_count(u32 ch)
 	case SPU_RdEventStat:     return ch_event_stat.load() & ch_event_mask ? 1 : 0; break;
 	}
 
-	LOG_ERROR(SPU, "get_ch_count(ch=%d [%s]): unknown/illegal channel", ch, ch < 128 ? spu_ch_name[ch] : "???");
-	throw __FUNCTION__;
+	throw EXCEPTION("Unknown/illegal channel (ch=%d [%s])", ch, ch < 128 ? spu_ch_name[ch] : "???");
 }
 
 u32 SPUThread::get_ch_value(u32 ch)
@@ -624,8 +620,7 @@ u32 SPUThread::get_ch_value(u32 ch)
 	}
 	}
 
-	LOG_ERROR(SPU, "get_ch_value(ch=%d [%s]): unknown/illegal channel", ch, ch < 128 ? spu_ch_name[ch] : "???");
-	throw __FUNCTION__;
+	throw EXCEPTION("Unknown/illegal channel (ch=%d [%s])", ch, ch < 128 ? spu_ch_name[ch] : "???");
 }
 
 void SPUThread::set_ch_value(u32 ch, u32 value)
@@ -664,8 +659,7 @@ void SPUThread::set_ch_value(u32 ch, u32 value)
 				u32 data;
 				if (!ch_out_mbox.pop(data))
 				{
-					LOG_ERROR(SPU, "sys_spu_thread_send_event(value=0x%x, spup=%d): Out_MBox is empty", value, spup);
-					throw __FUNCTION__;
+					throw EXCEPTION("sys_spu_thread_send_event(value=0x%x, spup=%d): Out_MBox is empty", value, spup);
 				}
 
 				if (Ini.HLELogging.GetValue())
@@ -701,8 +695,7 @@ void SPUThread::set_ch_value(u32 ch, u32 value)
 				u32 data;
 				if (!ch_out_mbox.pop(data))
 				{
-					LOG_ERROR(SPU, "sys_spu_thread_throw_event(value=0x%x, spup=%d): Out_MBox is empty", value, spup);
-					throw __FUNCTION__;
+					throw EXCEPTION("sys_spu_thread_throw_event(value=0x%x, spup=%d): Out_MBox is empty", value, spup);
 				}
 
 				if (Ini.HLELogging.GetValue())
@@ -738,14 +731,12 @@ void SPUThread::set_ch_value(u32 ch, u32 value)
 				u32 data;
 				if (!ch_out_mbox.pop(data))
 				{
-					LOG_ERROR(SPU, "sys_event_flag_set_bit(value=0x%x (flag=%d)): Out_MBox is empty", value, flag);
-					throw __FUNCTION__;
+					throw EXCEPTION("sys_event_flag_set_bit(value=0x%x (flag=%d)): Out_MBox is empty", value, flag);
 				}
 
 				if (flag > 63)
 				{
-					LOG_ERROR(SPU, "sys_event_flag_set_bit(id=%d, value=0x%x): flag > 63", data, value, flag);
-					throw __FUNCTION__;
+					throw EXCEPTION("sys_event_flag_set_bit(id=%d, value=0x%x): flag > 63", data, value, flag);
 				}
 
 				if (Ini.HLELogging.GetValue())
@@ -784,14 +775,12 @@ void SPUThread::set_ch_value(u32 ch, u32 value)
 				u32 data;
 				if (!ch_out_mbox.pop(data))
 				{
-					LOG_ERROR(SPU, "sys_event_flag_set_bit_impatient(value=0x%x (flag=%d)): Out_MBox is empty", value, flag);
-					throw __FUNCTION__;
+					throw EXCEPTION("sys_event_flag_set_bit_impatient(value=0x%x (flag=%d)): Out_MBox is empty", value, flag);
 				}
 
 				if (flag > 63)
 				{
-					LOG_ERROR(SPU, "sys_event_flag_set_bit_impatient(id=%d, value=0x%x): flag > 63", data, value, flag);
-					throw __FUNCTION__;
+					throw EXCEPTION("sys_event_flag_set_bit_impatient(id=%d, value=0x%x): flag > 63", data, value, flag);
 				}
 
 				if (Ini.HLELogging.GetValue())
@@ -826,14 +815,12 @@ void SPUThread::set_ch_value(u32 ch, u32 value)
 			{
 				if (ch_out_mbox.get_count())
 				{
-					LOG_ERROR(SPU, "SPU_WrOutIntrMbox: unknown data (value=0x%x); Out_MBox = 0x%x", value, ch_out_mbox.get_value());
+					throw EXCEPTION("SPU_WrOutIntrMbox: unknown data (value=0x%x); Out_MBox = 0x%x", value, ch_out_mbox.get_value());
 				}
 				else
 				{
-					LOG_ERROR(SPU, "SPU_WrOutIntrMbox: unknown data (value=0x%x)", value);
+					throw EXCEPTION("SPU_WrOutIntrMbox: unknown data (value=0x%x)", value);
 				}
-
-				throw __FUNCTION__;
 			}
 		}
 	}
@@ -972,8 +959,7 @@ void SPUThread::set_ch_value(u32 ch, u32 value)
 	}
 	}
 
-	LOG_ERROR(SPU, "set_ch_value(ch=%d [%s], value=0x%x): unknown/illegal channel", ch, ch < 128 ? spu_ch_name[ch] : "???", value);
-	throw __FUNCTION__;
+	throw EXCEPTION("Unknown/illegal channel (ch=%d [%s], value=0x%x)", ch, ch < 128 ? spu_ch_name[ch] : "???", value);
 }
 
 void SPUThread::stop_and_signal(u32 code)
@@ -1007,7 +993,8 @@ void SPUThread::stop_and_signal(u32 code)
 
 	case 0x002:
 	{
-		throw CPUThreadReturn{};
+		m_state |= CPU_STATE_RETURN;
+		return;
 	}
 
 	case 0x003:
@@ -1030,8 +1017,7 @@ void SPUThread::stop_and_signal(u32 code)
 		u32 spuq = 0;
 		if (!ch_out_mbox.pop(spuq))
 		{
-			LOG_ERROR(SPU, "sys_spu_thread_receive_event(): cannot read Out_MBox");
-			throw __FUNCTION__;
+			throw EXCEPTION("sys_spu_thread_receive_event(): cannot read Out_MBox");
 		}
 
 		if (ch_in_mbox.get_count())
@@ -1112,8 +1098,7 @@ void SPUThread::stop_and_signal(u32 code)
 		u32 value;
 		if (!ch_out_mbox.pop(value))
 		{
-			LOG_ERROR(SPU, "sys_spu_thread_group_exit(): cannot read Out_MBox");
-			throw __FUNCTION__;
+			throw EXCEPTION("sys_spu_thread_group_exit(): cannot read Out_MBox");
 		}
 
 		if (Ini.HLELogging.GetValue())
@@ -1127,8 +1112,7 @@ void SPUThread::stop_and_signal(u32 code)
 
 		if (!group)
 		{
-			LOG_ERROR(SPU, "sys_spu_thread_group_exit(status=0x%x): invalid group", value);
-			throw __FUNCTION__;
+			throw EXCEPTION("sys_spu_thread_group_exit(status=0x%x): invalid group", value);
 		}
 
 		for (auto t : group->threads)
@@ -1153,8 +1137,7 @@ void SPUThread::stop_and_signal(u32 code)
 
 		if (!ch_out_mbox.get_count())
 		{
-			LOG_ERROR(SPU, "sys_spu_thread_exit(): Out_MBox is empty");
-			throw __FUNCTION__;
+			throw EXCEPTION("sys_spu_thread_exit(): Out_MBox is empty");
 		}
 
 		if (Ini.HLELogging.GetValue())
@@ -1172,14 +1155,12 @@ void SPUThread::stop_and_signal(u32 code)
 
 	if (!ch_out_mbox.get_count())
 	{
-		LOG_ERROR(SPU, "Unknown STOP code: 0x%x", code);
+		throw EXCEPTION("Unknown STOP code: 0x%x", code);
 	}
 	else
 	{
-		LOG_ERROR(SPU, "Unknown STOP code: 0x%x; Out_MBox=0x%x", code, ch_out_mbox.get_value());
+		throw EXCEPTION("Unknown STOP code: 0x%x; Out_MBox=0x%x", code, ch_out_mbox.get_value());
 	}
-	
-	throw __FUNCTION__;
 }
 
 void SPUThread::halt()

rpcs3/Emu/Event.cpp

@@ -12,7 +12,7 @@ void EventManager::Init()
 
 void EventManager::Clear()
 {
-	eq_map.clear();
+	m_map.clear();
 }
 
 bool EventManager::CheckKey(u64 key)
@@ -23,29 +23,9 @@ bool EventManager::CheckKey(u64 key)
 		return false;
 	}
 
-	std::lock_guard<std::mutex> lock(m_lock);
+	std::lock_guard<std::mutex> lock(m_mutex);
 
-	return eq_map.find(key) != eq_map.end();
-}
-
-bool EventManager::RegisterKey(const std::shared_ptr<lv2_event_queue_t>& data)
-{
-	if (!data->key)
-	{
-		// always ok
-		return true;
-	}
-
-	std::lock_guard<std::mutex> lock(m_lock);
-
-	if (eq_map.find(data->key) != eq_map.end())
-	{
-		return false;
-	}
-
-	eq_map[data->key] = data;
-
-	return true;
+	return m_map.find(key) != m_map.end();
 }
 
 bool EventManager::UnregisterKey(u64 key)
@@ -56,12 +36,12 @@ bool EventManager::UnregisterKey(u64 key)
 		return true;
 	}
 
-	std::lock_guard<std::mutex> lock(m_lock);
+	std::lock_guard<std::mutex> lock(m_mutex);
 
-	auto f = eq_map.find(key);
-	if (f != eq_map.end())
+	auto f = m_map.find(key);
+	if (f != m_map.end())
 	{
-		eq_map.erase(f);
+		m_map.erase(f);
 		return true;
 	}
 
@@ -76,10 +56,10 @@ std::shared_ptr<lv2_event_queue_t> EventManager::GetEventQueue(u64 key)
 		return nullptr;
 	}
 
-	std::lock_guard<std::mutex> lock(m_lock);
+	std::lock_guard<std::mutex> lock(m_mutex);
 
-	auto f = eq_map.find(key);
-	if (f != eq_map.end())
+	auto f = m_map.find(key);
+	if (f != m_map.end())
 	{
 		return f->second;
 	}

rpcs3/Emu/Event.h

@@ -1,24 +1,37 @@
 #pragma once
 
+#include "Emu/IdManager.h"
+
 struct lv2_event_queue_t;
 
 class EventManager
 {
-	std::mutex m_lock;
-	std::unordered_map<u64, std::shared_ptr<lv2_event_queue_t>> eq_map;
+	std::mutex m_mutex;
+	std::unordered_map<u64, std::shared_ptr<lv2_event_queue_t>> m_map;
 
 public:
 	void Init();
 	void Clear();
 	bool CheckKey(u64 key);
-	bool RegisterKey(const std::shared_ptr<lv2_event_queue_t>& data);
 	bool UnregisterKey(u64 key);
 
-	template<typename... Args> std::shared_ptr<lv2_event_queue_t> MakeEventQueue(Args&&... args)
+	template<typename... Args, typename = std::enable_if_t<std::is_constructible<lv2_event_queue_t, Args...>::value>> std::shared_ptr<lv2_event_queue_t> MakeEventQueue(u64 key, Args&&... args)
 	{
-		const auto queue = std::make_shared<lv2_event_queue_t>(args...);
+		std::lock_guard<std::mutex> lock(m_mutex);
 
-		return RegisterKey(queue) ? queue : nullptr;
+		if (key && m_map.find(key) != m_map.end())
+		{
+			return nullptr;
+		}
+
+		auto queue = Emu.GetIdManager().make_ptr<lv2_event_queue_t>(std::forward<Args>(args)...);
+
+		if (key)
+		{
+			m_map[key] = queue;
+		}
+
+		return queue;
 	}
 
 	std::shared_ptr<lv2_event_queue_t> GetEventQueue(u64 key);

rpcs3/Emu/IdManager.h

@@ -92,15 +92,15 @@ public:
 		m_cur_id = 1; // first ID
 	}
 	
-	// add new ID using existing std::shared_ptr (not recommended, use make() instead)
-	template<typename T> u32 add(std::shared_ptr<T> data, u32 type = ID_type<T>::type)
-	{
-		std::lock_guard<std::mutex> lock(m_mutex);
+	//// add new ID using existing std::shared_ptr (not recommended, use make() instead)
+	//template<typename T> u32 add(std::shared_ptr<T> data, u32 type = ID_type<T>::type)
+	//{
+	//	std::lock_guard<std::mutex> lock(m_mutex);
 
-		m_id_map.emplace(m_cur_id, ID_data_t(std::move(data), type));
+	//	m_id_map.emplace(m_cur_id, ID_data_t(std::move(data), type));
 
-		return m_cur_id++;
-	}
+	//	return m_cur_id++;
+	//}
 
 	// add new ID of specified type with specified constructor arguments (returns object)
 	template<typename T, typename... Args, typename = std::enable_if_t<std::is_constructible<T, Args...>::value>> std::shared_ptr<T> make_ptr(Args&&... args)

rpcs3/Emu/Memory/Memory.cpp

@@ -4,8 +4,6 @@
 
 MemoryBase Memory;
 
-std::mutex g_memory_mutex;
-
 void MemoryBase::Init(MemoryType type)
 {
 	if (m_inited) return;
@@ -70,7 +68,7 @@ bool MemoryBase::Map(const u32 addr, const u32 size)
 {
 	assert(size && (size | addr) % 4096 == 0);
 
-	std::lock_guard<std::mutex> lock(g_memory_mutex);
+	std::lock_guard<std::mutex> lock(Memory.mutex);
 
 	for (u32 i = addr / 4096; i < addr / 4096 + size / 4096; i++)
 	{
@@ -88,7 +86,7 @@ bool MemoryBase::Map(const u32 addr, const u32 size)
 
 bool MemoryBase::Unmap(const u32 addr)
 {
-	std::lock_guard<std::mutex> lock(g_memory_mutex);
+	std::lock_guard<std::mutex> lock(Memory.mutex);
 
 	for (u32 i = 0; i < MemoryBlocks.size(); i++)
 	{
@@ -175,7 +173,7 @@ DynamicMemoryBlockBase::DynamicMemoryBlockBase()
 
 const u32 DynamicMemoryBlockBase::GetUsedSize() const
 {
-	std::lock_guard<std::mutex> lock(g_memory_mutex);
+	std::lock_guard<std::mutex> lock(Memory.mutex);
 
 	u32 size = 0;
 
@@ -194,7 +192,7 @@ bool DynamicMemoryBlockBase::IsInMyRange(const u32 addr, const u32 size)
 
 MemoryBlock* DynamicMemoryBlockBase::SetRange(const u32 start, const u32 size)
 {
-	std::lock_guard<std::mutex> lock(g_memory_mutex);
+	std::lock_guard<std::mutex> lock(Memory.mutex);
 
 	m_max_size = PAGE_4K(size);
 	if (!MemoryBlock::SetRange(start, 0))
@@ -208,7 +206,7 @@ MemoryBlock* DynamicMemoryBlockBase::SetRange(const u32 start, const u32 size)
 
 void DynamicMemoryBlockBase::Delete()
 {
-	std::lock_guard<std::mutex> lock(g_memory_mutex);
+	std::lock_guard<std::mutex> lock(Memory.mutex);
 
 	m_allocated.clear();
 	m_max_size = 0;
@@ -230,7 +228,7 @@ bool DynamicMemoryBlockBase::AllocFixed(u32 addr, u32 size)
 		return false;
 	}
 
-	std::lock_guard<std::mutex> lock(g_memory_mutex);
+	std::lock_guard<std::mutex> lock(Memory.mutex);
 
 	for (u32 i = 0; i<m_allocated.size(); ++i)
 	{
@@ -271,7 +269,7 @@ u32 DynamicMemoryBlockBase::AllocAlign(u32 size, u32 align)
 		exsize = size + align - 1;
 	}
 
-	std::lock_guard<std::mutex> lock(g_memory_mutex);
+	std::lock_guard<std::mutex> lock(Memory.mutex);
 
 	for (u32 addr = MemoryBlock::GetStartAddr(); addr <= MemoryBlock::GetEndAddr() - exsize;)
 	{
@@ -312,7 +310,7 @@ bool DynamicMemoryBlockBase::Alloc()
 
 bool DynamicMemoryBlockBase::Free(u32 addr)
 {
-	std::lock_guard<std::mutex> lock(g_memory_mutex);
+	std::lock_guard<std::mutex> lock(Memory.mutex);
 
 	for (u32 num = 0; num < m_allocated.size(); num++)
 	{

rpcs3/Emu/Memory/Memory.h

@@ -14,6 +14,8 @@ class MemoryBase
 	std::vector<MemoryBlock*> MemoryBlocks;
 
 public:
+	std::mutex mutex;
+
 	MemoryBlock* UserMemory;
 
 	DynamicMemoryBlock MainMem;

rpcs3/Emu/Memory/vm.cpp

@@ -102,7 +102,7 @@ namespace vm
 
 				if (old == owner)
 				{
-					throw __FUNCTION__;
+					throw EXCEPTION("Deadlock");
 				}
 
 				old = nullptr;
@@ -117,7 +117,7 @@ namespace vm
 
 			if (!m_owner.compare_and_swap_test(owner, nullptr))
 			{
-				throw __FUNCTION__;
+				throw EXCEPTION("Lost lock");
 			}
 
 			if (do_notify)

rpcs3/Emu/RSX/GL/GLGSRender.cpp

@@ -819,8 +819,11 @@ extern CellGcmContextData current_context;
 
 void GLGSRender::Close()
 {
-	cv.notify_one();
-	join();
+	if (joinable())
+	{
+		cv.notify_one();
+		join();
+	}
 
 	if (m_frame->IsShown())
 	{

rpcs3/Emu/SysCalls/Callback.cpp

@@ -125,6 +125,9 @@ void CallbackManager::Clear()
 
 	m_cb_list.clear();
 	m_async_list.clear();
+	m_pause_cb_list.clear();
+
+	m_cb_thread.reset();
 }
 
 u64 CallbackManager::AddPauseCallback(std::function<PauseResumeCB> func)

rpcs3/Emu/SysCalls/Modules/cellAudio.cpp

@@ -769,12 +769,10 @@ s32 cellAudioCreateNotifyEventQueue(vm::ptr<u32> id, vm::ptr<u64> key)
 	{
 		const u64 key_value = 0x80004d494f323221ull + k;
 
-		auto queue = std::make_shared<lv2_event_queue_t>(SYS_SYNC_FIFO, SYS_PPU_QUEUE, 0, key_value, 32);
-
 		// register key if not used yet
-		if (Emu.GetEventManager().RegisterKey(queue))
+		if (const auto queue = Emu.GetEventManager().MakeEventQueue(key_value, SYS_SYNC_FIFO, SYS_PPU_QUEUE, 0, key_value, 32))
 		{
-			*id = Emu.GetIdManager().add(std::move(queue));
+			*id = queue->id;
 			*key = key_value;
 
 			return CELL_OK;

rpcs3/Emu/SysCalls/Modules/cellDmux.cpp

@@ -84,6 +84,7 @@ PesHeader::PesHeader(DemuxerStream& stream)
 
 ElementaryStream::ElementaryStream(Demuxer* dmux, u32 addr, u32 size, u32 fidMajor, u32 fidMinor, u32 sup1, u32 sup2, vm::ptr<CellDmuxCbEsMsg> cbFunc, u32 cbArg, u32 spec)
 	: dmux(dmux)
+	, id(Emu.GetIdManager().get_current_id())
 	, memAddr(align(addr, 128))
 	, memSize(size - (addr - memAddr))
 	, fidMajor(fidMajor)
@@ -995,19 +996,17 @@ s32 cellDmuxEnableEs(u32 handle, vm::cptr<CellCodecEsFilterId> esFilterId, vm::c
 
 	// TODO: check esFilterId, esResourceInfo, esCb and esSpecificInfo correctly
 
-	auto es = std::make_shared<ElementaryStream>(dmux.get(), esResourceInfo->memAddr, esResourceInfo->memSize,
+	const auto es = Emu.GetIdManager().make_ptr<ElementaryStream>(dmux.get(), esResourceInfo->memAddr, esResourceInfo->memSize,
 		esFilterId->filterIdMajor, esFilterId->filterIdMinor, esFilterId->supplementalInfo1, esFilterId->supplementalInfo2,
 		esCb->cbEsMsgFunc, esCb->cbArg, esSpecificInfo);
 
-	u32 id = Emu.GetIdManager().add(es);
-	es->id = id;
-	*esHandle = id;
+	*esHandle = es->id;
 
-	cellDmux.Warning("*** New ES(dmux=0x%x, addr=0x%x, size=0x%x, filter={0x%x, 0x%x, 0x%x, 0x%x}, cb=0x%x, arg=0x%x, spec=0x%x): id = %d",
-		handle, es->memAddr, es->memSize, es->fidMajor, es->fidMinor, es->sup1, es->sup2, es->cbFunc, es->cbArg, es->spec, id);
+	cellDmux.Warning("*** New ES(dmux=0x%x, addr=0x%x, size=0x%x, filter={0x%x, 0x%x, 0x%x, 0x%x}, cb=0x%x, arg=0x%x, spec=0x%x): id = 0x%x",
+		handle, es->memAddr, es->memSize, es->fidMajor, es->fidMinor, es->sup1, es->sup2, es->cbFunc, es->cbArg, es->spec, es->id);
 
 	DemuxerTask task(dmuxEnableEs);
-	task.es.es = id;
+	task.es.es = es->id;
 	task.es.es_ptr = es.get();
 
 	dmux->job.push(task, &dmux->is_closed);

rpcs3/Emu/SysCalls/Modules/cellDmux.h

@@ -440,7 +440,7 @@ public:
 	ElementaryStream(Demuxer* dmux, u32 addr, u32 size, u32 fidMajor, u32 fidMinor, u32 sup1, u32 sup2, vm::ptr<CellDmuxCbEsMsg> cbFunc, u32 cbArg, u32 spec);
 
 	Demuxer* dmux;
-	u32 id;
+	const u32 id;
 	const u32 memAddr;
 	const u32 memSize;
 	const u32 fidMajor;

rpcs3/Emu/SysCalls/Modules/cellFs.cpp

@@ -223,7 +223,7 @@ s32 cellFsGetDirectoryEntries(u32 fd, vm::ptr<CellFsDirectoryEntry> entries, u32
 
 	for (; count < entries_size; count++)
 	{
-		if (const auto info = directory->Read())
+		if (const auto info = directory->dir->Read())
 		{
 			entries[count].attribute.mode = info->flags & DirEntry_TypeDir ? CELL_FS_S_IFDIR | 0777 : CELL_FS_S_IFREG | 0666;
 			entries[count].attribute.uid = 1; // ???

rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp

@@ -46,14 +46,14 @@ s32 cellGifDecOpen(
 {
 	cellGifDec.Warning("cellGifDecOpen(mainHandle=0x%x, subHandle=*0x%x, src=*0x%x, openInfo=*0x%x)", mainHandle, subHandle, src, openInfo);
 
-	auto current_subHandle = std::make_shared<GifStream>();
-	current_subHandle->fd = 0;
-	current_subHandle->src = *src;
+	GifStream current_subHandle;
+	current_subHandle.fd = 0;
+	current_subHandle.src = *src;
 
 	switch (src->srcSelect.value())
 	{
 	case CELL_GIFDEC_BUFFER:
-		current_subHandle->fileSize = src->streamSize;
+		current_subHandle.fileSize = src->streamSize;
 		break;
 
 	case CELL_GIFDEC_FILE:
@@ -62,14 +62,14 @@ s32 cellGifDecOpen(
 		std::shared_ptr<vfsStream> file_s(Emu.GetVFS().OpenFile(src->fileName.get_ptr(), vfsRead));
 		if (!file_s) return CELL_GIFDEC_ERROR_OPEN_FILE;
 
-		current_subHandle->fd = Emu.GetIdManager().make<lv2_file_t>(file_s, 0, 0);
-		current_subHandle->fileSize = file_s->GetSize();
+		current_subHandle.fd = Emu.GetIdManager().make<lv2_file_t>(file_s, 0, 0);
+		current_subHandle.fileSize = file_s->GetSize();
 		break;
 	}
 	}
 
 	// From now, every u32 subHandle argument is a pointer to a CellGifDecSubHandle struct.
-	*subHandle = Emu.GetIdManager().add(std::move(current_subHandle));
+	*subHandle = Emu.GetIdManager().make<GifStream>(current_subHandle);
 
 	return CELL_OK;
 }

rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp

@@ -39,15 +39,15 @@ s32 cellJpgDecOpen(u32 mainHandle, vm::ptr<u32> subHandle, vm::ptr<CellJpgDecSrc
 {
 	cellJpgDec.Warning("cellJpgDecOpen(mainHandle=0x%x, subHandle=*0x%x, src=*0x%x, openInfo=*0x%x)", mainHandle, subHandle, src, openInfo);
 
-	auto current_subHandle = std::make_shared<CellJpgDecSubHandle>();
+	CellJpgDecSubHandle current_subHandle;
 
-	current_subHandle->fd = 0;
-	current_subHandle->src = *src;
+	current_subHandle.fd = 0;
+	current_subHandle.src = *src;
 
 	switch(src->srcSelect.value())
 	{
 	case CELL_JPGDEC_BUFFER:
-		current_subHandle->fileSize = src->streamSize;
+		current_subHandle.fileSize = src->streamSize;
 		break;
 
 	case CELL_JPGDEC_FILE:
@@ -56,14 +56,14 @@ s32 cellJpgDecOpen(u32 mainHandle, vm::ptr<u32> subHandle, vm::ptr<CellJpgDecSrc
 		std::shared_ptr<vfsStream> file_s(Emu.GetVFS().OpenFile(src->fileName.get_ptr(), vfsRead));
 		if (!file_s) return CELL_JPGDEC_ERROR_OPEN_FILE;
 
-		current_subHandle->fd = Emu.GetIdManager().make<lv2_file_t>(file_s, 0, 0);
-		current_subHandle->fileSize = file_s->GetSize();
+		current_subHandle.fd = Emu.GetIdManager().make<lv2_file_t>(file_s, 0, 0);
+		current_subHandle.fileSize = file_s->GetSize();
 		break;
 	}
 	}
 
 	// From now, every u32 subHandle argument is a pointer to a CellJpgDecSubHandle struct.
-	*subHandle = Emu.GetIdManager().add(std::move(current_subHandle));
+	*subHandle = Emu.GetIdManager().make<CellJpgDecSubHandle>(current_subHandle);
 
 	return CELL_OK;
 }

rpcs3/Emu/SysCalls/Modules/cellSaveData.cpp

@@ -329,7 +329,7 @@ never_inline s32 savedata_op(
 			}
 			else
 			{
-				throw __FUNCTION__;
+				throw EXCEPTION("Invalid savedata selected");
 			}
 		}
 	}

rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp

@@ -272,9 +272,9 @@ u32 spursGetSdkVersion()
 {
 	s32 version;
 
-	if (process_get_sdk_version(process_getpid(), version) != CELL_OK)
+	if (s32 rc = process_get_sdk_version(process_getpid(), version))
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("process_get_sdk_version() failed (0x%x)", rc);
 	}
 
 	return version == -1 ? 0x465000 : version;
@@ -426,7 +426,7 @@ void spursHandlerWaitReady(PPUThread& CPU, vm::ptr<CellSpurs> spurs)
 {
 	if (s32 rc = sys_lwmutex_lock(CPU, spurs.of(&CellSpurs::mutex), 0))
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("sys_lwmutex_lock() failed (0x%x)", rc);
 	}
 
 	while (true)
@@ -440,7 +440,7 @@ void spursHandlerWaitReady(PPUThread& CPU, vm::ptr<CellSpurs> spurs)
 		{
 			if (s32 rc = sys_lwmutex_unlock(CPU, spurs.of(&CellSpurs::mutex)))
 			{
-				throw __FUNCTION__;
+				throw EXCEPTION("sys_lwmutex_unlock() failed (0x%x)", rc);
 			}
 
 			spursPpuThreadExit(CPU, 0);
@@ -500,7 +500,7 @@ void spursHandlerWaitReady(PPUThread& CPU, vm::ptr<CellSpurs> spurs)
 		{
 			if (s32 rc = sys_lwcond_wait(CPU, spurs.of(&CellSpurs::cond), 0))
 			{
-				throw __FUNCTION__;
+				throw EXCEPTION("sys_lwcond_wait() failed (0x%x)", rc);
 			}
 		}
 
@@ -510,7 +510,7 @@ void spursHandlerWaitReady(PPUThread& CPU, vm::ptr<CellSpurs> spurs)
 	// If we reach here then a runnable workload was found
 	if (s32 rc = sys_lwmutex_unlock(CPU, spurs.of(&CellSpurs::mutex)))
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("sys_lwmutex_unlock() failed (0x%x)", rc);
 	}
 }
 
@@ -535,7 +535,7 @@ void spursHandlerEntry(PPUThread& CPU)
 
 			if (s32 rc = sys_spu_thread_group_start(spurs->spuTG))
 			{
-				throw __FUNCTION__;
+				throw EXCEPTION("sys_spu_thread_group_start() failed (0x%x)", rc);
 			}
 
 			if (s32 rc = sys_spu_thread_group_join(spurs->spuTG, vm::null, vm::null))
@@ -545,7 +545,7 @@ void spursHandlerEntry(PPUThread& CPU)
 					spursPpuThreadExit(CPU, 0);
 				}
 
-				throw __FUNCTION__;
+				throw EXCEPTION("sys_spu_thread_group_join() failed (0x%x)", rc);
 			}
 
 			if (Emu.IsStopped())
@@ -658,7 +658,7 @@ void spursEventHelperEntry(PPUThread& CPU)
 	{
 		if (s32 rc = sys_event_queue_receive(CPU, spurs->eventQueue, vm::null, 0 /*timeout*/))
 		{
-			throw __FUNCTION__;
+			throw EXCEPTION("sys_event_queue_receive() failed (0x%x)", rc);
 		}
 
 		const u64 event_src   = CPU.GPR[4];
@@ -709,7 +709,7 @@ void spursEventHelperEntry(PPUThread& CPU)
 					{
 						if (s32 rc = spursWakeUpShutdownCompletionWaiter(CPU, spurs, wid))
 						{
-							throw __FUNCTION__;
+							throw EXCEPTION("spursWakeUpShutdownCompletionWaiter() failed (0x%x)", rc);
 						}
 					}
 
@@ -717,7 +717,7 @@ void spursEventHelperEntry(PPUThread& CPU)
 					{
 						if (s32 rc = spursWakeUpShutdownCompletionWaiter(CPU, spurs, wid + 0x10))
 						{
-							throw __FUNCTION__;
+							throw EXCEPTION("spursWakeUpShutdownCompletionWaiter() failed (0x%x)", rc);
 						}
 					}
 				}
@@ -726,19 +726,19 @@ void spursEventHelperEntry(PPUThread& CPU)
 			{
 				if (s32 rc = sys_semaphore_post((u32)spurs->semPrv, 1))
 				{
-					throw __FUNCTION__;
+					throw EXCEPTION("sys_semaphore_post() failed (0x%x)", rc);
 				}
 			}
 			else if (data0 == 3)
 			{
 				if (s32 rc = spursInvokeEventHandlers(CPU, spurs.of(&CellSpurs::eventPortMux)))
 				{
-					throw __FUNCTION__;
+					throw EXCEPTION("spursInvokeEventHandlers() failed (0x%x)", rc);
 				}
 			}
 			else
 			{
-				throw __FUNCTION__;
+				throw EXCEPTION("Unexpected value (data0=0x%x)", data0);
 			}
 		}
 	}
@@ -826,14 +826,14 @@ s32 spursFinalizeSpu(vm::ptr<CellSpurs> spurs)
 		{
 			if (s32 rc = sys_spu_thread_group_join(spurs->spuTG, vm::null, vm::null))
 			{
-				throw __FUNCTION__;
+				throw EXCEPTION("sys_spu_thread_group_join() failed (0x%x)", rc);
 			}
 
 			if (s32 rc = sys_spu_thread_group_destroy(spurs->spuTG))
 			{
 				if (rc != CELL_EBUSY)
 				{
-					throw __FUNCTION__;
+					throw EXCEPTION("sys_spu_thread_group_destroy() failed (0x%x)", rc);
 				}
 
 				continue;
@@ -852,7 +852,7 @@ s32 spursFinalizeSpu(vm::ptr<CellSpurs> spurs)
 
 	if (s32 rc = sys_spu_image_close(spurs.of(&CellSpurs::spuImg)))
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("sys_spu_image_close() failed (0x%x)", rc);
 	}
 
 	return CELL_OK;
@@ -880,22 +880,22 @@ s32 spursStopEventHelper(PPUThread& CPU, vm::ptr<CellSpurs> spurs)
 
 	if (s32 rc = sys_event_port_disconnect(spurs->eventPort))
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("sys_event_port_disconnect() failed (0x%x)", rc);
 	}
 
 	if (s32 rc = sys_event_port_destroy(spurs->eventPort))
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("sys_event_port_destroy() failed (0x%x)", rc);
 	}
 
 	if (s32 rc = spursDetachLv2EventQueue(spurs, spurs->spuPort, true /*spursCreated*/))
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("spursDetachLv2EventQueue() failed (0x%x)", rc);
 	}
 
 	if (s32 rc = sys_event_queue_destroy(spurs->eventQueue, SYS_EVENT_QUEUE_DESTROY_FORCE))
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("sys_event_queue_destroy() failed (0x%x)", rc);
 	}
 
 	return CELL_OK;
@@ -906,17 +906,17 @@ s32 spursSignalToHandlerThread(PPUThread& CPU, vm::ptr<CellSpurs> spurs)
 {
 	if (s32 rc = sys_lwmutex_lock(CPU, spurs.of(&CellSpurs::mutex), 0 /* forever */))
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("sys_lwmutex_lock() failed (0x%x)", rc);
 	}
 
 	if (s32 rc = sys_lwcond_signal(CPU, spurs.of(&CellSpurs::cond)))
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("sys_lwcond_signal() failed (0x%x)", rc);
 	}
 
 	if (s32 rc = sys_lwmutex_unlock(CPU, spurs.of(&CellSpurs::mutex)))
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("sys_lwmutex_unlock() failed (0x%x)", rc);
 	}
 
 	return CELL_OK;
@@ -932,7 +932,7 @@ s32 spursJoinHandlerThread(PPUThread& CPU, vm::ptr<CellSpurs> spurs)
 
 	if (s32 rc = sys_ppu_thread_join(CPU, spurs->ppu0, vm::stackvar<be_t<u64>>(CPU)))
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("sys_ppu_thread_join() failed (0x%x)", rc);
 	}
 
 	spurs->ppu0 = 0xFFFFFFFF;
@@ -1268,7 +1268,7 @@ s32 spursInit(
 	{
 		if (s32 rc = spursAddDefaultSystemWorkload(spurs, swlPriority, swlMaxSpu, swlIsPreem))
 		{
-			throw __FUNCTION__;
+			throw EXCEPTION("spursAddDefaultSystemWorkload() failed (0x%x)", rc);
 		}
 		
 		return CELL_OK;
@@ -1895,7 +1895,7 @@ void spursTraceStatusUpdate(vm::ptr<CellSpurs> spurs)
 
 		if (s32 rc = sys_semaphore_wait((u32)spurs->semPrv, 0))
 		{
-			throw __FUNCTION__;
+			throw EXCEPTION("sys_semaphore_wait() failed (0x%x)", rc);
 		}
 	}
 }
@@ -2871,7 +2871,7 @@ s32 cellSpursEventFlagSet(PPUThread& CPU, vm::ptr<CellSpursEventFlag> eventFlag,
 		eventFlag->pendingRecvTaskEvents[ppuWaitSlot] = ppuEvents;
 		if (s32 rc = sys_event_port_send(eventFlag->eventPortId, 0, 0, 0))
 		{
-			throw __FUNCTION__;
+			throw EXCEPTION("sys_event_port_send() failed (0x%x)", rc);
 		}
 	}
 
@@ -2901,7 +2901,7 @@ s32 cellSpursEventFlagSet(PPUThread& CPU, vm::ptr<CellSpursEventFlag> eventFlag,
 
 				if (rc != CELL_OK)
 				{
-					throw __FUNCTION__;
+					throw EXCEPTION("");
 				}
 			}
 		}
@@ -3051,7 +3051,7 @@ s32 spursEventFlagWait(PPUThread& CPU, vm::ptr<CellSpursEventFlag> eventFlag, vm
 		// Block till something happens
 		if (s32 rc = sys_event_queue_receive(CPU, eventFlag->eventQueueId, vm::null, 0))
 		{
-			throw __FUNCTION__;
+			throw EXCEPTION("sys_event_queue_receive() failed (0x%x)", rc);
 		}
 
 		int i = 0;
@@ -3619,7 +3619,7 @@ s32 spursTaskStart(PPUThread& CPU, vm::ptr<CellSpursTaskset> taskset, u32 taskId
 		}
 		else
 		{
-			throw __FUNCTION__;
+			throw EXCEPTION("cellSpursWakeUp() failed (0x%x)", rc);
 		}
 	}
 

rpcs3/Emu/SysCalls/Modules/cellSpursSpu.cpp

@@ -606,7 +606,7 @@ bool spursSysServiceEntry(SPUThread & spu) {
 void spursSysServiceIdleHandler(SPUThread & spu, SpursKernelContext * ctxt) {
     bool shouldExit;
 
-	std::unique_lock<std::mutex> lock(spu.mutex, std::defer_lock);
+    std::unique_lock<std::mutex> lock(spu.mutex, std::defer_lock);
 
     while (true) {
         vm::reservation_acquire(vm::get_ptr(spu.offset + 0x100), vm::cast(ctxt->spurs.addr()), 128, [&spu](){ spu.cv.notify_one(); });
@@ -677,9 +677,9 @@ void spursSysServiceIdleHandler(SPUThread & spu, SpursKernelContext * ctxt) {
         if (spuIdling && shouldExit == false && foundReadyWorkload == false) {
             // The system service blocks by making a reservation and waiting on the lock line reservation lost event.
             if (Emu.IsStopped()) throw SpursModuleExit();
-			if (!lock) lock.lock();
-			spu.cv.wait_for(lock, std::chrono::milliseconds(1));
-			continue;
+            if (!lock) lock.lock();
+            spu.cv.wait_for(lock, std::chrono::milliseconds(1));
+            continue;
         }
 
         if (vm::reservation_update(vm::cast(ctxt->spurs.addr()), vm::get_ptr(spu.offset + 0x100), 128) && (shouldExit || foundReadyWorkload)) {
@@ -1131,7 +1131,7 @@ bool spursTasksetSyscallEntry(SPUThread & spu) {
         spu.GPR[3]._u32[3] = spursTasksetProcessSyscall(spu, spu.GPR[3]._u32[3], spu.GPR[4]._u32[3]);
 
         // Resume the previously executing task if the syscall did not cause a context switch
-		throw __FUNCTION__;
+        throw EXCEPTION("Broken (TODO)");
         //if (spu.m_is_branch == false) {
         //    spursTasksetResumeTask(spu);
         //}

rpcs3/Emu/SysCalls/Modules/cellSync.cpp

@@ -905,7 +905,7 @@ s32 _cellSyncLFQueueGetPushPointer(PPUThread& CPU, vm::ptr<CellSyncLFQueue> queu
 
 		if (s32 res = sys_event_queue_receive(CPU, queue->m_eq_id, vm::null, 0))
 		{
-			throw __FUNCTION__;
+			throw EXCEPTION("");
 		}
 		var1 = 1;
 	}
@@ -916,7 +916,7 @@ s32 _cellSyncLFQueueGetPushPointer2(PPUThread& CPU, vm::ptr<CellSyncLFQueue> que
 	// arguments copied from _cellSyncLFQueueGetPushPointer
 	cellSync.Todo("_cellSyncLFQueueGetPushPointer2(queue=*0x%x, pointer=*0x%x, isBlocking=%d, useEventQueue=%d)", queue, pointer, isBlocking, useEventQueue);
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _cellSyncLFQueueCompletePushPointer(PPUThread& CPU, vm::ptr<CellSyncLFQueue> queue, s32 pointer, vm::ptr<s32(u32 addr, u32 arg)> fpSendSignal)
@@ -1060,7 +1060,7 @@ s32 _cellSyncLFQueueCompletePushPointer2(PPUThread& CPU, vm::ptr<CellSyncLFQueue
 	// arguments copied from _cellSyncLFQueueCompletePushPointer
 	cellSync.Todo("_cellSyncLFQueueCompletePushPointer2(queue=*0x%x, pointer=%d, fpSendSignal=*0x%x)", queue, pointer, fpSendSignal);
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _cellSyncLFQueuePushBody(PPUThread& CPU, vm::ptr<CellSyncLFQueue> queue, vm::cptr<void> buffer, u32 isBlocking)
@@ -1218,7 +1218,7 @@ s32 _cellSyncLFQueueGetPopPointer(PPUThread& CPU, vm::ptr<CellSyncLFQueue> queue
 
 		if (s32 res = sys_event_queue_receive(CPU, queue->m_eq_id, vm::null, 0))
 		{
-			throw __FUNCTION__;
+			throw EXCEPTION("");
 		}
 		var1 = 1;
 	}
@@ -1229,7 +1229,7 @@ s32 _cellSyncLFQueueGetPopPointer2(PPUThread& CPU, vm::ptr<CellSyncLFQueue> queu
 	// arguments copied from _cellSyncLFQueueGetPopPointer
 	cellSync.Todo("_cellSyncLFQueueGetPopPointer2(queue=*0x%x, pointer=*0x%x, isBlocking=%d, useEventQueue=%d)", queue, pointer, isBlocking, useEventQueue);
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _cellSyncLFQueueCompletePopPointer(PPUThread& CPU, vm::ptr<CellSyncLFQueue> queue, s32 pointer, vm::ptr<s32(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull)
@@ -1373,7 +1373,7 @@ s32 _cellSyncLFQueueCompletePopPointer2(PPUThread& CPU, vm::ptr<CellSyncLFQueue>
 	// arguments copied from _cellSyncLFQueueCompletePopPointer
 	cellSync.Todo("_cellSyncLFQueueCompletePopPointer2(queue=*0x%x, pointer=%d, fpSendSignal=*0x%x, noQueueFull=%d)", queue, pointer, fpSendSignal, noQueueFull);
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _cellSyncLFQueuePopBody(PPUThread& CPU, vm::ptr<CellSyncLFQueue> queue, vm::ptr<void> buffer, u32 isBlocking)
@@ -1606,14 +1606,14 @@ s32 _cellSyncLFQueueAttachLv2EventQueue(vm::ptr<u32> spus, u32 num, vm::ptr<Cell
 {
 	cellSync.Todo("_cellSyncLFQueueAttachLv2EventQueue(spus=*0x%x, num=%d, queue=*0x%x)", spus, num, queue);
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 s32 _cellSyncLFQueueDetachLv2EventQueue(vm::ptr<u32> spus, u32 num, vm::ptr<CellSyncLFQueue> queue)
 {
 	cellSync.Todo("_cellSyncLFQueueDetachLv2EventQueue(spus=*0x%x, num=%d, queue=*0x%x)", spus, num, queue);
 
-	throw __FUNCTION__;
+	throw EXCEPTION("");
 }
 
 Module cellSync("cellSync", []()

rpcs3/Emu/SysCalls/Modules/cellSync.h

@@ -260,7 +260,7 @@ struct set_alignment(32) CellSyncQueue
 
 		if ((data.m_v1 & 0xffffff) > depth || (data.m_v2 & 0xffffff) > depth)
 		{
-			throw __FUNCTION__;
+			throw EXCEPTION("Invalid queue pointers");
 		}
 
 		return depth;

rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp

@@ -239,7 +239,7 @@ s32 sys_lwmutex_lock(PPUThread& CPU, vm::ptr<sys_lwmutex_t> lwmutex, u64 timeout
 	if (res == CELL_EBUSY && lwmutex->attribute & SYS_SYNC_RETRY)
 	{
 		// TODO (protocol is ignored in current implementation)
-		throw __FUNCTION__;
+		throw EXCEPTION("");
 	}
 
 	return res;
@@ -892,7 +892,7 @@ s32 sys_raw_spu_load(s32 id, vm::cptr<char> path, vm::ptr<u32> entry)
 	return CELL_OK;
 }
 
-s32 sys_raw_spu_image_load(s32 id, vm::ptr<sys_spu_image> img)
+s32 sys_raw_spu_image_load(PPUThread& CPU, s32 id, vm::ptr<sys_spu_image> img)
 {
 	sysPrxForUser.Warning("sys_raw_spu_image_load(id=%d, img=*0x%x)", id, img);
 

rpcs3/Emu/SysCalls/lv2/sys_cond.cpp

@@ -34,7 +34,7 @@ s32 sys_cond_create(vm::ptr<u32> cond_id, u32 mutex_id, vm::ptr<sys_cond_attribu
 
 	if (!++mutex->cond_count)
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("Unexpected cond_count");
 	}
 
 	*cond_id = Emu.GetIdManager().make<lv2_cond_t>(mutex, attr->name_u64);
@@ -62,7 +62,7 @@ s32 sys_cond_destroy(u32 cond_id)
 
 	if (!cond->mutex->cond_count--)
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("Unexpected cond_count");
 	}
 
 	Emu.GetIdManager().remove<lv2_cond_t>(cond_id);
@@ -197,7 +197,7 @@ s32 sys_cond_wait(PPUThread& CPU, u32 cond_id, u64 timeout)
 
 			if (!cond->waiters.erase(CPU.GetId()))
 			{
-				throw __FUNCTION__;
+				throw EXCEPTION("Unexpected");
 			}
 
 			return CELL_ETIMEDOUT;

rpcs3/Emu/SysCalls/lv2/sys_event.cpp

@@ -13,6 +13,18 @@
 
 SysCallBase sys_event("sys_event");
 
+lv2_event_queue_t::lv2_event_queue_t(u32 protocol, s32 type, u64 name, u64 key, s32 size)
+	: id(Emu.GetIdManager().get_current_id())
+	, protocol(protocol)
+	, type(type)
+	, name(name)
+	, key(key)
+	, size(size)
+	, cancelled(false)
+	, waiters(0)
+{
+}
+
 s32 sys_event_queue_create(vm::ptr<u32> equeue_id, vm::ptr<sys_event_queue_attr> attr, u64 event_queue_key, s32 size)
 {
 	sys_event.Warning("sys_event_queue_create(equeue_id=*0x%x, attr=*0x%x, event_queue_key=0x%llx, size=%d)", equeue_id, attr, event_queue_key, size);
@@ -40,14 +52,14 @@ s32 sys_event_queue_create(vm::ptr<u32> equeue_id, vm::ptr<sys_event_queue_attr>
 	default: sys_event.Error("sys_event_queue_create(): unknown type (0x%x)", type); return CELL_EINVAL;
 	}
 
-	auto queue = Emu.GetEventManager().MakeEventQueue(protocol, type, attr->name_u64, event_queue_key, size);
+	const auto queue = Emu.GetEventManager().MakeEventQueue(event_queue_key, protocol, type, attr->name_u64, event_queue_key, size);
 
 	if (!queue)
 	{
 		return CELL_EEXIST;
 	}
 
-	*equeue_id = Emu.GetIdManager().add(std::move(queue));
+	*equeue_id = queue->id;
 	
 	return CELL_OK;
 }
@@ -77,7 +89,7 @@ s32 sys_event_queue_destroy(u32 equeue_id, s32 mode)
 
 	if (queue->cancelled.exchange(true))
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("Unexpected value");
 	}
 
 	if (queue->waiters)
@@ -106,7 +118,7 @@ s32 sys_event_queue_tryreceive(u32 equeue_id, vm::ptr<sys_event_t> event_array,
 
 	if (size < 0)
 	{
-		throw __FUNCTION__;
+		throw EXCEPTION("Negative size");
 	}
 
 	if (queue->type != SYS_PPU_QUEUE)

rpcs3/Emu/SysCalls/lv2/sys_event.h

@@ -86,6 +86,7 @@ struct event_t
 
 struct lv2_event_queue_t
 {
+	const u32 id;
 	const u32 protocol;
 	const s32 type;
 	const u64 name;
@@ -99,16 +100,7 @@ struct lv2_event_queue_t
 	std::condition_variable cv;
 	std::atomic<u32> waiters;
 
-	lv2_event_queue_t(u32 protocol, s32 type, u64 name, u64 key, s32 size)
-		: protocol(protocol)
-		, type(type)
-		, name(name)
-		, key(key)
-		, size(size)
-		, cancelled(false)
-		, waiters(0)
-	{
-	}
+	lv2_event_queue_t(u32 protocol, s32 type, u64 name, u64 key, s32 size);
 
 	void push(lv2_lock_type& lv2_lock, u64 source, u64 data1, u64 data2, u64 data3)
 	{

rpcs3/Emu/SysCalls/lv2/sys_fs.cpp

@@ -114,7 +114,7 @@ s32 sys_fs_open(vm::cptr<char> path, s32 flags, vm::ptr<u32> fd, s32 mode, vm::c
 		return CELL_FS_ENOENT;
 	}
 	
-	*fd = Emu.GetIdManager().make<lv2_file_t>(file, mode, flags);
+	*fd = Emu.GetIdManager().make<lv2_file_t>(std::move(file), mode, flags);
 
 	return CELL_OK;
 }
@@ -180,15 +180,15 @@ s32 sys_fs_opendir(vm::cptr<char> path, vm::ptr<u32> fd)
 	sys_fs.Warning("sys_fs_opendir(path=*0x%x, fd=*0x%x)", path, fd);
 	sys_fs.Warning("*** path = '%s'", path.get_ptr());
 
-	std::shared_ptr<lv2_dir_t> directory(Emu.GetVFS().OpenDir(path.get_ptr()));
+	std::shared_ptr<vfsDirBase> dir(Emu.GetVFS().OpenDir(path.get_ptr()));
 
-	if (!directory || !directory->IsOpened())
+	if (!dir || !dir->IsOpened())
 	{
 		sys_fs.Error("sys_fs_opendir('%s'): failed to open directory", path.get_ptr());
 		return CELL_FS_ENOENT;
 	}
 
-	*fd = Emu.GetIdManager().add(std::move(directory));
+	*fd = Emu.GetIdManager().make<lv2_dir_t>(std::move(dir));
 
 	return CELL_OK;
 }
@@ -204,7 +204,7 @@ s32 sys_fs_readdir(u32 fd, vm::ptr<CellFsDirent> dir, vm::ptr<u64> nread)
 		return CELL_FS_EBADF;
 	}
 
-	const DirEntryInfo* info = directory->Read();
+	const DirEntryInfo* info = directory->dir->Read();
 
 	if (info)
 	{

rpcs3/Emu/SysCalls/lv2/sys_fs.h

@@ -193,8 +193,8 @@ struct lv2_file_t
 
 	atomic<fs_st_cb_rec_t> st_callback;
 
-	lv2_file_t(const std::shared_ptr<vfsStream>& file, s32 mode, s32 flags)
-		: file(file)
+	lv2_file_t(std::shared_ptr<vfsStream> file, s32 mode, s32 flags)
+		: file(std::move(file))
 		, mode(mode)
 		, flags(flags)
 		, st_status({ SSS_NOT_INITIALIZED })
@@ -207,7 +207,15 @@ REG_ID_TYPE(lv2_file_t, 0x73); // SYS_FS_FD_OBJECT
 
 class vfsDirBase;
 
-using lv2_dir_t = vfsDirBase;
+struct lv2_dir_t
+{
+	const std::shared_ptr<vfsDirBase> dir;
+
+	lv2_dir_t(std::shared_ptr<vfsDirBase> dir)
+		: dir(std::move(dir))
+	{
+	}
+};
 
 REG_ID_TYPE(lv2_dir_t, 0x73); // SYS_FS_FD_OBJECT
 

rpcs3/Emu/SysCalls/lv2/sys_interrupt.cpp

@@ -114,14 +114,8 @@ s32 sys_interrupt_thread_establish(vm::ptr<u32> ih, u32 intrtag, u32 intrthread,
 				// call interrupt handler until int status is clear
 				if (tag.stat.load())
 				{
-					try
-					{
-						CPU.GPR[3] = arg;
-						CPU.FastCall2(pc, rtoc);
-					}
-					catch (CPUThreadReturn)
-					{
-					}
+					CPU.GPR[3] = arg;
+					CPU.FastCall2(pc, rtoc);
 				}
 
 				tag.cond.wait_for(cond_lock, std::chrono::milliseconds(1));

rpcs3/Emu/SysCalls/lv2/sys_lwcond.cpp

@@ -200,7 +200,7 @@ s32 _sys_lwcond_queue_wait(PPUThread& CPU, u32 lwcond_id, u32 lwmutex_id, u64 ti
 				}
 				else
 				{
-					throw __FUNCTION__;
+					throw EXCEPTION("Unexpected values");
 				}
 			}
 

rpcs3/Emu/SysCalls/lv2/sys_mutex.cpp

@@ -206,7 +206,7 @@ s32 sys_mutex_unlock(PPUThread& CPU, u32 mutex_id)
 	{
 		if (!mutex->recursive)
 		{
-			throw __FUNCTION__;
+			throw EXCEPTION("Unexpected recursive_count");
 		}
 		
 		mutex->recursive_count--;

rpcs3/Emu/SysCalls/lv2/sys_prx.cpp

@@ -18,6 +18,11 @@ SysCallBase sys_prx("sys_prx");
 
 extern void fill_ppu_exec_map(u32 addr, u32 size);
 
+lv2_prx_t::lv2_prx_t()
+	: id(Emu.GetIdManager().get_current_id())
+{
+}
+
 s32 prx_load_module(std::string path, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt)
 {
 	sys_prx.Warning("prx_load_module(path='%s', flags=0x%llx, pOpt=*0x%x)", path.c_str(), flags, pOpt);
@@ -34,7 +39,7 @@ s32 prx_load_module(std::string path, u64 flags, vm::ptr<sys_prx_load_module_opt
 	loader::handlers::elf64::sprx_info info;
 	loader.load_sprx(info);
 
-	auto prx = std::make_shared<lv2_prx_t>();
+	auto prx = Emu.GetIdManager().make_ptr<lv2_prx_t>();
 
 	auto meta = info.modules[""];
 	prx->start.set(meta.exports[0xBC9A0086]);
@@ -130,7 +135,7 @@ s32 prx_load_module(std::string path, u64 flags, vm::ptr<sys_prx_load_module_opt
 		}
 	}
 
-	return Emu.GetIdManager().add(std::move(prx));
+	return prx->id;
 }
 
 s32 sys_prx_load_module(vm::cptr<char> path, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt)

rpcs3/Emu/SysCalls/lv2/sys_prx.h

@@ -155,15 +155,15 @@ struct sys_prx_unload_module_option_t
 // Auxiliary data types
 struct lv2_prx_t
 {
+	const u32 id;
+
 	bool is_started = false;
 
 	vm::ptr<s32(int argc, vm::ptr<void> argv)> start = vm::null;
 	vm::ptr<s32(int argc, vm::ptr<void> argv)> stop = vm::null;
 	vm::ptr<s32()> exit = vm::null;
 
-	lv2_prx_t()
-	{
-	}
+	lv2_prx_t();
 };
 
 REG_ID_TYPE(lv2_prx_t, 0x23); // SYS_PRX_OBJECT

rpcs3/Emu/SysCalls/lv2/sys_spu.cpp

@@ -463,11 +463,6 @@ s32 sys_spu_thread_group_terminate(u32 id, s32 value)
 
 	if (thread)
 	{
-		if (group)
-		{
-			throw __FUNCTION__;
-		}
-
 		group = spu.tg.lock();
 
 		for (auto& t : group->threads)
@@ -584,7 +579,10 @@ s32 sys_spu_thread_group_join(u32 id, vm::ptr<u32> cause, vm::ptr<u32> status)
 		if (cause) *cause = SYS_SPU_THREAD_GROUP_JOIN_TERMINATED;
 		break;
 	}
-	default: throw __FUNCTION__;
+	default:
+	{
+		throw EXCEPTION("Unexpected join_state");
+	}
 	}
 
 	if (status)