diff --git a/rpcs3/Emu/Cell/Modules/cellCamera.cpp b/rpcs3/Emu/Cell/Modules/cellCamera.cpp
index 6c0abcc160..6fd923ad51 100644
--- a/rpcs3/Emu/Cell/Modules/cellCamera.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellCamera.cpp
@@ -61,11 +61,6 @@ void fmt_class_string<CellCameraFormat>::format(std::string& out, u64 arg)
 	});
 }
 
-// Temporarily
-#ifndef _MSC_VER
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#endif
-
 // **************
 // * Prototypes *
 // **************
@@ -402,7 +397,7 @@ error_code check_init_and_open(s32 dev_num)
 }
 
 // This represents a recurring subfunction throughout libCamera
-error_code check_resolution(s32 dev_num)
+error_code check_resolution(s32 /*dev_num*/)
 {
 	// TODO: Some sort of connection check maybe?
 	//if (error == CELL_CAMERA_ERROR_RESOLUTION_UNKNOWN)
@@ -413,7 +408,7 @@ error_code check_resolution(s32 dev_num)
 	return CELL_OK;
 }
 
-// This represents a oftenly used sequence in libCamera (usually the beginning of a subfunction).
+// This represents an often used sequence in libCamera (usually the beginning of a subfunction).
 // There also exist common sequences for mutex lock/unlock by the way.
 error_code check_resolution_ex(s32 dev_num)
 {
diff --git a/rpcs3/Emu/Cell/Modules/cellDaisy.cpp b/rpcs3/Emu/Cell/Modules/cellDaisy.cpp
index e0d2926b91..a6e35207e2 100644
--- a/rpcs3/Emu/Cell/Modules/cellDaisy.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellDaisy.cpp
@@ -26,11 +26,6 @@ void fmt_class_string<CellDaisyError>::format(std::string& out, u64 arg)
 	});
 }
 
-// Temporarily
-#ifndef _MSC_VER
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#endif
-
 using LFQueue2 = struct CellDaisyLFQueue2;
 using Lock = struct CellDaisyLock;
 using ScatterGatherInterlock = struct CellDaisyScatterGatherInterlock;
@@ -38,134 +33,134 @@ using AtomicInterlock = volatile struct CellDaisyAtomicInterlock;
 
 error_code cellDaisyLFQueue2GetPopPointer(vm::ptr<LFQueue2> queue, vm::ptr<s32> pPointer, u32 isBlocking)
 {
-	cellDaisy.todo("cellDaisyLFQueue2GetPopPointer()");
+	cellDaisy.todo("cellDaisyLFQueue2GetPopPointer(queue=*0x%x, pPointer=*0x%x, isBlocking=%d)", queue, pPointer, isBlocking);
 	return CELL_OK;
 }
 
 error_code cellDaisyLFQueue2CompletePopPointer(vm::ptr<LFQueue2> queue, s32 pointer, vm::ptr<s32(vm::ptr<void>, u32)> fpSendSignal, u32 isQueueFull)
 {
-	cellDaisy.todo("cellDaisyLFQueue2CompletePopPointer()");
+	cellDaisy.todo("cellDaisyLFQueue2CompletePopPointer(queue=*0x%x, pointer=0x%x, fpSendSignal=*0x%x, isQueueFull=%d)", queue, pointer, fpSendSignal, isQueueFull);
 	return CELL_OK;
 }
 
 void cellDaisyLFQueue2PushOpen(vm::ptr<LFQueue2> queue)
 {
-	cellDaisy.todo("cellDaisyLFQueue2PushOpen()");
+	cellDaisy.todo("cellDaisyLFQueue2PushOpen(queue=*0x%x)", queue);
 }
 
 error_code cellDaisyLFQueue2PushClose(vm::ptr<LFQueue2> queue, vm::ptr<s32(vm::ptr<void>, u32)> fpSendSignal)
 {
-	cellDaisy.todo("cellDaisyLFQueue2PushClose()");
+	cellDaisy.todo("cellDaisyLFQueue2PushClose(queue=*0x%x, fpSendSignal=*0x%x)", queue, fpSendSignal);
 	return CELL_OK;
 }
 
 void cellDaisyLFQueue2PopOpen(vm::ptr<LFQueue2> queue)
 {
-	cellDaisy.todo("cellDaisyLFQueue2PopOpen()");
+	cellDaisy.todo("cellDaisyLFQueue2PopOpen(queue=*0x%x)", queue);
 }
 
 error_code cellDaisyLFQueue2PopClose(vm::ptr<LFQueue2> queue, vm::ptr<s32(vm::ptr<void>, u32)> fpSendSignal)
 {
-	cellDaisy.todo("cellDaisyLFQueue2PopClose()");
+	cellDaisy.todo("cellDaisyLFQueue2PopClose(queue=*0x%x, fpSendSignal=*0x%x)", queue, fpSendSignal);
 	return CELL_OK;
 }
 
 error_code cellDaisyLFQueue2HasUnfinishedConsumer(vm::ptr<LFQueue2> queue, u32 isCancelled)
 {
-	cellDaisy.todo("cellDaisyLFQueue2HasUnfinishedConsumer()");
+	cellDaisy.todo("cellDaisyLFQueue2HasUnfinishedConsumer(queue=*0x%x, isCancelled=%d)", queue, isCancelled);
 	return CELL_OK;
 }
 
 error_code cellDaisy_snprintf(vm::ptr<char> buffer, u32 count, vm::cptr<char> fmt, ppu_va_args_t fmt_args)
 {
-	cellDaisy.todo("cellDaisy_snprintf()");
+	cellDaisy.todo("cellDaisy_snprintf(buffer=*0x%x, count=%d, fmt=*0x%x, fmt_args=%d)", buffer, count, fmt, fmt_args.count);
 	return CELL_OK;
 }
 
 error_code cellDaisyLock_initialize(vm::ptr<Lock> _this, u32 depth)
 {
-	cellDaisy.todo("cellDaisyLock_initialize()");
+	cellDaisy.todo("cellDaisyLock_initialize(_this=*0x%x, depth=%d)", _this, depth);
 	return CELL_OK;
 }
 
 error_code cellDaisyLock_getNextHeadPointer(vm::ptr<Lock> _this)
 {
-	cellDaisy.todo("cellDaisyLock_getNextHeadPointer()");
+	cellDaisy.todo("cellDaisyLock_getNextHeadPointer(_this=*0x%x)", _this);
 	return CELL_OK;
 }
 
 error_code cellDaisyLock_getNextTailPointer(vm::ptr<Lock> _this)
 {
-	cellDaisy.todo("cellDaisyLock_getNextTailPointer()");
+	cellDaisy.todo("cellDaisyLock_getNextTailPointer(_this=*0x%x)", _this);
 	return CELL_OK;
 }
 
 error_code cellDaisyLock_completeConsume(vm::ptr<Lock> _this, u32 pointer)
 {
-	cellDaisy.todo("cellDaisyLock_completeConsume()");
+	cellDaisy.todo("cellDaisyLock_completeConsume(_this=*0x%x, pointer=0x%x)", _this, pointer);
 	return CELL_OK;
 }
 
 error_code cellDaisyLock_completeProduce(vm::ptr<Lock> _this, u32 pointer)
 {
-	cellDaisy.todo("cellDaisyLock_completeProduce()");
+	cellDaisy.todo("cellDaisyLock_completeProduce(_this=*0x%x, pointer=0x%x)", _this, pointer);
 	return CELL_OK;
 }
 
 error_code cellDaisyLock_pushOpen(vm::ptr<Lock> _this)
 {
-	cellDaisy.todo("cellDaisyLock_pushOpen()");
+	cellDaisy.todo("cellDaisyLock_pushOpen(_this=*0x%x)", _this);
 	return CELL_OK;
 }
 
 error_code cellDaisyLock_pushClose(vm::ptr<Lock> _this)
 {
-	cellDaisy.todo("cellDaisyLock_pushClose()");
+	cellDaisy.todo("cellDaisyLock_pushClose(_this=*0x%x)", _this);
 	return CELL_OK;
 }
 
 error_code cellDaisyLock_popOpen(vm::ptr<Lock> _this)
 {
-	cellDaisy.todo("cellDaisyLock_popOpen()");
+	cellDaisy.todo("cellDaisyLock_popOpen(_this=*0x%x)", _this);
 	return CELL_OK;
 }
 
 error_code cellDaisyLock_popClose(vm::ptr<Lock> _this)
 {
-	cellDaisy.todo("cellDaisyLock_popClose()");
+	cellDaisy.todo("cellDaisyLock_popClose(_this=*0x%x)", _this);
 	return CELL_OK;
 }
 
 void cellDaisyScatterGatherInterlock_1(vm::ptr<ScatterGatherInterlock> _this, vm::ptr<AtomicInterlock> ea, u32 size, vm::ptr<void> eaSignal, vm::ptr<s32(vm::ptr<void>, u32)> fpSendSignal)
 {
-	cellDaisy.todo("cellDaisyScatterGatherInterlock_1()");
+	cellDaisy.todo("cellDaisyScatterGatherInterlock_1(_this=*0x%x, ea=*0x%x, size=%d, eaSignal=*0x%x, fpSendSignal=*0x%x)", _this, ea, size, eaSignal, fpSendSignal);
 }
 
 void cellDaisyScatterGatherInterlock_2(vm::ptr<ScatterGatherInterlock> _this, u32 size, vm::ptr<u32> ids, u32 numSpus, u8 spup)
 {
-	cellDaisy.todo("cellDaisyScatterGatherInterlock_2()");
+	cellDaisy.todo("cellDaisyScatterGatherInterlock_2(_this=*0x%x, size=%d, ids=*0x%x, numSpus=%d, spup=%d)", _this, size, ids, numSpus, spup);
 }
 
 void cellDaisyScatterGatherInterlock_9tor(vm::ptr<ScatterGatherInterlock> _this)
 {
-	cellDaisy.todo("cellDaisyScatterGatherInterlock_9tor()");
+	cellDaisy.todo("cellDaisyScatterGatherInterlock_9tor(_this=*0x%x)", _this);
 }
 
 error_code cellDaisyScatterGatherInterlock_probe(vm::ptr<ScatterGatherInterlock> _this, u32 isBlocking)
 {
-	cellDaisy.todo("cellDaisyScatterGatherInterlock_probe()");
+	cellDaisy.todo("cellDaisyScatterGatherInterlock_probe(_this=*0x%x, isBlocking=%d)", _this, isBlocking);
 	return CELL_OK;
 }
 
 error_code cellDaisyScatterGatherInterlock_release(vm::ptr<ScatterGatherInterlock> _this)
 {
-	cellDaisy.todo("cellDaisyScatterGatherInterlock_release()");
+	cellDaisy.todo("cellDaisyScatterGatherInterlock_release(_this=*0x%x)", _this);
 	return CELL_OK;
 }
 
 void cellDaisyScatterGatherInterlock_proceedSequenceNumber(vm::ptr<ScatterGatherInterlock> _this)
 {
-	cellDaisy.todo("cellDaisyScatterGatherInterlock_proceedSequenceNumber()");
+	cellDaisy.todo("cellDaisyScatterGatherInterlock_proceedSequenceNumber(_this=*0x%x)", _this);
 }
 
 
