Log style fix

2025-07-09 00:11:24 +12:00 · 2015-07-11 02:38:40 +03:00 · 2015-07-11 02:38:40 +03:00 · 06dacf04b5
commit 06dacf04b5
parent 2d37c6b5e2
25 changed files with 246 additions and 297 deletions
--- a/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
@ -13,7 +13,7 @@ CCellFontInternal* s_fontInternalInstance = nullptr;
 // Functions
 s32 cellFontInitializeWithRevision(u64 revisionFlags, vm::ptr<CellFontConfig> config)
 {
-	cellFont.Warning("cellFontInitializeWithRevision(revisionFlags=0x%llx, config=0x%x)", revisionFlags, config.addr());
+	cellFont.Warning("cellFontInitializeWithRevision(revisionFlags=0x%llx, config=*0x%x)", revisionFlags, config);
 	if (s_fontInternalInstance->m_bInitialized)
 		return CELL_FONT_ERROR_ALREADY_INITIALIZED;
@ -27,18 +27,18 @@ s32 cellFontInitializeWithRevision(u64 revisionFlags, vm::ptr<CellFontConfig> co
 	s_fontInternalInstance->m_userFontEntrys_addr = config->userFontEntrys_addr;
 	s_fontInternalInstance->m_userFontEntryMax    = config->userFontEntryMax;
 	s_fontInternalInstance->m_bInitialized = true;
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontGetRevisionFlags(vm::ptr<u64> revisionFlags)
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontInit(PPUThread& CPU, vm::ptr<CellFontConfig> config)
 {
-	cellFont.Log("cellFontInit(config=0x%x)", config.addr());
+	cellFont.Warning("cellFontInit(config=*0x%x)", config);
 	vm::stackvar<be_t<u64>> revisionFlags(CPU);
 	revisionFlags.value() = 0;
@ -48,26 +48,24 @@ s32 cellFontInit(PPUThread& CPU, vm::ptr<CellFontConfig> config)
 s32 cellFontEnd()
 {
-	cellFont.Log("cellFontEnd()");
+	cellFont.Warning("cellFontEnd()");
 	if (!s_fontInternalInstance->m_bInitialized)
 		return CELL_FONT_ERROR_UNINITIALIZED;
 	s_fontInternalInstance->m_bInitialized = false;
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontSetFontsetOpenMode(u32 openMode)
 {
-	cellFont.Log("cellFontSetFontsetOpenMode(openMode=0x%x)", openMode);
+	cellFont.Todo("cellFontSetFontsetOpenMode(openMode=0x%x)", openMode);
-	UNIMPLEMENTED_FUNC(cellFont);
+	return CELL_OK;
 	return CELL_FONT_OK;
 }
 s32 cellFontOpenFontMemory(vm::ptr<CellFontLibrary> library, u32 fontAddr, u32 fontSize, u32 subNum, u32 uniqueId, vm::ptr<CellFont> font)
 {
-	cellFont.Warning("cellFontOpenFontMemory(library_addr=0x%x, fontAddr=0x%x, fontSize=%d, subNum=%d, uniqueId=%d, font_addr=0x%x)",
+	cellFont.Warning("cellFontOpenFontMemory(library=*0x%x, fontAddr=0x%x, fontSize=%d, subNum=%d, uniqueId=%d, font=*0x%x)", library, fontAddr, fontSize, subNum, uniqueId, font);
 		library.addr(), fontAddr, fontSize, subNum, uniqueId, font.addr());
 	if (!s_fontInternalInstance->m_bInitialized)
 		return CELL_FONT_ERROR_UNINITIALIZED;
@ -80,16 +78,14 @@ s32 cellFontOpenFontMemory(vm::ptr<CellFontLibrary> library, u32 fontAddr, u32 f
 	font->renderer_addr = 0;
 	font->fontdata_addr = fontAddr;
 	font->origin = CELL_FONT_OPEN_MEMORY;
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontOpenFontFile(vm::ptr<CellFontLibrary> library, vm::cptr<char> fontPath, u32 subNum, s32 uniqueId, vm::ptr<CellFont> font)
 {
-	std::string fp(fontPath.get_ptr());
+	cellFont.Warning("cellFontOpenFontFile(library=*0x%x, fontPath=*0x%x, subNum=%d, uniqueId=%d, font=*0x%x)", library, fontPath, subNum, uniqueId, font);
 	cellFont.Warning("cellFontOpenFontFile(library_addr=0x%x, fontPath=\"%s\", subNum=%d, uniqueId=%d, font_addr=0x%x)",
 		library.addr(), fp.c_str(), subNum, uniqueId, font.addr());
-	vfsFile f(fp);
+	vfsFile f(fontPath.get_ptr());
 	if (!f.IsOpened())
 		return CELL_FONT_ERROR_FONT_OPEN_FAILED;
@ -103,8 +99,7 @@ s32 cellFontOpenFontFile(vm::ptr<CellFontLibrary> library, vm::cptr<char> fontPa
 s32 cellFontOpenFontset(PPUThread& CPU, vm::ptr<CellFontLibrary> library, vm::ptr<CellFontType> fontType, vm::ptr<CellFont> font)
 {
-	cellFont.Log("cellFontOpenFontset(library_addr=0x%x, fontType_addr=0x%x, font_addr=0x%x)",
+	cellFont.Warning("cellFontOpenFontset(library=*0x%x, fontType=*0x%x, font=*0x%x)", library, fontType, font);
 		library.addr(), fontType.addr(), font.addr());
 	if (!s_fontInternalInstance->m_bInitialized)
 		return CELL_FONT_ERROR_UNINITIALIZED;
@ -186,7 +181,7 @@ s32 cellFontOpenFontset(PPUThread& CPU, vm::ptr<CellFontLibrary> library, vm::pt
 s32 cellFontOpenFontInstance(vm::ptr<CellFont> openedFont, vm::ptr<CellFont> font)
 {
-	cellFont.Warning("cellFontOpenFontInstance(openedFont=0x%x, font=0x%x)", openedFont.addr(), font.addr());
+	cellFont.Warning("cellFontOpenFontInstance(openedFont=*0x%x, font=*0x%x)", openedFont, font);
 	font->renderer_addr = openedFont->renderer_addr;
 	font->scale_x = openedFont->scale_x;
@ -195,48 +190,44 @@ s32 cellFontOpenFontInstance(vm::ptr<CellFont> openedFont, vm::ptr<CellFont> fon
 	font->stbfont = openedFont->stbfont;
 	font->origin = CELL_FONT_OPEN_FONT_INSTANCE;
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontSetFontOpenMode(u32 openMode)
 {
-	cellFont.Log("cellFontSetFontOpenMode(openMode=0x%x)", openMode);
+	cellFont.Todo("cellFontSetFontOpenMode(openMode=0x%x)", openMode);
-	UNIMPLEMENTED_FUNC(cellFont);
+	return CELL_OK;
 	return CELL_FONT_OK;
 }
 s32 cellFontCreateRenderer(vm::ptr<CellFontLibrary> library, vm::ptr<CellFontRendererConfig> config, vm::ptr<CellFontRenderer> Renderer)
 {
-	cellFont.Warning("cellFontCreateRenderer(library_addr=0x%x, config_addr=0x%x, Renderer_addr=0x%x)",
+	cellFont.Warning("cellFontCreateRenderer(library=*0x%x, config=*0x%x, Renderer=*0x%x)", library, config, Renderer);
 		library.addr(), config.addr(), Renderer.addr());
 	if (!s_fontInternalInstance->m_bInitialized)
 		return CELL_FONT_ERROR_UNINITIALIZED;
 	//Write data in Renderer
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
-void cellFontRenderSurfaceInit(vm::ptr<CellFontRenderSurface> surface, u32 buffer_addr, s32 bufferWidthByte, s32 pixelSizeByte, s32 w, s32 h)
+void cellFontRenderSurfaceInit(vm::ptr<CellFontRenderSurface> surface, vm::ptr<void> buffer, s32 bufferWidthByte, s32 pixelSizeByte, s32 w, s32 h)
 {
-	cellFont.Warning("cellFontRenderSurfaceInit(surface_addr=0x%x, buffer_addr=0x%x, bufferWidthByte=%d, pixelSizeByte=%d, w=%d, h=%d)",
+	cellFont.Warning("cellFontRenderSurfaceInit(surface=*0x%x, buffer=*0x%x, bufferWidthByte=%d, pixelSizeByte=%d, w=%d, h=%d)", surface, buffer, bufferWidthByte, pixelSizeByte, w, h);
 		surface.addr(), buffer_addr, bufferWidthByte, pixelSizeByte, w, h);
-	surface->buffer_addr	= buffer_addr;
+	surface->buffer_addr	= buffer.addr();
 	surface->widthByte		= bufferWidthByte;
 	surface->pixelSizeByte	= pixelSizeByte;
 	surface->width			= w;
 	surface->height			= h;
-	if (!buffer_addr)
+	if (!buffer)
 		surface->buffer_addr = (u32)Memory.Alloc(bufferWidthByte * h, 1); // TODO: Huge memory leak
 }
 void cellFontRenderSurfaceSetScissor(vm::ptr<CellFontRenderSurface> surface, s32 x0, s32 y0, s32 w, s32 h)
 {
-	cellFont.Warning("cellFontRenderSurfaceSetScissor(surface_addr=0x%x, x0=%d, y0=%d, w=%d, h=%d)",
+	cellFont.Warning("cellFontRenderSurfaceSetScissor(surface=*0x%x, x0=%d, y0=%d, w=%d, h=%d)", surface, x0, y0, w, h);
 		surface.addr(), x0, y0, w, h);
 	surface->Scissor.x0 = x0;
 	surface->Scissor.y0 = y0;
@ -246,17 +237,16 @@ void cellFontRenderSurfaceSetScissor(vm::ptr<CellFontRenderSurface> surface, s32
 s32 cellFontSetScalePixel(vm::ptr<CellFont> font, float w, float h)
 {
-	cellFont.Log("cellFontSetScalePixel(font_addr=0x%x, w=%f, h=%f)", font.addr(), w, h);
+	cellFont.Log("cellFontSetScalePixel(font=*0x%x, w=%f, h=%f)", font, w, h);
 	font->scale_x = w;
 	font->scale_y = h;
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontGetHorizontalLayout(vm::ptr<CellFont> font, vm::ptr<CellFontHorizontalLayout> layout)
 {
-	cellFont.Log("cellFontGetHorizontalLayout(font_addr=0x%x, layout_addr=0x%x)",
+	cellFont.Log("cellFontGetHorizontalLayout(font=*0x%x, layout=*0x%x)", font, layout);
 		font.addr(), layout.addr());
 	s32 ascent, descent, lineGap;
 	float scale = stbtt_ScaleForPixelHeight(font->stbfont, font->scale_y);
@ -265,65 +255,62 @@ s32 cellFontGetHorizontalLayout(vm::ptr<CellFont> font, vm::ptr<CellFontHorizont
 	layout->baseLineY = ascent * scale;
 	layout->lineHeight = (ascent-descent+lineGap) * scale;
 	layout->effectHeight = lineGap * scale;
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontBindRenderer(vm::ptr<CellFont> font, vm::ptr<CellFontRenderer> renderer)
 {
-	cellFont.Warning("cellFontBindRenderer(font_addr=0x%x, renderer_addr=0x%x)",
+	cellFont.Warning("cellFontBindRenderer(font=*0x%x, renderer=*0x%x)", font, renderer);
 		font.addr(), renderer.addr());
 	if (font->renderer_addr)
 		return CELL_FONT_ERROR_RENDERER_ALREADY_BIND;
 	font->renderer_addr = renderer.addr();
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontUnbindRenderer(vm::ptr<CellFont> font)
 {
-	cellFont.Warning("cellFontBindRenderer(font_addr=0x%x)", font.addr());
+	cellFont.Warning("cellFontBindRenderer(font=*0x%x)", font);
 	if (!font->renderer_addr)
 		return CELL_FONT_ERROR_RENDERER_UNBIND;
 	font->renderer_addr = 0;
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontDestroyRenderer()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontSetupRenderScalePixel(vm::ptr<CellFont> font, float w, float h)
 {
-	cellFont.Log("cellFontSetupRenderScalePixel(font_addr=0x%x, w=%f, h=%f)", font.addr(), w, h);
+	cellFont.Log("cellFontSetupRenderScalePixel(font=*0x%x, w=%f, h=%f)", font, w, h);
 	if (!font->renderer_addr)
 		return CELL_FONT_ERROR_RENDERER_UNBIND;
 	// TODO: ?
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontGetRenderCharGlyphMetrics(vm::ptr<CellFont> font, u32 code, vm::ptr<CellFontGlyphMetrics> metrics)
 {
-	cellFont.Log("cellFontGetRenderCharGlyphMetrics(font_addr=0x%x, code=0x%x, metrics_addr=0x%x)",
+	cellFont.Log("cellFontGetRenderCharGlyphMetrics(font=*0x%x, code=0x%x, metrics=*0x%x)", font, code, metrics);
 		font.addr(), code, metrics.addr());
 	if (!font->renderer_addr)
 		return CELL_FONT_ERROR_RENDERER_UNBIND;
 	// TODO: ?
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontRenderCharGlyphImage(vm::ptr<CellFont> font, u32 code, vm::ptr<CellFontRenderSurface> surface, float x, float y, vm::ptr<CellFontGlyphMetrics> metrics, vm::ptr<CellFontImageTransInfo> transInfo)
 {
-	cellFont.Log("cellFontRenderCharGlyphImage(font_addr=0x%x, code=0x%x, surface_addr=0x%x, x=%f, y=%f, metrics_addr=0x%x, trans_addr=0x%x)",
+	cellFont.Log("cellFontRenderCharGlyphImage(font=*0x%x, code=0x%x, surface=*0x%x, x=%f, y=%f, metrics=*0x%x, trans=*0x%x)", font, code, surface, x, y, metrics, transInfo);
 		font.addr(), code, surface.addr(), x, y, metrics.addr(), transInfo.addr());
 	if (!font->renderer_addr)
 		return CELL_FONT_ERROR_RENDERER_UNBIND;
@ -355,57 +342,57 @@ s32 cellFontRenderCharGlyphImage(vm::ptr<CellFont> font, u32 code, vm::ptr<CellF
 		}
 	}
 	stbtt_FreeBitmap(box, 0);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontEndLibrary()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontSetEffectSlant(vm::ptr<CellFont> font, float slantParam)
 {
-	cellFont.Log("cellFontSetEffectSlant(font_addr=0x%x, slantParam=%f)", font.addr(), slantParam);
+	cellFont.Log("cellFontSetEffectSlant(font=*0x%x, slantParam=%f)", font, slantParam);
 	if (slantParam < -1.0 || slantParam > 1.0)
 		return CELL_FONT_ERROR_INVALID_PARAMETER;
 	font->slant = slantParam;
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontGetEffectSlant(vm::ptr<CellFont> font, vm::ptr<float> slantParam)
 {
-	cellFont.Warning("cellFontSetEffectSlant(font_addr=0x%x, slantParam_addr=0x%x)", font.addr(), slantParam.addr());
+	cellFont.Warning("cellFontSetEffectSlant(font=*0x%x, slantParam=*0x%x)", font, slantParam);
 	*slantParam = font->slant;
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontGetFontIdCode(vm::ptr<CellFont> font, u32 code, vm::ptr<u32> fontId, vm::ptr<u32> fontCode)
 {
-	cellFont.Todo("cellFontGetFontIdCode(font_addr=0x%x, code=0x%x, fontId_addr=0x%x, fontCode_addr=0x%x)", font.addr(), code, fontId.addr(), fontCode.addr());
+	cellFont.Todo("cellFontGetFontIdCode(font=*0x%x, code=0x%x, fontId=*0x%x, fontCode=*0x%x)", font, code, fontId, fontCode);
 	// TODO: ?
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontCloseFont(vm::ptr<CellFont> font)
 {
-	cellFont.Warning("cellFontCloseFont(font_addr=0x%x)", font.addr());
+	cellFont.Warning("cellFontCloseFont(font=*0x%x)", font);
 	if (font->origin == CELL_FONT_OPEN_FONTSET ||
 		font->origin == CELL_FONT_OPEN_FONT_FILE ||
 		font->origin == CELL_FONT_OPEN_MEMORY)
 		Memory.Free(font->fontdata_addr);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontGetCharGlyphMetrics(vm::ptr<CellFont> font, u32 code, vm::ptr<CellFontGlyphMetrics> metrics)
 {
-	cellFont.Log("cellFontGetCharGlyphMetrics(font_addr=0x%x, code=0x%x, metrics_addr=0x%x)", font.addr(), code, metrics.addr());
+	cellFont.Log("cellFontGetCharGlyphMetrics(font=*0x%x, code=0x%x, metrics=*0x%x)", font, code, metrics);
 	s32 x0, y0, x1, y1;
 	s32 advanceWidth, leftSideBearing;
@ -422,121 +409,121 @@ s32 cellFontGetCharGlyphMetrics(vm::ptr<CellFont> font, u32 code, vm::ptr<CellFo
 	metrics->Vertical.bearingX = 0.f;
 	metrics->Vertical.bearingY = 0.f;
 	metrics->Vertical.advance = 0.f;
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontGraphicsSetFontRGBA()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontOpenFontsetOnMemory()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontGraphicsSetScalePixel()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontGraphicsGetScalePixel()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontSetEffectWeight()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontGlyphSetupVertexesGlyph()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontGetVerticalLayout()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontGetRenderCharGlyphMetricsVertical()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontSetScalePoint()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontSetupRenderEffectSlant()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontGraphicsSetLineRGBA()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontGraphicsSetDrawType()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontEndGraphics()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontGraphicsSetupDrawContext()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontSetupRenderEffectWeight()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontGlyphGetOutlineControlDistance()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontGlyphGetVertexesGlyphSize()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontGenerateCharGlyph()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontDeleteGlyph()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontExtend(u32 a1, u32 a2, u32 a3)
@ -556,25 +543,25 @@ s32 cellFontExtend(u32 a1, u32 a2, u32 a3)
 		//Something happens
 	}
 	//Something happens?
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontRenderCharGlyphImageVertical()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontSetResolutionDpi()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 s32 cellFontGetCharGlyphMetricsVertical()
 {
 	UNIMPLEMENTED_FUNC(cellFont);
-	return CELL_FONT_OK;
+	return CELL_OK;
 }
 Module cellFont("cellFont", []()
--- a/rpcs3/Emu/SysCalls/Modules/cellFont.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellFont.h
@ -5,7 +5,6 @@ namespace vm { using namespace ps3; }
 // Error codes
 enum
 {
 	CELL_FONT_OK                               = 0, 
 	CELL_FONT_ERROR_FATAL                      = 0x80540001,
 	CELL_FONT_ERROR_INVALID_PARAMETER          = 0x80540002,
 	CELL_FONT_ERROR_UNINITIALIZED              = 0x80540003,
--- a/rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp
@ -9,15 +9,14 @@ extern Module cellFontFT;
 CCellFontFTInternal* s_fontFtInternalInstance = nullptr;
-s32 cellFontInitLibraryFreeTypeWithRevision(u64 revisionFlags, vm::ptr<CellFontLibraryConfigFT> config, u32 lib_addr_addr)
+s32 cellFontInitLibraryFreeTypeWithRevision(u64 revisionFlags, vm::ptr<CellFontLibraryConfigFT> config, vm::pptr<CellFontLibrary> lib)
 {
-	cellFontFT.Warning("cellFontInitLibraryFreeTypeWithRevision(revisionFlags=0x%llx, config_addr=0x%x, lib_addr_addr=0x%x",
+	cellFontFT.Warning("cellFontInitLibraryFreeTypeWithRevision(revisionFlags=0x%llx, config=*0x%x, lib=**0x%x)", revisionFlags, config, lib);
 		revisionFlags, config.addr(), lib_addr_addr);
 	//if (s_fontInternalInstance->m_bInitialized)
 		//return CELL_FONT_ERROR_UNINITIALIZED;
-	vm::write32(lib_addr_addr, (u32)Memory.Alloc(sizeof(CellFontLibrary), 1));
+	lib->set(Memory.Alloc(sizeof(CellFontLibrary), 1));
 	return CELL_OK;
 }
--- a/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
@ -277,7 +277,7 @@ s32 cellGcmBindZcull(u8 index)
 s32 cellGcmGetConfiguration(vm::ptr<CellGcmConfig> config)
 {
-	cellGcmSys.Log("cellGcmGetConfiguration(config_addr=0x%x)", config.addr());
+	cellGcmSys.Log("cellGcmGetConfiguration(config=*0x%x)", config);
 	*config = current_config;
@ -313,7 +313,7 @@ void _cellGcmFunc1()
 void _cellGcmFunc15(vm::ptr<CellGcmContextData> context)
 {
-	cellGcmSys.Todo("_cellGcmFunc15(context_addr=0x%x)", context.addr());
+	cellGcmSys.Todo("_cellGcmFunc15(context=*0x%x)", context);
 	return;
 }
@ -322,7 +322,7 @@ u32 g_defaultCommandBufferBegin, g_defaultCommandBufferFragmentCount;
 // Called by cellGcmInit
 s32 _cellGcmInitBody(vm::ptr<CellGcmContextData> context, u32 cmdSize, u32 ioSize, u32 ioAddress)
 {
-	cellGcmSys.Warning("_cellGcmInitBody(context_addr=0x%x, cmdSize=0x%x, ioSize=0x%x, ioAddress=0x%x)", context.addr(), cmdSize, ioSize, ioAddress);
+	cellGcmSys.Warning("_cellGcmInitBody(context=*0x%x, cmdSize=0x%x, ioSize=0x%x, ioAddress=0x%x)", context, cmdSize, ioSize, ioAddress);
 	if(!local_size && !local_addr)
 	{
@ -449,7 +449,7 @@ s32 cellGcmSetDisplayBuffer(u32 id, u32 offset, u32 pitch, u32 width, u32 height
 void cellGcmSetFlipHandler(vm::ptr<void(u32)> handler)
 {
-	cellGcmSys.Warning("cellGcmSetFlipHandler(handler_addr=%d)", handler.addr());
+	cellGcmSys.Warning("cellGcmSetFlipHandler(handler=*0x%x)", handler);
 	Emu.GetGSManager().GetRender().m_flip_handler = handler;
 }
@ -596,21 +596,21 @@ s32 cellGcmSetTileInfo(u8 index, u8 location, u32 offset, u32 size, u32 pitch, u
 void cellGcmSetUserHandler(vm::ptr<void(u32)> handler)
 {
-	cellGcmSys.Warning("cellGcmSetUserHandler(handler_addr=0x%x)", handler.addr());
+	cellGcmSys.Warning("cellGcmSetUserHandler(handler=*0x%x)", handler);
 	Emu.GetGSManager().GetRender().m_user_handler = handler;
 }
 void cellGcmSetVBlankHandler(vm::ptr<void(u32)> handler)
 {
-	cellGcmSys.Warning("cellGcmSetVBlankHandler(handler_addr=0x%x)", handler.addr());
+	cellGcmSys.Warning("cellGcmSetVBlankHandler(handler=*0x%x)", handler);
 	Emu.GetGSManager().GetRender().m_vblank_handler = handler;
 }
 s32 cellGcmSetWaitFlip(vm::ptr<CellGcmContextData> ctxt)
 {
-	cellGcmSys.Log("cellGcmSetWaitFlip(ctx=0x%x)", ctxt.addr());
+	cellGcmSys.Log("cellGcmSetWaitFlip(ctx=*0x%x)", ctxt);
 	GSLockCurrent lock(GS_LOCK_WAIT_FLIP);
 	return CELL_OK;
@ -694,11 +694,16 @@ u32 cellGcmGetDisplayInfo()
 	return Emu.GetGSManager().GetRender().m_gcm_buffers_addr;
 }
-s32 cellGcmGetCurrentDisplayBufferId(u32 id_addr)
+s32 cellGcmGetCurrentDisplayBufferId(vm::ptr<u8> id)
 {
-	cellGcmSys.Warning("cellGcmGetCurrentDisplayBufferId(id_addr=0x%x)", id_addr);
+	cellGcmSys.Warning("cellGcmGetCurrentDisplayBufferId(id=*0x%x)", id);
-	vm::write32(id_addr, Emu.GetGSManager().GetRender().m_gcm_current_buffer);
+	if (Emu.GetGSManager().GetRender().m_gcm_current_buffer > UINT8_MAX)
 	{
 		throw EXCEPTION("Unexpected");
 	}
 	*id = Emu.GetGSManager().GetRender().m_gcm_current_buffer;
 	return CELL_OK;
 }
@ -798,9 +803,9 @@ s32 cellGcmSortRemapEaIoAddress()
 //----------------------------------------------------------------------------
 // Memory Mapping
 //----------------------------------------------------------------------------
-s32 cellGcmAddressToOffset(u32 address, vm::ptr<be_t<u32>> offset)
+s32 cellGcmAddressToOffset(u32 address, vm::ptr<u32> offset)
 {
-	cellGcmSys.Log("cellGcmAddressToOffset(address=0x%x,offset_addr=0x%x)", address, offset.addr());
+	cellGcmSys.Log("cellGcmAddressToOffset(address=0x%x, offset=*0x%x)", address, offset);
 	// Address not on main memory or local memory
 	if (address >= 0xD0000000)
@ -844,7 +849,7 @@ u32 cellGcmGetMaxIoMapSize()
 void cellGcmGetOffsetTable(vm::ptr<CellGcmOffsetTable> table)
 {
-	cellGcmSys.Log("cellGcmGetOffsetTable(table_addr=0x%x)", table.addr());
+	cellGcmSys.Log("cellGcmGetOffsetTable(table=*0x%x)", table);
 	table->ioAddress = offsetTable.ioAddress;
 	table->eaAddress = offsetTable.eaAddress;
@ -852,7 +857,7 @@ void cellGcmGetOffsetTable(vm::ptr<CellGcmOffsetTable> table)
 s32 cellGcmIoOffsetToAddress(u32 ioOffset, vm::ptr<u32> address)
 {
-	cellGcmSys.Log("cellGcmIoOffsetToAddress(ioOffset=0x%x, address=0x%x)", ioOffset, address);
+	cellGcmSys.Log("cellGcmIoOffsetToAddress(ioOffset=0x%x, address=*0x%x)", ioOffset, address);
 	u32 realAddr;
@ -924,7 +929,7 @@ s32 cellGcmMapLocalMemory(vm::ptr<u32> address, vm::ptr<u32> size)
 s32 cellGcmMapMainMemory(u32 ea, u32 size, vm::ptr<u32> offset)
 {
-	cellGcmSys.Warning("cellGcmMapMainMemory(ea=0x%x,size=0x%x,offset_addr=0x%x)", ea, size, offset.addr());
+	cellGcmSys.Warning("cellGcmMapMainMemory(ea=0x%x, size=0x%x, offset=*0x%x)", ea, size, offset);
 	if ((ea & 0xFFFFF) || (size & 0xFFFFF)) return CELL_GCM_ERROR_FAILURE;
@ -1098,15 +1103,14 @@ void cellGcmSetDefaultCommandBuffer()
 s32 _cellGcmSetFlipCommand(PPUThread& CPU, vm::ptr<CellGcmContextData> ctx, u32 id)
 {
-	cellGcmSys.Log("cellGcmSetFlipCommand(ctx_addr=0x%x, id=0x%x)", ctx.addr(), id);
+	cellGcmSys.Log("cellGcmSetFlipCommand(ctx=*0x%x, id=0x%x)", ctx, id);
 	return cellGcmSetPrepareFlip(CPU, ctx, id);
 }
 s32 _cellGcmSetFlipCommandWithWaitLabel(PPUThread& CPU, vm::ptr<CellGcmContextData> ctx, u32 id, u32 label_index, u32 label_value)
 {
-	cellGcmSys.Log("cellGcmSetFlipCommandWithWaitLabel(ctx_addr=0x%x, id=0x%x, label_index=0x%x, label_value=0x%x)",
+	cellGcmSys.Log("cellGcmSetFlipCommandWithWaitLabel(ctx=*0x%x, id=0x%x, label_index=0x%x, label_value=0x%x)", ctx, id, label_index, label_value);
 		ctx.addr(), id, label_index, label_value);
 	s32 res = cellGcmSetPrepareFlip(CPU, ctx, id);
 	vm::write32(gcm_info.label_addr + 0x10 * label_index, label_value);
@ -1201,7 +1205,7 @@ static bool isInCommandBufferExcept(u32 getPos, u32 bufferBegin, u32 bufferEnd)
 s32 cellGcmCallback(vm::ptr<CellGcmContextData> context, u32 count)
 {
-	cellGcmSys.Log("cellGcmCallback(context_addr=0x%x, count=0x%x)", context.addr(), count);
+	cellGcmSys.Log("cellGcmCallback(context=*0x%x, count=0x%x)", context, count);
 	auto& ctrl = vm::get_ref<CellGcmControl>(gcm_info.control_addr);
 	const std::chrono::time_point<std::chrono::system_clock> enterWait = std::chrono::system_clock::now();
--- a/rpcs3/Emu/SysCalls/Modules/cellGem.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellGem.cpp
@ -265,7 +265,7 @@ s32 cellGemHSVtoRGB()
 s32 cellGemInit(vm::ptr<CellGemAttribute> attribute)
 {
-	cellGem.Warning("cellGemInit(attribute_addr=0x%x)", attribute.addr());
+	cellGem.Warning("cellGemInit(attribute=*0x%x)", attribute);
 	if (cellGemInstance.m_bInitialized)
 		return CELL_GEM_ERROR_ALREADY_INITIALIZED;
--- a/rpcs3/Emu/SysCalls/Modules/cellKb.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellKb.cpp
@ -96,7 +96,7 @@ u16 cellKbCnvRawCode(u32 arrange, u32 mkey, u32 led, u16 rawcode)
 s32 cellKbGetInfo(vm::ptr<CellKbInfo> info)
 {
-	sys_io.Log("cellKbGetInfo(info_addr=0x%x)", info.addr());
+	sys_io.Log("cellKbGetInfo(info=*0x%x)", info);
 	if (!Emu.GetKeyboardManager().IsInited())
 		return CELL_KB_ERROR_UNINITIALIZED;
@ -116,7 +116,7 @@ s32 cellKbGetInfo(vm::ptr<CellKbInfo> info)
 s32 cellKbRead(u32 port_no, vm::ptr<CellKbData> data)
 {
-	sys_io.Log("cellKbRead(port_no=%d,info_addr=0x%x)", port_no, data.addr());
+	sys_io.Log("cellKbRead(port_no=%d, data=*0x%x)", port_no, data);
 	const std::vector<Keyboard>& keyboards = Emu.GetKeyboardManager().GetKeyboards();
 	if (!Emu.GetKeyboardManager().IsInited())
@ -173,7 +173,7 @@ s32 cellKbSetReadMode(u32 port_no, u32 rmode)
 s32 cellKbGetConfiguration(u32 port_no, vm::ptr<CellKbConfig> config)
 {
-	sys_io.Log("cellKbGetConfiguration(port_no=%d,config_addr=0x%x)", port_no, config.addr());
+	sys_io.Log("cellKbGetConfiguration(port_no=%d, config=*0x%x)", port_no, config);
 	if (!Emu.GetKeyboardManager().IsInited())
 		return CELL_KB_ERROR_UNINITIALIZED;
--- a/rpcs3/Emu/SysCalls/Modules/cellKb.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellKb.h
@ -40,14 +40,3 @@ struct CellKbConfig
 	be_t<u32> read_mode;
 	be_t<u32> code_type;
 };
 int cellKbInit(u32 max_connect);
 int cellKbEnd();
 int cellKbClearBuf(u32 port_no);
 u16 cellKbCnvRawCode(u32 arrange, u32 mkey, u32 led, u16 rawcode);
 int cellKbGetInfo(vm::ptr<CellKbInfo> info);
 int cellKbRead(u32 port_no, vm::ptr<CellKbData> data);
 int cellKbSetCodeType(u32 port_no, u32 type);
 int cellKbSetLEDStatus(u32 port_no, u8 led);
 int cellKbSetReadMode(u32 port_no, u32 rmode);
 int cellKbGetConfiguration(u32 port_no, vm::ptr<CellKbConfig> config);
--- a/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
@ -57,7 +57,7 @@ s32 UTF16stoUTF8s(vm::cptr<char16_t> utf16, vm::ref<u32> utf16_len, vm::ptr<char
 s32 jstrchk(vm::cptr<char> jstr)
 {
-	cellL10n.Warning("jstrchk(jstr_addr=0x%x) -> utf8", jstr.addr());
+	cellL10n.Warning("jstrchk(jstr=*0x%x) -> utf8", jstr);
 	return L10N_STR_UTF8;
 }
@ -299,8 +299,7 @@ s32 _L10nConvertStr(s32 src_code, const void* src, size_t * src_len, s32 dst_cod
 //TODO: Check the code in emulation. If support for UTF8/UTF16/UTF32/UCS2/UCS4 should use wider chars.. awful.
 s32 L10nConvertStr(s32 src_code, vm::cptr<void> src, vm::ptr<u32> src_len, s32 dst_code, vm::ptr<void> dst, vm::ptr<u32> dst_len)
 {
-	cellL10n.Error("L10nConvertStr(src_code=%d, srca_addr=0x%x, src_len_addr=0x%x, dst_code=%d, dst_addr=0x%x, dst_len_addr=0x%x)",
+	cellL10n.Error("L10nConvertStr(src_code=%d, srca=*0x%x, src_len=*0x%x, dst_code=%d, dst=*0x%x, dst_len=*0x%x)", src_code, src, src_len, dst_code, dst, dst_len);
 		src_code, src.addr(), src_len.addr(), dst_code, dst.addr(), dst_len.addr());
 	//cellL10n.Todo("L10nConvertStr: 1st char at dst: 0x%x", *((char*)src.get_ptr()));
 #ifdef _MSC_VER
 	u32 srcCode = 0, dstCode = 0;	//OEM code pages
--- a/rpcs3/Emu/SysCalls/Modules/cellMouse.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellMouse.cpp
@ -40,7 +40,7 @@ s32 cellMouseEnd()
 s32 cellMouseGetInfo(vm::ptr<CellMouseInfo> info)
 {
-	sys_io.Log("cellMouseGetInfo(info_addr=0x%x)", info.addr());
+	sys_io.Log("cellMouseGetInfo(info=*0x%x)", info);
 	if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
 	const MouseInfo& current_info = Emu.GetMouseManager().GetInfo();
@ -56,7 +56,7 @@ s32 cellMouseGetInfo(vm::ptr<CellMouseInfo> info)
 s32 cellMouseInfoTabletMode(u32 port_no, vm::ptr<CellMouseInfoTablet> info)
 {
-	sys_io.Log("cellMouseInfoTabletMode(port_no=%d,info_addr=0x%x)", port_no, info.addr());
+	sys_io.Log("cellMouseInfoTabletMode(port_no=%d, info=*0x%x)", port_no, info);
 	if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
 	if(port_no >= Emu.GetMouseManager().GetMice().size()) return CELL_MOUSE_ERROR_INVALID_PARAMETER;
@ -68,7 +68,7 @@ s32 cellMouseInfoTabletMode(u32 port_no, vm::ptr<CellMouseInfoTablet> info)
 s32 cellMouseGetData(u32 port_no, vm::ptr<CellMouseData> data)
 {
-	sys_io.Log("cellMouseGetData(port_no=%d,data_addr=0x%x)", port_no, data.addr());
+	sys_io.Log("cellMouseGetData(port_no=%d, data=*0x%x)", port_no, data);
 	if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
 	if(port_no >= Emu.GetMouseManager().GetMice().size()) return CELL_MOUSE_ERROR_NO_DEVICE;
@ -109,12 +109,10 @@ s32 cellMouseGetTabletDataList(u32 port_no, u32 data_addr)
 	return CELL_OK;
 }
-s32 cellMouseGetRawData(u32 port_no, u32 data_addr)
+s32 cellMouseGetRawData(u32 port_no, vm::ptr<struct CellMouseRawData> data)
 {
-	UNIMPLEMENTED_FUNC(sys_io);
+	sys_io.Todo("cellMouseGetRawData(port_no=%d, data=*0x%x)", port_no, data);
-
+	/*if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
 	/*sys_io.Log("cellMouseGetRawData(port_no=%d,data_addr=0x%x)", port_no, data.addr());
 	if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
 	if(port_no >= Emu.GetMouseManager().GetMice().size()) return CELL_MOUSE_ERROR_NO_DEVICE;
 	CellMouseRawData& current_rawdata = Emu.GetMouseManager().GetRawData(port_no);
--- a/rpcs3/Emu/SysCalls/Modules/cellMouse.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellMouse.h
@ -51,14 +51,3 @@ struct CellMouseDataList
 };
 static const u32 CELL_MOUSE_MAX_CODES = 64;
 int cellMouseInit(u32 max_connect);
 int cellMouseClearBuf(u32 port_no);
 int cellMouseEnd();
 int cellMouseGetInfo(vm::ptr<CellMouseInfo> info);
 int cellMouseInfoTabletMode(u32 port_no, vm::ptr<CellMouseInfoTablet> info);
 int cellMouseGetData(u32 port_no, vm::ptr<CellMouseData> data);
 int cellMouseGetDataList(u32 port_no, vm::ptr<CellMouseDataList> data);
 int cellMouseSetTabletMode(u32 port_no, u32 mode);
 int cellMouseGetTabletDataList(u32 port_no, u32 data_addr);
 int cellMouseGetRawData(u32 port_no, u32 data_addr);
--- a/rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp
@ -47,7 +47,7 @@ s32 cellNetCtlTerm()
 s32 cellNetCtlGetState(vm::ptr<u32> state)
 {
-	cellNetCtl.Log("cellNetCtlGetState(state_addr=0x%x)", state.addr());
+	cellNetCtl.Log("cellNetCtlGetState(state=*0x%x)", state);
 	if (Ini.NETStatus.GetValue() == 0)
 	{
@ -71,7 +71,7 @@ s32 cellNetCtlGetState(vm::ptr<u32> state)
 s32 cellNetCtlAddHandler(vm::ptr<cellNetCtlHandler> handler, vm::ptr<void> arg, vm::ptr<s32> hid)
 {
-	cellNetCtl.Todo("cellNetCtlAddHandler(handler_addr=0x%x, arg_addr=0x%x, hid_addr=0x%x)", handler.addr(), arg.addr(), hid.addr());
+	cellNetCtl.Todo("cellNetCtlAddHandler(handler=*0x%x, arg=*0x%x, hid=*0x%x)", handler, arg, hid);
 	return CELL_OK;
 }
@ -85,7 +85,7 @@ s32 cellNetCtlDelHandler(s32 hid)
 s32 cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
 {
-	cellNetCtl.Todo("cellNetCtlGetInfo(code=0x%x, info_addr=0x%x)", code, info.addr());
+	cellNetCtl.Todo("cellNetCtlGetInfo(code=0x%x, info=*0x%x)", code, info);
 	if (code == CELL_NET_CTL_INFO_IP_ADDRESS)
 	{
@ -97,7 +97,7 @@ s32 cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
 s32 cellNetCtlNetStartDialogLoadAsync(vm::ptr<CellNetCtlNetStartDialogParam> param)
 {
-	cellNetCtl.Warning("cellNetCtlNetStartDialogLoadAsync(param_addr=0x%x)", param.addr());
+	cellNetCtl.Warning("cellNetCtlNetStartDialogLoadAsync(param=*0x%x)", param);
 	// TODO: Actually sign into PSN or an emulated network similar to PSN
 	sysutilSendSystemCommand(CELL_SYSUTIL_NET_CTL_NETSTART_FINISHED, 0);
@ -114,7 +114,7 @@ s32 cellNetCtlNetStartDialogAbortAsync()
 s32 cellNetCtlNetStartDialogUnloadAsync(vm::ptr<CellNetCtlNetStartDialogResult> result)
 {
-	cellNetCtl.Warning("cellNetCtlNetStartDialogUnloadAsync(result_addr=0x%x)", result.addr());
+	cellNetCtl.Warning("cellNetCtlNetStartDialogUnloadAsync(result=*0x%x)", result);
 	sysutilSendSystemCommand(CELL_SYSUTIL_NET_CTL_NETSTART_UNLOADED, 0);
@ -123,7 +123,7 @@ s32 cellNetCtlNetStartDialogUnloadAsync(vm::ptr<CellNetCtlNetStartDialogResult>
 s32 cellNetCtlGetNatInfo(vm::ptr<CellNetCtlNatInfo> natInfo)
 {
-	cellNetCtl.Todo("cellNetCtlGetNatInfo(natInfo_addr=0x%x)", natInfo.addr());
+	cellNetCtl.Todo("cellNetCtlGetNatInfo(natInfo=*0x%x)", natInfo);
 	if (natInfo->size == 0)
 	{
--- a/rpcs3/Emu/SysCalls/Modules/cellOvis.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellOvis.cpp
@ -16,7 +16,7 @@ enum
 s32 cellOvisGetOverlayTableSize(vm::cptr<char> elf)
 {
-	cellOvis.Todo("cellOvisGetOverlayTableSize(elf_addr=0x%x)", elf.addr());
+	cellOvis.Todo("cellOvisGetOverlayTableSize(elf=*0x%x)", elf);
 	return CELL_OK;
 }
--- a/rpcs3/Emu/SysCalls/Modules/cellPad.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellPad.cpp
@ -72,7 +72,7 @@ s32 cellPadClearBuf(u32 port_no)
 s32 cellPadPeriphGetInfo(vm::ptr<CellPadPeriphInfo> info)
 {
-	sys_io.Warning("cellPadPeriphGetInfo(info_addr=0x%x)", info.addr());
+	sys_io.Warning("cellPadPeriphGetInfo(info=*0x%x)", info);
 	// TODO: Support other types of controllers
 	for (u32 i = 0; i < info->now_connect; i++)
@ -85,7 +85,7 @@ s32 cellPadPeriphGetInfo(vm::ptr<CellPadPeriphInfo> info)
 s32 cellPadGetData(u32 port_no, vm::ptr<CellPadData> data)
 {
-	sys_io.Log("cellPadGetData(port_no=%d, data_addr=0x%x)", port_no, data.addr());
+	sys_io.Log("cellPadGetData(port_no=%d, data=*0x%x)", port_no, data);
 	std::vector<Pad>& pads = Emu.GetPadManager().GetPads();
@ -262,9 +262,9 @@ s32 cellPadGetData(u32 port_no, vm::ptr<CellPadData> data)
 	return CELL_OK;
 }
-s32 cellPadGetDataExtra(u32 port_no, u32 device_type_addr, u32 data_addr)
+s32 cellPadGetDataExtra(u32 port_no, vm::ptr<u32> device_type, vm::ptr<CellPadData> data)
 {
-	sys_io.Log("cellPadGetDataExtra(port_no=%d, device_type_addr=0x%x, device_type_addr=0x%x)", port_no, device_type_addr, data_addr);
+	sys_io.Log("cellPadGetDataExtra(port_no=%d, device_type=*0x%x, device_type=*0x%x)", port_no, device_type, data);
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;
@ -279,9 +279,9 @@ s32 cellPadGetDataExtra(u32 port_no, u32 device_type_addr, u32 data_addr)
 	return CELL_OK;
 }
-s32 cellPadSetActDirect(u32 port_no, u32 param_addr)
+s32 cellPadSetActDirect(u32 port_no, vm::ptr<struct CellPadActParam> param)
 {
-	sys_io.Log("cellPadSetActDirect(port_no=%d, param_addr=0x%x)", port_no, param_addr);
+	sys_io.Log("cellPadSetActDirect(port_no=%d, param=*0x%x)", port_no, param);
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;
@ -298,7 +298,7 @@ s32 cellPadSetActDirect(u32 port_no, u32 param_addr)
 s32 cellPadGetInfo(vm::ptr<CellPadInfo> info)
 {
-	sys_io.Log("cellPadGetInfo(info_addr=0x%x)", info.addr());
+	sys_io.Log("cellPadGetInfo(info=*0x%x)", info);
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;
@ -327,7 +327,7 @@ s32 cellPadGetInfo(vm::ptr<CellPadInfo> info)
 s32 cellPadGetInfo2(vm::ptr<CellPadInfo2> info)
 {
-	sys_io.Log("cellPadGetInfo2(info_addr=0x%x)", info.addr());
+	sys_io.Log("cellPadGetInfo2(info=*0x%x)", info);
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;
@ -498,7 +498,7 @@ s32 cellPadLddRegisterController()
 s32 cellPadLddDataInsert(s32 handle, vm::ptr<CellPadData> data)
 {
-	sys_io.Todo("cellPadLddDataInsert(handle=%d, data_addr=0x%x)", handle, data.addr());
+	sys_io.Todo("cellPadLddDataInsert(handle=%d, data=*0x%x)", handle, data);
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;
--- a/rpcs3/Emu/SysCalls/Modules/cellPad.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellPad.h
@ -71,18 +71,3 @@ struct CellCapabilityInfo
 {
 	be_t<u32> info[CELL_PAD_MAX_CAPABILITY_INFO];
 };
 int cellPadInit(u32 max_connect);
 int cellPadEnd();
 int cellPadClearBuf(u32 port_no);
 int cellPadGetData(u32 port_no, vm::ptr<CellPadData> data);
 int cellPadGetDataExtra(u32 port_no, u32 device_type_addr, u32 data_addr);
 int cellPadSetActDirect(u32 port_no, u32 param_addr);
 int cellPadGetInfo(vm::ptr<CellPadInfo> info);
 int cellPadGetInfo2(vm::ptr<CellPadInfo2> info);
 int cellPadGetCapabilityInfo(u32 port_no, vm::ptr<CellCapabilityInfo> info);
 int cellPadSetPortSetting(u32 port_no, u32 port_setting);
 int cellPadInfoPressMode(u32 port_no);
 int cellPadInfoSensorMode(u32 port_no);
 int cellPadSetPressMode(u32 port_no, u32 mode);
 int cellPadSetSensorMode(u32 port_no, u32 mode);
--- a/rpcs3/Emu/SysCalls/Modules/cellPamf.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellPamf.cpp
@ -173,7 +173,7 @@ u8 pamfGetStreamChannel(vm::ptr<CellPamfReader> pSelf, u32 stream)
 s32 cellPamfGetHeaderSize(vm::ptr<PamfHeader> pAddr, u64 fileSize, vm::ptr<u64> pSize)
 {
-	cellPamf.Warning("cellPamfGetHeaderSize(pAddr=0x%x, fileSize=%d, pSize_addr=0x%x)", pAddr.addr(), fileSize, pSize.addr());
+	cellPamf.Warning("cellPamfGetHeaderSize(pAddr=*0x%x, fileSize=0x%llx, pSize=*0x%x)", pAddr, fileSize, pSize);
 	//if ((u32)pAddr->magic != 0x464d4150) return CELL_PAMF_ERROR_UNKNOWN_TYPE;
@ -184,7 +184,7 @@ s32 cellPamfGetHeaderSize(vm::ptr<PamfHeader> pAddr, u64 fileSize, vm::ptr<u64>
 s32 cellPamfGetHeaderSize2(vm::ptr<PamfHeader> pAddr, u64 fileSize, u32 attribute, vm::ptr<u64> pSize)
 {
-	cellPamf.Warning("cellPamfGetHeaderSize2(pAddr=0x%x, fileSize=%d, attribute=0x%x, pSize_addr=0x%x)", pAddr.addr(), fileSize, attribute, pSize.addr());
+	cellPamf.Warning("cellPamfGetHeaderSize2(pAddr=*0x%x, fileSize=0x%llx, attribute=0x%x, pSize=*0x%x)", pAddr, fileSize, attribute, pSize);
 	//if ((u32)pAddr->magic != 0x464d4150) return CELL_PAMF_ERROR_UNKNOWN_TYPE;
@ -195,7 +195,7 @@ s32 cellPamfGetHeaderSize2(vm::ptr<PamfHeader> pAddr, u64 fileSize, u32 attribut
 s32 cellPamfGetStreamOffsetAndSize(vm::ptr<PamfHeader> pAddr, u64 fileSize, vm::ptr<u64> pOffset, vm::ptr<u64> pSize)
 {
-	cellPamf.Warning("cellPamfGetStreamOffsetAndSize(pAddr=0x%x, fileSize=%d, pOffset_addr=0x%x, pSize_addr=0x%x)", pAddr.addr(), fileSize, pOffset.addr(), pSize.addr());
+	cellPamf.Warning("cellPamfGetStreamOffsetAndSize(pAddr=*0x%x, fileSize=0x%llx, pOffset=*0x%x, pSize=*0x%x)", pAddr, fileSize, pOffset, pSize);
 	//if ((u32)pAddr->magic != 0x464d4150) return CELL_PAMF_ERROR_UNKNOWN_TYPE;
@ -208,7 +208,7 @@ s32 cellPamfGetStreamOffsetAndSize(vm::ptr<PamfHeader> pAddr, u64 fileSize, vm::
 s32 cellPamfVerify(vm::ptr<PamfHeader> pAddr, u64 fileSize)
 {
-	cellPamf.Todo("cellPamfVerify(pAddr=0x%x, fileSize=%d)", pAddr.addr(), fileSize);
+	cellPamf.Todo("cellPamfVerify(pAddr=*0x%x, fileSize=0x%llx)", pAddr, fileSize);
 	// TODO
 	return CELL_OK;
@ -216,7 +216,7 @@ s32 cellPamfVerify(vm::ptr<PamfHeader> pAddr, u64 fileSize)
 s32 cellPamfReaderInitialize(vm::ptr<CellPamfReader> pSelf, vm::cptr<PamfHeader> pAddr, u64 fileSize, u32 attribute)
 {
-	cellPamf.Warning("cellPamfReaderInitialize(pSelf=0x%x, pAddr=0x%x, fileSize=%d, attribute=0x%x)", pSelf.addr(), pAddr.addr(), fileSize, attribute);
+	cellPamf.Warning("cellPamfReaderInitialize(pSelf=*0x%x, pAddr=*0x%x, fileSize=0x%llx, attribute=0x%x)", pSelf, pAddr, fileSize, attribute);
 	if (fileSize)
 	{
@ -240,7 +240,7 @@ s32 cellPamfReaderInitialize(vm::ptr<CellPamfReader> pSelf, vm::cptr<PamfHeader>
 s32 cellPamfReaderGetPresentationStartTime(vm::ptr<CellPamfReader> pSelf, vm::ptr<CellCodecTimeStamp> pTimeStamp)
 {
-	cellPamf.Warning("cellPamfReaderGetPresentationStartTime(pSelf=0x%x, pTimeStamp_addr=0x%x)", pSelf.addr(), pTimeStamp.addr());
+	cellPamf.Warning("cellPamfReaderGetPresentationStartTime(pSelf=*0x%x, pTimeStamp=*0x%x)", pSelf, pTimeStamp);
 	// always returns CELL_OK
@ -251,7 +251,7 @@ s32 cellPamfReaderGetPresentationStartTime(vm::ptr<CellPamfReader> pSelf, vm::pt
 s32 cellPamfReaderGetPresentationEndTime(vm::ptr<CellPamfReader> pSelf, vm::ptr<CellCodecTimeStamp> pTimeStamp)
 {
-	cellPamf.Warning("cellPamfReaderGetPresentationEndTime(pSelf=0x%x, pTimeStamp_addr=0x%x)", pSelf.addr(), pTimeStamp.addr());
+	cellPamf.Warning("cellPamfReaderGetPresentationEndTime(pSelf=*0x%x, pTimeStamp=*0x%x)", pSelf, pTimeStamp);
 	// always returns CELL_OK
@ -262,7 +262,7 @@ s32 cellPamfReaderGetPresentationEndTime(vm::ptr<CellPamfReader> pSelf, vm::ptr<
 u32 cellPamfReaderGetMuxRateBound(vm::ptr<CellPamfReader> pSelf)
 {
-	cellPamf.Warning("cellPamfReaderGetMuxRateBound(pSelf=0x%x)", pSelf.addr());
+	cellPamf.Warning("cellPamfReaderGetMuxRateBound(pSelf=*0x%x)", pSelf);
 	// cannot return error code
 	return pSelf->pAddr->mux_rate_max;
@ -270,7 +270,7 @@ u32 cellPamfReaderGetMuxRateBound(vm::ptr<CellPamfReader> pSelf)
 u8 cellPamfReaderGetNumberOfStreams(vm::ptr<CellPamfReader> pSelf)
 {
-	cellPamf.Warning("cellPamfReaderGetNumberOfStreams(pSelf=0x%x)", pSelf.addr());
+	cellPamf.Warning("cellPamfReaderGetNumberOfStreams(pSelf=*0x%x)", pSelf);
 	// cannot return error code
 	return pSelf->pAddr->stream_count;
@ -278,7 +278,7 @@ u8 cellPamfReaderGetNumberOfStreams(vm::ptr<CellPamfReader> pSelf)
 u8 cellPamfReaderGetNumberOfSpecificStreams(vm::ptr<CellPamfReader> pSelf, u8 streamType)
 {
-	cellPamf.Warning("cellPamfReaderGetNumberOfSpecificStreams(pSelf=0x%x, streamType=%d)", pSelf.addr(), streamType);
+	cellPamf.Warning("cellPamfReaderGetNumberOfSpecificStreams(pSelf=*0x%x, streamType=%d)", pSelf, streamType);
 	// cannot return error code
@ -319,7 +319,7 @@ u8 cellPamfReaderGetNumberOfSpecificStreams(vm::ptr<CellPamfReader> pSelf, u8 st
 s32 cellPamfReaderSetStreamWithIndex(vm::ptr<CellPamfReader> pSelf, u8 streamIndex)
 {
-	cellPamf.Warning("cellPamfReaderSetStreamWithIndex(pSelf=0x%x, streamIndex=%d)", pSelf.addr(), streamIndex);
+	cellPamf.Warning("cellPamfReaderSetStreamWithIndex(pSelf=*0x%x, streamIndex=%d)", pSelf, streamIndex);
 	if (streamIndex >= pSelf->pAddr->stream_count)
 	{
@ -332,7 +332,7 @@ s32 cellPamfReaderSetStreamWithIndex(vm::ptr<CellPamfReader> pSelf, u8 streamInd
 s32 cellPamfReaderSetStreamWithTypeAndChannel(vm::ptr<CellPamfReader> pSelf, u8 streamType, u8 ch)
 {
-	cellPamf.Warning("cellPamfReaderSetStreamWithTypeAndChannel(pSelf=0x%x, streamType=%d, ch=%d)", pSelf.addr(), streamType, ch);
+	cellPamf.Warning("cellPamfReaderSetStreamWithTypeAndChannel(pSelf=*0x%x, streamType=%d, ch=%d)", pSelf, streamType, ch);
 	// it probably doesn't support "any audio" or "any video" argument
 	if (streamType > 5 || ch >= 16)
@ -359,7 +359,7 @@ s32 cellPamfReaderSetStreamWithTypeAndChannel(vm::ptr<CellPamfReader> pSelf, u8
 s32 cellPamfReaderSetStreamWithTypeAndIndex(vm::ptr<CellPamfReader> pSelf, u8 streamType, u8 streamIndex)
 {
-	cellPamf.Warning("cellPamfReaderSetStreamWithTypeAndIndex(pSelf=0x%x, streamType=%d, streamIndex=%d)", pSelf.addr(), streamType, streamIndex);
+	cellPamf.Warning("cellPamfReaderSetStreamWithTypeAndIndex(pSelf=*0x%x, streamType=%d, streamIndex=%d)", pSelf, streamType, streamIndex);
 	u32 found = 0;
@ -412,7 +412,7 @@ s32 cellPamfReaderSetStreamWithTypeAndIndex(vm::ptr<CellPamfReader> pSelf, u8 st
 s32 cellPamfStreamTypeToEsFilterId(u8 type, u8 ch, vm::ptr<CellCodecEsFilterId> pEsFilterId)
 {
-	cellPamf.Warning("cellPamfStreamTypeToEsFilterId(type=%d, ch=%d, pEsFilterId_addr=0x%x)", type, ch, pEsFilterId.addr());
+	cellPamf.Warning("cellPamfStreamTypeToEsFilterId(type=%d, ch=%d, pEsFilterId=*0x%x)", type, ch, pEsFilterId);
 	if (!pEsFilterId)
 	{
@ -424,7 +424,7 @@ s32 cellPamfStreamTypeToEsFilterId(u8 type, u8 ch, vm::ptr<CellCodecEsFilterId>
 s32 cellPamfReaderGetStreamIndex(vm::ptr<CellPamfReader> pSelf)
 {
-	cellPamf.Log("cellPamfReaderGetStreamIndex(pSelf=0x%x)", pSelf.addr());
+	cellPamf.Log("cellPamfReaderGetStreamIndex(pSelf=*0x%x)", pSelf);
 	// seems that CELL_PAMF_ERROR_INVALID_PAMF must be already written in pSelf->stream if it's the case
 	return pSelf->stream;
@ -432,8 +432,7 @@ s32 cellPamfReaderGetStreamIndex(vm::ptr<CellPamfReader> pSelf)
 s32 cellPamfReaderGetStreamTypeAndChannel(vm::ptr<CellPamfReader> pSelf, vm::ptr<u8> pType, vm::ptr<u8> pCh)
 {
-	cellPamf.Warning("cellPamfReaderGetStreamTypeAndChannel(pSelf=0x%x (stream=%d), pType_addr=0x%x, pCh_addr=0x%x",
+	cellPamf.Warning("cellPamfReaderGetStreamTypeAndChannel(pSelf=*0x%x, pType=*0x%x, pCh=*0x%x", pSelf, pType, pCh);
 		pSelf.addr(), pSelf->stream, pType.addr(), pCh.addr());
 	// unclear
@ -444,7 +443,7 @@ s32 cellPamfReaderGetStreamTypeAndChannel(vm::ptr<CellPamfReader> pSelf, vm::ptr
 s32 cellPamfReaderGetEsFilterId(vm::ptr<CellPamfReader> pSelf, vm::ptr<CellCodecEsFilterId> pEsFilterId)
 {
-	cellPamf.Warning("cellPamfReaderGetEsFilterId(pSelf=0x%x (stream=%d), pEsFilterId_addr=0x%x)", pSelf.addr(), pSelf->stream, pEsFilterId.addr());
+	cellPamf.Warning("cellPamfReaderGetEsFilterId(pSelf=*0x%x, pEsFilterId=*0x%x)", pSelf, pEsFilterId);
 	// always returns CELL_OK
@ -457,9 +456,9 @@ s32 cellPamfReaderGetEsFilterId(vm::ptr<CellPamfReader> pSelf, vm::ptr<CellCodec
 	return CELL_OK;
 }
-s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, u32 pInfo_addr, u32 size)
+s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, vm::ptr<void> pInfo, u32 size)
 {
-	cellPamf.Warning("cellPamfReaderGetStreamInfo(pSelf=0x%x, stream=%d, pInfo_addr=0x%x, size=%d)", pSelf.addr(), pSelf->stream, pInfo_addr, size);
+	cellPamf.Warning("cellPamfReaderGetStreamInfo(pSelf=*0x%x, pInfo_addr=0x%x, size=%d)", pSelf, pInfo, size);
 	assert((u32)pSelf->stream < (u32)pSelf->pAddr->stream_count);
 	auto& header = pSelf->pAddr->stream_headers[pSelf->stream];
@ -475,7 +474,7 @@ s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, u32 pInfo_addr, u
 			return CELL_PAMF_ERROR_INVALID_ARG;
 		}
-		auto info = vm::ptr<CellPamfAvcInfo>::make(pInfo_addr);
+		auto info = vm::static_ptr_cast<CellPamfAvcInfo>(pInfo);
 		info->profileIdc = header.AVC.profileIdc;
 		info->levelIdc = header.AVC.levelIdc;
@ -536,7 +535,7 @@ s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, u32 pInfo_addr, u
 			return CELL_PAMF_ERROR_INVALID_ARG;
 		}
-		auto info = vm::ptr<CellPamfM2vInfo>::make(pInfo_addr);
+		auto info = vm::static_ptr_cast<CellPamfM2vInfo>(pInfo);
 		switch (header.M2V.x0)
 		{
@ -594,7 +593,7 @@ s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, u32 pInfo_addr, u
 			return CELL_PAMF_ERROR_INVALID_ARG;
 		}
-		auto info = vm::ptr<CellPamfAtrac3plusInfo>::make(pInfo_addr);
+		auto info = vm::static_ptr_cast<CellPamfAtrac3plusInfo>(pInfo);
 		info->samplingFrequency = header.audio.freq & 0xf;
 		info->numberOfChannels = header.audio.channels & 0xf;
@ -610,7 +609,7 @@ s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, u32 pInfo_addr, u
 			return CELL_PAMF_ERROR_INVALID_ARG;
 		}
-		auto info = vm::ptr<CellPamfLpcmInfo>::make(pInfo_addr);
+		auto info = vm::static_ptr_cast<CellPamfLpcmInfo>(pInfo);
 		info->samplingFrequency = header.audio.freq & 0xf;
 		info->numberOfChannels = header.audio.channels & 0xf;
@ -627,7 +626,7 @@ s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, u32 pInfo_addr, u
 			return CELL_PAMF_ERROR_INVALID_ARG;
 		}
-		auto info = vm::ptr<CellPamfAc3Info>::make(pInfo_addr);
+		auto info = vm::static_ptr_cast<CellPamfAc3Info>(pInfo);
 		info->samplingFrequency = header.audio.freq & 0xf;
 		info->numberOfChannels = header.audio.channels & 0xf;
@ -694,7 +693,7 @@ s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, u32 pInfo_addr, u
 u32 cellPamfReaderGetNumberOfEp(vm::ptr<CellPamfReader> pSelf)
 {
-	cellPamf.Todo("cellPamfReaderGetNumberOfEp(pSelf=0x%x, stream=%d)", pSelf.addr(), pSelf->stream);
+	cellPamf.Todo("cellPamfReaderGetNumberOfEp(pSelf=*0x%x)", pSelf);
 	// cannot return error code
 	return 0; //pSelf->pAddr->stream_headers[pSelf->stream].ep_num;
@ -702,7 +701,7 @@ u32 cellPamfReaderGetNumberOfEp(vm::ptr<CellPamfReader> pSelf)
 s32 cellPamfReaderGetEpIteratorWithIndex(vm::ptr<CellPamfReader> pSelf, u32 epIndex, vm::ptr<CellPamfEpIterator> pIt)
 {
-	cellPamf.Todo("cellPamfReaderGetEpIteratorWithIndex(pSelf=0x%x, stream=%d, epIndex=%d, pIt_addr=0x%x)", pSelf.addr(), pSelf->stream, epIndex, pIt.addr());
+	cellPamf.Todo("cellPamfReaderGetEpIteratorWithIndex(pSelf=*0x%x, epIndex=%d, pIt=*0x%x)", pSelf, epIndex, pIt);
 	// TODO
 	return CELL_OK;
@ -710,7 +709,7 @@ s32 cellPamfReaderGetEpIteratorWithIndex(vm::ptr<CellPamfReader> pSelf, u32 epIn
 s32 cellPamfReaderGetEpIteratorWithTimeStamp(vm::ptr<CellPamfReader> pSelf, vm::ptr<CellCodecTimeStamp> pTimeStamp, vm::ptr<CellPamfEpIterator> pIt)
 {
-	cellPamf.Todo("cellPamfReaderGetEpIteratorWithTimeStamp(pSelf=0x%x, pTimeStamp_addr=0x%x, pIt_addr=0x%x)", pSelf.addr(), pTimeStamp.addr(), pIt.addr());
+	cellPamf.Todo("cellPamfReaderGetEpIteratorWithTimeStamp(pSelf=*0x%x, pTimeStamp=*0x%x, pIt=*0x%x)", pSelf, pTimeStamp, pIt);
 	// TODO
 	return CELL_OK;
@ -718,7 +717,7 @@ s32 cellPamfReaderGetEpIteratorWithTimeStamp(vm::ptr<CellPamfReader> pSelf, vm::
 s32 cellPamfEpIteratorGetEp(vm::ptr<CellPamfEpIterator> pIt, vm::ptr<CellPamfEp> pEp)
 {
-	cellPamf.Todo("cellPamfEpIteratorGetEp(pIt_addr=0x%x, pEp_addr=0x%x)", pIt.addr(), pEp.addr());
+	cellPamf.Todo("cellPamfEpIteratorGetEp(pIt=*0x%x, pEp=*0x%x)", pIt, pEp);
 	// always returns CELL_OK
 	// TODO
@ -727,7 +726,7 @@ s32 cellPamfEpIteratorGetEp(vm::ptr<CellPamfEpIterator> pIt, vm::ptr<CellPamfEp>
 s32 cellPamfEpIteratorMove(vm::ptr<CellPamfEpIterator> pIt, s32 steps, vm::ptr<CellPamfEp> pEp)
 {
-	cellPamf.Todo("cellPamfEpIteratorMove(pIt_addr=0x%x, steps=%d, pEp_addr=0x%x)", pIt.addr(), steps, pEp.addr());
+	cellPamf.Todo("cellPamfEpIteratorMove(pIt=*0x%x, steps=%d, pEp=*0x%x)", pIt, steps, pEp);
 	// cannot return error code
 	// TODO
--- a/rpcs3/Emu/SysCalls/Modules/cellResc.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellResc.cpp
@ -570,7 +570,7 @@ void SetupSurfaces(vm::ptr<CellGcmContextData>& cntxt)
 // Module Functions
 s32 cellRescInit(vm::ptr<CellRescInitConfig> initConfig)
 {
-	cellResc.Warning("cellRescInit(initConfig_addr=0x%x)", initConfig.addr());
+	cellResc.Warning("cellRescInit(initConfig=*0x%x)", initConfig);
 	if (s_rescInternalInstance->m_bInitialized)
 	{
@ -623,7 +623,7 @@ void cellRescExit()
 s32 cellRescVideoOutResolutionId2RescBufferMode(u32 resolutionId, vm::ptr<u32> bufferMode)
 {
-	cellResc.Log("cellRescVideoOutResolutionId2RescBufferMode(resolutionId=%d, bufferMode_addr=0x%x)", resolutionId, bufferMode.addr());
+	cellResc.Log("cellRescVideoOutResolutionId2RescBufferMode(resolutionId=%d, bufferMode=*0x%x)", resolutionId, bufferMode);
 	switch (resolutionId)
 	{
@ -649,7 +649,7 @@ s32 cellRescVideoOutResolutionId2RescBufferMode(u32 resolutionId, vm::ptr<u32> b
 s32 cellRescSetDsts(u32 dstsMode, vm::ptr<CellRescDsts> dsts)
 {
-	cellResc.Log("cellRescSetDsts(dstsMode=%d, CellRescDsts_addr=0x%x)", dstsMode, dsts.addr());
+	cellResc.Log("cellRescSetDsts(dstsMode=%d, dsts=*0x%x)", dstsMode, dsts);
 	if (!s_rescInternalInstance->m_bInitialized)
 	{
@ -861,8 +861,7 @@ s32 cellRescSetPalInterpolateDropFlexRatio(float ratio)
 s32 cellRescGetBufferSize(vm::ptr<u32> colorBuffers, vm::ptr<u32> vertexArray, vm::ptr<u32> fragmentShader)
 {
-	cellResc.Warning("cellRescGetBufferSize(colorBuffers_addr=0x%x, vertexArray_addr=0x%x, fragmentShader_addr=0x%x)",
+	cellResc.Warning("cellRescGetBufferSize(colorBuffers=*0x%x, vertexArray=*0x%x, fragmentShader=*0x%x)", colorBuffers, vertexArray, fragmentShader);
 		colorBuffers.addr(), vertexArray.addr(), fragmentShader.addr());
 	if (!s_rescInternalInstance->m_bInitialized)
 	{
@ -926,7 +925,7 @@ s32 cellRescGetNumColorBuffers(u32 dstMode, u32 palTemporalMode, u32 reserved)
 s32 cellRescGcmSurface2RescSrc(vm::ptr<CellGcmSurface> gcmSurface, vm::ptr<CellRescSrc> rescSrc)
 {
-	cellResc.Log("cellRescGcmSurface2RescSrc(gcmSurface_addr=0x%x, rescSrc_addr=0x%x)", gcmSurface.addr(), rescSrc.addr());
+	cellResc.Log("cellRescGcmSurface2RescSrc(gcmSurface=*0x%x, rescSrc=*0x%x)", gcmSurface, rescSrc);
 	u8 textureFormat = GcmSurfaceFormat2GcmTextureFormat(gcmSurface->colorFormat, gcmSurface->type);
 	s32 xW = 1, xH = 1;
@ -957,7 +956,7 @@ s32 cellRescGcmSurface2RescSrc(vm::ptr<CellGcmSurface> gcmSurface, vm::ptr<CellR
 s32 cellRescSetSrc(s32 idx, vm::ptr<CellRescSrc> src)
 {
-	cellResc.Log("cellRescSetSrc(idx=0x%x, src_addr=0x%x)", idx, src.addr());
+	cellResc.Log("cellRescSetSrc(idx=0x%x, src=*0x%x)", idx, src);
 	if(!s_rescInternalInstance->m_bInitialized)
 	{
@ -986,7 +985,7 @@ s32 cellRescSetSrc(s32 idx, vm::ptr<CellRescSrc> src)
 s32 cellRescSetConvertAndFlip(PPUThread& CPU, vm::ptr<CellGcmContextData> cntxt, s32 idx)
 {
-	cellResc.Log("cellRescSetConvertAndFlip(cntxt_addr=0x%x, indx=0x%x)", cntxt.addr(), idx);
+	cellResc.Log("cellRescSetConvertAndFlip(cntxt=*0x%x, idx=0x%x)", cntxt, idx);
 	if(!s_rescInternalInstance->m_bInitialized)
 	{
@ -1032,7 +1031,7 @@ s32 cellRescSetWaitFlip()
 s32 cellRescSetBufferAddress(PPUThread& CPU, vm::ptr<u32> colorBuffers, vm::ptr<u32> vertexArray, vm::ptr<u32> fragmentShader)
 {
-	cellResc.Warning("cellRescSetBufferAddress(colorBuffers_addr=0x%x, vertexArray_addr=0x%x, fragmentShader_addr=0x%x)", colorBuffers.addr(), vertexArray.addr(), fragmentShader.addr());
+	cellResc.Warning("cellRescSetBufferAddress(colorBuffers=*0x%x, vertexArray=*0x%x, fragmentShader=*0x%x)", colorBuffers, vertexArray, fragmentShader);
 	if(!s_rescInternalInstance->m_bInitialized)
 	{
@ -1076,7 +1075,7 @@ s32 cellRescSetBufferAddress(PPUThread& CPU, vm::ptr<u32> colorBuffers, vm::ptr<
 void cellRescSetFlipHandler(vm::ptr<void(u32)> handler)
 {
-	cellResc.Warning("cellRescSetFlipHandler(handler_addr=0x%x)", handler.addr());
+	cellResc.Warning("cellRescSetFlipHandler(handler=*0x%x)", handler);
 	Emu.GetGSManager().GetRender().m_flip_handler = handler;
 }
@ -1116,7 +1115,7 @@ s32 cellRescSetRegisterCount()
 void cellRescSetVBlankHandler(vm::ptr<void(u32)> handler)
 {
-	cellResc.Warning("cellRescSetVBlankHandler(handler_addr=0x%x)", handler.addr());
+	cellResc.Warning("cellRescSetVBlankHandler(handler=*0x%x)", handler);
 	Emu.GetGSManager().GetRender().m_vblank_handler = handler;
 }
--- a/rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
@ -71,7 +71,7 @@ s32 cellRtcGetCurrentClockLocalTime(vm::ptr<CellRtcDateTime> pClock)
 s32 cellRtcFormatRfc2822(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc, s32 iTimeZone)
 {
-	cellRtc.Log("cellRtcFormatRfc2822(pszDateTime_addr=0x%x, pUtc=0x%x, time_zone=%d)", pszDateTime.addr(), pUtc.addr(), iTimeZone);
+	cellRtc.Log("cellRtcFormatRfc2822(pszDateTime=*0x%x, pUtc=*0x%x, time_zone=%d)", pszDateTime, pUtc, iTimeZone);
 	// Add time_zone as offset in minutes.
 	rTimeSpan tz = rTimeSpan(0, (long) iTimeZone, 0, 0);
@ -89,7 +89,7 @@ s32 cellRtcFormatRfc2822(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc, s
 s32 cellRtcFormatRfc2822LocalTime(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc)
 {
-	cellRtc.Log("cellRtcFormatRfc2822LocalTime(pszDateTime_addr=0x%x, pUtc=0x%x)", pszDateTime.addr(), pUtc.addr());
+	cellRtc.Log("cellRtcFormatRfc2822LocalTime(pszDateTime=*0x%x, pUtc=*0x%x)", pszDateTime, pUtc);
 	// Get date from ticks.
 	rDateTime date = rDateTime((time_t)pUtc->tick);
@ -103,7 +103,7 @@ s32 cellRtcFormatRfc2822LocalTime(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick
 s32 cellRtcFormatRfc3339(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc, s32 iTimeZone)
 {
-	cellRtc.Log("cellRtcFormatRfc3339(pszDateTime_addr=0x%x, pUtc=0x%x, iTimeZone=%d)", pszDateTime.addr(), pUtc.addr(), iTimeZone);
+	cellRtc.Log("cellRtcFormatRfc3339(pszDateTime=*0x%x, pUtc=*0x%x, iTimeZone=%d)", pszDateTime, pUtc, iTimeZone);
 	// Add time_zone as offset in minutes.
 	rTimeSpan tz = rTimeSpan(0, (long) iTimeZone, 0, 0);
@ -121,7 +121,7 @@ s32 cellRtcFormatRfc3339(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc, s
 s32 cellRtcFormatRfc3339LocalTime(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc)
 {
-	cellRtc.Log("cellRtcFormatRfc3339LocalTime(pszDateTime_addr=0x%x, pUtc=0x%x)", pszDateTime.addr(), pUtc.addr());
+	cellRtc.Log("cellRtcFormatRfc3339LocalTime(pszDateTime=*0x%x, pUtc=*0x%x)", pszDateTime, pUtc);
 	// Get date from ticks.
 	rDateTime date = rDateTime((time_t) pUtc->tick);
@ -135,7 +135,7 @@ s32 cellRtcFormatRfc3339LocalTime(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick
 s32 cellRtcParseDateTime(vm::ptr<CellRtcTick> pUtc, vm::cptr<char> pszDateTime)
 {
-	cellRtc.Log("cellRtcParseDateTime(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.addr(), pszDateTime.addr());
+	cellRtc.Log("cellRtcParseDateTime(pUtc=*0x%x, pszDateTime=*0x%x)", pUtc, pszDateTime);
 	// Get date from formatted string.
 	rDateTime date;
@ -148,7 +148,7 @@ s32 cellRtcParseDateTime(vm::ptr<CellRtcTick> pUtc, vm::cptr<char> pszDateTime)
 s32 cellRtcParseRfc3339(vm::ptr<CellRtcTick> pUtc, vm::cptr<char> pszDateTime)
 {
-	cellRtc.Log("cellRtcParseRfc3339(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.addr(), pszDateTime.addr());
+	cellRtc.Log("cellRtcParseRfc3339(pUtc=*0x%x, pszDateTime=*0x%x)", pUtc, pszDateTime);
 	// Get date from RFC3339 formatted string.
 	rDateTime date;
@ -382,7 +382,7 @@ s32 cellRtcSetTime_t(vm::ptr<CellRtcDateTime> pDateTime, u64 iTime)
 s32 cellRtcSetWin32FileTime(vm::ptr<CellRtcDateTime> pDateTime, u64 ulWin32FileTime)
 {
-	cellRtc.Log("cellRtcSetWin32FileTime(pDateTime_addr=0x%x, ulWin32FileTime=0x%llx)", pDateTime.addr(), ulWin32FileTime);
+	cellRtc.Log("cellRtcSetWin32FileTime(pDateTime=*0x%x, ulWin32FileTime=0x%llx)", pDateTime, ulWin32FileTime);
 	rDateTime date_time = rDateTime((time_t)ulWin32FileTime);
--- a/rpcs3/Emu/SysCalls/Modules/cellSubdisplay.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSubdisplay.cpp
@ -20,7 +20,7 @@ s32 cellSubDisplayEnd()
 s32 cellSubDisplayGetRequiredMemory(vm::ptr<CellSubDisplayParam> pParam)
 {
-	cellSubdisplay.Warning("cellSubDisplayGetRequiredMemory(pParam_addr=0x%x)", pParam.addr());
+	cellSubdisplay.Warning("cellSubDisplayGetRequiredMemory(pParam=*0x%x)", pParam);
 	if (pParam->version == CELL_SUBDISPLAY_VERSION_0002)
 	{
--- a/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp
@ -9,7 +9,7 @@ extern Module cellSync2;
 s32 _cellSync2MutexAttributeInitialize(vm::ptr<CellSync2MutexAttribute> attr, u32 sdkVersion)
 {
-	cellSync2.Warning("_cellSync2MutexAttributeInitialize(attr_addr=0x%x, sdkVersion=0x%x)", attr.addr(), sdkVersion);
+	cellSync2.Warning("_cellSync2MutexAttributeInitialize(attr=*0x%x, sdkVersion=0x%x)", attr, sdkVersion);
 	attr->sdkVersion = sdkVersion;
 	attr->threadTypes = CELL_SYNC2_THREAD_TYPE_PPU_THREAD | CELL_SYNC2_THREAD_TYPE_PPU_FIBER |
@ -24,7 +24,7 @@ s32 _cellSync2MutexAttributeInitialize(vm::ptr<CellSync2MutexAttribute> attr, u3
 s32 cellSync2MutexEstimateBufferSize(vm::cptr<CellSync2MutexAttribute> attr, vm::ptr<u32> bufferSize)
 {
-	cellSync2.Todo("cellSync2MutexEstimateBufferSize(attr_addr=0x%x, bufferSize_addr=0x%x)", attr.addr(), bufferSize.addr());
+	cellSync2.Todo("cellSync2MutexEstimateBufferSize(attr=*0x%x, bufferSize=*0x%x)", attr, bufferSize);
 	if (attr->maxWaiters > 32768)
 		return CELL_SYNC2_ERROR_INVAL;
@ -64,7 +64,7 @@ s32 cellSync2MutexUnlock()
 s32 _cellSync2CondAttributeInitialize(vm::ptr<CellSync2CondAttribute> attr, u32 sdkVersion)
 {
-	cellSync2.Warning("_cellSync2CondAttributeInitialize(attr_addr=0x%x, sdkVersion=0x%x)", attr.addr(), sdkVersion);
+	cellSync2.Warning("_cellSync2CondAttributeInitialize(attr=*0x%x, sdkVersion=0x%x)", attr, sdkVersion);
 	attr->sdkVersion = sdkVersion;
 	attr->maxWaiters = 15;
@ -75,7 +75,7 @@ s32 _cellSync2CondAttributeInitialize(vm::ptr<CellSync2CondAttribute> attr, u32
 s32 cellSync2CondEstimateBufferSize(vm::cptr<CellSync2CondAttribute> attr, vm::ptr<u32> bufferSize)
 {
-	cellSync2.Todo("cellSync2CondEstimateBufferSize(attr_addr=0x%x, bufferSize_addr=0x%x)", attr.addr(), bufferSize.addr());
+	cellSync2.Todo("cellSync2CondEstimateBufferSize(attr=*0x%x, bufferSize=*0x%x)", attr, bufferSize);
 	if (attr->maxWaiters == 0 || attr->maxWaiters > 32768)
 		return CELL_SYNC2_ERROR_INVAL;
@ -115,7 +115,7 @@ s32 cellSync2CondSignalAll()
 s32 _cellSync2SemaphoreAttributeInitialize(vm::ptr<CellSync2SemaphoreAttribute> attr, u32 sdkVersion)
 {
-	cellSync2.Warning("_cellSync2SemaphoreAttributeInitialize(attr_addr=0x%x, sdkVersion=0x%x)", attr.addr(), sdkVersion);
+	cellSync2.Warning("_cellSync2SemaphoreAttributeInitialize(attr=*0x%x, sdkVersion=0x%x)", attr, sdkVersion);
 	attr->sdkVersion = sdkVersion;
 	attr->threadTypes = CELL_SYNC2_THREAD_TYPE_PPU_THREAD | CELL_SYNC2_THREAD_TYPE_PPU_FIBER |
@ -129,7 +129,7 @@ s32 _cellSync2SemaphoreAttributeInitialize(vm::ptr<CellSync2SemaphoreAttribute>
 s32 cellSync2SemaphoreEstimateBufferSize(vm::cptr<CellSync2SemaphoreAttribute> attr, vm::ptr<u32> bufferSize)
 {
-	cellSync2.Todo("cellSync2SemaphoreEstimateBufferSize(attr_addr=0x%x, bufferSize_addr=0x%x)", attr.addr(), bufferSize.addr());
+	cellSync2.Todo("cellSync2SemaphoreEstimateBufferSize(attr=*0x%x, bufferSize=*0x%x)", attr, bufferSize);
 	if (attr->maxWaiters == 0 || attr->maxWaiters > 32768)
 		return CELL_SYNC2_ERROR_INVAL;
@ -175,7 +175,7 @@ s32 cellSync2SemaphoreGetCount()
 s32 _cellSync2QueueAttributeInitialize(vm::ptr<CellSync2QueueAttribute> attr, u32 sdkVersion)
 {
-	cellSync2.Warning("_cellSync2QueueAttributeInitialize(attr_addr=0x%x, sdkVersion=0x%x)", attr.addr(), sdkVersion);
+	cellSync2.Warning("_cellSync2QueueAttributeInitialize(attr=*0x%x, sdkVersion=0x%x)", attr, sdkVersion);
 	attr->sdkVersion = sdkVersion;
 	attr->threadTypes = CELL_SYNC2_THREAD_TYPE_PPU_THREAD | CELL_SYNC2_THREAD_TYPE_PPU_FIBER |
@ -192,7 +192,7 @@ s32 _cellSync2QueueAttributeInitialize(vm::ptr<CellSync2QueueAttribute> attr, u3
 s32 cellSync2QueueEstimateBufferSize(vm::cptr<CellSync2QueueAttribute> attr, vm::ptr<u32> bufferSize)
 {
-	cellSync2.Todo("cellSync2QueueEstimateBufferSize(attr_addr=0x%x, bufferSize_addr=0x%x)", attr.addr(), bufferSize.addr());
+	cellSync2.Todo("cellSync2QueueEstimateBufferSize(attr=*0x%x, bufferSize=*0x%x)", attr, bufferSize);
 	if (attr->elementSize == 0 || attr->elementSize > 16384 || attr->elementSize % 16 || attr->depth == 0 || attr->depth > 4294967292 ||
 		attr->maxPushWaiters > 32768 || attr->maxPopWaiters > 32768)
--- a/rpcs3/Emu/SysCalls/Modules/cellUserInfo.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellUserInfo.cpp
@ -11,7 +11,7 @@ extern Module cellUserInfo;
 s32 cellUserInfoGetStat(u32 id, vm::ptr<CellUserInfoUserStat> stat)
 {
-	cellUserInfo.Warning("cellUserInfoGetStat(id=%d, stat_addr=0x%x)", id, stat.addr());
+	cellUserInfo.Warning("cellUserInfoGetStat(id=%d, stat=*0x%x)", id, stat);
 	if (id > CELL_USERINFO_USER_MAX)
 		return CELL_USERINFO_ERROR_NOUSER;
@ -57,8 +57,7 @@ s32 cellUserInfoEnableOverlay()
 s32 cellUserInfoGetList(vm::ptr<u32> listNum, vm::ptr<CellUserInfoUserList> listBuf, vm::ptr<u32> currentUserId)
 {
-	cellUserInfo.Warning("cellUserInfoGetList(listNum_addr=0x%x, listBuf_addr=0x%x, currentUserId_addr=0x%x)",
+	cellUserInfo.Warning("cellUserInfoGetList(listNum=*0x%x, listBuf=*0x%x, currentUserId=*0x%x)", listNum, listBuf, currentUserId);
 		listNum.addr(), listBuf.addr(), currentUserId.addr());
 	// If only listNum is NULL, an error will be returned
 	if (listBuf && !listNum)
--- a/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
@ -22,7 +22,7 @@ std::vector<SSPlayer> ssp;
 s32 cellAANAddData(u32 aan_handle, u32 aan_port, u32 offset, vm::ptr<float> addr, u32 samples)
 {
-	libmixer.Log("cellAANAddData(handle=0x%x, port=0x%x, offset=0x%x, addr_addr=0x%x, samples=%d)", aan_handle, aan_port, offset, addr.addr(), samples);
+	libmixer.Log("cellAANAddData(aan_handle=0x%x, aan_port=0x%x, offset=0x%x, addr=*0x%x, samples=%d)", aan_handle, aan_port, offset, addr, samples);
 	u32 type = aan_port >> 16;
 	u32 port = aan_port & 0xffff;
@ -43,7 +43,7 @@ s32 cellAANAddData(u32 aan_handle, u32 aan_port, u32 offset, vm::ptr<float> addr
 	if (aan_handle != 0x11111111 || samples != 256 || !type || offset != 0)
 	{
-		libmixer.Error("cellAANAddData(handle=0x%x, port=0x%x, offset=0x%x, addr_addr=0x%x, samples=%d): invalid parameters", aan_handle, aan_port, offset, addr.addr(), samples);
+		libmixer.Error("cellAANAddData(aan_handle=0x%x, aan_port=0x%x, offset=0x%x, addr=*0x%x, samples=%d): invalid parameters", aan_handle, aan_port, offset, addr, samples);
 		return CELL_LIBMIXER_ERROR_INVALID_PARAMATER;
 	}
@ -139,13 +139,11 @@ s32 cellAANDisconnect(u32 receive, u32 receivePortNo, u32 source, u32 sourcePort
 s32 cellSSPlayerCreate(vm::ptr<u32> handle, vm::ptr<CellSSPlayerConfig> config)
 {
-	libmixer.Warning("cellSSPlayerCreate(handle_addr=0x%x, config_addr=0x%x)",
+	libmixer.Warning("cellSSPlayerCreate(handle=*0x%x, config=*0x%x)", handle, config);
 		handle.addr(), config.addr());
 	if (config->outputMode != 0 || config->channels - 1 >= 2)
 	{
-		libmixer.Error("cellSSPlayerCreate(config.outputMode=%d, config.channels=%d): invalid parameters",
+		libmixer.Error("cellSSPlayerCreate(config.outputMode=%d, config.channels=%d): invalid parameters", config->outputMode, config->channels);
 			(u32)config->outputMode, (u32)config->channels);
 		return CELL_LIBMIXER_ERROR_INVALID_PARAMATER;
 	}
@ -183,8 +181,7 @@ s32 cellSSPlayerRemove(u32 handle)
 s32 cellSSPlayerSetWave(u32 handle, vm::ptr<CellSSPlayerWaveParam> waveInfo, vm::ptr<CellSSPlayerCommonParam> commonInfo)
 {
-	libmixer.Warning("cellSSPlayerSetWave(handle=0x%x, waveInfo_addr=0x%x, commonInfo_addr=0x%x)",
+	libmixer.Warning("cellSSPlayerSetWave(handle=0x%x, waveInfo=*0x%x, commonInfo=*0x%x)", handle, waveInfo, commonInfo);
 		handle, waveInfo.addr(), commonInfo.addr());
 	std::lock_guard<std::mutex> lock(mixer_mutex);
@ -207,7 +204,7 @@ s32 cellSSPlayerSetWave(u32 handle, vm::ptr<CellSSPlayerWaveParam> waveInfo, vm:
 s32 cellSSPlayerPlay(u32 handle, vm::ptr<CellSSPlayerRuntimeInfo> info)
 {
-	libmixer.Warning("cellSSPlayerPlay(handle=0x%x, info_addr=0x%x)", handle, info.addr());
+	libmixer.Warning("cellSSPlayerPlay(handle=0x%x, info=*0x%x)", handle, info);
 	std::lock_guard<std::mutex> lock(mixer_mutex);
@ -250,7 +247,7 @@ s32 cellSSPlayerStop(u32 handle, u32 mode)
 s32 cellSSPlayerSetParam(u32 handle, vm::ptr<CellSSPlayerRuntimeInfo> info)
 {
-	libmixer.Warning("cellSSPlayerSetParam(handle=0x%x, info_addr=0x%x)", handle, info.addr());
+	libmixer.Warning("cellSSPlayerSetParam(handle=0x%x, info=*0x%x)", handle, info);
 	std::lock_guard<std::mutex> lock(mixer_mutex);
@ -293,7 +290,7 @@ s32 cellSSPlayerGetState(u32 handle)
 s32 cellSurMixerCreate(vm::cptr<CellSurMixerConfig> config)
 {
-	libmixer.Warning("cellSurMixerCreate(config_addr=0x%x)", config.addr());
+	libmixer.Warning("cellSurMixerCreate(config=*0x%x)", config);
 	g_surmx.audio_port = g_audio.open_port();
@ -469,43 +466,46 @@ s32 cellSurMixerCreate(vm::cptr<CellSurMixerConfig> config)
 s32 cellSurMixerGetAANHandle(vm::ptr<u32> handle)
 {
-	libmixer.Warning("cellSurMixerGetAANHandle(handle_addr=0x%x) -> %d", handle.addr(), 0x11111111);
+	libmixer.Warning("cellSurMixerGetAANHandle(handle=*0x%x) -> %d", handle, 0x11111111);
 	*handle = 0x11111111;
 	return CELL_OK;
 }
 s32 cellSurMixerChStripGetAANPortNo(vm::ptr<u32> port, u32 type, u32 index)
 {
-	libmixer.Warning("cellSurMixerChStripGetAANPortNo(port_addr=0x%x, type=0x%x, index=0x%x) -> 0x%x", port.addr(), type, index, (type << 16) | index);
+	libmixer.Warning("cellSurMixerChStripGetAANPortNo(port=*0x%x, type=0x%x, index=0x%x) -> 0x%x", port, type, index, (type << 16) | index);
 	*port = (type << 16) | index;
 	return CELL_OK;
 }
 s32 cellSurMixerSetNotifyCallback(vm::ptr<CellSurMixerNotifyCallbackFunction> func, vm::ptr<void> arg)
 {
-	libmixer.Warning("cellSurMixerSetNotifyCallback(func_addr=0x%x, arg=0x%x)", func.addr(), arg.addr());
+	libmixer.Warning("cellSurMixerSetNotifyCallback(func=*0x%x, arg=*0x%x)", func, arg);
 	if (surMixerCb)
 	{
-		libmixer.Error("cellSurMixerSetNotifyCallback: surMixerCb already set (addr=0x%x)", surMixerCb.addr());
+		libmixer.Error("cellSurMixerSetNotifyCallback: surMixerCb already set (*0x%x)", surMixerCb);
 	}
 	surMixerCb = func;
 	surMixerCbArg = arg;
 	return CELL_OK;
 }
 s32 cellSurMixerRemoveNotifyCallback(vm::ptr<CellSurMixerNotifyCallbackFunction> func)
 {
-	libmixer.Warning("cellSurMixerRemoveNotifyCallback(func_addr=0x%x)", func.addr());
+	libmixer.Warning("cellSurMixerRemoveNotifyCallback(func=*0x%x)", func);
-	if (surMixerCb.addr() != func.addr())
+	if (surMixerCb != func)
 	{
-		libmixer.Error("cellSurMixerRemoveNotifyCallback: surMixerCb had different value (addr=0x%x)", surMixerCb.addr());
+		libmixer.Error("cellSurMixerRemoveNotifyCallback: surMixerCb had different value (*0x%x)", surMixerCb);
 	}
 	else
 	{
-		surMixerCb.set(0);
+		surMixerCb = vm::null;
 	}
 	return CELL_OK;
 }
@ -568,7 +568,7 @@ s32 cellSurMixerSurBusAddData(u32 busNo, u32 offset, vm::ptr<float> addr, u32 sa
 s32 cellSurMixerChStripSetParameter(u32 type, u32 index, vm::ptr<CellSurMixerChStripParam> param)
 {
-	libmixer.Todo("cellSurMixerChStripSetParameter(type=%d, index=%d, param_addr=0x%x)", type, index, param.addr());
+	libmixer.Todo("cellSurMixerChStripSetParameter(type=%d, index=%d, param=*0x%x)", type, index, param);
 	return CELL_OK;
 }
@ -588,7 +588,7 @@ s32 cellSurMixerPause(u32 type)
 s32 cellSurMixerGetCurrentBlockTag(vm::ptr<u64> tag)
 {
-	libmixer.Log("cellSurMixerGetCurrentBlockTag(tag_addr=0x%x)", tag.addr());
+	libmixer.Log("cellSurMixerGetCurrentBlockTag(tag=*0x%x)", tag);
 	*tag = mixcount;
 	return CELL_OK;
@ -596,7 +596,7 @@ s32 cellSurMixerGetCurrentBlockTag(vm::ptr<u64> tag)
 s32 cellSurMixerGetTimestamp(u64 tag, vm::ptr<u64> stamp)
 {
-	libmixer.Log("cellSurMixerGetTimestamp(tag=0x%llx, stamp_addr=0x%x)", tag, stamp.addr());
+	libmixer.Log("cellSurMixerGetTimestamp(tag=0x%llx, stamp=*0x%x)", tag, stamp);
 	*stamp = g_audio.start_time + (tag) * 256000000 / 48000; // ???
 	return CELL_OK;
--- a/rpcs3/Emu/SysCalls/Modules/sceNpClans.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sceNpClans.cpp
@ -22,7 +22,7 @@ sceNpClansInternal sceNpClansInstance;
 s32 sceNpClansInit(vm::ptr<SceNpCommunicationId> commId, vm::ptr<SceNpCommunicationPassphrase> passphrase, vm::ptr<void> pool, vm::ptr<u32> poolSize, u32 flags)
 {
-	sceNpClans.Warning("sceNpClansInit(commId_addr=0x%x, passphrase_addr=0x%x, pool_addr=0x%x,poolSize_addr=0x%x, flags=%d)", commId.addr(), passphrase.addr(), pool.addr(), poolSize.addr(), flags);
+	sceNpClans.Warning("sceNpClansInit(commId=*0x%x, passphrase=*0x%x, pool=*0x%x, poolSize=*0x%x, flags=0x%x)", commId, passphrase, pool, poolSize, flags);
 	if (sceNpClansInstance.m_bSceNpClansInitialized)
 		return SCE_NP_CLANS_ERROR_ALREADY_INITIALIZED;
@ -49,7 +49,7 @@ s32 sceNpClansTerm()
 s32 sceNpClansCreateRequest(vm::ptr<SceNpClansRequestHandle> handle, u64 flags)
 {
-	sceNpClans.Todo("sceNpClansCreateRequest(handle_addr=0x%x, flags=0x%llx)", handle.addr(), flags);
+	sceNpClans.Todo("sceNpClansCreateRequest(handle=*0x%x, flags=0x%llx)", handle, flags);
 	if (!sceNpClansInstance.m_bSceNpClansInitialized)
 		return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
--- a/rpcs3/Emu/SysCalls/Modules/sys_net.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sys_net.cpp
@ -97,7 +97,7 @@ namespace sys_net_func
 	// Functions
 	s32 accept(s32 s, vm::ptr<sys_net_sockaddr> addr, vm::ptr<pck_len_t> paddrlen)
 	{
-		sys_net.Warning("accept(s=%d, family_addr=0x%x, paddrlen=0x%x)", s, addr.addr(), paddrlen.addr());
+		sys_net.Warning("accept(s=%d, family=*0x%x, paddrlen=*0x%x)", s, addr, paddrlen);
 		if (!addr) {
 			int ret = ::accept(s, nullptr, nullptr);
 			*g_lastError = getLastError();
@ -117,7 +117,7 @@ namespace sys_net_func
 	s32 bind(s32 s, vm::ptr<sys_net_sockaddr_in> addr, u32 addrlen)
 	{
-		sys_net.Warning("bind(s=%d, family_addr=0x%x, addrlen=%d)", s, addr.addr(), addrlen);
+		sys_net.Warning("bind(s=%d, family=*0x%x, addrlen=%d)", s, addr, addrlen);
 		sockaddr_in saddr;
 		memcpy(&saddr, addr.get_ptr(), sizeof(sockaddr_in));
 		saddr.sin_family = addr->sin_family;
@ -130,7 +130,7 @@ namespace sys_net_func
 	s32 connect(s32 s, vm::ptr<sys_net_sockaddr_in> addr, u32 addrlen)
 	{
-		sys_net.Warning("connect(s=%d, family_addr=0x%x, addrlen=%d)", s, addr.addr(), addrlen);
+		sys_net.Warning("connect(s=%d, family=*0x%x, addrlen=%d)", s, addr, addrlen);
 		sockaddr_in saddr;
 		memcpy(&saddr, addr.get_ptr(), sizeof(sockaddr_in));
 		saddr.sin_family = addr->sin_family;
@ -173,7 +173,7 @@ namespace sys_net_func
 	s32 inet_addr(vm::cptr<char> cp)
 	{
-		sys_net.Warning("inet_addr(cp_addr=0x%x['%s'])", cp.addr(), cp.get_ptr());
+		sys_net.Warning("inet_addr(cp=*0x%x)", cp.addr());
 		return htonl(::inet_addr(cp.get_ptr())); // return a big-endian IP address (WTF? function should return LITTLE-ENDIAN value)
 	}
@ -221,7 +221,7 @@ namespace sys_net_func
 	s32 inet_pton(s32 af, vm::cptr<char> src, vm::ptr<char> dst)
 	{
-		sys_net.Warning("inet_pton(af=%d, src_addr=0x%x, dst_addr=0x%x)", af, src.addr(), dst.addr());
+		sys_net.Warning("inet_pton(af=%d, src=*0x%x, dst=*0x%x)", af, src, dst);
 		return ::inet_pton(af, src.get_ptr(), dst.get_ptr());
 	}
@ -236,7 +236,7 @@ namespace sys_net_func
 	s32 recv(s32 s, vm::ptr<char> buf, u32 len, s32 flags)
 	{
-		sys_net.Warning("recv(s=%d, buf_addr=0x%x, len=%d, flags=0x%x)", s, buf.addr(), len, flags);
+		sys_net.Warning("recv(s=%d, buf=*0x%x, len=%d, flags=0x%x)", s, buf, len, flags);
 		int ret = ::recv(s, buf.get_ptr(), len, flags);
 		*g_lastError = getLastError();
@ -245,8 +245,7 @@ namespace sys_net_func
 	s32 recvfrom(s32 s, vm::ptr<char> buf, u32 len, s32 flags, vm::ptr<sys_net_sockaddr> addr, vm::ptr<pck_len_t> paddrlen)
 	{
-		sys_net.Warning("recvfrom(s=%d, buf_addr=0x%x, len=%d, flags=0x%x, addr_addr=0x%x, paddrlen=0x%x)",
+		sys_net.Warning("recvfrom(s=%d, buf=*0x%x, len=%d, flags=0x%x, addr=*0x%x, paddrlen=*0x%x)", s, buf, len, flags, addr, paddrlen);
 			s, buf.addr(), len, flags, addr.addr(), paddrlen.addr());
 		sockaddr _addr;
 		memcpy(&_addr, addr.get_ptr(), sizeof(sockaddr));
@ -266,7 +265,7 @@ namespace sys_net_func
 	s32 send(s32 s, vm::cptr<char> buf, u32 len, s32 flags)
 	{
-		sys_net.Warning("send(s=%d, buf_addr=0x%x, len=%d, flags=0x%x)", s, buf.addr(), len, flags);
+		sys_net.Warning("send(s=%d, buf=*0x%x, len=%d, flags=0x%x)", s, buf, len, flags);
 		int ret = ::send(s, buf.get_ptr(), len, flags);
 		*g_lastError = getLastError();
@ -281,8 +280,7 @@ namespace sys_net_func
 	s32 sendto(s32 s, vm::cptr<char> buf, u32 len, s32 flags, vm::ptr<sys_net_sockaddr> addr, u32 addrlen)
 	{
-		sys_net.Warning("sendto(s=%d, buf_addr=0x%x, len=%d, flags=0x%x, addr=0x%x, addrlen=%d)",
+		sys_net.Warning("sendto(s=%d, buf=*0x%x, len=%d, flags=0x%x, addr=*0x%x, addrlen=%d)", s, buf, len, flags, addr, addrlen);
 			s, buf.addr(), len, flags, addr.addr(), addrlen);
 		sockaddr _addr;
 		memcpy(&_addr, addr.get_ptr(), sizeof(sockaddr));
@ -294,7 +292,7 @@ namespace sys_net_func
 	s32 setsockopt(s32 s, s32 level, s32 optname, vm::cptr<char> optval, u32 optlen)
 	{
-		sys_net.Warning("socket(s=%d, level=%d, optname=%d, optval_addr=0x%x, optlen=%d)", s, level, optname, optval.addr(), optlen);
+		sys_net.Warning("socket(s=%d, level=%d, optname=%d, optval=*0x%x, optlen=%d)", s, level, optname, optval, optlen);
 		int ret = ::setsockopt(s, level, optname, optval.get_ptr(), optlen);
 		*g_lastError = getLastError();
@ -344,7 +342,7 @@ namespace sys_net_func
 s32 sys_net_initialize_network_ex(vm::ptr<sys_net_initialize_parameter> param)
 {
-	sys_net.Warning("sys_net_initialize_network_ex(param_addr=0x%x)", param.addr());
+	sys_net.Warning("sys_net_initialize_network_ex(param=*0x%x)", param);
 	g_lastError = vm::ptr<s32>::make((u32)Memory.Alloc(4, 1));
 #ifdef _WIN32
 	WSADATA wsaData;
--- a/rpcs3/Emu/SysCalls/lv2/sys_rsx.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_rsx.cpp
@ -10,12 +10,14 @@ SysCallBase sys_rsx("sys_rsx");
 s32 sys_rsx_device_open()
 {
 	sys_rsx.Todo("sys_rsx_device_open()");
 	return CELL_OK;
 }
 s32 sys_rsx_device_close()
 {
 	sys_rsx.Todo("sys_rsx_device_close()");
 	return CELL_OK;
 }
@ -29,10 +31,10 @@ s32 sys_rsx_device_close()
 * @param a6 (IN): E.g. Immediate value passed in cellGcmSys is 16. 
 * @param a7 (IN): E.g. Immediate value passed in cellGcmSys is 8.
 */
-s32 sys_rsx_memory_allocate(vm::ptr<u32> mem_handle, vm::ptr<u32> mem_addr, u32 size, u64 flags, u64 a5, u64 a6, u64 a7)
+s32 sys_rsx_memory_allocate(vm::ptr<u32> mem_handle, vm::ptr<u64> mem_addr, u32 size, u64 flags, u64 a5, u64 a6, u64 a7)
 {
-	sys_rsx.Todo("sys_rsx_memory_allocate(mem_handle_addr=0x%x, local_mem_addr=0x%x, size=0x%x, flags=0x%x, a5=%d, a6=%d, a7=%d)",
+	sys_rsx.Todo("sys_rsx_memory_allocate(mem_handle=*0x%x, mem_addr=*0x%x, size=0x%x, flags=0x%llx, a5=0x%llx, a6=0x%llx, a7=0x%llx)", mem_handle, mem_addr, size, flags, a5, a6, a7);
-		mem_handle.addr(), mem_addr.addr(), size, flags, a5, a6, a7);
+
 	return CELL_OK;
 }
@ -42,7 +44,8 @@ s32 sys_rsx_memory_allocate(vm::ptr<u32> mem_handle, vm::ptr<u32> mem_addr, u32
 */
 s32 sys_rsx_memory_free(u32 mem_handle)
 {
-	sys_rsx.Todo("sys_rsx_memory_free(mem_handle=%d)", mem_handle);
+	sys_rsx.Todo("sys_rsx_memory_free(mem_handle=0x%x)", mem_handle);
 	return CELL_OK;
 }
@ -57,8 +60,8 @@ s32 sys_rsx_memory_free(u32 mem_handle)
 */
 s32 sys_rsx_context_allocate(vm::ptr<u32> context_id, vm::ptr<u32> lpar_dma_control, vm::ptr<u32> lpar_driver_info, vm::ptr<u32> lpar_reports, u64 mem_ctx, u64 system_mode)
 {
-	sys_rsx.Todo("sys_rsx_context_allocate(context_id_addr=0x%x, lpar_dma_control_addr=0x%x, lpar_driver_info_addr=0x%x, lpar_reports_addr=0x%x, mem_ctx=0x%x, system_mode=0x%x)",
+	sys_rsx.Todo("sys_rsx_context_allocate(context_id=*0x%x, lpar_dma_control=*0x%x, lpar_driver_info=*0x%x, lpar_reports=*0x%x, mem_ctx=0x%llx, system_mode=0x%llx)",
-		context_id.addr(), lpar_dma_control.addr(), lpar_driver_info.addr(), lpar_reports.addr(), mem_ctx, system_mode);
+		context_id, lpar_dma_control, lpar_driver_info, lpar_reports, mem_ctx, system_mode);
 	return CELL_OK;
 }
@ -69,7 +72,8 @@ s32 sys_rsx_context_allocate(vm::ptr<u32> context_id, vm::ptr<u32> lpar_dma_cont
 */
 s32 sys_rsx_context_free(u32 context_id)
 {
-	sys_rsx.Todo("sys_rsx_context_free(context_id=%d)", context_id);
+	sys_rsx.Todo("sys_rsx_context_free(context_id=0x%x)", context_id);
 	return CELL_OK;
 }
@ -83,8 +87,8 @@ s32 sys_rsx_context_free(u32 context_id)
 */
 s32 sys_rsx_context_iomap(u32 context_id, u32 io, u32 ea, u32 size, u64 flags)
 {
-	sys_rsx.Todo("sys_rsx_context_iomap(context_id=0x%x, io=0x%x, ea=0x%x, size=0x%x, flags=0x%llx)",
+	sys_rsx.Todo("sys_rsx_context_iomap(context_id=0x%x, io=0x%x, ea=0x%x, size=0x%x, flags=0x%llx)", context_id, io, ea, size, flags);
-		context_id, io, ea, size, flags);
+
 	return CELL_OK;
 }
@ -97,8 +101,8 @@ s32 sys_rsx_context_iomap(u32 context_id, u32 io, u32 ea, u32 size, u64 flags)
 */
 s32 sys_rsx_context_iounmap(u32 context_id, u32 a2, u32 io_addr, u32 size)
 {
-	sys_rsx.Todo("sys_rsx_context_iounmap(context_id=0x%x, a2=0x%x, io_addr=0x%x, size=0x%x)",
+	sys_rsx.Todo("sys_rsx_context_iounmap(context_id=0x%x, a2=0x%x, io_addr=0x%x, size=0x%x)", context_id, a2, io_addr, size);
-		context_id, a2, io_addr, size);
+
 	return CELL_OK;
 }
@ -113,8 +117,7 @@ s32 sys_rsx_context_iounmap(u32 context_id, u32 a2, u32 io_addr, u32 size)
 */
 s32 sys_rsx_context_attribute(s32 context_id, u32 package_id, u64 a3, u64 a4, u64 a5, u64 a6)
 {
-	sys_rsx.Todo("sys_rsx_context_attribute(context_id=0x%x, package_id=0x%x, a3=0x%llx, a4=0x%llx, a5=0x%llx, a6=0x%llx)",
+	sys_rsx.Todo("sys_rsx_context_attribute(context_id=0x%x, package_id=0x%x, a3=0x%llx, a4=0x%llx, a5=0x%llx, a6=0x%llx)", context_id, package_id, a3, a4, a5, a6);
 		context_id, package_id, a3, a4, a5, a6);
 	switch(package_id)
 	{
@ -170,9 +173,9 @@ s32 sys_rsx_context_attribute(s32 context_id, u32 package_id, u64 a3, u64 a4, u6
 * @param a2 (OUT): Unused?
 * @param dev_id (IN): An immediate value and always 8. (cellGcmInitPerfMon uses 11, 10, 9, 7, 12 successively).
 */
-s32 sys_rsx_device_map(vm::ptr<u32> a1, vm::ptr<u32> a2, u32 dev_id)
+s32 sys_rsx_device_map(vm::ptr<u32> addr, vm::ptr<u32> a2, u32 dev_id)
 {
-	sys_rsx.Todo("sys_rsx_device_map(a1_addr=0x%x, a2_addr=0x%x, a3=%d)", a1.addr(), a2.addr(), dev_id);
+	sys_rsx.Todo("sys_rsx_device_map(addr=*0x%x, a2=0x%x, dev_id=0x%x)", addr, a2, dev_id);
 	if (dev_id > 15) {
 		// TODO: Throw RSX error
@ -193,12 +196,14 @@ s32 sys_rsx_device_map(vm::ptr<u32> a1, vm::ptr<u32> a2, u32 dev_id)
 */
 s32 sys_rsx_device_unmap(u32 dev_id)
 {
-	sys_rsx.Todo("sys_rsx_device_unmap(a1=%d)", dev_id);
+	sys_rsx.Todo("sys_rsx_device_unmap(dev_id=0x%x)", dev_id);
 	return CELL_OK;
 }
-s32 sys_rsx_attribute()
+s32 sys_rsx_attribute(u32 a1, u32 a2, u32 a3, u32 a4, u32 a5)
 {
-	sys_rsx.Todo("sys_rsx_attribute()");
+	sys_rsx.Todo("sys_rsx_attribute(a1=0x%x, a2=0x%x, a3=0x%x, a4=0x%x, a5=0x%x)", a1, a2, a3, a4, a5);
 	return CELL_OK;
 }
--- a/rpcs3/Emu/SysCalls/lv2/sys_rsx.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_rsx.h
@ -5,13 +5,13 @@ namespace vm { using namespace ps3; }
 // SysCalls
 s32 sys_rsx_device_open();
 s32 sys_rsx_device_close();
-s32 sys_rsx_memory_allocate(vm::ptr<u32> mem_handle, vm::ptr<u32> mem_addr, u32 size, u64 flags, u64 a5, u64 a6, u64 a7);
+s32 sys_rsx_memory_allocate(vm::ptr<u32> mem_handle, vm::ptr<u64> mem_addr, u32 size, u64 flags, u64 a5, u64 a6, u64 a7);
 s32 sys_rsx_memory_free(u32 mem_handle);
 s32 sys_rsx_context_allocate(vm::ptr<u32> context_id, vm::ptr<u32> lpar_dma_control, vm::ptr<u32> lpar_driver_info, vm::ptr<u32> lpar_reports, u64 mem_ctx, u64 system_mode);
 s32 sys_rsx_context_free(u32 context_id);
 s32 sys_rsx_context_iomap(u32 context_id, u32 io, u32 ea, u32 size, u64 flags);
 s32 sys_rsx_context_iounmap(u32 context_id, u32 a2, u32 io_addr, u32 size);
 s32 sys_rsx_context_attribute(s32 context_id, u32 package_id, u64 a3, u64 a4, u64 a5, u64 a6);
-s32 sys_rsx_device_map(vm::ptr<u32> a1, vm::ptr<u32> a2, u32 dev_id);
+s32 sys_rsx_device_map(vm::ptr<u32> addr, vm::ptr<u32> a2, u32 dev_id);
 s32 sys_rsx_device_unmap(u32 dev_id);
-s32 sys_rsx_attribute();
+s32 sys_rsx_attribute(u32 a1, u32 a2, u32 a3, u32 a4, u32 a5);