diff --git a/rpcs3/Emu/Cell/Modules/cellGifDec.cpp b/rpcs3/Emu/Cell/Modules/cellGifDec.cpp
index 9a49e03ec3..faf8defa6d 100644
--- a/rpcs3/Emu/Cell/Modules/cellGifDec.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellGifDec.cpp
@@ -11,11 +11,6 @@
 
 LOG_CHANNEL(cellGifDec);
 
-// Temporarily
-#ifndef _MSC_VER
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#endif
-
 template <>
 void fmt_class_string<CellGifDecError>::format(std::string& out, u64 arg)
 {
diff --git a/rpcs3/Emu/Cell/Modules/cellJpgDec.cpp b/rpcs3/Emu/Cell/Modules/cellJpgDec.cpp
index be72ce4294..5123ec68cf 100644
--- a/rpcs3/Emu/Cell/Modules/cellJpgDec.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellJpgDec.cpp
@@ -11,11 +11,6 @@
 
 LOG_CHANNEL(cellJpgDec);
 
-// Temporarily
-#ifndef _MSC_VER
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#endif
-
 template <>
 void fmt_class_string<CellJpgDecError>::format(std::string& out, u64 arg)
 {
@@ -40,19 +35,19 @@ void fmt_class_string<CellJpgDecError>::format(std::string& out, u64 arg)
 
 error_code cellJpgDecCreate(u32 mainHandle, u32 threadInParam, u32 threadOutParam)
 {
-	UNIMPLEMENTED_FUNC(cellJpgDec);
+	cellJpgDec.todo("cellJpgDecCreate(mainHandle=0x%x, threadInParam=0x%x, threadOutParam=0x%x)", mainHandle, threadInParam, threadOutParam);
 	return CELL_OK;
 }
 
 error_code cellJpgDecExtCreate(u32 mainHandle, u32 threadInParam, u32 threadOutParam, u32 extThreadInParam, u32 extThreadOutParam)
 {
-	UNIMPLEMENTED_FUNC(cellJpgDec);
+	cellJpgDec.todo("cellJpgDecExtCreate(mainHandle=0x%x, threadInParam=0x%x, threadOutParam=0x%x, extThreadInParam=0x%x, extThreadOutParam=0x%x)", mainHandle, threadInParam, threadOutParam, extThreadInParam, extThreadOutParam);
 	return CELL_OK;
 }
 
 error_code cellJpgDecDestroy(u32 mainHandle)
 {
-	UNIMPLEMENTED_FUNC(cellJpgDec);
+	cellJpgDec.todo("cellJpgDecDestroy(mainHandle=0x%x)", mainHandle);
 	return CELL_OK;
 }
 
@@ -230,7 +225,7 @@ error_code cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data,
 	}
 
 	//Decode JPG file. (TODO: Is there any faster alternative? Can we do it without external libraries?)
-	int width, height, actual_components;
+	int width = 0, height = 0, actual_components = 0;
 	auto image = std::unique_ptr<unsigned char,decltype(&::free)>
 		(
 			stbi_load_from_memory(jpg.get(), ::narrow<int>(fileSize), &width, &height, &actual_components, 4),
@@ -275,7 +270,7 @@ error_code cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data,
 		{
 			//TODO: Find out if we can't do padding without an extra copy
 			const int linesize = std::min(bytesPerLine, width * nComponents);
-			const auto output = std::make_unique<char[]>(linesize);
+			std::vector<char> output(image_size);
 			for (int i = 0; i < height; i++)
 			{
 				const int dstOffset = i * bytesPerLine;
@@ -287,22 +282,22 @@ error_code cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data,
 					output[j + 2] = image.get()[srcOffset + j + 1];
 					output[j + 3] = image.get()[srcOffset + j + 2];
 				}
-				std::memcpy(&data[dstOffset], output.get(), linesize);
+				std::memcpy(&data[dstOffset], output.data(), linesize);
 			}
 		}
 		else
 		{
-			const auto img = std::make_unique<uint[]>(image_size);
-			uint* source_current = reinterpret_cast<uint*>(image.get());
-			uint* dest_current = img.get();
-			for (uint i = 0; i < image_size / nComponents; i++)
+			std::vector<u32> img(image_size);
+			const u32* source_current = reinterpret_cast<const u32*>(image.get());
+			u32* dest_current = img.data();
+			for (u32 i = 0; i < image_size / nComponents; i++)
 			{
-				uint val = *source_current;
+				const u32 val = *source_current;
 				*dest_current = (val >> 24) | (val << 8); // set alpha (A8) as leftmost byte
 				source_current++;
 				dest_current++;
 			}
-			std::memcpy(data.get_ptr(), img.get(), image_size);
+			std::memcpy(data.get_ptr(), img.data(), image_size);
 		}
 		break;
 	}
diff --git a/rpcs3/Emu/Cell/Modules/cellPngDec.cpp b/rpcs3/Emu/Cell/Modules/cellPngDec.cpp
index cfb75b611a..74c4cc6fa3 100644
--- a/rpcs3/Emu/Cell/Modules/cellPngDec.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellPngDec.cpp
@@ -19,11 +19,6 @@ typedef png_bytep iCCP_profile_type;
 typedef png_charp iCCP_profile_type;
 #endif
 
-// Temporarily
-#ifndef _MSC_VER
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#endif
-
 LOG_CHANNEL(cellPngDec);
 
 template <>
@@ -149,7 +144,7 @@ void pngDecRowCallback(png_structp png_ptr, png_bytep new_row, png_uint_32 row_n
 	png_progressive_combine_row(png_ptr, data, new_row);
 }
 
-void pngDecInfoCallback(png_structp png_ptr, png_infop info)
+void pngDecInfoCallback(png_structp png_ptr, png_infop /*info*/)
 {
 	PngStream* stream = static_cast<PngStream*>(png_get_progressive_ptr(png_ptr));
 	if (!stream)
@@ -162,7 +157,7 @@ void pngDecInfoCallback(png_structp png_ptr, png_infop info)
 	stream->buffer->cursor += (stream->buffer->length - remaining);
 }
 
-void pngDecEndCallback(png_structp png_ptr, png_infop info)
+void pngDecEndCallback(png_structp png_ptr, png_infop /*info*/)
 {
 	PngStream* stream = static_cast<PngStream*>(png_get_progressive_ptr(png_ptr));
 	if (!stream)
@@ -175,17 +170,17 @@ void pngDecEndCallback(png_structp png_ptr, png_infop info)
 }
 
 // Custom error handler for libpng
-[[noreturn]] void pngDecError(png_structp png_ptr, png_const_charp error_message)
+[[noreturn]] void pngDecError(png_structp /*png_ptr*/, png_const_charp error_message)
 {
-	cellPngDec.error("%s", error_message);
+	cellPngDec.error("pngDecError: %s", error_message);
 	// we can't return here or libpng blows up
 	fmt::throw_exception("Fatal Error in libpng: %s", error_message);
 }
 
 // Custom warning handler for libpng
-void pngDecWarning(png_structp png_ptr, png_const_charp error_message)
+void pngDecWarning(png_structp /*png_ptr*/, png_const_charp error_message)
 {
-	cellPngDec.warning("%s", error_message);
+	cellPngDec.warning("pngDecWarning: %s", error_message);
 }
 
 // Get the chunk information of the PNG file. IDAT is marked as existing, only after decoding or reading the header.
@@ -337,7 +332,7 @@ be_t<u32> pngDecGetChunkInformation(PngStream* stream, bool IDAT = false)
 	return chunk_information;
 }
 
-error_code pngDecCreate(ppu_thread& ppu, PPHandle png_handle, PThreadInParam thread_in_param, PThreadOutParam thread_out_param, PExtThreadInParam extra_thread_in_param = vm::null, PExtThreadOutParam extra_thread_out_param = vm::null)
+error_code pngDecCreate(ppu_thread& ppu, PPHandle png_handle, PThreadInParam thread_in_param, PThreadOutParam thread_out_param, PExtThreadInParam /*extra_thread_in_param*/ = vm::null, PExtThreadOutParam extra_thread_out_param = vm::null)
 {
 	// Check if partial image decoding is used
 	if (extra_thread_out_param)
@@ -908,103 +903,103 @@ error_code cellPngDecExtDecodeData(ppu_thread& ppu, PHandle handle, PStream stre
 
 error_code cellPngDecGetUnknownChunks(PHandle handle, PStream stream, vm::pptr<CellPngUnknownChunk> unknownChunk, vm::ptr<u32> unknownChunkNumber)
 {
-	cellPngDec.todo("cellPngDecGetUnknownChunks()");
+	cellPngDec.todo("cellPngDecGetUnknownChunks(handle=*0x%x, stream=*0x%x, unknownChunk=*0x%x, unknownChunkNumber=*0x%x)", handle, stream, unknownChunk, unknownChunkNumber);
 	return CELL_OK;
 }
 
 error_code cellPngDecGetpCAL(PHandle handle, PStream stream, vm::ptr<CellPngPCAL> pcal)
 {
-	cellPngDec.todo("cellPngDecGetpCAL()");
+	cellPngDec.todo("cellPngDecGetpCAL(handle=*0x%x, stream=*0x%x, pcal=*0x%x)", handle, stream, pcal);
 	return CELL_OK;
 }
 
 error_code cellPngDecGetcHRM(PHandle handle, PStream stream, vm::ptr<CellPngCHRM> chrm)
 {
-	cellPngDec.todo("cellPngDecGetcHRM()");
+	cellPngDec.todo("cellPngDecGetcHRM(handle=*0x%x, stream=*0x%x, chrm=*0x%x)", handle, stream, chrm);
 	return CELL_OK;
 }
 
 error_code cellPngDecGetsCAL(PHandle handle, PStream stream, vm::ptr<CellPngSCAL> scal)
 {
-	cellPngDec.todo("cellPngDecGetsCAL()");
+	cellPngDec.todo("cellPngDecGetsCAL(handle=*0x%x, stream=*0x%x, scal=*0x%x)", handle, stream, scal);
 	return CELL_OK;
 }
 
 error_code cellPngDecGetpHYs(PHandle handle, PStream stream, vm::ptr<CellPngPHYS> phys)
 {
-	cellPngDec.todo("cellPngDecGetpHYs()");
+	cellPngDec.todo("cellPngDecGetpHYs(handle=*0x%x, stream=*0x%x, phys=*0x%x)", handle, stream, phys);
 	return CELL_OK;
 }
 
 error_code cellPngDecGetoFFs(PHandle handle, PStream stream, vm::ptr<CellPngOFFS> offs)
 {
-	cellPngDec.todo("cellPngDecGetoFFs()");
+	cellPngDec.todo("cellPngDecGetoFFs(handle=*0x%x, stream=*0x%x, offs=*0x%x)", handle, stream, offs);
 	return CELL_OK;
 }
 
 error_code cellPngDecGetsPLT(PHandle handle, PStream stream, vm::ptr<CellPngSPLT> splt)
 {
-	cellPngDec.todo("cellPngDecGetsPLT()");
+	cellPngDec.todo("cellPngDecGetsPLT(handle=*0x%x, stream=*0x%x, splt=*0x%x)", handle, stream, splt);
 	return CELL_OK;
 }
 
 error_code cellPngDecGetbKGD(PHandle handle, PStream stream, vm::ptr<CellPngBKGD> bkgd)
 {
-	cellPngDec.todo("cellPngDecGetbKGD()");
+	cellPngDec.todo("cellPngDecGetbKGD(handle=*0x%x, stream=*0x%x, bkgd=*0x%x)", handle, stream, bkgd);
 	return CELL_OK;
 }
 
 error_code cellPngDecGettIME(PHandle handle, PStream stream, vm::ptr<CellPngTIME> time)
 {
-	cellPngDec.todo("cellPngDecGettIME()");
+	cellPngDec.todo("cellPngDecGettIME(handle=*0x%x, stream=*0x%x, time=*0x%x)", handle, stream, time);
 	return CELL_OK;
 }
 
 error_code cellPngDecGethIST(PHandle handle, PStream stream, vm::ptr<CellPngHIST> hist)
 {
-	cellPngDec.todo("cellPngDecGethIST()");
+	cellPngDec.todo("cellPngDecGethIST(handle=*0x%x, stream=*0x%x, hist=*0x%x)", handle, stream, hist);
 	return CELL_OK;
 }
 
 error_code cellPngDecGettRNS(PHandle handle, PStream stream, vm::ptr<CellPngTRNS> trns)
 {
-	cellPngDec.todo("cellPngDecGettRNS()");
+	cellPngDec.todo("cellPngDecGettRNS(handle=*0x%x, stream=*0x%x, trns=*0x%x)", handle, stream, trns);
 	return CELL_OK;
 }
 
 error_code cellPngDecGetsBIT(PHandle handle, PStream stream, vm::ptr<CellPngSBIT> sbit)
 {
-	cellPngDec.todo("cellPngDecGetsBIT()");
+	cellPngDec.todo("cellPngDecGetsBIT(handle=*0x%x, stream=*0x%x, sbit=*0x%x)", handle, stream, sbit);
 	return CELL_OK;
 }
 
 error_code cellPngDecGetiCCP(PHandle handle, PStream stream, vm::ptr<CellPngICCP> iccp)
 {
-	cellPngDec.todo("cellPngDecGetiCCP()");
+	cellPngDec.todo("cellPngDecGetiCCP(handle=*0x%x, stream=*0x%x, iccp=*0x%x)", handle, stream, iccp);
 	return CELL_OK;
 }
 
 error_code cellPngDecGetsRGB(PHandle handle, PStream stream, vm::ptr<CellPngSRGB> srgb)
 {
-	cellPngDec.todo("cellPngDecGetsRGB()");
+	cellPngDec.todo("cellPngDecGetsRGB(handle=*0x%x, stream=*0x%x, srgb=*0x%x)", handle, stream, srgb);
 	return CELL_OK;
 }
 
 error_code cellPngDecGetgAMA(PHandle handle, PStream stream, vm::ptr<CellPngGAMA> gama)
 {
-	cellPngDec.todo("cellPngDecGetgAMA()");
+	cellPngDec.todo("cellPngDecGetgAMA(handle=*0x%x, stream=*0x%x, gama=*0x%x)", handle, stream, gama);
 	return CELL_OK;
 }
 
 error_code cellPngDecGetPLTE(PHandle handle, PStream stream, vm::ptr<CellPngPLTE> plte)
 {
-	cellPngDec.todo("cellPngDecGetPLTE()");
+	cellPngDec.todo("cellPngDecGetPLTE(handle=*0x%x, stream=*0x%x, plte=*0x%x)", handle, stream, plte);
 	return CELL_OK;
 }
 
 error_code cellPngDecGetTextChunk(PHandle handle, PStream stream, vm::ptr<u32> textInfoNum, vm::pptr<CellPngTextInfo> textInfo)
 {
-	cellPngDec.todo("cellPngDecGetTextChunk()");
+	cellPngDec.todo("cellPngDecGetTextChunk(handle=*0x%x, stream=*0x%x, textInfoNum=*0x%x, textInfo=*0x%x)", handle, stream, textInfoNum, textInfo);
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/Cell/Modules/cellSaveData.cpp b/rpcs3/Emu/Cell/Modules/cellSaveData.cpp
index db57195a5c..eec2652f21 100644
--- a/rpcs3/Emu/Cell/Modules/cellSaveData.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellSaveData.cpp
@@ -2500,12 +2500,7 @@ error_code cellSaveDataListDelete(ppu_thread& ppu, PSetList setList, PSetBuf set
 	return savedata_op(ppu, SAVEDATA_OP_LIST_DELETE, 0, vm::null, 0, setList, setBuf, funcList, vm::null, vm::null, vm::null, container, 0x40, userdata, 0, funcDone);
 }
 
-// Temporarily
-#ifndef _MSC_VER
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#endif
-
-error_code cellSaveDataListImport(ppu_thread& ppu, PSetList setList, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
+error_code cellSaveDataListImport(ppu_thread& /*ppu*/, PSetList setList, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
 {
 	cellSaveData.todo("cellSaveDataListImport(setList=*0x%x, maxSizeKB=%d, funcDone=*0x%x, container=0x%x, userdata=*0x%x)", setList, maxSizeKB, funcDone, container, userdata);
 
@@ -2520,7 +2515,7 @@ error_code cellSaveDataListImport(ppu_thread& ppu, PSetList setList, u32 maxSize
 	return CELL_OK;
 }
 
-error_code cellSaveDataListExport(ppu_thread& ppu, PSetList setList, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
+error_code cellSaveDataListExport(ppu_thread& /*ppu*/, PSetList setList, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
 {
 	cellSaveData.todo("cellSaveDataListExport(setList=*0x%x, maxSizeKB=%d, funcDone=*0x%x, container=0x%x, userdata=*0x%x)", setList, maxSizeKB, funcDone, container, userdata);
 	
@@ -2535,7 +2530,7 @@ error_code cellSaveDataListExport(ppu_thread& ppu, PSetList setList, u32 maxSize
 	return CELL_OK;
 }
 
-error_code cellSaveDataFixedImport(ppu_thread& ppu, vm::cptr<char> dirName, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
+error_code cellSaveDataFixedImport(ppu_thread& /*ppu*/, vm::cptr<char> dirName, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
 {
 	cellSaveData.todo("cellSaveDataFixedImport(dirName=%s, maxSizeKB=%d, funcDone=*0x%x, container=0x%x, userdata=*0x%x)", dirName, maxSizeKB, funcDone, container, userdata);
 
@@ -2550,7 +2545,7 @@ error_code cellSaveDataFixedImport(ppu_thread& ppu, vm::cptr<char> dirName, u32
 	return CELL_OK;
 }
 
-error_code cellSaveDataFixedExport(ppu_thread& ppu, vm::cptr<char> dirName, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
+error_code cellSaveDataFixedExport(ppu_thread& /*ppu*/, vm::cptr<char> dirName, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
 {
 	cellSaveData.todo("cellSaveDataFixedExport(dirName=%s, maxSizeKB=%d, funcDone=*0x%x, container=0x%x, userdata=*0x%x)", dirName, maxSizeKB, funcDone, container, userdata);
 
@@ -2581,7 +2576,7 @@ error_code cellSaveDataUserListDelete(ppu_thread& ppu, u32 userId, PSetList setL
 	return savedata_op(ppu, SAVEDATA_OP_LIST_DELETE, 0, vm::null, 0, setList, setBuf, funcList, vm::null, vm::null, vm::null, container, 0x40, userdata, userId, funcDone);
 }
 
-error_code cellSaveDataUserListImport(ppu_thread& ppu, u32 userId, PSetList setList, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
+error_code cellSaveDataUserListImport(ppu_thread& /*ppu*/, u32 userId, PSetList setList, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
 {
 	cellSaveData.todo("cellSaveDataUserListImport(userId=%d, setList=*0x%x, maxSizeKB=%d, funcDone=*0x%x, container=0x%x, userdata=*0x%x)", userId, setList, maxSizeKB, funcDone, container, userdata);
 
@@ -2596,7 +2591,7 @@ error_code cellSaveDataUserListImport(ppu_thread& ppu, u32 userId, PSetList setL
 	return CELL_OK;
 }
 
-error_code cellSaveDataUserListExport(ppu_thread& ppu, u32 userId, PSetList setList, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
+error_code cellSaveDataUserListExport(ppu_thread& /*ppu*/, u32 userId, PSetList setList, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
 {
 	cellSaveData.todo("cellSaveDataUserListExport(userId=%d, setList=*0x%x, maxSizeKB=%d, funcDone=*0x%x, container=0x%x, userdata=*0x%x)", userId, setList, maxSizeKB, funcDone, container, userdata);
 
@@ -2611,7 +2606,7 @@ error_code cellSaveDataUserListExport(ppu_thread& ppu, u32 userId, PSetList setL
 	return CELL_OK;
 }
 
-error_code cellSaveDataUserFixedImport(ppu_thread& ppu, u32 userId, vm::cptr<char> dirName, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
+error_code cellSaveDataUserFixedImport(ppu_thread& /*ppu*/, u32 userId, vm::cptr<char> dirName, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
 {
 	cellSaveData.todo("cellSaveDataUserFixedImport(userId=%d, dirName=%s, maxSizeKB=%d, funcDone=*0x%x, container=0x%x, userdata=*0x%x)", userId, dirName, maxSizeKB, funcDone, container, userdata);
 
@@ -2626,7 +2621,7 @@ error_code cellSaveDataUserFixedImport(ppu_thread& ppu, u32 userId, vm::cptr<cha
 	return CELL_OK;
 }
 
-error_code cellSaveDataUserFixedExport(ppu_thread& ppu, u32 userId, vm::cptr<char> dirName, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
+error_code cellSaveDataUserFixedExport(ppu_thread& /*ppu*/, u32 userId, vm::cptr<char> dirName, u32 maxSizeKB, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
 {
 	cellSaveData.todo("cellSaveDataUserFixedExport(userId=%d, dirName=%s, maxSizeKB=%d, funcDone=*0x%x, container=0x%x, userdata=*0x%x)", userId, dirName, maxSizeKB, funcDone, container, userdata);
 
diff --git a/rpcs3/Emu/Cell/Modules/cellSpurs.cpp b/rpcs3/Emu/Cell/Modules/cellSpurs.cpp
index 7cdb317cc2..c09c808e92 100644
--- a/rpcs3/Emu/Cell/Modules/cellSpurs.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellSpurs.cpp
@@ -160,11 +160,6 @@ void fmt_class_string<SpursWorkloadState>::format(std::string& out, u64 arg)
 
 error_code sys_spu_image_close(ppu_thread&, vm::ptr<sys_spu_image> img);
 
-// Temporarily
-#ifndef _MSC_VER
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#endif
-
 //----------------------------------------------------------------------------
 // Function prototypes
 //----------------------------------------------------------------------------
@@ -738,7 +733,7 @@ void _spurs::handler_entry(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
 	}
 }
 
-s32 _spurs::create_handler(vm::ptr<CellSpurs> spurs, u32 ppuPriority)
+s32 _spurs::create_handler(vm::ptr<CellSpurs> /*spurs*/, u32 /*ppuPriority*/)
 {
 	struct handler_thread : ppu_thread
 	{
@@ -909,7 +904,7 @@ void _spurs::event_helper_entry(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
 	}
 }
 
-s32 _spurs::create_event_helper(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 ppuPriority)
+s32 _spurs::create_event_helper(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 /*ppuPriority*/)
 {
 	if (s32 rc = _spurs::create_lv2_eq(ppu, spurs, spurs.ptr(&CellSpurs::eventQueue), spurs.ptr(&CellSpurs::spuPort), 0x2A, sys_event_queue_attribute_t{SYS_SYNC_PRIORITY, SYS_PPU_QUEUE, {"_spuPrv\0"_u64}}))
 	{
@@ -981,7 +976,7 @@ void _spurs::init_event_port_mux(vm::ptr<CellSpurs::EventPortMux> eventPortMux,
 	eventPortMux->x08       = unknown;
 }
 
-s32 _spurs::add_default_syswkl(vm::ptr<CellSpurs> spurs, vm::cptr<u8> swlPriority, u32 swlMaxSpu, u32 swlIsPreem)
+s32 _spurs::add_default_syswkl(vm::ptr<CellSpurs> /*spurs*/, vm::cptr<u8> /*swlPriority*/, u32 /*swlMaxSpu*/, u32 /*swlIsPreem*/)
 {
 	// TODO: Implement this
 	return CELL_OK;
@@ -1859,7 +1854,7 @@ s32 cellSpursSetPriority(vm::ptr<CellSpurs> spurs, u32 wid, u32 spuId, u32 prior
 /// Set preemption victim SPU
 s32 cellSpursSetPreemptionVictimHints(vm::ptr<CellSpurs> spurs, vm::cptr<b8> isPreemptible)
 {
-	UNIMPLEMENTED_FUNC(cellSpurs);
+	cellSpurs.todo("cellSpursSetPreemptionVictimHints(spurs=*0x%x, isPreemptible=*0x%x)", spurs, isPreemptible);
 	return CELL_OK;
 }
 
@@ -2230,7 +2225,7 @@ s32 cellSpursTraceStop(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
 //----------------------------------------------------------------------------
 
 /// Initialize attributes of a workload
-s32 _cellSpursWorkloadAttributeInitialize(ppu_thread& ppu, vm::ptr<CellSpursWorkloadAttribute> attr, u32 revision, u32 sdkVersion, vm::cptr<void> pm, u32 size, u64 data, vm::cptr<u8[8]> priority, u32 minCnt, u32 maxCnt)
+s32 _cellSpursWorkloadAttributeInitialize(ppu_thread& /*ppu*/, vm::ptr<CellSpursWorkloadAttribute> attr, u32 revision, u32 sdkVersion, vm::cptr<void> pm, u32 size, u64 data, vm::cptr<u8[8]> priority, u32 minCnt, u32 maxCnt)
 {
 	cellSpurs.warning("_cellSpursWorkloadAttributeInitialize(attr=*0x%x, revision=%d, sdkVersion=0x%x, pm=*0x%x, size=0x%x, data=0x%llx, priority=*0x%x, minCnt=0x%x, maxCnt=0x%x)",
 		attr, revision, sdkVersion, pm, size, data, priority, minCnt, maxCnt);
@@ -2277,7 +2272,7 @@ s32 _cellSpursWorkloadAttributeInitialize(ppu_thread& ppu, vm::ptr<CellSpursWork
 }
 
 /// Set the name of a workload
-s32 cellSpursWorkloadAttributeSetName(ppu_thread& ppu, vm::ptr<CellSpursWorkloadAttribute> attr, vm::cptr<char> nameClass, vm::cptr<char> nameInstance)
+s32 cellSpursWorkloadAttributeSetName(ppu_thread& /*ppu*/, vm::ptr<CellSpursWorkloadAttribute> attr, vm::cptr<char> nameClass, vm::cptr<char> nameInstance)
 {
 	cellSpurs.warning("cellSpursWorkloadAttributeSetName(attr=*0x%x, nameClass=%s, nameInstance=%s)", attr, nameClass, nameInstance);
 
@@ -2771,7 +2766,7 @@ s32 cellSpursWakeUp(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
 }
 
 /// Send a workload signal
-s32 cellSpursSendWorkloadSignal(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid)
+s32 cellSpursSendWorkloadSignal(ppu_thread& /*ppu*/, vm::ptr<CellSpurs> spurs, u32 wid)
 {
 	cellSpurs.warning("cellSpursSendWorkloadSignal(spurs=*0x%x, wid=%d)", spurs, wid);
 
@@ -2833,7 +2828,7 @@ s32 cellSpursGetWorkloadFlag(vm::ptr<CellSpurs> spurs, vm::pptr<CellSpursWorkloa
 }
 
 /// Set ready count
-s32 cellSpursReadyCountStore(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, u32 value)
+s32 cellSpursReadyCountStore(ppu_thread& /*ppu*/, vm::ptr<CellSpurs> spurs, u32 wid, u32 value)
 {
 	cellSpurs.trace("cellSpursReadyCountStore(spurs=*0x%x, wid=%d, value=0x%x)", spurs, wid, value);
 
@@ -2871,7 +2866,7 @@ s32 cellSpursReadyCountStore(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid,
 }
 
 /// Swap ready count
-s32 cellSpursReadyCountSwap(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<u32> old, u32 swap)
+s32 cellSpursReadyCountSwap(ppu_thread& /*ppu*/, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<u32> old, u32 swap)
 {
 	cellSpurs.trace("cellSpursReadyCountSwap(spurs=*0x%x, wid=%d, old=*0x%x, swap=0x%x)", spurs, wid, old, swap);
 
@@ -2909,7 +2904,7 @@ s32 cellSpursReadyCountSwap(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid,
 }
 
 /// Compare and swap ready count
-s32 cellSpursReadyCountCompareAndSwap(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<u32> old, u32 compare, u32 swap)
+s32 cellSpursReadyCountCompareAndSwap(ppu_thread& /*ppu*/, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<u32> old, u32 compare, u32 swap)
 {
 	cellSpurs.trace("cellSpursReadyCountCompareAndSwap(spurs=*0x%x, wid=%d, old=*0x%x, compare=0x%x, swap=0x%x)", spurs, wid, old, compare, swap);
 
@@ -2950,7 +2945,7 @@ s32 cellSpursReadyCountCompareAndSwap(ppu_thread& ppu, vm::ptr<CellSpurs> spurs,
 }
 
 /// Increase or decrease ready count
-s32 cellSpursReadyCountAdd(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<u32> old, s32 value)
+s32 cellSpursReadyCountAdd(ppu_thread& /*ppu*/, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<u32> old, s32 value)
 {
 	cellSpurs.trace("cellSpursReadyCountAdd(spurs=*0x%x, wid=%d, old=*0x%x, value=0x%x)", spurs, wid, old, value);
 
@@ -3030,7 +3025,7 @@ s32 cellSpursGetWorkloadData(vm::ptr<CellSpurs> spurs, vm::ptr<u64> data, u32 wi
 }
 
 /// Get workload information
-s32 cellSpursGetWorkloadInfo(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<CellSpursWorkloadInfo> info)
+s32 cellSpursGetWorkloadInfo(ppu_thread& /*ppu*/, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<CellSpursWorkloadInfo> info)
 {
 	cellSpurs.todo("cellSpursGetWorkloadInfo(spurs=*0x%x, wid=0x%x, info=*0x%x)", spurs, wid, info);
 	return CELL_OK;
@@ -3135,7 +3130,7 @@ s32 _cellSpursWorkloadFlagReceiver(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u3
 }
 
 /// Set/unset the recipient of the workload flag
-s32 _cellSpursWorkloadFlagReceiver2(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, u32 is_set, u32 print_debug_output)
+s32 _cellSpursWorkloadFlagReceiver2(ppu_thread& /*ppu*/, vm::ptr<CellSpurs> spurs, u32 wid, u32 is_set, u32 print_debug_output)
 {
 	cellSpurs.warning("_cellSpursWorkloadFlagReceiver2(spurs=*0x%x, wid=%d, is_set=%d, print_debug_output=%d)", spurs, wid, is_set, print_debug_output);
 
@@ -3833,19 +3828,19 @@ s32 _cellSpursLFQueueInitialize(vm::ptr<void> pTasksetOrSpurs, vm::ptr<CellSpurs
 
 s32 _cellSpursLFQueuePushBody()
 {
-	UNIMPLEMENTED_FUNC(cellSpurs);
+	cellSpurs.todo("_cellSpursLFQueuePushBody()");
 	return CELL_OK;
 }
 
 s32 cellSpursLFQueueAttachLv2EventQueue(vm::ptr<CellSyncLFQueue> queue)
 {
-	UNIMPLEMENTED_FUNC(cellSpurs);
+	cellSpurs.todo("cellSpursLFQueueAttachLv2EventQueue(queue=*0x%x)", queue);
 	return CELL_OK;
 }
 
 s32 cellSpursLFQueueDetachLv2EventQueue(vm::ptr<CellSyncLFQueue> queue)
 {
-	UNIMPLEMENTED_FUNC(cellSpurs);
+	cellSpurs.todo("cellSpursLFQueueDetachLv2EventQueue(queue=*0x%x)", queue);
 	return CELL_OK;
 }
 
@@ -4571,7 +4566,7 @@ s32 cellSpursTasksetUnsetExceptionEventHandler(vm::ptr<CellSpursTaskset> taskset
 	return CELL_OK;
 }
 
-s32 cellSpursLookUpTasksetAddress(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::pptr<CellSpursTaskset> taskset, u32 id)
+s32 cellSpursLookUpTasksetAddress(ppu_thread& /*ppu*/, vm::ptr<CellSpurs> spurs, vm::pptr<CellSpursTaskset> taskset, u32 id)
 {
 	cellSpurs.warning("cellSpursLookUpTasksetAddress(spurs=*0x%x, taskset=**0x%x, id=0x%x)", spurs, taskset, id);
 
@@ -4653,9 +4648,9 @@ s32 _cellSpursTasksetAttributeInitialize(vm::ptr<CellSpursTasksetAttribute> attr
 	return CELL_OK;
 }
 
-s32 _spurs::check_job_chain_attribute(u32 sdkVer, vm::cptr<u64> jcEntry, u16 sizeJobDescr, u16 maxGrabbedJob
-    , u64 priorities, u32 maxContention, u8 autoSpuCount, u32 tag1, u32 tag2
-    , u8 isFixedMemAlloc, u32 maxSizeJob, u32 initSpuCount)
+s32 _spurs::check_job_chain_attribute(u32 sdkVer, vm::cptr<u64> jcEntry, u16 sizeJobDescr, u16 maxGrabbedJob,
+	u64 priorities, u32 /*maxContention*/, u8 autoSpuCount, u32 tag1, u32 tag2,
+	u8 /*isFixedMemAlloc*/, u32 maxSizeJob, u32 initSpuCount)
 {
 	if (!jcEntry)
 		return CELL_SPURS_JOB_ERROR_NULL_POINTER;
@@ -4686,9 +4681,9 @@ s32 _spurs::check_job_chain_attribute(u32 sdkVer, vm::cptr<u64> jcEntry, u16 siz
 	return CELL_OK;
 }
 
-s32 _spurs::create_job_chain(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursJobChain> jobChain, vm::cptr<u64> jobChainEntry, u16 sizeJob
-		, u16 maxGrabbedJob, vm::cptr<u8[8]> prio, u32 maxContention, b8 autoReadyCount
-		, u32 tag1, u32 tag2, u32 HaltOnError, vm::cptr<char> name, u32 param_13, u32 param_14)
+s32 _spurs::create_job_chain(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursJobChain> jobChain, vm::cptr<u64> jobChainEntry, u16 /*sizeJob*/,
+	u16 maxGrabbedJob, vm::cptr<u8[8]> prio, u32 maxContention, b8 /*autoReadyCount*/,
+	u32 tag1, u32 tag2, u32 /*HaltOnError*/, vm::cptr<char> name, u32 /*param_13*/, u32 /*param_14*/)
 {
 	const s32 sdkVer = _spurs::get_sdk_version();
 	jobChain->spurs = spurs;
diff --git a/rpcs3/Emu/Cell/Modules/cellSpursSpu.cpp b/rpcs3/Emu/Cell/Modules/cellSpursSpu.cpp
index a6cdeb6d82..4be245810f 100644
--- a/rpcs3/Emu/Cell/Modules/cellSpursSpu.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellSpursSpu.cpp
@@ -15,7 +15,6 @@ LOG_CHANNEL(cellSpurs);
 // Temporarily
 #ifndef _MSC_VER
 #pragma GCC diagnostic ignored "-Wunused-function"
-#pragma GCC diagnostic ignored "-Wunused-parameter"
 #endif
 
 //----------------------------------------------------------------------------
@@ -89,7 +88,7 @@ void spursJobchainPopUrgentCommand(spu_thread& spu);
 //----------------------------------------------------------------------------
 
 // Output trace information
-void cellSpursModulePutTrace(CellSpursTracePacket* packet, u32 dmaTagId)
+void cellSpursModulePutTrace(CellSpursTracePacket* /*packet*/, u32 /*dmaTagId*/)
 {
 	// TODO: Implement this
 }
@@ -871,7 +870,7 @@ void spursSysServiceIdleHandler(spu_thread& spu, SpursKernelContext* ctxt)
 }
 
 // Main function for the system service
-void spursSysServiceMain(spu_thread& spu, u32 pollStatus)
+void spursSysServiceMain(spu_thread& spu, u32 /*pollStatus*/)
 {
 	const auto ctxt = spu._ptr<SpursKernelContext>(0x100);
 
@@ -1166,7 +1165,7 @@ void spursSysServiceUpdateShutdownCompletionEvents(spu_thread& spu, SpursKernelC
 }
 
 // Update the trace count for this SPU
-void spursSysServiceTraceSaveCount(spu_thread& spu, SpursKernelContext* ctxt)
+void spursSysServiceTraceSaveCount(spu_thread& /*spu*/, SpursKernelContext* ctxt)
 {
 	if (ctxt->traceBuffer)
 	{
@@ -2056,7 +2055,7 @@ s32 spursTasksetLoadElf(spu_thread& spu, u32* entryPoint, u32* lowestLoadAddr, u
 //----------------------------------------------------------------------------
 // SPURS taskset policy module functions
 //----------------------------------------------------------------------------
-bool spursJobChainEntry(spu_thread& spu)
+bool spursJobChainEntry(spu_thread& /*spu*/)
 {
 	//const auto ctxt = spu._ptr<SpursJobChainContext>(0x4a00);
 	//auto kernelCtxt = spu._ptr<SpursKernelContext>(spu.gpr[3]._u32[3]);
diff --git a/rpcs3/Emu/Cell/Modules/cellVideoOut.cpp b/rpcs3/Emu/Cell/Modules/cellVideoOut.cpp
index 001d725887..330604a34a 100644
--- a/rpcs3/Emu/Cell/Modules/cellVideoOut.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellVideoOut.cpp
@@ -478,11 +478,6 @@ error_code cellVideoOutGetResolutionAvailability(u32 videoOut, u32 resolutionId,
 	return CELL_VIDEO_OUT_ERROR_UNSUPPORTED_VIDEO_OUT;
 }
 
-// Temporarily
-#ifndef _MSC_VER
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#endif
-
 error_code cellVideoOutGetConvertCursorColorInfo(vm::ptr<u8> rgbOutputRange)
 {
 	cellSysutil.todo("cellVideoOutGetConvertCursorColorInfo(rgbOutputRange=*0x%x)", rgbOutputRange);
diff --git a/rpcs3/Emu/Cell/Modules/libsnd3.cpp b/rpcs3/Emu/Cell/Modules/libsnd3.cpp
index 0263f92ff6..146d9ad6a5 100644
--- a/rpcs3/Emu/Cell/Modules/libsnd3.cpp
+++ b/rpcs3/Emu/Cell/Modules/libsnd3.cpp
@@ -34,308 +34,303 @@ void fmt_class_string<CellSnd3Error>::format(std::string& out, u64 arg)
 	});
 }
 
-// Temporarily
-#ifndef _MSC_VER
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#endif
-
 error_code cellSnd3Init(u32 maxVoice, u32 samples, vm::ptr<CellSnd3RequestQueueCtx> queue)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3Init(maxVoice=%d, samples=%d, queue=*0x%x)", maxVoice, samples, queue);
 	return CELL_OK;
 }
 
 error_code cellSnd3Exit()
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3Exit()");
 	return CELL_OK;
 }
 
 u16 cellSnd3Note2Pitch(u16 center_note, u16 center_fine, u16 note, s16 fine)
 {
-	libsnd3.todo("cellSnd3Note2Pitch()");
+	libsnd3.todo("cellSnd3Note2Pitch(center_note=%d, center_fine=%d, note=%d, fine=%d)", center_note, center_fine, note, fine);
 	return 0;
 }
 
 u16 cellSnd3Pitch2Note(u16 center_note, u16 center_fine, u16 pitch)
 {
-	libsnd3.todo("cellSnd3Pitch2Note()");
+	libsnd3.todo("cellSnd3Pitch2Note(center_note=%d, center_fine=%d, pitch=%d)", center_note, center_fine, pitch);
 	return 0;
 }
 
 error_code cellSnd3SetOutputMode(u32 mode)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3SetOutputMode(mode=%d)", mode);
 	return CELL_OK;
 }
 
 error_code cellSnd3Synthesis(vm::ptr<f32> pOutL, vm::ptr<f32> pOutR)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3Synthesis(pOutL=*0x%x, pOutR=*0x%x)", pOutL, pOutR);
 	return CELL_OK;
 }
 
 error_code cellSnd3SynthesisEx(vm::ptr<f32> pOutL, vm::ptr<f32> pOutR, vm::ptr<f32> pOutRL, vm::ptr<f32> pOutRR)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3SynthesisEx(pOutL=*0x%x, pOutR=*0x%x, pOutRL=*0x%x, pOutRR=*0x%x)", pOutL, pOutR, pOutRL, pOutRR);
 	return CELL_OK;
 }
 
 error_code cellSnd3BindSoundData(vm::ptr<CellSnd3DataCtx> snd3Ctx, vm::ptr<void> hd3, u32 synthMemOffset)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3BindSoundData(snd3Ctx=*0x%x, hd3=*0x%x, synthMemOffset=0x%x)", snd3Ctx, hd3, synthMemOffset);
 	return CELL_OK;
 }
 
 error_code cellSnd3UnbindSoundData(u32 hd3ID)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3UnbindSoundData(hd3ID=0x%x)", hd3ID);
 	return CELL_OK;
 }
 
 error_code cellSnd3NoteOnByTone(u32 hd3ID, u32 toneIndex, u32 note, u32 keyOnID, vm::ptr<CellSnd3KeyOnParam> keyOnParam)
 {
-	libsnd3.todo("cellSnd3NoteOnByTone()");
+	libsnd3.todo("cellSnd3NoteOnByTone(hd3ID=0x%x, toneIndex=%d, note=%d, keyOnID=0x%x, keyOnParam=*0x%x)", hd3ID, toneIndex, note, keyOnID, keyOnParam);
 	return CELL_OK;
 }
 
 error_code cellSnd3KeyOnByTone(u32 hd3ID, u32 toneIndex, u32 pitch, u32 keyOnID, vm::ptr<CellSnd3KeyOnParam> keyOnParam)
 {
-	libsnd3.todo("cellSnd3KeyOnByTone()");
+	libsnd3.todo("cellSnd3KeyOnByTone(hd3ID=0x%x, toneIndex=%d, pitch=%d, keyOnID=0x%x, keyOnParam=*0x%x)", hd3ID, toneIndex, pitch, keyOnID, keyOnParam);
 	return CELL_OK;
 }
 
 error_code cellSnd3VoiceNoteOnByTone(u32 hd3ID, u32 voiceNum, u32 toneIndex, u32 note, u32 keyOnID, vm::ptr<CellSnd3KeyOnParam> keyOnParam)
 {
-	libsnd3.todo("cellSnd3VoiceNoteOnByTone()");
+	libsnd3.todo("cellSnd3VoiceNoteOnByTone(hd3ID=0x%x, voiceNum=%d, toneIndex=%d, note=%d, keyOnID=0x%x, keyOnParam=*0x%x)", hd3ID, voiceNum, toneIndex, note, keyOnID, keyOnParam);
 	return CELL_OK;
 }
 
 error_code cellSnd3VoiceKeyOnByTone(u32 hd3ID, u32 voiceNum, u32 toneIndex, u32 pitch, u32 keyOnID, vm::ptr<CellSnd3KeyOnParam> keyOnParam)
 {
-	libsnd3.todo("cellSnd3VoiceKeyOnByTone()");
+	libsnd3.todo("cellSnd3VoiceKeyOnByTone(hd3ID=0x%x, voiceNum=%d, toneIndex=%d, pitch=%d, keyOnID=0x%x, keyOnParam=*0x%x)", hd3ID, voiceNum, toneIndex, pitch, keyOnID, keyOnParam);
 	return CELL_OK;
 }
 
 error_code cellSnd3VoiceSetReserveMode(u32 voiceNum, u32 reserveMode)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3VoiceSetReserveMode(voiceNum=%d, reserveMode=%d)", voiceNum, reserveMode);
 	return CELL_OK;
 }
 
 error_code cellSnd3VoiceSetSustainHold(u32 voiceNum, u32 sustainHold)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3VoiceSetSustainHold(voiceNum=%d, sustainHold=%d)", voiceNum, sustainHold);
 	return CELL_OK;
 }
 
 error_code cellSnd3VoiceKeyOff(u32 voiceNum)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3VoiceKeyOff(voiceNum=%d)", voiceNum);
 	return CELL_OK;
 }
 
 error_code cellSnd3VoiceSetPitch(u32 voiceNum, s32 addPitch)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3VoiceSetPitch(voiceNum=%d, addPitch=%d)", voiceNum, addPitch);
 	return CELL_OK;
 }
 
 error_code cellSnd3VoiceSetVelocity(u32 voiceNum, u32 velocity)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3VoiceSetVelocity(voiceNum=%d, velocity=%d)", voiceNum, velocity);
 	return CELL_OK;
 }
 
 error_code cellSnd3VoiceSetPanpot(u32 voiceNum, u32 panpot)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3VoiceSetPanpot(voiceNum=%d, panpot=%d)", voiceNum, panpot);
 	return CELL_OK;
 }
 
 error_code cellSnd3VoiceSetPanpotEx(u32 voiceNum, u32 panpotEx)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3VoiceSetPanpotEx(voiceNum=%d, panpotEx=%d)", voiceNum, panpotEx);
 	return CELL_OK;
 }
 
 error_code cellSnd3VoiceSetPitchBend(u32 voiceNum, u32 bendValue)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3VoiceSetPitchBend(voiceNum=%d, bendValue=%d)", voiceNum, bendValue);
 	return CELL_OK;
 }
 
 error_code cellSnd3VoiceAllKeyOff()
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3VoiceAllKeyOff()");
 	return CELL_OK;
 }
 
 error_code cellSnd3VoiceGetEnvelope(u32 voiceNum)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3VoiceGetEnvelope(voiceNum=%d)", voiceNum);
 	return CELL_OK;
 }
 
 error_code cellSnd3VoiceGetStatus(u32 voiceNum)
 {
-	libsnd3.todo("cellSnd3VoiceGetStatus()");
+	libsnd3.todo("cellSnd3VoiceGetStatus(voiceNum=%d)", voiceNum);
 	return CELL_OK;
 }
 
 u32 cellSnd3KeyOffByID(u32 keyOnID)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3KeyOffByID(keyOnID=%d)", keyOnID);
 	return CELL_OK;
 }
 
 error_code cellSnd3GetVoice(u32 midiChannel, u32 keyOnID, vm::ptr<CellSnd3VoiceBitCtx> voiceBit)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3GetVoice(midiChannel=%d, keyOnID=%d, voiceBit=*0x%x)", midiChannel, keyOnID, voiceBit);
 	return CELL_OK;
 }
 
 error_code cellSnd3GetVoiceByID(u32 ID, vm::ptr<CellSnd3VoiceBitCtx> voiceBit)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3GetVoiceByID(ID=%d, voiceBit=*0x%x)", ID, voiceBit);
 	return CELL_OK;
 }
 
 error_code cellSnd3NoteOn(u32 hd3ID, u32 midiChannel, u32 midiProgram, u32 midiNote, u32 sustain, vm::ptr<CellSnd3KeyOnParam> keyOnParam, u32 keyOnID)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3NoteOn(hd3ID=%d, midiChannel=%d, midiProgram=%d, midiNote=%d, sustain=%d, keyOnParam=*0x%x, keyOnID=%d)", hd3ID, midiChannel, midiProgram, midiNote, sustain, keyOnParam, keyOnID);
 	return CELL_OK;
 }
 
 error_code cellSnd3NoteOff(u32 midiChannel, u32 midiNote, u32 keyOnID)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3NoteOff(midiChannel=%d, midiNote=%d, keyOnID=%d)", midiChannel, midiNote, keyOnID);
 	return CELL_OK;
 }
 
 error_code cellSnd3SetSustainHold(u32 midiChannel, u32 sustainHold, u32 keyOnID)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3SetSustainHold(midiChannel=%d, sustainHold=%d, keyOnID=%d)", midiChannel, sustainHold, keyOnID);
 	return CELL_OK;
 }
 
 error_code cellSnd3SetEffectType(u16 effectType, s16 returnVol, u16 delay, u16 feedback)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3SetEffectType(effectType=%d, returnVol=%d, delay=%d, feedback=%d)", effectType, returnVol, delay, feedback);
 	return CELL_OK;
 }
 
 error_code cellSnd3SMFBind(vm::ptr<CellSnd3SmfCtx> smfCtx, vm::ptr<void> smf, u32 hd3ID)
 {
-	libsnd3.todo("cellSnd3SMFBind()");
+	libsnd3.todo("cellSnd3SMFBind(smfCtx=*0x%x, delay=*0x%x, hd3ID=%d)", smfCtx, smf, hd3ID);
 	return CELL_OK;
 }
 
 error_code cellSnd3SMFUnbind(u32 smfID)
 {
-	libsnd3.todo("cellSnd3SMFUnbind()");
+	libsnd3.todo("cellSnd3SMFUnbind(smfID=%d)", smfID);
 	return CELL_OK;
 }
 
 error_code cellSnd3SMFPlay(u32 smfID, u32 playVelocity, u32 playPan, u32 playCount)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3SMFPlay(smfID=%d, playVelocity=%d, playPan=%d, playCount=%d)", smfID, playVelocity, playPan, playCount);
 	return CELL_OK;
 }
 
 error_code cellSnd3SMFPlayEx(u32 smfID, u32 playVelocity, u32 playPan, u32 playPanEx, u32 playCount)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3SMFPlayEx(smfID=%d, playVelocity=%d, playPan=%d, playPanEx=%d, playCount=%d)", smfID, playVelocity, playPan, playPanEx, playCount);
 	return CELL_OK;
 }
 
 error_code cellSnd3SMFPause(u32 smfID)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3SMFPause(smfID=%d)", smfID);
 	return CELL_OK;
 }
 
 error_code cellSnd3SMFResume(u32 smfID)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3SMFResume(smfID=%d)", smfID);
 	return CELL_OK;
 }
 
 error_code cellSnd3SMFStop(u32 smfID)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3SMFStop(smfID=%d)", smfID);
 	return CELL_OK;
 }
 
 error_code cellSnd3SMFAddTempo(u32 smfID, s32 addTempo)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3SMFAddTempo(smfID=%d, addTempo=%d)", smfID, addTempo);
 	return CELL_OK;
 }
 
 error_code cellSnd3SMFGetTempo(u32 smfID)
 {
-	libsnd3.todo("cellSnd3SMFGetTempo()");
+	libsnd3.todo("cellSnd3SMFGetTempo(smfID=%d)", smfID);
 	return CELL_OK;
 }
 
 error_code cellSnd3SMFSetPlayVelocity(u32 smfID, u32 playVelocity)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3SMFSetPlayVelocity(smfID=%d, playVelocity=%d)", smfID, playVelocity);
 	return CELL_OK;
 }
 
 error_code cellSnd3SMFGetPlayVelocity(u32 smfID)
 {
-	libsnd3.todo("cellSnd3SMFGetPlayVelocity()");
+	libsnd3.todo("cellSnd3SMFGetPlayVelocity(smfID=%d)", smfID);
 	return CELL_OK;
 }
 
 error_code cellSnd3SMFSetPlayPanpot(u32 smfID, u32 playPanpot)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3SMFSetPlayPanpot(smfID=%d, playPanpot=%d)", smfID, playPanpot);
 	return CELL_OK;
 }
 
 error_code cellSnd3SMFSetPlayPanpotEx(u32 smfID, u32 playPanpotEx)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3SMFSetPlayPanpotEx(smfID=%d, playPanpotEx=%d)", smfID, playPanpotEx);
 	return CELL_OK;
 }
 
 error_code cellSnd3SMFGetPlayPanpot(u32 smfID)
 {
-	libsnd3.todo("cellSnd3SMFGetPlayPanpot()");
+	libsnd3.todo("cellSnd3SMFGetPlayPanpot(smfID=%d)", smfID);
 	return CELL_OK;
 }
 
 error_code cellSnd3SMFGetPlayPanpotEx(u32 smfID)
 {
-	libsnd3.todo("cellSnd3SMFGetPlayPanpotEx()");
+	libsnd3.todo("cellSnd3SMFGetPlayPanpotEx(smfID=%d)", smfID);
 	return CELL_OK;
 }
 
 error_code cellSnd3SMFGetPlayStatus(u32 smfID)
 {
-	libsnd3.todo("cellSnd3SMFGetPlayStatus()");
+	libsnd3.todo("cellSnd3SMFGetPlayStatus(smfID=%d)", smfID);
 	return CELL_OK;
 }
 
 error_code cellSnd3SMFSetPlayChannel(u32 smfID, u32 playChannelBit)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3SMFSetPlayChannel(smfID=%d, playChannelBit=%d)", smfID, playChannelBit);
 	return CELL_OK;
 }
 
 error_code cellSnd3SMFGetPlayChannel(u32 smfID, vm::ptr<u32> playChannelBit)
 {
-	libsnd3.todo("cellSnd3SMFGetPlayChannel()");
+	libsnd3.todo("cellSnd3SMFGetPlayChannel(smfID=%d, playChannelBit=*0x%x)", smfID, playChannelBit);
 	return CELL_OK;
 }
 
 error_code cellSnd3SMFGetKeyOnID(u32 smfID, u32 midiChannel, vm::ptr<u32> keyOnID)
 {
-	UNIMPLEMENTED_FUNC(libsnd3);
+	libsnd3.todo("cellSnd3SMFAddTempo(smfID=%d, midiChannel=%d, keyOnID=*0x%x)", smfID, midiChannel, keyOnID);
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/Cell/Modules/sys_lv2dbg.cpp b/rpcs3/Emu/Cell/Modules/sys_lv2dbg.cpp
index 2e13cf798b..c9bb020e26 100644
--- a/rpcs3/Emu/Cell/Modules/sys_lv2dbg.cpp
+++ b/rpcs3/Emu/Cell/Modules/sys_lv2dbg.cpp
@@ -65,38 +65,33 @@ void fmt_class_string<CellLv2DbgError>::format(std::string& out, u64 arg)
 	});
 }
 
-// Temporarily
-#ifndef _MSC_VER
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#endif
-
 error_code sys_dbg_read_ppu_thread_context(u64 id, vm::ptr<sys_dbg_ppu_thread_context_t> ppu_context)
 {
-	sys_lv2dbg.todo("sys_dbg_read_ppu_thread_context()");
+	sys_lv2dbg.todo("sys_dbg_read_ppu_thread_context(id=0x%x, ppu_context=*0x%x)", id, ppu_context);
 	return CELL_OK;
 }
 
 error_code sys_dbg_read_spu_thread_context(u32 id, vm::ptr<sys_dbg_spu_thread_context_t> spu_context)
 {
-	sys_lv2dbg.todo("sys_dbg_read_spu_thread_context()");
+	sys_lv2dbg.todo("sys_dbg_read_spu_thread_context(id=0x%x, spu_context=*0x%x)", id, spu_context);
 	return CELL_OK;
 }
 
 error_code sys_dbg_read_spu_thread_context2(u32 id, vm::ptr<sys_dbg_spu_thread_context2_t> spu_context)
 {
-	sys_lv2dbg.todo("sys_dbg_read_spu_thread_context2()");
+	sys_lv2dbg.todo("sys_dbg_read_spu_thread_context2(id=0x%x, spu_context=*0x%x)", id, spu_context);
 	return CELL_OK;
 }
 
 error_code sys_dbg_set_stacksize_ppu_exception_handler(u32 stacksize)
 {
-	sys_lv2dbg.todo("sys_dbg_set_stacksize_ppu_exception_handler()");
+	sys_lv2dbg.todo("sys_dbg_set_stacksize_ppu_exception_handler(stacksize=0x%x)", stacksize);
 	return CELL_OK;
 }
 
 error_code sys_dbg_initialize_ppu_exception_handler(s32 prio)
 {
-	sys_lv2dbg.todo("sys_dbg_initialize_ppu_exception_handler()");
+	sys_lv2dbg.todo("sys_dbg_initialize_ppu_exception_handler(prio=0x%x)", prio);
 	return CELL_OK;
 }
 
@@ -108,7 +103,7 @@ error_code sys_dbg_finalize_ppu_exception_handler()
 
 error_code sys_dbg_register_ppu_exception_handler(vm::ptr<dbg_exception_handler_t> callback, u64 ctrl_flags)
 {
-	sys_lv2dbg.todo("sys_dbg_register_ppu_exception_handler()");
+	sys_lv2dbg.todo("sys_dbg_register_ppu_exception_handler(callback=*0x%x, ctrl_flags=0x%x)", callback, ctrl_flags);
 	return CELL_OK;
 }
 
@@ -120,170 +115,163 @@ error_code sys_dbg_unregister_ppu_exception_handler()
 
 error_code sys_dbg_signal_to_ppu_exception_handler(u64 flags)
 {
-	sys_lv2dbg.todo("sys_dbg_signal_to_ppu_exception_handler()");
+	sys_lv2dbg.todo("sys_dbg_signal_to_ppu_exception_handler(flags=0x%x)", flags);
 	return CELL_OK;
 }
 
 error_code sys_dbg_get_mutex_information(u32 id, vm::ptr<sys_dbg_mutex_information_t> info)
 {
-	sys_lv2dbg.todo("sys_dbg_get_mutex_information()");
+	sys_lv2dbg.todo("sys_dbg_get_mutex_information(id=0x%x, info=*0x%x)", id, info);
 	return CELL_OK;
 }
 
 error_code sys_dbg_get_cond_information(u32 id, vm::ptr<sys_dbg_cond_information_t> info)
 {
-	sys_lv2dbg.todo("sys_dbg_get_cond_information()");
+	sys_lv2dbg.todo("sys_dbg_get_cond_information(id=0x%x, info=*0x%x)", id, info);
 	return CELL_OK;
 }
 
 error_code sys_dbg_get_rwlock_information(u32 id, vm::ptr<sys_dbg_rwlock_information_t> info)
 {
-	sys_lv2dbg.todo("sys_dbg_get_rwlock_information()");
+	sys_lv2dbg.todo("sys_dbg_get_rwlock_information(id=0x%x, info=*0x%x)", id, info);
 	return CELL_OK;
 }
 
 error_code sys_dbg_get_event_queue_information(u32 id, vm::ptr<sys_dbg_event_queue_information_t> info)
 {
-	sys_lv2dbg.todo("sys_dbg_get_event_queue_information()");
+	sys_lv2dbg.todo("sys_dbg_get_event_queue_information(id=0x%x, info=*0x%x)", id, info);
 	return CELL_OK;
 }
 
 error_code sys_dbg_get_semaphore_information(u32 id, vm::ptr<sys_dbg_semaphore_information_t> info)
 {
-	sys_lv2dbg.todo("sys_dbg_get_semaphore_information()");
+	sys_lv2dbg.todo("sys_dbg_get_semaphore_information(id=0x%x, info=*0x%x)", id, info);
 	return CELL_OK;
 }
 
 error_code sys_dbg_get_lwmutex_information(u32 id, vm::ptr<sys_dbg_lwmutex_information_t> info)
 {
-	sys_lv2dbg.todo("sys_dbg_get_lwmutex_information()");
+	sys_lv2dbg.todo("sys_dbg_get_lwmutex_information(id=0x%x, info=*0x%x)", id, info);
 	return CELL_OK;
 }
 
 error_code sys_dbg_get_lwcond_information(u32 id, vm::ptr<sys_dbg_lwcond_information_t> info)
 {
-	sys_lv2dbg.todo("sys_dbg_get_lwcond_information()");
+	sys_lv2dbg.todo("sys_dbg_get_lwcond_information(id=0x%x, info=*0x%x)", id, info);
 	return CELL_OK;
 }
 
 error_code sys_dbg_get_event_flag_information(u32 id, vm::ptr<sys_dbg_event_flag_information_t> info)
 {
-	sys_lv2dbg.todo("sys_dbg_get_event_flag_information()");
+	sys_lv2dbg.todo("sys_dbg_get_event_flag_information(id=0x%x, info=*0x%x)", id, info);
 	return CELL_OK;
 }
 
 error_code sys_dbg_get_ppu_thread_ids(vm::ptr<u64> ids, vm::ptr<u64> ids_num, vm::ptr<u64> all_ids_num)
 {
-	sys_lv2dbg.todo("sys_dbg_get_ppu_thread_ids()");
+	sys_lv2dbg.todo("sys_dbg_get_ppu_thread_ids(ids=*0x%x, ids_num=*0x%x, all_ids_num=*0x%x)", ids, ids_num, all_ids_num);
 	return CELL_OK;
 }
 
 error_code sys_dbg_get_spu_thread_group_ids(vm::ptr<u32> ids, vm::ptr<u64> ids_num, vm::ptr<u64> all_ids_num)
 {
-	sys_lv2dbg.todo("sys_dbg_get_spu_thread_group_ids()");
+	sys_lv2dbg.todo("sys_dbg_get_spu_thread_group_ids(ids=*0x%x, ids_num=*0x%x, all_ids_num=*0x%x)", ids, ids_num, all_ids_num);
 	return CELL_OK;
 }
 
 error_code sys_dbg_get_spu_thread_ids(u32 group_id, vm::ptr<u32> ids, vm::ptr<u64> ids_num, vm::ptr<u64> all_ids_num)
 {
-	sys_lv2dbg.todo("sys_dbg_get_spu_thread_ids()");
+	sys_lv2dbg.todo("sys_dbg_get_spu_thread_ids(group_id=0x%x, ids=*0x%x, ids_num=*0x%x, all_ids_num=*0x%x)", group_id, ids, ids_num, all_ids_num);
 	return CELL_OK;
 }
 
 error_code sys_dbg_get_ppu_thread_name(u64 id, vm::ptr<char> name)
 {
-	sys_lv2dbg.todo("sys_dbg_get_ppu_thread_name()");
+	sys_lv2dbg.todo("sys_dbg_get_ppu_thread_name(id=0x%x, name=*0x%x)", id, name);
 	return CELL_OK;
 }
 
 error_code sys_dbg_get_spu_thread_name(u32 id, vm::ptr<char> name)
 {
-	sys_lv2dbg.todo("sys_dbg_get_spu_thread_name()");
+	sys_lv2dbg.todo("sys_dbg_get_spu_thread_name(id=0x%x, name=*0x%x)", id, name);
 	return CELL_OK;
 }
 
 error_code sys_dbg_get_spu_thread_group_name(u32 id, vm::ptr<char> name)
 {
-	sys_lv2dbg.todo("sys_dbg_get_spu_thread_group_name()");
+	sys_lv2dbg.todo("sys_dbg_get_spu_thread_group_name(id=0x%x, name=*0x%x)", id, name);
 	return CELL_OK;
 }
 
-
 error_code sys_dbg_get_ppu_thread_status(u64 id, vm::ptr<u32> status)
 {
-	sys_lv2dbg.todo("sys_dbg_get_ppu_thread_status()");
+	sys_lv2dbg.todo("sys_dbg_get_ppu_thread_status(id=0x%x, status=*0x%x)", id, status);
 	return CELL_OK;
 }
 
 error_code sys_dbg_get_spu_thread_group_status(u32 id, vm::ptr<u32> status)
 {
-	sys_lv2dbg.todo("sys_dbg_get_spu_thread_group_status()");
+	sys_lv2dbg.todo("sys_dbg_get_spu_thread_group_status(id=0x%x, status=*0x%x)", id, status);
 	return CELL_OK;
 }
 
-
 error_code sys_dbg_enable_floating_point_enabled_exception(u64 id, u64 flags, u64 opt1, u64 opt2)
 {
-	sys_lv2dbg.todo("sys_dbg_enable_floating_point_enabled_exception()");
+	sys_lv2dbg.todo("sys_dbg_enable_floating_point_enabled_exception(id=0x%x, flags=0x%x, opt1=0x%x, opt2=0x%x)", id, flags, opt1, opt2);
 	return CELL_OK;
 }
 
 error_code sys_dbg_disable_floating_point_enabled_exception(u64 id, u64 flags, u64 opt1, u64 opt2)
 {
-	sys_lv2dbg.todo("sys_dbg_disable_floating_point_enabled_exception()");
+	sys_lv2dbg.todo("sys_dbg_disable_floating_point_enabled_exception(id=0x%x, flags=0x%x, opt1=0x%x, opt2=0x%x)", id, flags, opt1, opt2);
 	return CELL_OK;
 }
 
-
 error_code sys_dbg_vm_get_page_information(u32 addr, u32 num, vm::ptr<sys_vm_page_information_t> pageinfo)
 {
-	sys_lv2dbg.todo("sys_dbg_vm_get_page_information()");
+	sys_lv2dbg.todo("sys_dbg_vm_get_page_information(addr=0x%x, num=0x%x, pageinfo=*0x%x)", addr, num, pageinfo);
 	return CELL_OK;
 }
 
-
 error_code sys_dbg_set_address_to_dabr(u64 addr, u64 ctrl_flag)
 {
-	sys_lv2dbg.todo("sys_dbg_set_address_to_dabr()");
+	sys_lv2dbg.todo("sys_dbg_set_address_to_dabr(addr=0x%x, spu_context=0x%x)", addr, ctrl_flag);
 	return CELL_OK;
 }
 
 error_code sys_dbg_get_address_from_dabr(vm::ptr<u64> addr, vm::ptr<u64> ctrl_flag)
 {
-	sys_lv2dbg.todo("sys_dbg_get_address_from_dabr()");
+	sys_lv2dbg.todo("sys_dbg_get_address_from_dabr(addr=*0x%x, spu_context=*0x%x)", addr, ctrl_flag);
 	return CELL_OK;
 }
 
-
 error_code sys_dbg_signal_to_coredump_handler(u64 data1, u64 data2, u64 data3)
 {
-	sys_lv2dbg.todo("sys_dbg_signal_to_coredump_handler()");
+	sys_lv2dbg.todo("sys_dbg_signal_to_coredump_handler(data1=0x%x, data2=0x%x, data3=0x%x)", data1, data2, data3);
 	return CELL_OK;
 }
 
-
 error_code sys_dbg_mat_set_condition(u32 addr, u64 cond)
 {
-	sys_lv2dbg.todo("sys_dbg_mat_set_condition()");
+	sys_lv2dbg.todo("sys_dbg_mat_set_condition(addr=0x%x, cond=0x%x)", addr, cond);
 	return CELL_OK;
 }
 
 error_code sys_dbg_mat_get_condition(u32 addr, vm::ptr<u64> condp)
 {
-	sys_lv2dbg.todo("sys_dbg_mat_get_condition()");
+	sys_lv2dbg.todo("sys_dbg_mat_get_condition(addr=0x%x, condp=*0x%x)", addr, condp);
 	return CELL_OK;
 }
 
-
 error_code sys_dbg_get_coredump_params(vm::ptr<s32> param)
 {
-	sys_lv2dbg.todo("sys_dbg_get_coredump_params()");
+	sys_lv2dbg.todo("sys_dbg_get_coredump_params(param=*0x%x)", param);
 	return CELL_OK;
 }
 
 error_code sys_dbg_set_mask_to_ppu_exception_handler(u64 mask, u64 flags)
 {
-	sys_lv2dbg.todo("sys_dbg_set_mask_to_ppu_exception_handler()");
+	sys_lv2dbg.todo("sys_dbg_set_mask_to_ppu_exception_handler(mask=0x%x, flags=0x%x)", mask, flags);
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/Cell/Modules/sys_net_.cpp b/rpcs3/Emu/Cell/Modules/sys_net_.cpp
index 9e487aa8eb..affca674c7 100644
--- a/rpcs3/Emu/Cell/Modules/sys_net_.cpp
+++ b/rpcs3/Emu/Cell/Modules/sys_net_.cpp
@@ -4,11 +4,6 @@
 
 LOG_CHANNEL(libnet);
 
-// Temporarily
-#ifndef _MSC_VER
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#endif
-
 s32 sys_net_accept(s32 s, vm::ptr<sys_net_sockaddr> addr, vm::ptr<u32> paddrlen)
 {
 	libnet.todo("accept(s=%d, addr=*0x%x, paddrlen=*0x%x)", s, addr, paddrlen);
@@ -44,19 +39,22 @@ s32 sys_net_gethostbyname()
 
 s32 sys_net_getpeername(s32 s, vm::ptr<sys_net_sockaddr> addr, vm::ptr<u32> paddrlen)
 {
-	UNIMPLEMENTED_FUNC(libnet);
+	libnet.todo("getpeername(s=%d, addr=*0x%x, paddrlen=*0x%x)", s, addr, paddrlen);
+
 	return CELL_OK;
 }
 
 s32 sys_net_getsockname(s32 s, vm::ptr<sys_net_sockaddr> addr, vm::ptr<u32> paddrlen)
 {
-	UNIMPLEMENTED_FUNC(libnet);
+	libnet.todo("getsockname(s=%d, addr=*0x%x, paddrlen=*0x%x)", s, addr, paddrlen);
+
 	return CELL_OK;
 }
 
 s32 sys_net_getsockopt(s32 s, s32 level, s32 optname, vm::ptr<void> optval, vm::ptr<u32> optlen)
 {
-	UNIMPLEMENTED_FUNC(libnet);
+	libnet.todo("getsockopt(s=%d, level=%d, optname=%d, optval=*0x%x, optlen=*0x%x)", s, level, optname, optval, optlen);
+
 	return CELL_OK;
 }
 
@@ -141,7 +139,8 @@ s32 sys_net_recvfrom(s32 s, vm::ptr<void> buf, u32 len, s32 flags, vm::ptr<sys_n
 
 s32 sys_net_recvmsg(s32 s, vm::ptr<sys_net_msghdr> msg, s32 flags)
 {
-	UNIMPLEMENTED_FUNC(libnet);
+	libnet.todo("recvmsg(s=%d, msg=*0x%x, flags=0x%x)", s, msg, flags);
+
 	return CELL_OK;
 }
 
@@ -154,7 +153,8 @@ s32 sys_net_send(s32 s, vm::cptr<void> buf, u32 len, s32 flags)
 
 s32 sys_net_sendmsg(s32 s, vm::cptr<sys_net_msghdr> msg, s32 flags)
 {
-	UNIMPLEMENTED_FUNC(libnet);
+	libnet.todo("sendmsg(s=%d, msg=*0x%x, flags=0x%x)", s, msg, flags);
+
 	return CELL_OK;
 }
 
@@ -195,7 +195,8 @@ s32 sys_net_socketclose(s32 s)
 
 s32 sys_net_socketpoll(vm::ptr<sys_net_pollfd> fds, s32 nfds, s32 ms)
 {
-	UNIMPLEMENTED_FUNC(libnet);
+	libnet.todo("socketpoll(fds=*0x%x, nfds=%d, ms=%d)", fds, nfds, ms);
+
 	return CELL_OK;
 }
 
@@ -270,7 +271,8 @@ s32 sys_net_get_sockinfo(s32 s, vm::ptr<sys_net_sockinfo_t> p, s32 n)
 
 s32 sys_net_close_dump(s32 id, vm::ptr<s32> pflags)
 {
-	UNIMPLEMENTED_FUNC(libnet);
+	libnet.todo("sys_net_close_dump(id=%d, pflags=*0x%x)", id, pflags);
+
 	return CELL_OK;
 }
 
@@ -308,7 +310,8 @@ s32 sys_net_show_route()
 
 s32 sys_net_read_dump(s32 id, vm::ptr<void> buf, s32 len, vm::ptr<s32> pflags)
 {
-	UNIMPLEMENTED_FUNC(libnet);
+	libnet.todo("sys_net_read_dump(id=%d, buf=*0x%x, len=%d, pflags=*0x%x)", id, buf, len, pflags);
+
 	return CELL_OK;
 }
 
@@ -344,7 +347,8 @@ s32 sys_net_get_sockinfo_ex()
 
 s32 sys_net_open_dump(s32 len, s32 flags)
 {
-	UNIMPLEMENTED_FUNC(libnet);
+	libnet.todo("sys_net_open_dump(len=%d, flags=0x%x)", len, flags);
+
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/Io/usb_device.cpp b/rpcs3/Emu/Io/usb_device.cpp
index be35a61469..9291805a8c 100644
--- a/rpcs3/Emu/Io/usb_device.cpp
+++ b/rpcs3/Emu/Io/usb_device.cpp
@@ -307,16 +307,11 @@ void usb_device_emulated::control_transfer(u8 bmRequestType, u8 bRequest, u16 wV
 	}
 }
 
-// Temporarily
-#ifndef _MSC_VER
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#endif
-
-void usb_device_emulated::interrupt_transfer(u32 buf_size, u8* buf, u32 endpoint, UsbTransfer* transfer)
+void usb_device_emulated::interrupt_transfer(u32 /*buf_size*/, u8* /*buf*/, u32 /*endpoint*/, UsbTransfer* /*transfer*/)
 {
 }
 
-void usb_device_emulated::isochronous_transfer(UsbTransfer* transfer)
+void usb_device_emulated::isochronous_transfer(UsbTransfer* /*transfer*/)
 {
 }
 
diff --git a/rpcs3/Emu/RSX/VK/vkutils/shared.cpp b/rpcs3/Emu/RSX/VK/vkutils/shared.cpp
index 3ce129ea89..c4a0219e68 100644
--- a/rpcs3/Emu/RSX/VK/vkutils/shared.cpp
+++ b/rpcs3/Emu/RSX/VK/vkutils/shared.cpp
@@ -235,14 +235,9 @@ namespace vk
 		return false;
 	}
 
-	// Temporarily
-#ifndef _MSC_VER
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#endif
-
-	VkBool32 BreakCallback(VkFlags msgFlags, VkDebugReportObjectTypeEXT objType,
-		u64 srcObject, usz location, s32 msgCode,
-		const char* pLayerPrefix, const char* pMsg, void* pUserData)
+	VkBool32 BreakCallback(VkFlags /*msgFlags*/, VkDebugReportObjectTypeEXT /*objType*/,
+		u64 /*srcObject*/, usz /*location*/, s32 /*msgCode*/,
+		const char* /*pLayerPrefix*/, const char* /*pMsg*/, void* /*pUserData*/)
 	{
 #ifdef _WIN32
 		DebugBreak();