vm::cptr/bcptr/lcptr used widely for const pointers

rpcs3/Emu/ARMv7/Modules/sceAppUtil.cpp

@@ -4,7 +4,7 @@
 
 #include "sceAppUtil.h"
 
-s32 sceAppUtilInit(vm::ptr<const SceAppUtilInitParam> initParam, vm::ptr<SceAppUtilBootParam> bootParam)
+s32 sceAppUtilInit(vm::cptr<SceAppUtilInitParam> initParam, vm::ptr<SceAppUtilBootParam> bootParam)
 {
 	throw __FUNCTION__;
 }
@@ -14,27 +14,27 @@ s32 sceAppUtilShutdown()
 	throw __FUNCTION__;
 }
 
-s32 sceAppUtilSaveDataSlotCreate(u32 slotId, vm::ptr<const SceAppUtilSaveDataSlotParam> param, vm::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
+s32 sceAppUtilSaveDataSlotCreate(u32 slotId, vm::cptr<SceAppUtilSaveDataSlotParam> param, vm::cptr<SceAppUtilSaveDataMountPoint> mountPoint)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAppUtilSaveDataSlotDelete(u32 slotId, vm::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
+s32 sceAppUtilSaveDataSlotDelete(u32 slotId, vm::cptr<SceAppUtilSaveDataMountPoint> mountPoint)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAppUtilSaveDataSlotSetParam(u32 slotId, vm::ptr<const SceAppUtilSaveDataSlotParam> param, vm::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
+s32 sceAppUtilSaveDataSlotSetParam(u32 slotId, vm::cptr<SceAppUtilSaveDataSlotParam> param, vm::cptr<SceAppUtilSaveDataMountPoint> mountPoint)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAppUtilSaveDataSlotGetParam(u32 slotId, vm::ptr<SceAppUtilSaveDataSlotParam> param, vm::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
+s32 sceAppUtilSaveDataSlotGetParam(u32 slotId, vm::ptr<SceAppUtilSaveDataSlotParam> param, vm::cptr<SceAppUtilSaveDataMountPoint> mountPoint)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAppUtilSaveDataFileSave(vm::ptr<const SceAppUtilSaveDataFileSlot> slot, vm::ptr<const SceAppUtilSaveDataFile> files, u32 fileNum, vm::ptr<const SceAppUtilSaveDataMountPoint> mountPoint, vm::ptr<u32> requiredSizeKB)
+s32 sceAppUtilSaveDataFileSave(vm::cptr<SceAppUtilSaveDataFileSlot> slot, vm::cptr<SceAppUtilSaveDataFile> files, u32 fileNum, vm::cptr<SceAppUtilSaveDataMountPoint> mountPoint, vm::ptr<u32> requiredSizeKB)
 {
 	throw __FUNCTION__;
 }
@@ -59,7 +59,7 @@ s32 sceAppUtilSystemParamGetString(u32 paramId, vm::ptr<char> buf, u32 bufSize)
 	throw __FUNCTION__;
 }
 
-s32 sceAppUtilSaveSafeMemory(vm::ptr<const void> buf, u32 bufSize, s64 offset)
+s32 sceAppUtilSaveSafeMemory(vm::cptr<void> buf, u32 bufSize, s64 offset)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceAppUtil.h

@@ -50,7 +50,7 @@ struct SceAppUtilSaveDataSlot
 
 struct SceAppUtilSaveDataFile
 {
-	vm::lptr<const char> filePath;
+	vm::lcptr<char> filePath;
 	vm::lptr<void> buf;
 	le_t<u32> bufSize;
 	le_t<s64> offset;

rpcs3/Emu/ARMv7/Modules/sceCommonDialog.cpp

@@ -4,12 +4,12 @@
 
 #include "sceCommonDialog.h"
 
-s32 sceCommonDialogUpdate(vm::ptr<const SceCommonDialogUpdateParam> updateParam)
+s32 sceCommonDialogUpdate(vm::cptr<SceCommonDialogUpdateParam> updateParam)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceMsgDialogInit(vm::ptr<const SceMsgDialogParam> param)
+s32 sceMsgDialogInit(vm::cptr<SceMsgDialogParam> param)
 {
 	throw __FUNCTION__;
 }
@@ -74,7 +74,7 @@ s32 sceNetCheckDialogTerm()
 	throw __FUNCTION__;
 }
 
-s32 sceSaveDataDialogInit(vm::ptr<const SceSaveDataDialogParam> param)
+s32 sceSaveDataDialogInit(vm::cptr<SceSaveDataDialogParam> param)
 {
 	throw __FUNCTION__;
 }
@@ -109,12 +109,12 @@ s32 sceSaveDataDialogSubClose()
 	throw __FUNCTION__;
 }
 
-s32 sceSaveDataDialogContinue(vm::ptr<const SceSaveDataDialogParam> param)
+s32 sceSaveDataDialogContinue(vm::cptr<SceSaveDataDialogParam> param)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSaveDataDialogFinish(vm::ptr<const SceSaveDataDialogFinishParam> param)
+s32 sceSaveDataDialogFinish(vm::cptr<SceSaveDataDialogFinishParam> param)
 {
 	throw __FUNCTION__;
 }
@@ -129,7 +129,7 @@ s32 sceSaveDataDialogProgressBarSetValue(s32 target, u32 rate)
 	throw __FUNCTION__;
 }
 
-s32 sceImeDialogInit(vm::ptr<const SceImeDialogParam> param)
+s32 sceImeDialogInit(vm::cptr<SceImeDialogParam> param)
 {
 	throw __FUNCTION__;
 }
@@ -154,7 +154,7 @@ s32 sceImeDialogTerm()
 	throw __FUNCTION__;
 }
 
-s32 scePhotoImportDialogInit(vm::ptr<const ScePhotoImportDialogParam> param)
+s32 scePhotoImportDialogInit(vm::cptr<ScePhotoImportDialogParam> param)
 {
 	throw __FUNCTION__;
 }
@@ -179,7 +179,7 @@ s32 scePhotoImportDialogAbort()
 	throw __FUNCTION__;
 }
 
-s32 scePhotoReviewDialogInit(vm::ptr<const ScePhotoReviewDialogParam> param)
+s32 scePhotoReviewDialogInit(vm::cptr<ScePhotoReviewDialogParam> param)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceCommonDialog.h

@@ -40,7 +40,7 @@ struct SceCommonDialogUpdateParam
 struct SceMsgDialogUserMessageParam
 {
 	le_t<s32> buttonType;
-	vm::lptr<const char> msg;
+	vm::lcptr<char> msg;
 	char reserved[32];
 };
 
@@ -61,7 +61,7 @@ struct SceMsgDialogProgressBarParam
 {
 	le_t<s32> barType;
 	SceMsgDialogSystemMessageParam sysMsgParam;
-	vm::lptr<const char> msg;
+	vm::lcptr<char> msg;
 	char reserved[32];
 };
 
@@ -107,18 +107,18 @@ struct SceSaveDataDialogFixedParam
 
 struct SceSaveDataDialogListParam
 {
-	vm::lptr<const u32> slotList;
+	vm::lcptr<u32> slotList;
 	le_t<u32> slotListSize;
 	le_t<s32> focusPos;
 	le_t<u32> focusId;
-	vm::lptr<const char> listTitle;
+	vm::lcptr<char> listTitle;
 	char reserved[32];
 };
 
 struct SceSaveDataDialogUserMessageParam
 {
 	le_t<s32> buttonType;
-	vm::lptr<const char> msg;
+	vm::lcptr<char> msg;
 	le_t<u32> targetSlot;
 	char reserved[32];
 };
@@ -142,15 +142,15 @@ struct SceSaveDataDialogProgressBarParam
 {
 	le_t<s32> barType;
 	SceSaveDataDialogSystemMessageParam sysMsgParam;
-	vm::lptr<const char> msg;
+	vm::lcptr<char> msg;
 	le_t<u32> targetSlot;
 	char reserved[32];
 };
 
 struct SceSaveDataDialogSlotConfigParam
 {
-	vm::lptr<const SceAppUtilSaveDataMountPoint> mountPoint;
+	vm::lcptr<SceAppUtilSaveDataMountPoint> mountPoint;
-	vm::lptr<const char> appSubDir;
+	vm::lcptr<char> appSubDir;
 	char reserved[32];
 };
 
@@ -207,7 +207,7 @@ struct SceImeDialogParam
 	vm::lptr<SceImeCharFilter> filter;
 	le_t<u32> dialogMode;
 	le_t<u32> textBoxMode;
-	vm::lptr<const u16> title;
+	vm::lcptr<u16> title;
 	le_t<u32> maxTextLength;
 	vm::lptr<u16> initialText;
 	vm::lptr<u16> inputTextBuffer;

rpcs3/Emu/ARMv7/Modules/sceCtrl.cpp

@@ -34,7 +34,7 @@ s32 sceCtrlReadBufferNegative(s32 port, vm::ptr<SceCtrlData> pData, s32 nBufs)
 	throw __FUNCTION__;
 }
 
-s32 sceCtrlSetRapidFire(s32 port, s32 idx, vm::ptr<const SceCtrlRapidFireRule> pRule)
+s32 sceCtrlSetRapidFire(s32 port, s32 idx, vm::cptr<SceCtrlRapidFireRule> pRule)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceDbg.cpp

@@ -14,12 +14,12 @@ s32 sceDbgSetBreakOnErrorState(SceDbgBreakOnErrorState state)
 	throw __FUNCTION__;
 }
 
-s32 sceDbgAssertionHandler(vm::ptr<const char> pFile, s32 line, bool stop, vm::ptr<const char> pComponent, vm::ptr<const char> pMessage) // va_args...
+s32 sceDbgAssertionHandler(vm::cptr<char> pFile, s32 line, bool stop, vm::cptr<char> pComponent, vm::cptr<char> pMessage) // va_args...
 {
 	throw __FUNCTION__;
 }
 
-s32 sceDbgLoggingHandler(vm::ptr<const char> pFile, s32 line, s32 severity, vm::ptr<const char> pComponent, vm::ptr<const char> pMessage) // va_args...
+s32 sceDbgLoggingHandler(vm::cptr<char> pFile, s32 line, s32 severity, vm::cptr<char> pComponent, vm::cptr<char> pMessage) // va_args...
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceDeci4p.cpp

@@ -4,7 +4,7 @@
 
 #include "sceDeci4p.h"
 
-s32 sceKernelDeci4pOpen(vm::ptr<const char> protoname, u32 protonum, u32 bufsize)
+s32 sceKernelDeci4pOpen(vm::cptr<char> protoname, u32 protonum, u32 bufsize)
 {
 	throw __FUNCTION__;
 }
@@ -19,7 +19,7 @@ s32 sceKernelDeci4pRead(s32 socketid, vm::ptr<void> buffer, u32 size, u32 reserv
 	throw __FUNCTION__;
 }
 
-s32 sceKernelDeci4pWrite(s32 socketid, vm::ptr<const void> buffer, u32 size, u32 reserved)
+s32 sceKernelDeci4pWrite(s32 socketid, vm::cptr<void> buffer, u32 size, u32 reserved)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceDeflt.cpp

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

rpcs3/Emu/ARMv7/Modules/sceDisplay.cpp

@@ -9,7 +9,7 @@ s32 sceDisplayGetRefreshRate(vm::ptr<float> pFps)
 	throw __FUNCTION__;
 }
 
-s32 sceDisplaySetFrameBuf(vm::ptr<const SceDisplayFrameBuf> pFrameBuf, s32 iUpdateTimingMode)
+s32 sceDisplaySetFrameBuf(vm::cptr<SceDisplayFrameBuf> pFrameBuf, s32 iUpdateTimingMode)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceFiber.cpp

@@ -4,7 +4,7 @@
 
 #include "sceFiber.h"
 
-s32 _sceFiberInitializeImpl(vm::ptr<SceFiber> fiber, vm::ptr<const char> name, vm::ptr<SceFiberEntry> entry, u32 argOnInitialize, vm::ptr<void> addrContext, u32 sizeContext, vm::ptr<const SceFiberOptParam> optParam, u32 buildVersion)
+s32 _sceFiberInitializeImpl(vm::ptr<SceFiber> fiber, vm::cptr<char> name, vm::ptr<SceFiberEntry> entry, u32 argOnInitialize, vm::ptr<void> addrContext, u32 sizeContext, vm::cptr<SceFiberOptParam> optParam, u32 buildVersion)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceFios.cpp

@@ -4,7 +4,7 @@
 
 #include "sceFios.h"
 
-s32 sceFiosInitialize(vm::ptr<const SceFiosParams> pParameters)
+s32 sceFiosInitialize(vm::cptr<SceFiosParams> pParameters)
 {
 	throw __FUNCTION__;
 }
@@ -19,12 +19,12 @@ bool sceFiosIsInitialized(vm::ptr<SceFiosParams> pOutParameters)
 	throw __FUNCTION__;
 }
 
-void sceFiosUpdateParameters(vm::ptr<const SceFiosParams> pParameters)
+void sceFiosUpdateParameters(vm::cptr<SceFiosParams> pParameters)
 {
 	throw __FUNCTION__;
 }
 
-void sceFiosSetGlobalDefaultOpAttr(vm::ptr<const SceFiosOpAttr> pAttr)
+void sceFiosSetGlobalDefaultOpAttr(vm::cptr<SceFiosOpAttr> pAttr)
 {
 	throw __FUNCTION__;
 }
@@ -34,7 +34,7 @@ bool sceFiosGetGlobalDefaultOpAttr(vm::ptr<SceFiosOpAttr> pOutAttr)
 	throw __FUNCTION__;
 }
 
-void sceFiosSetThreadDefaultOpAttr(vm::ptr<const SceFiosOpAttr> pAttr)
+void sceFiosSetThreadDefaultOpAttr(vm::cptr<SceFiosOpAttr> pAttr)
 {
 	throw __FUNCTION__;
 }
@@ -109,292 +109,292 @@ bool sceFiosIsValidHandle(s32 h)
 	throw __FUNCTION__;
 }
 
-s32 sceFiosPathcmp(vm::ptr<const char> pA, vm::ptr<const char> pB)
+s32 sceFiosPathcmp(vm::cptr<char> pA, vm::cptr<char> pB)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosPathncmp(vm::ptr<const char> pA, vm::ptr<const char> pB, u32 n)
+s32 sceFiosPathncmp(vm::cptr<char> pA, vm::cptr<char> pB, u32 n)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosPrintf(vm::ptr<const char> pFormat) // va_args...
+s32 sceFiosPrintf(vm::cptr<char> pFormat) // va_args...
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosVprintf(vm::ptr<const char> pFormat) // va_list
+s32 sceFiosVprintf(vm::cptr<char> pFormat) // va_list
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFileExists(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<bool> pOutExists)
+s32 sceFiosFileExists(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, vm::ptr<bool> pOutExists)
 {
 	throw __FUNCTION__;
 }
 
-bool sceFiosFileExistsSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
+bool sceFiosFileExistsSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFileGetSize(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<s64> pOutSize)
+s32 sceFiosFileGetSize(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, vm::ptr<s64> pOutSize)
 {
 	throw __FUNCTION__;
 }
 
-s64 sceFiosFileGetSizeSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
+s64 sceFiosFileGetSizeSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFileDelete(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
+s32 sceFiosFileDelete(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFileDeleteSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
+s32 sceFiosFileDeleteSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosDirectoryExists(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<bool> pOutExists)
+s32 sceFiosDirectoryExists(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, vm::ptr<bool> pOutExists)
 {
 	throw __FUNCTION__;
 }
 
-bool sceFiosDirectoryExistsSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
+bool sceFiosDirectoryExistsSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosDirectoryCreate(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
+s32 sceFiosDirectoryCreate(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosDirectoryCreateSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
+s32 sceFiosDirectoryCreateSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosDirectoryDelete(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
+s32 sceFiosDirectoryDelete(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosDirectoryDeleteSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
+s32 sceFiosDirectoryDeleteSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosExists(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<bool> pOutExists)
+s32 sceFiosExists(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, vm::ptr<bool> pOutExists)
 {
 	throw __FUNCTION__;
 }
 
-bool sceFiosExistsSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
+bool sceFiosExistsSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosStat(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<SceFiosStat> pOutStatus)
+s32 sceFiosStat(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, vm::ptr<SceFiosStat> pOutStatus)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosStatSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<SceFiosStat> pOutStatus)
+s32 sceFiosStatSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, vm::ptr<SceFiosStat> pOutStatus)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosDelete(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
+s32 sceFiosDelete(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosDeleteSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
+s32 sceFiosDeleteSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosResolve(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const SceFiosTuple> pInTuple, vm::ptr<SceFiosTuple> pOutTuple)
+s32 sceFiosResolve(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<SceFiosTuple> pInTuple, vm::ptr<SceFiosTuple> pOutTuple)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosResolveSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const SceFiosTuple> pInTuple, vm::ptr<SceFiosTuple> pOutTuple)
+s32 sceFiosResolveSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<SceFiosTuple> pInTuple, vm::ptr<SceFiosTuple> pOutTuple)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosRename(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pOldPath, vm::ptr<const char> pNewPath)
+s32 sceFiosRename(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pOldPath, vm::cptr<char> pNewPath)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosRenameSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pOldPath, vm::ptr<const char> pNewPath)
+s32 sceFiosRenameSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pOldPath, vm::cptr<char> pNewPath)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFileRead(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<void> pBuf, s64 length, s64 offset)
+s32 sceFiosFileRead(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, vm::ptr<void> pBuf, s64 length, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-s64 sceFiosFileReadSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<void> pBuf, s64 length, s64 offset)
+s64 sceFiosFileReadSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, vm::ptr<void> pBuf, s64 length, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFileWrite(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<const void> pBuf, s64 length, s64 offset)
+s32 sceFiosFileWrite(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, vm::cptr<void> pBuf, s64 length, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-s64 sceFiosFileWriteSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<const void> pBuf, s64 length, s64 offset)
+s64 sceFiosFileWriteSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, vm::cptr<void> pBuf, s64 length, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFileTruncate(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, s64 length)
+s32 sceFiosFileTruncate(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, s64 length)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFileTruncateSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, s64 length)
+s32 sceFiosFileTruncateSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pPath, s64 length)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHOpen(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<s32> pOutFH, vm::ptr<const char> pPath, vm::ptr<const SceFiosOpenParams> pOpenParams)
+s32 sceFiosFHOpen(vm::cptr<SceFiosOpAttr> pAttr, vm::ptr<s32> pOutFH, vm::cptr<char> pPath, vm::cptr<SceFiosOpenParams> pOpenParams)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHOpenSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<s32> pOutFH, vm::ptr<const char> pPath, vm::ptr<const SceFiosOpenParams> pOpenParams)
+s32 sceFiosFHOpenSync(vm::cptr<SceFiosOpAttr> pAttr, vm::ptr<s32> pOutFH, vm::cptr<char> pPath, vm::cptr<SceFiosOpenParams> pOpenParams)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHStat(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<SceFiosStat> pOutStatus)
+s32 sceFiosFHStat(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::ptr<SceFiosStat> pOutStatus)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHStatSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<SceFiosStat> pOutStatus)
+s32 sceFiosFHStatSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::ptr<SceFiosStat> pOutStatus)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHTruncate(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, s64 length)
+s32 sceFiosFHTruncate(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, s64 length)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHTruncateSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, s64 length)
+s32 sceFiosFHTruncateSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, s64 length)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh)
+s32 sceFiosFHSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHSyncSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh)
+s32 sceFiosFHSyncSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHRead(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<void> pBuf, s64 length)
+s32 sceFiosFHRead(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::ptr<void> pBuf, s64 length)
 {
 	throw __FUNCTION__;
 }
 
-s64 sceFiosFHReadSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<void> pBuf, s64 length)
+s64 sceFiosFHReadSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::ptr<void> pBuf, s64 length)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHWrite(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const void> pBuf, s64 length)
+s32 sceFiosFHWrite(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<void> pBuf, s64 length)
 {
 	throw __FUNCTION__;
 }
 
-s64 sceFiosFHWriteSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const void> pBuf, s64 length)
+s64 sceFiosFHWriteSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<void> pBuf, s64 length)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHReadv(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt)
+s32 sceFiosFHReadv(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<SceFiosBuffer> iov, s32 iovcnt)
 {
 	throw __FUNCTION__;
 }
 
-s64 sceFiosFHReadvSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt)
+s64 sceFiosFHReadvSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<SceFiosBuffer> iov, s32 iovcnt)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHWritev(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt)
+s32 sceFiosFHWritev(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<SceFiosBuffer> iov, s32 iovcnt)
 {
 	throw __FUNCTION__;
 }
 
-s64 sceFiosFHWritevSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt)
+s64 sceFiosFHWritevSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<SceFiosBuffer> iov, s32 iovcnt)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHPread(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<void> pBuf, s64 length, s64 offset)
+s32 sceFiosFHPread(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::ptr<void> pBuf, s64 length, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-s64 sceFiosFHPreadSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<void> pBuf, s64 length, s64 offset)
+s64 sceFiosFHPreadSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::ptr<void> pBuf, s64 length, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHPwrite(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const void> pBuf, s64 length, s64 offset)
+s32 sceFiosFHPwrite(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<void> pBuf, s64 length, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-s64 sceFiosFHPwriteSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const void> pBuf, s64 length, s64 offset)
+s64 sceFiosFHPwriteSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<void> pBuf, s64 length, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHPreadv(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt, s64 offset)
+s32 sceFiosFHPreadv(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<SceFiosBuffer> iov, s32 iovcnt, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-s64 sceFiosFHPreadvSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt, s64 offset)
+s64 sceFiosFHPreadvSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<SceFiosBuffer> iov, s32 iovcnt, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHPwritev(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt, s64 offset)
+s32 sceFiosFHPwritev(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<SceFiosBuffer> iov, s32 iovcnt, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-s64 sceFiosFHPwritevSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt, s64 offset)
+s64 sceFiosFHPwritevSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh, vm::cptr<SceFiosBuffer> iov, s32 iovcnt, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHClose(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh)
+s32 sceFiosFHClose(vm::cptr<SceFiosOpAttr> pAttr, s32 fh)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHCloseSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh)
+s32 sceFiosFHCloseSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh)
 {
 	throw __FUNCTION__;
 }
@@ -409,7 +409,7 @@ s64 sceFiosFHTell(s32 fh)
 	throw __FUNCTION__;
 }
 
-vm::ptr<const char> sceFiosFHGetPath(s32 fh)
+vm::cptr<char> sceFiosFHGetPath(s32 fh)
 {
 	throw __FUNCTION__;
 }
@@ -424,37 +424,37 @@ vm::ptr<SceFiosOpenParams> sceFiosFHGetOpenParams(s32 fh)
 	throw __FUNCTION__;
 }
 
-s32 sceFiosDHOpen(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<s32> pOutDH, vm::ptr<const char> pPath, SceFiosBuffer buf)
+s32 sceFiosDHOpen(vm::cptr<SceFiosOpAttr> pAttr, vm::ptr<s32> pOutDH, vm::cptr<char> pPath, SceFiosBuffer buf)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosDHOpenSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<s32> pOutDH, vm::ptr<const char> pPath, SceFiosBuffer buf)
+s32 sceFiosDHOpenSync(vm::cptr<SceFiosOpAttr> pAttr, vm::ptr<s32> pOutDH, vm::cptr<char> pPath, SceFiosBuffer buf)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosDHRead(vm::ptr<const SceFiosOpAttr> pAttr, s32 dh, vm::ptr<SceFiosDirEntry> pOutEntry)
+s32 sceFiosDHRead(vm::cptr<SceFiosOpAttr> pAttr, s32 dh, vm::ptr<SceFiosDirEntry> pOutEntry)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosDHReadSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 dh, vm::ptr<SceFiosDirEntry> pOutEntry)
+s32 sceFiosDHReadSync(vm::cptr<SceFiosOpAttr> pAttr, s32 dh, vm::ptr<SceFiosDirEntry> pOutEntry)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosDHClose(vm::ptr<const SceFiosOpAttr> pAttr, s32 dh)
+s32 sceFiosDHClose(vm::cptr<SceFiosOpAttr> pAttr, s32 dh)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosDHCloseSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 dh)
+s32 sceFiosDHCloseSync(vm::cptr<SceFiosOpAttr> pAttr, s32 dh)
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const char> sceFiosDHGetPath(s32 dh)
+vm::cptr<char> sceFiosDHGetPath(s32 dh)
 {
 	throw __FUNCTION__;
 }
@@ -504,12 +504,12 @@ bool sceFiosOpIsCancelled(s32 op)
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceFiosOpAttr> sceFiosOpGetAttr(s32 op)
+vm::cptr<SceFiosOpAttr> sceFiosOpGetAttr(s32 op)
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const char> sceFiosOpGetPath(s32 op)
+vm::cptr<char> sceFiosOpGetPath(s32 op)
 {
 	throw __FUNCTION__;
 }
@@ -559,7 +559,7 @@ u64 sceFiosDateGetCurrent()
 	throw __FUNCTION__;
 }
 
-u64 sceFiosDateFromComponents(vm::ptr<const tm> pComponents)
+u64 sceFiosDateFromComponents(vm::cptr<tm> pComponents)
 {
 	throw __FUNCTION__;
 }
@@ -569,7 +569,7 @@ vm::ptr<tm> sceFiosDateToComponents(u64 date, vm::ptr<tm> pOutComponents)
 	throw __FUNCTION__;
 }
 
-u64 sceFiosDateFromSceDateTime(vm::ptr<const SceDateTime> pSceDateTime)
+u64 sceFiosDateFromSceDateTime(vm::cptr<SceDateTime> pSceDateTime)
 {
 	throw __FUNCTION__;
 }
@@ -579,7 +579,7 @@ vm::ptr<SceDateTime> sceFiosDateToSceDateTime(u64 date, vm::ptr<SceDateTime> pSc
 	throw __FUNCTION__;
 }
 
-s32 sceFiosOverlayAdd(vm::ptr<const SceFiosOverlay> pOverlay, vm::ptr<s32> pOutID)
+s32 sceFiosOverlayAdd(vm::cptr<SceFiosOverlay> pOverlay, vm::ptr<s32> pOutID)
 {
 	throw __FUNCTION__;
 }
@@ -594,7 +594,7 @@ s32 sceFiosOverlayGetInfo(s32 id, vm::ptr<SceFiosOverlay> pOutOverlay)
 	throw __FUNCTION__;
 }
 
-s32 sceFiosOverlayModify(s32 id, vm::ptr<const SceFiosOverlay> pNewValue)
+s32 sceFiosOverlayModify(s32 id, vm::cptr<SceFiosOverlay> pNewValue)
 {
 	throw __FUNCTION__;
 }
@@ -604,37 +604,37 @@ s32 sceFiosOverlayGetList(vm::ptr<s32> pOutIDs, u32 maxIDs, vm::ptr<u32> pActual
 	throw __FUNCTION__;
 }
 
-s32 sceFiosOverlayResolveSync(s32 resolveFlag, vm::ptr<const char> pInPath, vm::ptr<char> pOutPath, u32 maxPath)
+s32 sceFiosOverlayResolveSync(s32 resolveFlag, vm::cptr<char> pInPath, vm::ptr<char> pOutPath, u32 maxPath)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosArchiveGetMountBufferSize(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pArchivePath, vm::ptr<const SceFiosOpenParams> pOpenParams)
+s32 sceFiosArchiveGetMountBufferSize(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pArchivePath, vm::cptr<SceFiosOpenParams> pOpenParams)
 {
 	throw __FUNCTION__;
 }
 
-s64 sceFiosArchiveGetMountBufferSizeSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pArchivePath, vm::ptr<const SceFiosOpenParams> pOpenParams)
+s64 sceFiosArchiveGetMountBufferSizeSync(vm::cptr<SceFiosOpAttr> pAttr, vm::cptr<char> pArchivePath, vm::cptr<SceFiosOpenParams> pOpenParams)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosArchiveMount(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<s32> pOutFH, vm::ptr<const char> pArchivePath, vm::ptr<const char> pMountPoint, SceFiosBuffer mountBuffer, vm::ptr<const SceFiosOpenParams> pOpenParams)
+s32 sceFiosArchiveMount(vm::cptr<SceFiosOpAttr> pAttr, vm::ptr<s32> pOutFH, vm::cptr<char> pArchivePath, vm::cptr<char> pMountPoint, SceFiosBuffer mountBuffer, vm::cptr<SceFiosOpenParams> pOpenParams)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosArchiveMountSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<s32> pOutFH, vm::ptr<const char> pArchivePath, vm::ptr<const char> pMountPoint, SceFiosBuffer mountBuffer, vm::ptr<const SceFiosOpenParams> pOpenParams)
+s32 sceFiosArchiveMountSync(vm::cptr<SceFiosOpAttr> pAttr, vm::ptr<s32> pOutFH, vm::cptr<char> pArchivePath, vm::cptr<char> pMountPoint, SceFiosBuffer mountBuffer, vm::cptr<SceFiosOpenParams> pOpenParams)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosArchiveUnmount(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh)
+s32 sceFiosArchiveUnmount(vm::cptr<SceFiosOpAttr> pAttr, s32 fh)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosArchiveUnmountSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh)
+s32 sceFiosArchiveUnmountSync(vm::cptr<SceFiosOpAttr> pAttr, s32 fh)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceGxm.cpp

@@ -4,7 +4,7 @@
 
 #include "sceGxm.h"
 
-s32 sceGxmInitialize(vm::ptr<const SceGxmInitializeParams> params)
+s32 sceGxmInitialize(vm::cptr<SceGxmInitializeParams> params)
 {
 	throw __FUNCTION__;
 }
@@ -19,7 +19,7 @@ vm::ptr<volatile u32> sceGxmGetNotificationRegion()
 	throw __FUNCTION__;
 }
 
-s32 sceGxmNotificationWait(vm::ptr<const SceGxmNotification> notification)
+s32 sceGxmNotificationWait(vm::cptr<SceGxmNotification> notification)
 {
 	throw __FUNCTION__;
 }
@@ -54,7 +54,7 @@ s32 sceGxmUnmapFragmentUsseMemory(vm::ptr<void> base)
 	throw __FUNCTION__;
 }
 
-s32 sceGxmDisplayQueueAddEntry(vm::ptr<SceGxmSyncObject> oldBuffer, vm::ptr<SceGxmSyncObject> newBuffer, vm::ptr<const void> callbackData)
+s32 sceGxmDisplayQueueAddEntry(vm::ptr<SceGxmSyncObject> oldBuffer, vm::ptr<SceGxmSyncObject> newBuffer, vm::cptr<void> callbackData)
 {
 	throw __FUNCTION__;
 }
@@ -75,7 +75,7 @@ s32 sceGxmSyncObjectDestroy(vm::ptr<SceGxmSyncObject> syncObject)
 }
 
 
-s32 sceGxmCreateContext(vm::ptr<const SceGxmContextParams> params, vm::pptr<SceGxmContext> context)
+s32 sceGxmCreateContext(vm::cptr<SceGxmContextParams> params, vm::pptr<SceGxmContext> context)
 {
 	throw __FUNCTION__;
 }
@@ -91,12 +91,12 @@ void sceGxmSetValidationEnable(vm::ptr<SceGxmContext> context, bool enable)
 }
 
 
-void sceGxmSetVertexProgram(vm::ptr<SceGxmContext> context, vm::ptr<const SceGxmVertexProgram> vertexProgram)
+void sceGxmSetVertexProgram(vm::ptr<SceGxmContext> context, vm::cptr<SceGxmVertexProgram> vertexProgram)
 {
 	throw __FUNCTION__;
 }
 
-void sceGxmSetFragmentProgram(vm::ptr<SceGxmContext> context, vm::ptr<const SceGxmFragmentProgram> fragmentProgram)
+void sceGxmSetFragmentProgram(vm::ptr<SceGxmContext> context, vm::cptr<SceGxmFragmentProgram> fragmentProgram)
 {
 	throw __FUNCTION__;
 }
@@ -111,58 +111,58 @@ s32 sceGxmReserveFragmentDefaultUniformBuffer(vm::ptr<SceGxmContext> context, vm
 	throw __FUNCTION__;
 }
 
-s32 sceGxmSetVertexStream(vm::ptr<SceGxmContext> context, u32 streamIndex, vm::ptr<const void> streamData)
+s32 sceGxmSetVertexStream(vm::ptr<SceGxmContext> context, u32 streamIndex, vm::cptr<void> streamData)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmSetVertexTexture(vm::ptr<SceGxmContext> context, u32 textureIndex, vm::ptr<const SceGxmTexture> texture)
+s32 sceGxmSetVertexTexture(vm::ptr<SceGxmContext> context, u32 textureIndex, vm::cptr<SceGxmTexture> texture)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmSetFragmentTexture(vm::ptr<SceGxmContext> context, u32 textureIndex, vm::ptr<const SceGxmTexture> texture)
+s32 sceGxmSetFragmentTexture(vm::ptr<SceGxmContext> context, u32 textureIndex, vm::cptr<SceGxmTexture> texture)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmSetVertexUniformBuffer(vm::ptr<SceGxmContext> context, u32 bufferIndex, vm::ptr<const void> bufferData)
+s32 sceGxmSetVertexUniformBuffer(vm::ptr<SceGxmContext> context, u32 bufferIndex, vm::cptr<void> bufferData)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmSetFragmentUniformBuffer(vm::ptr<SceGxmContext> context, u32 bufferIndex, vm::ptr<const void> bufferData)
+s32 sceGxmSetFragmentUniformBuffer(vm::ptr<SceGxmContext> context, u32 bufferIndex, vm::cptr<void> bufferData)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmSetAuxiliarySurface(vm::ptr<SceGxmContext> context, u32 surfaceIndex, vm::ptr<const SceGxmAuxiliarySurface> surface)
+s32 sceGxmSetAuxiliarySurface(vm::ptr<SceGxmContext> context, u32 surfaceIndex, vm::cptr<SceGxmAuxiliarySurface> surface)
 {
 	throw __FUNCTION__;
 }
 
 
-void sceGxmSetPrecomputedFragmentState(vm::ptr<SceGxmContext> context, vm::ptr<const SceGxmPrecomputedFragmentState> precomputedState)
+void sceGxmSetPrecomputedFragmentState(vm::ptr<SceGxmContext> context, vm::cptr<SceGxmPrecomputedFragmentState> precomputedState)
 {
 	throw __FUNCTION__;
 }
 
-void sceGxmSetPrecomputedVertexState(vm::ptr<SceGxmContext> context, vm::ptr<const SceGxmPrecomputedVertexState> precomputedState)
+void sceGxmSetPrecomputedVertexState(vm::ptr<SceGxmContext> context, vm::cptr<SceGxmPrecomputedVertexState> precomputedState)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmDrawPrecomputed(vm::ptr<SceGxmContext> context, vm::ptr<const SceGxmPrecomputedDraw> precomputedDraw)
+s32 sceGxmDrawPrecomputed(vm::ptr<SceGxmContext> context, vm::cptr<SceGxmPrecomputedDraw> precomputedDraw)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmDraw(vm::ptr<SceGxmContext> context, SceGxmPrimitiveType primType, SceGxmIndexFormat indexType, vm::ptr<const void> indexData, u32 indexCount)
+s32 sceGxmDraw(vm::ptr<SceGxmContext> context, SceGxmPrimitiveType primType, SceGxmIndexFormat indexType, vm::cptr<void> indexData, u32 indexCount)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmDrawInstanced(vm::ptr<SceGxmContext> context, SceGxmPrimitiveType primType, SceGxmIndexFormat indexType, vm::ptr<const void> indexData, u32 indexCount, u32 indexWrap)
+s32 sceGxmDrawInstanced(vm::ptr<SceGxmContext> context, SceGxmPrimitiveType primType, SceGxmIndexFormat indexType, vm::cptr<void> indexData, u32 indexCount, u32 indexWrap)
 {
 	throw __FUNCTION__;
 }
@@ -172,17 +172,17 @@ s32 sceGxmSetVisibilityBuffer(vm::ptr<SceGxmContext> context, vm::ptr<void> buff
 	throw __FUNCTION__;
 }
 
-s32 sceGxmBeginScene(vm::ptr<SceGxmContext> context, u32 flags, vm::ptr<const SceGxmRenderTarget> renderTarget, vm::ptr<const SceGxmValidRegion> validRegion, vm::ptr<SceGxmSyncObject> vertexSyncObject, vm::ptr<SceGxmSyncObject> fragmentSyncObject, vm::ptr<const SceGxmColorSurface> colorSurface, vm::ptr<const SceGxmDepthStencilSurface> depthStencil)
+s32 sceGxmBeginScene(vm::ptr<SceGxmContext> context, u32 flags, vm::cptr<SceGxmRenderTarget> renderTarget, vm::cptr<SceGxmValidRegion> validRegion, vm::ptr<SceGxmSyncObject> vertexSyncObject, vm::ptr<SceGxmSyncObject> fragmentSyncObject, vm::cptr<SceGxmColorSurface> colorSurface, vm::cptr<SceGxmDepthStencilSurface> depthStencil)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmMidSceneFlush(vm::ptr<SceGxmContext> context, u32 flags, vm::ptr<SceGxmSyncObject> vertexSyncObject, vm::ptr<const SceGxmNotification> vertexNotification)
+s32 sceGxmMidSceneFlush(vm::ptr<SceGxmContext> context, u32 flags, vm::ptr<SceGxmSyncObject> vertexSyncObject, vm::cptr<SceGxmNotification> vertexNotification)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmEndScene(vm::ptr<SceGxmContext> context, vm::ptr<const SceGxmNotification> vertexNotification, vm::ptr<const SceGxmNotification> fragmentNotification)
+s32 sceGxmEndScene(vm::ptr<SceGxmContext> context, vm::cptr<SceGxmNotification> vertexNotification, vm::cptr<SceGxmNotification> fragmentNotification)
 {
 	throw __FUNCTION__;
 }
@@ -353,7 +353,7 @@ void sceGxmFinish(vm::ptr<SceGxmContext> context)
 	throw __FUNCTION__;
 }
 
-s32 sceGxmPushUserMarker(vm::ptr<SceGxmContext> context, vm::ptr<const char> tag)
+s32 sceGxmPushUserMarker(vm::ptr<SceGxmContext> context, vm::cptr<char> tag)
 {
 	throw __FUNCTION__;
 }
@@ -363,12 +363,12 @@ s32 sceGxmPopUserMarker(vm::ptr<SceGxmContext> context)
 	throw __FUNCTION__;
 }
 
-s32 sceGxmSetUserMarker(vm::ptr<SceGxmContext> context, vm::ptr<const char> tag)
+s32 sceGxmSetUserMarker(vm::ptr<SceGxmContext> context, vm::cptr<char> tag)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmPadHeartbeat(vm::ptr<const SceGxmColorSurface> displaySurface, vm::ptr<SceGxmSyncObject> displaySyncObject)
+s32 sceGxmPadHeartbeat(vm::cptr<SceGxmColorSurface> displaySurface, vm::ptr<SceGxmSyncObject> displaySyncObject)
 {
 	throw __FUNCTION__;
 }
@@ -388,12 +388,12 @@ s32 sceGxmColorSurfaceInitDisabled(vm::ptr<SceGxmColorSurface> surface)
 	throw __FUNCTION__;
 }
 
-bool sceGxmColorSurfaceIsEnabled(vm::ptr<const SceGxmColorSurface> surface)
+bool sceGxmColorSurfaceIsEnabled(vm::cptr<SceGxmColorSurface> surface)
 {
 	throw __FUNCTION__;
 }
 
-void sceGxmColorSurfaceGetClip(vm::ptr<const SceGxmColorSurface> surface, vm::ptr<u32> xMin, vm::ptr<u32> yMin, vm::ptr<u32> xMax, vm::ptr<u32> yMax)
+void sceGxmColorSurfaceGetClip(vm::cptr<SceGxmColorSurface> surface, vm::ptr<u32> xMin, vm::ptr<u32> yMin, vm::ptr<u32> xMax, vm::ptr<u32> yMax)
 {
 	throw __FUNCTION__;
 }
@@ -403,7 +403,7 @@ void sceGxmColorSurfaceSetClip(vm::ptr<SceGxmColorSurface> surface, u32 xMin, u3
 	throw __FUNCTION__;
 }
 
-SceGxmColorSurfaceScaleMode sceGxmColorSurfaceGetScaleMode(vm::ptr<const SceGxmColorSurface> surface)
+SceGxmColorSurfaceScaleMode sceGxmColorSurfaceGetScaleMode(vm::cptr<SceGxmColorSurface> surface)
 {
 	throw __FUNCTION__;
 }
@@ -413,7 +413,7 @@ void sceGxmColorSurfaceSetScaleMode(vm::ptr<SceGxmColorSurface> surface, SceGxmC
 	throw __FUNCTION__;
 }
 
-vm::ptr<void> sceGxmColorSurfaceGetData(vm::ptr<const SceGxmColorSurface> surface)
+vm::ptr<void> sceGxmColorSurfaceGetData(vm::cptr<SceGxmColorSurface> surface)
 {
 	throw __FUNCTION__;
 }
@@ -423,7 +423,7 @@ s32 sceGxmColorSurfaceSetData(vm::ptr<SceGxmColorSurface> surface, vm::ptr<void>
 	throw __FUNCTION__;
 }
 
-SceGxmColorFormat sceGxmColorSurfaceGetFormat(vm::ptr<const SceGxmColorSurface> surface)
+SceGxmColorFormat sceGxmColorSurfaceGetFormat(vm::cptr<SceGxmColorSurface> surface)
 {
 	throw __FUNCTION__;
 }
@@ -433,12 +433,12 @@ s32 sceGxmColorSurfaceSetFormat(vm::ptr<SceGxmColorSurface> surface, SceGxmColor
 	throw __FUNCTION__;
 }
 
-SceGxmColorSurfaceType sceGxmColorSurfaceGetType(vm::ptr<const SceGxmColorSurface> surface)
+SceGxmColorSurfaceType sceGxmColorSurfaceGetType(vm::cptr<SceGxmColorSurface> surface)
 {
 	throw __FUNCTION__;
 }
 
-u32 sceGxmColorSurfaceGetStrideInPixels(vm::ptr<const SceGxmColorSurface> surface)
+u32 sceGxmColorSurfaceGetStrideInPixels(vm::cptr<SceGxmColorSurface> surface)
 {
 	throw __FUNCTION__;
 }
@@ -453,7 +453,7 @@ s32 sceGxmDepthStencilSurfaceInitDisabled(vm::ptr<SceGxmDepthStencilSurface> sur
 	throw __FUNCTION__;
 }
 
-float sceGxmDepthStencilSurfaceGetBackgroundDepth(vm::ptr<const SceGxmDepthStencilSurface> surface)
+float sceGxmDepthStencilSurfaceGetBackgroundDepth(vm::cptr<SceGxmDepthStencilSurface> surface)
 {
 	throw __FUNCTION__;
 }
@@ -463,7 +463,7 @@ void sceGxmDepthStencilSurfaceSetBackgroundDepth(vm::ptr<SceGxmDepthStencilSurfa
 	throw __FUNCTION__;
 }
 
-u8 sceGxmDepthStencilSurfaceGetBackgroundStencil(vm::ptr<const SceGxmDepthStencilSurface> surface)
+u8 sceGxmDepthStencilSurfaceGetBackgroundStencil(vm::cptr<SceGxmDepthStencilSurface> surface)
 {
 	throw __FUNCTION__;
 }
@@ -473,7 +473,7 @@ void sceGxmDepthStencilSurfaceSetBackgroundStencil(vm::ptr<SceGxmDepthStencilSur
 	throw __FUNCTION__;
 }
 
-bool sceGxmDepthStencilSurfaceIsEnabled(vm::ptr<const SceGxmDepthStencilSurface> surface)
+bool sceGxmDepthStencilSurfaceIsEnabled(vm::cptr<SceGxmDepthStencilSurface> surface)
 {
 	throw __FUNCTION__;
 }
@@ -483,7 +483,7 @@ void sceGxmDepthStencilSurfaceSetForceLoadMode(vm::ptr<SceGxmDepthStencilSurface
 	throw __FUNCTION__;
 }
 
-SceGxmDepthStencilForceLoadMode sceGxmDepthStencilSurfaceGetForceLoadMode(vm::ptr<const SceGxmDepthStencilSurface> surface)
+SceGxmDepthStencilForceLoadMode sceGxmDepthStencilSurfaceGetForceLoadMode(vm::cptr<SceGxmDepthStencilSurface> surface)
 {
 	throw __FUNCTION__;
 }
@@ -493,12 +493,12 @@ void sceGxmDepthStencilSurfaceSetForceStoreMode(vm::ptr<SceGxmDepthStencilSurfac
 	throw __FUNCTION__;
 }
 
-SceGxmDepthStencilForceStoreMode sceGxmDepthStencilSurfaceGetForceStoreMode(vm::ptr<const SceGxmDepthStencilSurface> surface)
+SceGxmDepthStencilForceStoreMode sceGxmDepthStencilSurfaceGetForceStoreMode(vm::cptr<SceGxmDepthStencilSurface> surface)
 {
 	throw __FUNCTION__;
 }
 
-SceGxmColorSurfaceGammaMode sceGxmColorSurfaceGetGammaMode(vm::ptr<const SceGxmColorSurface> surface)
+SceGxmColorSurfaceGammaMode sceGxmColorSurfaceGetGammaMode(vm::cptr<SceGxmColorSurface> surface)
 {
 	throw __FUNCTION__;
 }
@@ -508,7 +508,7 @@ s32 sceGxmColorSurfaceSetGammaMode(vm::ptr<SceGxmColorSurface> surface, SceGxmCo
 	throw __FUNCTION__;
 }
 
-SceGxmColorSurfaceDitherMode sceGxmColorSurfaceGetDitherMode(vm::ptr<const SceGxmColorSurface> surface)
+SceGxmColorSurfaceDitherMode sceGxmColorSurfaceGetDitherMode(vm::cptr<SceGxmColorSurface> surface)
 {
 	throw __FUNCTION__;
 }
@@ -518,139 +518,139 @@ s32 sceGxmColorSurfaceSetDitherMode(vm::ptr<SceGxmColorSurface> surface, SceGxmC
 	throw __FUNCTION__;
 }
 
-SceGxmDepthStencilFormat sceGxmDepthStencilSurfaceGetFormat(vm::ptr<const SceGxmDepthStencilSurface> surface)
+SceGxmDepthStencilFormat sceGxmDepthStencilSurfaceGetFormat(vm::cptr<SceGxmDepthStencilSurface> surface)
 {
 	throw __FUNCTION__;
 }
 
-u32 sceGxmDepthStencilSurfaceGetStrideInSamples(vm::ptr<const SceGxmDepthStencilSurface> surface)
+u32 sceGxmDepthStencilSurfaceGetStrideInSamples(vm::cptr<SceGxmDepthStencilSurface> surface)
 {
 	throw __FUNCTION__;
 }
 
 
-s32 sceGxmProgramCheck(vm::ptr<const SceGxmProgram> program)
+s32 sceGxmProgramCheck(vm::cptr<SceGxmProgram> program)
 {
 	throw __FUNCTION__;
 }
 
-u32 sceGxmProgramGetSize(vm::ptr<const SceGxmProgram> program)
+u32 sceGxmProgramGetSize(vm::cptr<SceGxmProgram> program)
 {
 	throw __FUNCTION__;
 }
 
-SceGxmProgramType sceGxmProgramGetType(vm::ptr<const SceGxmProgram> program)
+SceGxmProgramType sceGxmProgramGetType(vm::cptr<SceGxmProgram> program)
 {
 	throw __FUNCTION__;
 }
 
-bool sceGxmProgramIsDiscardUsed(vm::ptr<const SceGxmProgram> program)
+bool sceGxmProgramIsDiscardUsed(vm::cptr<SceGxmProgram> program)
 {
 	throw __FUNCTION__;
 }
 
-bool sceGxmProgramIsDepthReplaceUsed(vm::ptr<const SceGxmProgram> program)
+bool sceGxmProgramIsDepthReplaceUsed(vm::cptr<SceGxmProgram> program)
 {
 	throw __FUNCTION__;
 }
 
-bool sceGxmProgramIsSpriteCoordUsed(vm::ptr<const SceGxmProgram> program)
+bool sceGxmProgramIsSpriteCoordUsed(vm::cptr<SceGxmProgram> program)
 {
 	throw __FUNCTION__;
 }
 
-u32 sceGxmProgramGetDefaultUniformBufferSize(vm::ptr<const SceGxmProgram> program)
+u32 sceGxmProgramGetDefaultUniformBufferSize(vm::cptr<SceGxmProgram> program)
 {
 	throw __FUNCTION__;
 }
 
-u32 sceGxmProgramGetParameterCount(vm::ptr<const SceGxmProgram> program)
+u32 sceGxmProgramGetParameterCount(vm::cptr<SceGxmProgram> program)
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceGxmProgramParameter> sceGxmProgramGetParameter(vm::ptr<const SceGxmProgram> program, u32 index)
+vm::cptr<SceGxmProgramParameter> sceGxmProgramGetParameter(vm::cptr<SceGxmProgram> program, u32 index)
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceGxmProgramParameter> sceGxmProgramFindParameterByName(vm::ptr<const SceGxmProgram> program, vm::ptr<const char> name)
+vm::cptr<SceGxmProgramParameter> sceGxmProgramFindParameterByName(vm::cptr<SceGxmProgram> program, vm::cptr<char> name)
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceGxmProgramParameter> sceGxmProgramFindParameterBySemantic(vm::ptr<const SceGxmProgram> program, SceGxmParameterSemantic semantic, u32 index)
+vm::cptr<SceGxmProgramParameter> sceGxmProgramFindParameterBySemantic(vm::cptr<SceGxmProgram> program, SceGxmParameterSemantic semantic, u32 index)
 {
 	throw __FUNCTION__;
 }
 
-u32 sceGxmProgramParameterGetIndex(vm::ptr<const SceGxmProgram> program, vm::ptr<const SceGxmProgramParameter> parameter)
+u32 sceGxmProgramParameterGetIndex(vm::cptr<SceGxmProgram> program, vm::cptr<SceGxmProgramParameter> parameter)
 {
 	throw __FUNCTION__;
 }
 
-SceGxmParameterCategory sceGxmProgramParameterGetCategory(vm::ptr<const SceGxmProgramParameter> parameter)
+SceGxmParameterCategory sceGxmProgramParameterGetCategory(vm::cptr<SceGxmProgramParameter> parameter)
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const char> sceGxmProgramParameterGetName(vm::ptr<const SceGxmProgramParameter> parameter)
+vm::cptr<char> sceGxmProgramParameterGetName(vm::cptr<SceGxmProgramParameter> parameter)
 {
 	throw __FUNCTION__;
 }
 
-SceGxmParameterSemantic sceGxmProgramParameterGetSemantic(vm::ptr<const SceGxmProgramParameter> parameter)
+SceGxmParameterSemantic sceGxmProgramParameterGetSemantic(vm::cptr<SceGxmProgramParameter> parameter)
 {
 	throw __FUNCTION__;
 }
 
-u32 sceGxmProgramParameterGetSemanticIndex(vm::ptr<const SceGxmProgramParameter> parameter)
+u32 sceGxmProgramParameterGetSemanticIndex(vm::cptr<SceGxmProgramParameter> parameter)
 {
 	throw __FUNCTION__;
 }
 
-SceGxmParameterType sceGxmProgramParameterGetType(vm::ptr<const SceGxmProgramParameter> parameter)
+SceGxmParameterType sceGxmProgramParameterGetType(vm::cptr<SceGxmProgramParameter> parameter)
 {
 	throw __FUNCTION__;
 }
 
-u32 sceGxmProgramParameterGetComponentCount(vm::ptr<const SceGxmProgramParameter> parameter)
+u32 sceGxmProgramParameterGetComponentCount(vm::cptr<SceGxmProgramParameter> parameter)
 {
 	throw __FUNCTION__;
 }
 
-u32 sceGxmProgramParameterGetArraySize(vm::ptr<const SceGxmProgramParameter> parameter)
+u32 sceGxmProgramParameterGetArraySize(vm::cptr<SceGxmProgramParameter> parameter)
 {
 	throw __FUNCTION__;
 }
 
-u32 sceGxmProgramParameterGetResourceIndex(vm::ptr<const SceGxmProgramParameter> parameter)
+u32 sceGxmProgramParameterGetResourceIndex(vm::cptr<SceGxmProgramParameter> parameter)
 {
 	throw __FUNCTION__;
 }
 
-u32 sceGxmProgramParameterGetContainerIndex(vm::ptr<const SceGxmProgramParameter> parameter)
+u32 sceGxmProgramParameterGetContainerIndex(vm::cptr<SceGxmProgramParameter> parameter)
 {
 	throw __FUNCTION__;
 }
 
-bool sceGxmProgramParameterIsSamplerCube(vm::ptr<const SceGxmProgramParameter> parameter)
+bool sceGxmProgramParameterIsSamplerCube(vm::cptr<SceGxmProgramParameter> parameter)
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceGxmProgram> sceGxmFragmentProgramGetProgram(vm::ptr<const SceGxmFragmentProgram> fragmentProgram)
+vm::cptr<SceGxmProgram> sceGxmFragmentProgramGetProgram(vm::cptr<SceGxmFragmentProgram> fragmentProgram)
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceGxmProgram> sceGxmVertexProgramGetProgram(vm::ptr<const SceGxmVertexProgram> vertexProgram)
+vm::cptr<SceGxmProgram> sceGxmVertexProgramGetProgram(vm::cptr<SceGxmVertexProgram> vertexProgram)
 {
 	throw __FUNCTION__;
 }
 
 
-s32 sceGxmShaderPatcherCreate(vm::ptr<const SceGxmShaderPatcherParams> params, vm::pptr<SceGxmShaderPatcher> shaderPatcher)
+s32 sceGxmShaderPatcherCreate(vm::cptr<SceGxmShaderPatcherParams> params, vm::pptr<SceGxmShaderPatcher> shaderPatcher)
 {
 	throw __FUNCTION__;
 }
@@ -670,7 +670,7 @@ s32 sceGxmShaderPatcherDestroy(vm::ptr<SceGxmShaderPatcher> shaderPatcher)
 	throw __FUNCTION__;
 }
 
-s32 sceGxmShaderPatcherRegisterProgram(vm::ptr<SceGxmShaderPatcher> shaderPatcher, vm::ptr<const SceGxmProgram> programHeader, vm::pptr<SceGxmRegisteredProgram> programId)
+s32 sceGxmShaderPatcherRegisterProgram(vm::ptr<SceGxmShaderPatcher> shaderPatcher, vm::cptr<SceGxmProgram> programHeader, vm::pptr<SceGxmRegisteredProgram> programId)
 {
 	throw __FUNCTION__;
 }
@@ -680,22 +680,22 @@ s32 sceGxmShaderPatcherUnregisterProgram(vm::ptr<SceGxmShaderPatcher> shaderPatc
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceGxmProgram> sceGxmShaderPatcherGetProgramFromId(vm::ptr<SceGxmRegisteredProgram> programId)
+vm::cptr<SceGxmProgram> sceGxmShaderPatcherGetProgramFromId(vm::ptr<SceGxmRegisteredProgram> programId)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmShaderPatcherSetAuxiliarySurface(vm::ptr<SceGxmShaderPatcher> shaderPatcher, u32 auxSurfaceIndex, vm::ptr<const SceGxmAuxiliarySurface> auxSurface)
+s32 sceGxmShaderPatcherSetAuxiliarySurface(vm::ptr<SceGxmShaderPatcher> shaderPatcher, u32 auxSurfaceIndex, vm::cptr<SceGxmAuxiliarySurface> auxSurface)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmShaderPatcherCreateVertexProgram(vm::ptr<SceGxmShaderPatcher> shaderPatcher, vm::ptr<SceGxmRegisteredProgram> programId, vm::ptr<const SceGxmVertexAttribute> attributes, u32 attributeCount, vm::ptr<const SceGxmVertexStream> streams, u32 streamCount, vm::pptr<SceGxmVertexProgram> vertexProgram)
+s32 sceGxmShaderPatcherCreateVertexProgram(vm::ptr<SceGxmShaderPatcher> shaderPatcher, vm::ptr<SceGxmRegisteredProgram> programId, vm::cptr<SceGxmVertexAttribute> attributes, u32 attributeCount, vm::cptr<SceGxmVertexStream> streams, u32 streamCount, vm::pptr<SceGxmVertexProgram> vertexProgram)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmShaderPatcherCreateFragmentProgram(vm::ptr<SceGxmShaderPatcher> shaderPatcher, vm::ptr<SceGxmRegisteredProgram> programId, SceGxmOutputRegisterFormat outputFormat, SceGxmMultisampleMode multisampleMode, vm::ptr<const SceGxmBlendInfo> blendInfo, vm::ptr<const SceGxmProgram> vertexProgram, vm::pptr<SceGxmFragmentProgram> fragmentProgram)
+s32 sceGxmShaderPatcherCreateFragmentProgram(vm::ptr<SceGxmShaderPatcher> shaderPatcher, vm::ptr<SceGxmRegisteredProgram> programId, SceGxmOutputRegisterFormat outputFormat, SceGxmMultisampleMode multisampleMode, vm::cptr<SceGxmBlendInfo> blendInfo, vm::cptr<SceGxmProgram> vertexProgram, vm::pptr<SceGxmFragmentProgram> fragmentProgram)
 {
 	throw __FUNCTION__;
 }
@@ -720,52 +720,52 @@ s32 sceGxmShaderPatcherReleaseFragmentProgram(vm::ptr<SceGxmShaderPatcher> shade
 	throw __FUNCTION__;
 }
 
-u32 sceGxmShaderPatcherGetHostMemAllocated(vm::ptr<const SceGxmShaderPatcher> shaderPatcher)
+u32 sceGxmShaderPatcherGetHostMemAllocated(vm::cptr<SceGxmShaderPatcher> shaderPatcher)
 {
 	throw __FUNCTION__;
 }
 
-u32 sceGxmShaderPatcherGetBufferMemAllocated(vm::ptr<const SceGxmShaderPatcher> shaderPatcher)
+u32 sceGxmShaderPatcherGetBufferMemAllocated(vm::cptr<SceGxmShaderPatcher> shaderPatcher)
 {
 	throw __FUNCTION__;
 }
 
-u32 sceGxmShaderPatcherGetVertexUsseMemAllocated(vm::ptr<const SceGxmShaderPatcher> shaderPatcher)
+u32 sceGxmShaderPatcherGetVertexUsseMemAllocated(vm::cptr<SceGxmShaderPatcher> shaderPatcher)
 {
 	throw __FUNCTION__;
 }
 
-u32 sceGxmShaderPatcherGetFragmentUsseMemAllocated(vm::ptr<const SceGxmShaderPatcher> shaderPatcher)
+u32 sceGxmShaderPatcherGetFragmentUsseMemAllocated(vm::cptr<SceGxmShaderPatcher> shaderPatcher)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmTextureInitSwizzled(vm::ptr<SceGxmTexture> texture, vm::ptr<const void> data, SceGxmTextureFormat texFormat, u32 width, u32 height, u32 mipCount)
+s32 sceGxmTextureInitSwizzled(vm::ptr<SceGxmTexture> texture, vm::cptr<void> data, SceGxmTextureFormat texFormat, u32 width, u32 height, u32 mipCount)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmTextureInitLinear(vm::ptr<SceGxmTexture> texture, vm::ptr<const void> data, SceGxmTextureFormat texFormat, u32 width, u32 height, u32 mipCount)
+s32 sceGxmTextureInitLinear(vm::ptr<SceGxmTexture> texture, vm::cptr<void> data, SceGxmTextureFormat texFormat, u32 width, u32 height, u32 mipCount)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmTextureInitLinearStrided(vm::ptr<SceGxmTexture> texture, vm::ptr<const void> data, SceGxmTextureFormat texFormat, u32 width, u32 height, u32 byteStride)
+s32 sceGxmTextureInitLinearStrided(vm::ptr<SceGxmTexture> texture, vm::cptr<void> data, SceGxmTextureFormat texFormat, u32 width, u32 height, u32 byteStride)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmTextureInitTiled(vm::ptr<SceGxmTexture> texture, vm::ptr<const void> data, SceGxmTextureFormat texFormat, u32 width, u32 height, u32 mipCount)
+s32 sceGxmTextureInitTiled(vm::ptr<SceGxmTexture> texture, vm::cptr<void> data, SceGxmTextureFormat texFormat, u32 width, u32 height, u32 mipCount)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmTextureInitCube(vm::ptr<SceGxmTexture> texture, vm::ptr<const void> data, SceGxmTextureFormat texFormat, u32 width, u32 height, u32 mipCount)
+s32 sceGxmTextureInitCube(vm::ptr<SceGxmTexture> texture, vm::cptr<void> data, SceGxmTextureFormat texFormat, u32 width, u32 height, u32 mipCount)
 {
 	throw __FUNCTION__;
 }
 
-SceGxmTextureType sceGxmTextureGetType(vm::ptr<const SceGxmTexture> texture)
+SceGxmTextureType sceGxmTextureGetType(vm::cptr<SceGxmTexture> texture)
 {
 	throw __FUNCTION__;
 }
@@ -775,7 +775,7 @@ s32 sceGxmTextureSetMinFilter(vm::ptr<SceGxmTexture> texture, SceGxmTextureFilte
 	throw __FUNCTION__;
 }
 
-SceGxmTextureFilter sceGxmTextureGetMinFilter(vm::ptr<const SceGxmTexture> texture)
+SceGxmTextureFilter sceGxmTextureGetMinFilter(vm::cptr<SceGxmTexture> texture)
 {
 	throw __FUNCTION__;
 }
@@ -785,7 +785,7 @@ s32 sceGxmTextureSetMagFilter(vm::ptr<SceGxmTexture> texture, SceGxmTextureFilte
 	throw __FUNCTION__;
 }
 
-SceGxmTextureFilter sceGxmTextureGetMagFilter(vm::ptr<const SceGxmTexture> texture)
+SceGxmTextureFilter sceGxmTextureGetMagFilter(vm::cptr<SceGxmTexture> texture)
 {
 	throw __FUNCTION__;
 }
@@ -795,7 +795,7 @@ s32 sceGxmTextureSetMipFilter(vm::ptr<SceGxmTexture> texture, SceGxmTextureMipFi
 	throw __FUNCTION__;
 }
 
-SceGxmTextureMipFilter sceGxmTextureGetMipFilter(vm::ptr<const SceGxmTexture> texture)
+SceGxmTextureMipFilter sceGxmTextureGetMipFilter(vm::cptr<SceGxmTexture> texture)
 {
 	throw __FUNCTION__;
 }
@@ -805,7 +805,7 @@ s32 sceGxmTextureSetAnisoMode(vm::ptr<SceGxmTexture> texture, SceGxmTextureAniso
 	throw __FUNCTION__;
 }
 
-SceGxmTextureAnisoMode sceGxmTextureGetAnisoMode(vm::ptr<const SceGxmTexture> texture)
+SceGxmTextureAnisoMode sceGxmTextureGetAnisoMode(vm::cptr<SceGxmTexture> texture)
 {
 	throw __FUNCTION__;
 }
@@ -815,7 +815,7 @@ s32 sceGxmTextureSetUAddrMode(vm::ptr<SceGxmTexture> texture, SceGxmTextureAddrM
 	throw __FUNCTION__;
 }
 
-SceGxmTextureAddrMode sceGxmTextureGetUAddrMode(vm::ptr<const SceGxmTexture> texture)
+SceGxmTextureAddrMode sceGxmTextureGetUAddrMode(vm::cptr<SceGxmTexture> texture)
 {
 	throw __FUNCTION__;
 }
@@ -825,7 +825,7 @@ s32 sceGxmTextureSetVAddrMode(vm::ptr<SceGxmTexture> texture, SceGxmTextureAddrM
 	throw __FUNCTION__;
 }
 
-SceGxmTextureAddrMode sceGxmTextureGetVAddrMode(vm::ptr<const SceGxmTexture> texture)
+SceGxmTextureAddrMode sceGxmTextureGetVAddrMode(vm::cptr<SceGxmTexture> texture)
 {
 	throw __FUNCTION__;
 }
@@ -835,7 +835,7 @@ s32 sceGxmTextureSetFormat(vm::ptr<SceGxmTexture> texture, SceGxmTextureFormat t
 	throw __FUNCTION__;
 }
 
-SceGxmTextureFormat sceGxmTextureGetFormat(vm::ptr<const SceGxmTexture> texture)
+SceGxmTextureFormat sceGxmTextureGetFormat(vm::cptr<SceGxmTexture> texture)
 {
 	throw __FUNCTION__;
 }
@@ -845,7 +845,7 @@ s32 sceGxmTextureSetLodBias(vm::ptr<SceGxmTexture> texture, u32 bias)
 	throw __FUNCTION__;
 }
 
-u32 sceGxmTextureGetLodBias(vm::ptr<const SceGxmTexture> texture)
+u32 sceGxmTextureGetLodBias(vm::cptr<SceGxmTexture> texture)
 {
 	throw __FUNCTION__;
 }
@@ -855,7 +855,7 @@ s32 sceGxmTextureSetStride(vm::ptr<SceGxmTexture> texture, u32 byteStride)
 	throw __FUNCTION__;
 }
 
-u32 sceGxmTextureGetStride(vm::ptr<const SceGxmTexture> texture)
+u32 sceGxmTextureGetStride(vm::cptr<SceGxmTexture> texture)
 {
 	throw __FUNCTION__;
 }
@@ -865,7 +865,7 @@ s32 sceGxmTextureSetWidth(vm::ptr<SceGxmTexture> texture, u32 width)
 	throw __FUNCTION__;
 }
 
-u32 sceGxmTextureGetWidth(vm::ptr<const SceGxmTexture> texture)
+u32 sceGxmTextureGetWidth(vm::cptr<SceGxmTexture> texture)
 {
 	throw __FUNCTION__;
 }
@@ -875,17 +875,17 @@ s32 sceGxmTextureSetHeight(vm::ptr<SceGxmTexture> texture, u32 height)
 	throw __FUNCTION__;
 }
 
-u32 sceGxmTextureGetHeight(vm::ptr<const SceGxmTexture> texture)
+u32 sceGxmTextureGetHeight(vm::cptr<SceGxmTexture> texture)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmTextureSetData(vm::ptr<SceGxmTexture> texture, vm::ptr<const void> data)
+s32 sceGxmTextureSetData(vm::ptr<SceGxmTexture> texture, vm::cptr<void> data)
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<void> sceGxmTextureGetData(vm::ptr<const SceGxmTexture> texture)
+vm::ptr<void> sceGxmTextureGetData(vm::cptr<SceGxmTexture> texture)
 {
 	throw __FUNCTION__;
 }
@@ -895,22 +895,22 @@ s32 sceGxmTextureSetMipmapCount(vm::ptr<SceGxmTexture> texture, u32 mipCount)
 	throw __FUNCTION__;
 }
 
-u32 sceGxmTextureGetMipmapCount(vm::ptr<const SceGxmTexture> texture)
+u32 sceGxmTextureGetMipmapCount(vm::cptr<SceGxmTexture> texture)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmTextureSetPalette(vm::ptr<SceGxmTexture> texture, vm::ptr<const void> paletteData)
+s32 sceGxmTextureSetPalette(vm::ptr<SceGxmTexture> texture, vm::cptr<void> paletteData)
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<void> sceGxmTextureGetPalette(vm::ptr<const SceGxmTexture> texture)
+vm::ptr<void> sceGxmTextureGetPalette(vm::cptr<SceGxmTexture> texture)
 {
 	throw __FUNCTION__;
 }
 
-SceGxmTextureGammaMode sceGxmTextureGetGammaMode(vm::ptr<const SceGxmTexture> texture)
+SceGxmTextureGammaMode sceGxmTextureGetGammaMode(vm::cptr<SceGxmTexture> texture)
 {
 	throw __FUNCTION__;
 }
@@ -920,12 +920,12 @@ s32 sceGxmTextureSetGammaMode(vm::ptr<SceGxmTexture> texture, SceGxmTextureGamma
 	throw __FUNCTION__;
 }
 
-u32 sceGxmGetPrecomputedVertexStateSize(vm::ptr<const SceGxmVertexProgram> vertexProgram)
+u32 sceGxmGetPrecomputedVertexStateSize(vm::cptr<SceGxmVertexProgram> vertexProgram)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmPrecomputedVertexStateInit(vm::ptr<SceGxmPrecomputedVertexState> precomputedState, vm::ptr<const SceGxmVertexProgram> vertexProgram, vm::ptr<void> memBlock)
+s32 sceGxmPrecomputedVertexStateInit(vm::ptr<SceGxmPrecomputedVertexState> precomputedState, vm::cptr<SceGxmVertexProgram> vertexProgram, vm::ptr<void> memBlock)
 {
 	throw __FUNCTION__;
 }
@@ -935,37 +935,37 @@ void sceGxmPrecomputedVertexStateSetDefaultUniformBuffer(vm::ptr<SceGxmPrecomput
 	throw __FUNCTION__;
 }
 
-vm::ptr<void> sceGxmPrecomputedVertexStateGetDefaultUniformBuffer(vm::ptr<const SceGxmPrecomputedVertexState> precomputedState)
+vm::ptr<void> sceGxmPrecomputedVertexStateGetDefaultUniformBuffer(vm::cptr<SceGxmPrecomputedVertexState> precomputedState)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmPrecomputedVertexStateSetAllTextures(vm::ptr<SceGxmPrecomputedVertexState> precomputedState, vm::ptr<const SceGxmTexture> textures)
+s32 sceGxmPrecomputedVertexStateSetAllTextures(vm::ptr<SceGxmPrecomputedVertexState> precomputedState, vm::cptr<SceGxmTexture> textures)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmPrecomputedVertexStateSetTexture(vm::ptr<SceGxmPrecomputedVertexState> precomputedState, u32 textureIndex, vm::ptr<const SceGxmTexture> texture)
+s32 sceGxmPrecomputedVertexStateSetTexture(vm::ptr<SceGxmPrecomputedVertexState> precomputedState, u32 textureIndex, vm::cptr<SceGxmTexture> texture)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmPrecomputedVertexStateSetAllUniformBuffers(vm::ptr<SceGxmPrecomputedVertexState> precomputedState, vm::ptr<const vm::ptr<const void>> bufferDataArray)
+s32 sceGxmPrecomputedVertexStateSetAllUniformBuffers(vm::ptr<SceGxmPrecomputedVertexState> precomputedState, vm::cptr<vm::cptr<void>> bufferDataArray)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmPrecomputedVertexStateSetUniformBuffer(vm::ptr<SceGxmPrecomputedVertexState> precomputedState, u32 bufferIndex, vm::ptr<const void> bufferData)
+s32 sceGxmPrecomputedVertexStateSetUniformBuffer(vm::ptr<SceGxmPrecomputedVertexState> precomputedState, u32 bufferIndex, vm::cptr<void> bufferData)
 {
 	throw __FUNCTION__;
 }
 
-u32 sceGxmGetPrecomputedFragmentStateSize(vm::ptr<const SceGxmFragmentProgram> fragmentProgram)
+u32 sceGxmGetPrecomputedFragmentStateSize(vm::cptr<SceGxmFragmentProgram> fragmentProgram)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmPrecomputedFragmentStateInit(vm::ptr<SceGxmPrecomputedFragmentState> precomputedState, vm::ptr<const SceGxmFragmentProgram> fragmentProgram, vm::ptr<void> memBlock)
+s32 sceGxmPrecomputedFragmentStateInit(vm::ptr<SceGxmPrecomputedFragmentState> precomputedState, vm::cptr<SceGxmFragmentProgram> fragmentProgram, vm::ptr<void> memBlock)
 {
 	throw __FUNCTION__;
 }
@@ -975,83 +975,83 @@ void sceGxmPrecomputedFragmentStateSetDefaultUniformBuffer(vm::ptr<SceGxmPrecomp
 	throw __FUNCTION__;
 }
 
-vm::ptr<void> sceGxmPrecomputedFragmentStateGetDefaultUniformBuffer(vm::ptr<const SceGxmPrecomputedFragmentState> precomputedState)
+vm::ptr<void> sceGxmPrecomputedFragmentStateGetDefaultUniformBuffer(vm::cptr<SceGxmPrecomputedFragmentState> precomputedState)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmPrecomputedFragmentStateSetAllTextures(vm::ptr<SceGxmPrecomputedFragmentState> precomputedState, vm::ptr<const SceGxmTexture> textureArray)
+s32 sceGxmPrecomputedFragmentStateSetAllTextures(vm::ptr<SceGxmPrecomputedFragmentState> precomputedState, vm::cptr<SceGxmTexture> textureArray)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmPrecomputedFragmentStateSetTexture(vm::ptr<SceGxmPrecomputedFragmentState> precomputedState, u32 textureIndex, vm::ptr<const SceGxmTexture> texture)
+s32 sceGxmPrecomputedFragmentStateSetTexture(vm::ptr<SceGxmPrecomputedFragmentState> precomputedState, u32 textureIndex, vm::cptr<SceGxmTexture> texture)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmPrecomputedFragmentStateSetAllUniformBuffers(vm::ptr<SceGxmPrecomputedFragmentState> precomputedState, vm::ptr<const vm::ptr<const void>> bufferDataArray)
+s32 sceGxmPrecomputedFragmentStateSetAllUniformBuffers(vm::ptr<SceGxmPrecomputedFragmentState> precomputedState, vm::cptr<vm::cptr<void>> bufferDataArray)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmPrecomputedFragmentStateSetUniformBuffer(vm::ptr<SceGxmPrecomputedFragmentState> precomputedState, u32 bufferIndex, vm::ptr<const void> bufferData)
+s32 sceGxmPrecomputedFragmentStateSetUniformBuffer(vm::ptr<SceGxmPrecomputedFragmentState> precomputedState, u32 bufferIndex, vm::cptr<void> bufferData)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmPrecomputedFragmentStateSetAllAuxiliarySurfaces(vm::ptr<SceGxmPrecomputedFragmentState> precomputedState, vm::ptr<const SceGxmAuxiliarySurface> auxSurfaceArray)
+s32 sceGxmPrecomputedFragmentStateSetAllAuxiliarySurfaces(vm::ptr<SceGxmPrecomputedFragmentState> precomputedState, vm::cptr<SceGxmAuxiliarySurface> auxSurfaceArray)
 {
 	throw __FUNCTION__;
 }
 
-u32 sceGxmGetPrecomputedDrawSize(vm::ptr<const SceGxmVertexProgram> vertexProgram)
+u32 sceGxmGetPrecomputedDrawSize(vm::cptr<SceGxmVertexProgram> vertexProgram)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmPrecomputedDrawInit(vm::ptr<SceGxmPrecomputedDraw> precomputedDraw, vm::ptr<const SceGxmVertexProgram> vertexProgram, vm::ptr<void> memBlock)
+s32 sceGxmPrecomputedDrawInit(vm::ptr<SceGxmPrecomputedDraw> precomputedDraw, vm::cptr<SceGxmVertexProgram> vertexProgram, vm::ptr<void> memBlock)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmPrecomputedDrawSetAllVertexStreams(vm::ptr<SceGxmPrecomputedDraw> precomputedDraw, vm::ptr<const vm::ptr<const void>> streamDataArray)
+s32 sceGxmPrecomputedDrawSetAllVertexStreams(vm::ptr<SceGxmPrecomputedDraw> precomputedDraw, vm::cptr<vm::cptr<void>> streamDataArray)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmPrecomputedDrawSetVertexStream(vm::ptr<SceGxmPrecomputedDraw> precomputedDraw, u32 streamIndex, vm::ptr<const void> streamData)
+s32 sceGxmPrecomputedDrawSetVertexStream(vm::ptr<SceGxmPrecomputedDraw> precomputedDraw, u32 streamIndex, vm::cptr<void> streamData)
 {
 	throw __FUNCTION__;
 }
 
-void sceGxmPrecomputedDrawSetParams(vm::ptr<SceGxmPrecomputedDraw> precomputedDraw, SceGxmPrimitiveType primType, SceGxmIndexFormat indexType, vm::ptr<const void> indexData, u32 indexCount)
+void sceGxmPrecomputedDrawSetParams(vm::ptr<SceGxmPrecomputedDraw> precomputedDraw, SceGxmPrimitiveType primType, SceGxmIndexFormat indexType, vm::cptr<void> indexData, u32 indexCount)
 {
 	throw __FUNCTION__;
 }
 
-void sceGxmPrecomputedDrawSetParamsInstanced(vm::ptr<SceGxmPrecomputedDraw> precomputedDraw, SceGxmPrimitiveType primType, SceGxmIndexFormat indexType, vm::ptr<const void> indexData, u32 indexCount, u32 indexWrap)
+void sceGxmPrecomputedDrawSetParamsInstanced(vm::ptr<SceGxmPrecomputedDraw> precomputedDraw, SceGxmPrimitiveType primType, SceGxmIndexFormat indexType, vm::cptr<void> indexData, u32 indexCount, u32 indexWrap)
 {
 	throw __FUNCTION__;
 }
 
 
-s32 sceGxmGetRenderTargetMemSizes(vm::ptr<const SceGxmRenderTargetParams> params, vm::ptr<u32> hostMemSize, vm::ptr<u32> driverMemSize)
+s32 sceGxmGetRenderTargetMemSizes(vm::cptr<SceGxmRenderTargetParams> params, vm::ptr<u32> hostMemSize, vm::ptr<u32> driverMemSize)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmCreateRenderTarget(vm::ptr<const SceGxmRenderTargetParams> params, vm::pptr<SceGxmRenderTarget> renderTarget)
+s32 sceGxmCreateRenderTarget(vm::cptr<SceGxmRenderTargetParams> params, vm::pptr<SceGxmRenderTarget> renderTarget)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmRenderTargetGetHostMem(vm::ptr<const SceGxmRenderTarget> renderTarget, vm::pptr<void> hostMem)
+s32 sceGxmRenderTargetGetHostMem(vm::cptr<SceGxmRenderTarget> renderTarget, vm::pptr<void> hostMem)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGxmRenderTargetGetDriverMemBlock(vm::ptr<const SceGxmRenderTarget> renderTarget, vm::ptr<s32> driverMemBlock)
+s32 sceGxmRenderTargetGetDriverMemBlock(vm::cptr<SceGxmRenderTarget> renderTarget, vm::ptr<s32> driverMemBlock)
 {
 	throw __FUNCTION__;
 }
@@ -1061,7 +1061,7 @@ s32 sceGxmDestroyRenderTarget(vm::ptr<SceGxmRenderTarget> renderTarget)
 	throw __FUNCTION__;
 }
 
-s32 sceGxmSetUniformDataF(vm::ptr<void> uniformBuffer, vm::ptr<const SceGxmProgramParameter> parameter, u32 componentOffset, u32 componentCount, vm::ptr<const float> sourceData)
+s32 sceGxmSetUniformDataF(vm::ptr<void> uniformBuffer, vm::cptr<SceGxmProgramParameter> parameter, u32 componentOffset, u32 componentCount, vm::cptr<float> sourceData)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceHttp.cpp

@@ -19,7 +19,7 @@ s32 sceHttpGetMemoryPoolStats(vm::ptr<SceHttpMemoryPoolStats> currentStat)
 	throw __FUNCTION__;
 }
 
-s32 sceHttpCreateTemplate(vm::ptr<const char> userAgent, s32 httpVer, s32 autoProxyConf)
+s32 sceHttpCreateTemplate(vm::cptr<char> userAgent, s32 httpVer, s32 autoProxyConf)
 {
 	throw __FUNCTION__;
 }
@@ -29,12 +29,12 @@ s32 sceHttpDeleteTemplate(s32 tmplId)
 	throw __FUNCTION__;
 }
 
-s32 sceHttpCreateConnection(s32 tmplId, vm::ptr<const char> serverName, vm::ptr<const char> scheme, u16 port, s32 enableKeepalive)
+s32 sceHttpCreateConnection(s32 tmplId, vm::cptr<char> serverName, vm::cptr<char> scheme, u16 port, s32 enableKeepalive)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpCreateConnectionWithURL(s32 tmplId, vm::ptr<const char> url, s32 enableKeepalive)
+s32 sceHttpCreateConnectionWithURL(s32 tmplId, vm::cptr<char> url, s32 enableKeepalive)
 {
 	throw __FUNCTION__;
 }
@@ -44,12 +44,12 @@ s32 sceHttpDeleteConnection(s32 connId)
 	throw __FUNCTION__;
 }
 
-s32 sceHttpCreateRequest(s32 connId, s32 method, vm::ptr<const char> path, u64 contentLength)
+s32 sceHttpCreateRequest(s32 connId, s32 method, vm::cptr<char> path, u64 contentLength)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpCreateRequestWithURL(s32 connId, s32 method, vm::ptr<const char> url, u64 contentLength)
+s32 sceHttpCreateRequestWithURL(s32 connId, s32 method, vm::cptr<char> url, u64 contentLength)
 {
 	throw __FUNCTION__;
 }
@@ -74,7 +74,7 @@ s32 sceHttpSetRequestContentLength(s32 id, u64 contentLength)
 	throw __FUNCTION__;
 }
 
-s32 sceHttpSendRequest(s32 reqId, vm::ptr<const void> postData, u32 size)
+s32 sceHttpSendRequest(s32 reqId, vm::cptr<void> postData, u32 size)
 {
 	throw __FUNCTION__;
 }
@@ -104,22 +104,22 @@ s32 sceHttpReadData(s32 reqId, vm::ptr<void> data, u32 size)
 	throw __FUNCTION__;
 }
 
-s32 sceHttpAddRequestHeader(s32 id, vm::ptr<const char> name, vm::ptr<const char> value, u32 mode)
+s32 sceHttpAddRequestHeader(s32 id, vm::cptr<char> name, vm::cptr<char> value, u32 mode)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpRemoveRequestHeader(s32 id, vm::ptr<const char> name)
+s32 sceHttpRemoveRequestHeader(s32 id, vm::cptr<char> name)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpParseResponseHeader(vm::ptr<const char> header, u32 headerLen, vm::ptr<const char> fieldStr, vm::pptr<const char> fieldValue, vm::ptr<u32> valueLen)
+s32 sceHttpParseResponseHeader(vm::cptr<char> header, u32 headerLen, vm::cptr<char> fieldStr, vm::cpptr<char> fieldValue, vm::ptr<u32> valueLen)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpParseStatusLine(vm::ptr<const char> statusLine, u32 lineLen, vm::ptr<s32> httpMajorVer, vm::ptr<s32> httpMinorVer, vm::ptr<s32> responseCode, vm::pptr<const char> reasonPhrase, vm::ptr<u32> phraseLen)
+s32 sceHttpParseStatusLine(vm::cptr<char> statusLine, u32 lineLen, vm::ptr<s32> httpMajorVer, vm::ptr<s32> httpMinorVer, vm::ptr<s32> responseCode, vm::cpptr<char> reasonPhrase, vm::ptr<u32> phraseLen)
 {
 	throw __FUNCTION__;
 }
@@ -179,32 +179,32 @@ s32 sceHttpSetRecvTimeOut(s32 id, u32 usec)
 	throw __FUNCTION__;
 }
 
-s32 sceHttpUriEscape(vm::ptr<char> out, vm::ptr<u32> require, u32 prepare, vm::ptr<const char> in)
+s32 sceHttpUriEscape(vm::ptr<char> out, vm::ptr<u32> require, u32 prepare, vm::cptr<char> in)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpUriUnescape(vm::ptr<char> out, vm::ptr<u32> require, u32 prepare, vm::ptr<const char> in)
+s32 sceHttpUriUnescape(vm::ptr<char> out, vm::ptr<u32> require, u32 prepare, vm::cptr<char> in)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpUriParse(vm::ptr<SceHttpUriElement> out, vm::ptr<const char> srcUrl, vm::ptr<void> pool, vm::ptr<u32> require, u32 prepare)
+s32 sceHttpUriParse(vm::ptr<SceHttpUriElement> out, vm::cptr<char> srcUrl, vm::ptr<void> pool, vm::ptr<u32> require, u32 prepare)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpUriBuild(vm::ptr<char> out, vm::ptr<u32> require, u32 prepare, vm::ptr<const SceHttpUriElement> srcElement, u32 option)
+s32 sceHttpUriBuild(vm::ptr<char> out, vm::ptr<u32> require, u32 prepare, vm::cptr<SceHttpUriElement> srcElement, u32 option)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpUriMerge(vm::ptr<char> mergedUrl, vm::ptr<const char> url, vm::ptr<const char> relativeUrl, vm::ptr<u32> require, u32 prepare, u32 option)
+s32 sceHttpUriMerge(vm::ptr<char> mergedUrl, vm::cptr<char> url, vm::cptr<char> relativeUrl, vm::ptr<u32> require, u32 prepare, u32 option)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpUriSweepPath(vm::ptr<char> dst, vm::ptr<const char> src, u32 srcSize)
+s32 sceHttpUriSweepPath(vm::ptr<char> dst, vm::cptr<char> src, u32 srcSize)
 {
 	throw __FUNCTION__;
 }
@@ -219,12 +219,12 @@ s32 sceHttpGetCookieEnabled(s32 id, vm::ptr<s32> enable)
 	throw __FUNCTION__;
 }
 
-s32 sceHttpGetCookie(vm::ptr<const char> url, vm::ptr<char> cookie, vm::ptr<u32> cookieLength, u32 prepare, s32 secure)
+s32 sceHttpGetCookie(vm::cptr<char> url, vm::ptr<char> cookie, vm::ptr<u32> cookieLength, u32 prepare, s32 secure)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpAddCookie(vm::ptr<const char> url, vm::ptr<const char> cookie, u32 cookieLength)
+s32 sceHttpAddCookie(vm::cptr<char> url, vm::cptr<char> cookie, u32 cookieLength)
 {
 	throw __FUNCTION__;
 }
@@ -239,7 +239,7 @@ s32 sceHttpSetCookieSendCallback(s32 id, vm::ptr<SceHttpCookieSendCallback> cbfu
 	throw __FUNCTION__;
 }
 
-s32 sceHttpsLoadCert(s32 caCertNum, vm::pptr<const SceHttpsData> caList, vm::ptr<const SceHttpsData> cert, vm::ptr<const SceHttpsData> privKey)
+s32 sceHttpsLoadCert(s32 caCertNum, vm::cpptr<SceHttpsData> caList, vm::cptr<SceHttpsData> cert, vm::cptr<SceHttpsData> privKey)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceIme.cpp

@@ -14,12 +14,12 @@ s32 sceImeUpdate()
 	throw __FUNCTION__;
 }
 
-s32 sceImeSetCaret(vm::ptr<const SceImeCaret> caret)
+s32 sceImeSetCaret(vm::cptr<SceImeCaret> caret)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceImeSetPreeditGeometry(vm::ptr<const SceImePreeditGeometry> preedit)
+s32 sceImeSetPreeditGeometry(vm::cptr<SceImePreeditGeometry> preedit)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceJpeg.cpp

@@ -15,7 +15,7 @@ s32 sceJpegFinishMJpeg()
 }
 
 s32 sceJpegDecodeMJpeg(
-	vm::ptr<const u8> pJpeg,
+	vm::cptr<u8> pJpeg,
 	u32 isize,
 	vm::ptr<void> pRGBA,
 	u32 osize,
@@ -29,7 +29,7 @@ s32 sceJpegDecodeMJpeg(
 }
 
 s32 sceJpegDecodeMJpegYCbCr(
-	vm::ptr<const u8> pJpeg,
+	vm::cptr<u8> pJpeg,
 	u32 isize,
 	vm::ptr<u8> pYCbCr,
 	u32 osize,
@@ -42,7 +42,7 @@ s32 sceJpegDecodeMJpegYCbCr(
 
 s32 sceJpegMJpegCsc(
 	vm::ptr<void> pRGBA,
-	vm::ptr<const u8> pYCbCr,
+	vm::cptr<u8> pYCbCr,
 	s32 xysize,
 	s32 iFrameWidth,
 	s32 colorOption,
@@ -52,7 +52,7 @@ s32 sceJpegMJpegCsc(
 }
 
 s32 sceJpegGetOutputInfo(
-	vm::ptr<const u8> pJpeg,
+	vm::cptr<u8> pJpeg,
 	u32 isize,
 	s32 outputFormat,
 	s32 decodeMode,

rpcs3/Emu/ARMv7/Modules/sceJpegEnc.cpp

@@ -22,7 +22,7 @@ s32 sceJpegEncoderInit(
 
 s32 sceJpegEncoderEncode(
 	SceJpegEncoderContext context,
-	vm::ptr<const void> pYCbCr)
+	vm::cptr<void> pYCbCr)
 {
 	throw __FUNCTION__;
 }
@@ -65,7 +65,7 @@ s32 sceJpegEncoderSetOutputAddr(
 s32 sceJpegEncoderCsc(
 	SceJpegEncoderContext context,
 	vm::ptr<void> pYCbCr,
-	vm::ptr<const void> pRGBA,
+	vm::cptr<void> pRGBA,
 	s32 iFrameWidth,
 	s32 inputPixelFormat)
 {

rpcs3/Emu/ARMv7/Modules/sceLibKernel.cpp

@@ -13,7 +13,7 @@
 #include "psv_mutex.h"
 #include "psv_cond.h"
 
-s32 sceKernelAllocMemBlock(vm::ptr<const char> name, s32 type, u32 vsize, vm::ptr<SceKernelAllocMemBlockOpt> pOpt)
+s32 sceKernelAllocMemBlock(vm::cptr<char> name, s32 type, u32 vsize, vm::ptr<SceKernelAllocMemBlockOpt> pOpt)
 {
 	throw __FUNCTION__;
 }
@@ -34,13 +34,13 @@ s32 sceKernelGetMemBlockInfoByAddr(vm::ptr<void> vbase, vm::ptr<SceKernelMemBloc
 }
 
 s32 sceKernelCreateThread(
-	vm::ptr<const char> pName,
+	vm::cptr<char> pName,
 	vm::ptr<SceKernelThreadEntry> entry,
 	s32 initPriority,
 	u32 stackSize,
 	u32 attr,
 	s32 cpuAffinityMask,
-	vm::ptr<const SceKernelThreadOptParam> pOptParam)
+	vm::cptr<SceKernelThreadOptParam> pOptParam)
 {
 	sceLibKernel.Warning("sceKernelCreateThread(pName=*0x%x, entry=*0x%x, initPriority=%d, stackSize=0x%x, attr=0x%x, cpuAffinityMask=0x%x, pOptParam=*0x%x)",
 		pName, entry, initPriority, stackSize, attr, cpuAffinityMask, pOptParam);
@@ -58,7 +58,7 @@ s32 sceKernelCreateThread(
 	return armv7.GetId();
 }
 
-s32 sceKernelStartThread(s32 threadId, u32 argSize, vm::ptr<const void> pArgBlock)
+s32 sceKernelStartThread(s32 threadId, u32 argSize, vm::cptr<void> pArgBlock)
 {
 	sceLibKernel.Warning("sceKernelStartThread(threadId=0x%x, argSize=0x%x, pArgBlock=*0x%x)", threadId, argSize, pArgBlock);
 
@@ -302,7 +302,7 @@ s32 sceKernelWaitThreadEndCB(s32 threadId, vm::ptr<s32> pExitStatus, vm::ptr<u32
 
 // Callback functions
 
-s32 sceKernelCreateCallback(vm::ptr<const char> pName, u32 attr, vm::ptr<SceKernelCallbackFunction> callbackFunc, vm::ptr<void> pCommon)
+s32 sceKernelCreateCallback(vm::cptr<char> pName, u32 attr, vm::ptr<SceKernelCallbackFunction> callbackFunc, vm::ptr<void> pCommon)
 {
 	throw __FUNCTION__;
 }
@@ -391,7 +391,7 @@ s32 sceKernelWaitMultipleEventsCB(vm::ptr<SceKernelWaitEvent> pWaitEventList, s3
 
 // Event flag functions
 
-s32 sceKernelCreateEventFlag(vm::ptr<const char> pName, u32 attr, u32 initPattern, vm::ptr<const SceKernelEventFlagOptParam> pOptParam)
+s32 sceKernelCreateEventFlag(vm::cptr<char> pName, u32 attr, u32 initPattern, vm::cptr<SceKernelEventFlagOptParam> pOptParam)
 {
 	sceLibKernel.Error("sceKernelCreateEventFlag(pName=*0x%x, attr=0x%x, initPattern=0x%x, pOptParam=*0x%x)", pName, attr, initPattern, pOptParam);
 
@@ -408,7 +408,7 @@ s32 sceKernelDeleteEventFlag(s32 evfId)
 	throw __FUNCTION__;
 }
 
-s32 sceKernelOpenEventFlag(vm::ptr<const char> pName)
+s32 sceKernelOpenEventFlag(vm::cptr<char> pName)
 {
 	throw __FUNCTION__;
 }
@@ -455,7 +455,7 @@ s32 sceKernelGetEventFlagInfo(s32 evfId, vm::ptr<SceKernelEventFlagInfo> pInfo)
 
 // Semaphore functions
 
-s32 sceKernelCreateSema(vm::ptr<const char> pName, u32 attr, s32 initCount, s32 maxCount, vm::ptr<const SceKernelSemaOptParam> pOptParam)
+s32 sceKernelCreateSema(vm::cptr<char> pName, u32 attr, s32 initCount, s32 maxCount, vm::cptr<SceKernelSemaOptParam> pOptParam)
 {
 	sceLibKernel.Error("sceKernelCreateSema(pName=*0x%x, attr=0x%x, initCount=%d, maxCount=%d, pOptParam=*0x%x)", pName, attr, initCount, maxCount, pOptParam);
 
@@ -486,7 +486,7 @@ s32 sceKernelDeleteSema(s32 semaId)
 	return SCE_OK;
 }
 
-s32 sceKernelOpenSema(vm::ptr<const char> pName)
+s32 sceKernelOpenSema(vm::cptr<char> pName)
 {
 	throw __FUNCTION__;
 }
@@ -539,7 +539,7 @@ s32 sceKernelGetSemaInfo(s32 semaId, vm::ptr<SceKernelSemaInfo> pInfo)
 
 // Mutex functions
 
-s32 sceKernelCreateMutex(vm::ptr<const char> pName, u32 attr, s32 initCount, vm::ptr<const SceKernelMutexOptParam> pOptParam)
+s32 sceKernelCreateMutex(vm::cptr<char> pName, u32 attr, s32 initCount, vm::cptr<SceKernelMutexOptParam> pOptParam)
 {
 	sceLibKernel.Error("sceKernelCreateMutex(pName=*0x%x, attr=0x%x, initCount=%d, pOptParam=*0x%x)", pName, attr, initCount, pOptParam);
 
@@ -556,7 +556,7 @@ s32 sceKernelDeleteMutex(s32 mutexId)
 	throw __FUNCTION__;
 }
 
-s32 sceKernelOpenMutex(vm::ptr<const char> pName)
+s32 sceKernelOpenMutex(vm::cptr<char> pName)
 {
 	throw __FUNCTION__;
 }
@@ -598,7 +598,7 @@ s32 sceKernelGetMutexInfo(s32 mutexId, vm::ptr<SceKernelMutexInfo> pInfo)
 
 // Lightweight mutex functions
 
-s32 sceKernelCreateLwMutex(vm::ptr<SceKernelLwMutexWork> pWork, vm::ptr<const char> pName, u32 attr, s32 initCount, vm::ptr<const SceKernelLwMutexOptParam> pOptParam)
+s32 sceKernelCreateLwMutex(vm::ptr<SceKernelLwMutexWork> pWork, vm::cptr<char> pName, u32 attr, s32 initCount, vm::cptr<SceKernelLwMutexOptParam> pOptParam)
 {
 	throw __FUNCTION__;
 }
@@ -640,7 +640,7 @@ s32 sceKernelGetLwMutexInfoById(s32 lwMutexId, vm::ptr<SceKernelLwMutexInfo> pIn
 
 // Condition variable functions
 
-s32 sceKernelCreateCond(vm::ptr<const char> pName, u32 attr, s32 mutexId, vm::ptr<const SceKernelCondOptParam> pOptParam)
+s32 sceKernelCreateCond(vm::cptr<char> pName, u32 attr, s32 mutexId, vm::cptr<SceKernelCondOptParam> pOptParam)
 {
 	sceLibKernel.Error("sceKernelCreateCond(pName=*0x%x, attr=0x%x, mutexId=0x%x, pOptParam=*0x%x)", pName, attr, mutexId, pOptParam);
 
@@ -657,7 +657,7 @@ s32 sceKernelDeleteCond(s32 condId)
 	throw __FUNCTION__;
 }
 
-s32 sceKernelOpenCond(vm::ptr<const char> pName)
+s32 sceKernelOpenCond(vm::cptr<char> pName)
 {
 	throw __FUNCTION__;
 }
@@ -699,7 +699,7 @@ s32 sceKernelGetCondInfo(s32 condId, vm::ptr<SceKernelCondInfo> pInfo)
 
 // Lightweight condition variable functions
 
-s32 sceKernelCreateLwCond(vm::ptr<SceKernelLwCondWork> pWork, vm::ptr<const char> pName, u32 attr, vm::ptr<SceKernelLwMutexWork> pLwMutex, vm::ptr<const SceKernelLwCondOptParam> pOptParam)
+s32 sceKernelCreateLwCond(vm::ptr<SceKernelLwCondWork> pWork, vm::cptr<char> pName, u32 attr, vm::ptr<SceKernelLwMutexWork> pLwMutex, vm::cptr<SceKernelLwCondOptParam> pOptParam)
 {
 	throw __FUNCTION__;
 }
@@ -763,7 +763,7 @@ u32 sceKernelGetSystemTimeLow()
 
 // Timer functions
 
-s32 sceKernelCreateTimer(vm::ptr<const char> pName, u32 attr, vm::ptr<const SceKernelTimerOptParam> pOptParam)
+s32 sceKernelCreateTimer(vm::cptr<char> pName, u32 attr, vm::cptr<SceKernelTimerOptParam> pOptParam)
 {
 	throw __FUNCTION__;
 }
@@ -773,7 +773,7 @@ s32 sceKernelDeleteTimer(s32 timerId)
 	throw __FUNCTION__;
 }
 
-s32 sceKernelOpenTimer(vm::ptr<const char> pName)
+s32 sceKernelOpenTimer(vm::cptr<char> pName)
 {
 	throw __FUNCTION__;
 }
@@ -840,7 +840,7 @@ s32 sceKernelGetTimerInfo(s32 timerId, vm::ptr<SceKernelTimerInfo> pInfo)
 
 // Reader/writer lock functions
 
-s32 sceKernelCreateRWLock(vm::ptr<const char> pName, u32 attr, vm::ptr<const SceKernelRWLockOptParam> pOptParam)
+s32 sceKernelCreateRWLock(vm::cptr<char> pName, u32 attr, vm::cptr<SceKernelRWLockOptParam> pOptParam)
 {
 	throw __FUNCTION__;
 }
@@ -850,7 +850,7 @@ s32 sceKernelDeleteRWLock(s32 rwLockId)
 	throw __FUNCTION__;
 }
 
-s32 sceKernelOpenRWLock(vm::ptr<const char> pName)
+s32 sceKernelOpenRWLock(vm::cptr<char> pName)
 {
 	throw __FUNCTION__;
 }
@@ -912,37 +912,37 @@ s32 sceKernelGetRWLockInfo(s32 rwLockId, vm::ptr<SceKernelRWLockInfo> pInfo)
 
 // IO/File functions
 
-s32 sceIoRemove(vm::ptr<const char> filename)
+s32 sceIoRemove(vm::cptr<char> filename)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceIoMkdir(vm::ptr<const char> dirname, s32 mode)
+s32 sceIoMkdir(vm::cptr<char> dirname, s32 mode)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceIoRmdir(vm::ptr<const char> dirname)
+s32 sceIoRmdir(vm::cptr<char> dirname)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceIoRename(vm::ptr<const char> oldname, vm::ptr<const char> newname)
+s32 sceIoRename(vm::cptr<char> oldname, vm::cptr<char> newname)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceIoDevctl(vm::ptr<const char> devname, s32 cmd, vm::ptr<const void> arg, u32 arglen, vm::ptr<void> bufp, u32 buflen)
+s32 sceIoDevctl(vm::cptr<char> devname, s32 cmd, vm::cptr<void> arg, u32 arglen, vm::ptr<void> bufp, u32 buflen)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceIoSync(vm::ptr<const char> devname, s32 flag)
+s32 sceIoSync(vm::cptr<char> devname, s32 flag)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceIoOpen(vm::ptr<const char> filename, s32 flag, s32 mode)
+s32 sceIoOpen(vm::cptr<char> filename, s32 flag, s32 mode)
 {
 	throw __FUNCTION__;
 }
@@ -952,7 +952,7 @@ s32 sceIoClose(s32 fd)
 	throw __FUNCTION__;
 }
 
-s32 sceIoIoctl(s32 fd, s32 cmd, vm::ptr<const void> argp, u32 arglen, vm::ptr<void> bufp, u32 buflen)
+s32 sceIoIoctl(s32 fd, s32 cmd, vm::cptr<void> argp, u32 arglen, vm::ptr<void> bufp, u32 buflen)
 {
 	throw __FUNCTION__;
 }
@@ -972,7 +972,7 @@ s32 sceIoRead(s32 fd, vm::ptr<void> buf, u32 nbyte)
 	throw __FUNCTION__;
 }
 
-s32 sceIoWrite(s32 fd, vm::ptr<const void> buf, u32 nbyte)
+s32 sceIoWrite(s32 fd, vm::cptr<void> buf, u32 nbyte)
 {
 	throw __FUNCTION__;
 }
@@ -982,12 +982,12 @@ s32 sceIoPread(s32 fd, vm::ptr<void> buf, u32 nbyte, s64 offset)
 	throw __FUNCTION__;
 }
 
-s32 sceIoPwrite(s32 fd, vm::ptr<const void> buf, u32 nbyte, s64 offset)
+s32 sceIoPwrite(s32 fd, vm::cptr<void> buf, u32 nbyte, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceIoDopen(vm::ptr<const char> dirname)
+s32 sceIoDopen(vm::cptr<char> dirname)
 {
 	throw __FUNCTION__;
 }
@@ -1002,12 +1002,12 @@ s32 sceIoDread(s32 fd, vm::ptr<SceIoDirent> buf)
 	throw __FUNCTION__;
 }
 
-s32 sceIoChstat(vm::ptr<const char> name, vm::ptr<const SceIoStat> buf, u32 cbit)
+s32 sceIoChstat(vm::cptr<char> name, vm::cptr<SceIoStat> buf, u32 cbit)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceIoGetstat(vm::ptr<const char> name, vm::ptr<SceIoStat> buf)
+s32 sceIoGetstat(vm::cptr<char> name, vm::ptr<SceIoStat> buf)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceMd5.cpp

@@ -4,7 +4,7 @@
 
 #include "sceMd5.h"
 
-s32 sceMd5Digest(vm::ptr<const void> plain, u32 len, vm::ptr<u8> digest)
+s32 sceMd5Digest(vm::cptr<void> plain, u32 len, vm::ptr<u8> digest)
 {
 	throw __FUNCTION__;
 }
@@ -14,7 +14,7 @@ s32 sceMd5BlockInit(vm::ptr<SceMd5Context> pContext)
 	throw __FUNCTION__;
 }
 
-s32 sceMd5BlockUpdate(vm::ptr<SceMd5Context> pContext, vm::ptr<const void> plain, u32 len)
+s32 sceMd5BlockUpdate(vm::ptr<SceMd5Context> pContext, vm::cptr<void> plain, u32 len)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceNet.cpp

@@ -14,7 +14,7 @@ s32 sceNetClearDnsCache(s32 flags)
 	throw __FUNCTION__;
 }
 
-s32 sceNetDumpCreate(vm::ptr<const char> name, s32 len, s32 flags)
+s32 sceNetDumpCreate(vm::cptr<char> name, s32 len, s32 flags)
 {
 	throw __FUNCTION__;
 }
@@ -34,7 +34,7 @@ s32 sceNetDumpAbort(s32 id, s32 flags)
 	throw __FUNCTION__;
 }
 
-s32 sceNetEpollCreate(vm::ptr<const char> name, s32 flags)
+s32 sceNetEpollCreate(vm::cptr<char> name, s32 flags)
 {
 	throw __FUNCTION__;
 }
@@ -69,12 +69,12 @@ vm::ptr<s32> sceNetErrnoLoc()
 	throw __FUNCTION__;
 }
 
-s32 sceNetEtherStrton(vm::ptr<const char> str, vm::ptr<SceNetEtherAddr> n)
+s32 sceNetEtherStrton(vm::cptr<char> str, vm::ptr<SceNetEtherAddr> n)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetEtherNtostr(vm::ptr<const SceNetEtherAddr> n, vm::ptr<char> str, u32 len)
+s32 sceNetEtherNtostr(vm::cptr<SceNetEtherAddr> n, vm::ptr<char> str, u32 len)
 {
 	throw __FUNCTION__;
 }
@@ -84,12 +84,12 @@ s32 sceNetGetMacAddress(vm::ptr<SceNetEtherAddr> addr, s32 flags)
 	throw __FUNCTION__;
 }
 
-vm::ptr<const char> sceNetInetNtop(s32 af, vm::ptr<const void> src, vm::ptr<char> dst, SceNetSocklen_t size)
+vm::cptr<char> sceNetInetNtop(s32 af, vm::cptr<void> src, vm::ptr<char> dst, SceNetSocklen_t size)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetInetPton(s32 af, vm::ptr<const char> src, vm::ptr<void> dst)
+s32 sceNetInetPton(s32 af, vm::cptr<char> src, vm::ptr<void> dst)
 {
 	throw __FUNCTION__;
 }
@@ -159,17 +159,17 @@ s32 sceNetEmulationGet(vm::ptr<SceNetEmulationParam> param, s32 flags)
 	throw __FUNCTION__;
 }
 
-s32 sceNetResolverCreate(vm::ptr<const char> name, vm::ptr<SceNetResolverParam> param, s32 flags)
+s32 sceNetResolverCreate(vm::cptr<char> name, vm::ptr<SceNetResolverParam> param, s32 flags)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetResolverStartNtoa(s32 rid, vm::ptr<const char> hostname, vm::ptr<SceNetInAddr> addr, s32 timeout, s32 retry, s32 flags)
+s32 sceNetResolverStartNtoa(s32 rid, vm::cptr<char> hostname, vm::ptr<SceNetInAddr> addr, s32 timeout, s32 retry, s32 flags)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetResolverStartAton(s32 rid, vm::ptr<const SceNetInAddr> addr, vm::ptr<char> hostname, s32 len, s32 timeout, s32 retry, s32 flags)
+s32 sceNetResolverStartAton(s32 rid, vm::cptr<SceNetInAddr> addr, vm::ptr<char> hostname, s32 len, s32 timeout, s32 retry, s32 flags)
 {
 	throw __FUNCTION__;
 }
@@ -189,7 +189,7 @@ s32 sceNetResolverAbort(s32 rid, s32 flags)
 	throw __FUNCTION__;
 }
 
-s32 sceNetSocket(vm::ptr<const char> name, s32 domain, s32 type, s32 protocol)
+s32 sceNetSocket(vm::cptr<char> name, s32 domain, s32 type, s32 protocol)
 {
 	throw __FUNCTION__;
 }
@@ -199,12 +199,12 @@ s32 sceNetAccept(s32 s, vm::ptr<SceNetSockaddr> addr, vm::ptr<SceNetSocklen_t> a
 	throw __FUNCTION__;
 }
 
-s32 sceNetBind(s32 s, vm::ptr<const SceNetSockaddr> addr, SceNetSocklen_t addrlen)
+s32 sceNetBind(s32 s, vm::cptr<SceNetSockaddr> addr, SceNetSocklen_t addrlen)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetConnect(s32 s, vm::ptr<const SceNetSockaddr> name, SceNetSocklen_t namelen)
+s32 sceNetConnect(s32 s, vm::cptr<SceNetSockaddr> name, SceNetSocklen_t namelen)
 {
 	throw __FUNCTION__;
 }
@@ -244,22 +244,22 @@ s32 sceNetRecvmsg(s32 s, vm::ptr<SceNetMsghdr> msg, s32 flags)
 	throw __FUNCTION__;
 }
 
-s32 sceNetSend(s32 s, vm::ptr<const void> msg, u32 len, s32 flags)
+s32 sceNetSend(s32 s, vm::cptr<void> msg, u32 len, s32 flags)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetSendto(s32 s, vm::ptr<const void> msg, u32 len, s32 flags, vm::ptr<const SceNetSockaddr> to, SceNetSocklen_t tolen)
+s32 sceNetSendto(s32 s, vm::cptr<void> msg, u32 len, s32 flags, vm::cptr<SceNetSockaddr> to, SceNetSocklen_t tolen)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetSendmsg(s32 s, vm::ptr<const SceNetMsghdr> msg, s32 flags)
+s32 sceNetSendmsg(s32 s, vm::cptr<SceNetMsghdr> msg, s32 flags)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetSetsockopt(s32 s, s32 level, s32 optname, vm::ptr<const void> optval, SceNetSocklen_t optlen)
+s32 sceNetSetsockopt(s32 s, s32 level, s32 optname, vm::cptr<void> optval, SceNetSocklen_t optlen)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceNgs.cpp

@@ -4,12 +4,12 @@
 
 #include "sceNgs.h"
 
-s32 sceNgsSystemGetRequiredMemorySize(vm::ptr<const SceNgsSystemInitParams> pSynthParams, vm::ptr<u32> pnSize)
+s32 sceNgsSystemGetRequiredMemorySize(vm::cptr<SceNgsSystemInitParams> pSynthParams, vm::ptr<u32> pnSize)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsSystemInit(vm::ptr<void> pSynthSysMemory, const u32 uMemSize, vm::ptr<const SceNgsSystemInitParams> pSynthParams, vm::ptr<SceNgsHSynSystem> pSystemHandle)
+s32 sceNgsSystemInit(vm::ptr<void> pSynthSysMemory, const u32 uMemSize, vm::cptr<SceNgsSystemInitParams> pSynthParams, vm::ptr<SceNgsHSynSystem> pSystemHandle)
 {
 	throw __FUNCTION__;
 }
@@ -44,12 +44,12 @@ s32 sceNgsSystemSetFlags(SceNgsHSynSystem hSystemHandle, const u32 uSystemFlags)
 	throw __FUNCTION__;
 }
 
-s32 sceNgsRackGetRequiredMemorySize(SceNgsHSynSystem hSystemHandle, vm::ptr<const SceNgsRackDescription> pRackDesc, vm::ptr<u32> pnSize)
+s32 sceNgsRackGetRequiredMemorySize(SceNgsHSynSystem hSystemHandle, vm::cptr<SceNgsRackDescription> pRackDesc, vm::ptr<u32> pnSize)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsRackInit(SceNgsHSynSystem hSystemHandle, vm::ptr<SceNgsBufferInfo> pRackBuffer, vm::ptr<const SceNgsRackDescription> pRackDesc, vm::ptr<SceNgsHRack> pRackHandle)
+s32 sceNgsRackInit(SceNgsHSynSystem hSystemHandle, vm::ptr<SceNgsBufferInfo> pRackBuffer, vm::cptr<SceNgsRackDescription> pRackDesc, vm::ptr<SceNgsHRack> pRackHandle)
 {
 	throw __FUNCTION__;
 }
@@ -69,7 +69,7 @@ s32 sceNgsRackSetParamErrorCallback(SceNgsHRack hRackHandle, vm::ptr<SceNgsCallb
 	throw __FUNCTION__;
 }
 
-s32 sceNgsVoiceInit(SceNgsHVoice hVoiceHandle, vm::ptr<const SceNgsVoicePreset> pPreset, const u32 uInitFlags)
+s32 sceNgsVoiceInit(SceNgsHVoice hVoiceHandle, vm::cptr<SceNgsVoicePreset> pPreset, const u32 uInitFlags)
 {
 	throw __FUNCTION__;
 }
@@ -99,7 +99,7 @@ s32 sceNgsVoiceResume(SceNgsHVoice hVoiceHandle)
 	throw __FUNCTION__;
 }
 
-s32 sceNgsVoiceSetPreset(SceNgsHVoice hVoiceHandle, vm::ptr<const SceNgsVoicePreset> pVoicePreset)
+s32 sceNgsVoiceSetPreset(SceNgsHVoice hVoiceHandle, vm::cptr<SceNgsVoicePreset> pVoicePreset)
 {
 	throw __FUNCTION__;
 }
@@ -114,7 +114,7 @@ s32 sceNgsVoiceUnlockParams(SceNgsHVoice hVoiceHandle, const u32 uModule)
 	throw __FUNCTION__;
 }
 
-s32 sceNgsVoiceSetParamsBlock(SceNgsHVoice hVoiceHandle, vm::ptr<const SceNgsModuleParamHeader> pParamData, const u32 uSize, vm::ptr<s32> pnErrorCount)
+s32 sceNgsVoiceSetParamsBlock(SceNgsHVoice hVoiceHandle, vm::cptr<SceNgsModuleParamHeader> pParamData, const u32 uSize, vm::ptr<s32> pnErrorCount)
 {
 	throw __FUNCTION__;
 }
@@ -159,7 +159,7 @@ s32 sceNgsVoiceGetParamsOutOfRange(SceNgsHVoice hVoiceHandle, const u32 uModule,
 	throw __FUNCTION__;
 }
 
-s32 sceNgsPatchCreateRouting(vm::ptr<const SceNgsPatchSetupInfo> pPatchInfo, vm::ptr<SceNgsHPatch> pPatchHandle)
+s32 sceNgsPatchCreateRouting(vm::cptr<SceNgsPatchSetupInfo> pPatchInfo, vm::ptr<SceNgsHPatch> pPatchHandle)
 {
 	throw __FUNCTION__;
 }
@@ -184,12 +184,12 @@ s32 sceNgsVoicePatchSetVolume(SceNgsHPatch hPatchHandle, const s32 nOutputChanne
 	throw __FUNCTION__;
 }
 
-s32 sceNgsVoicePatchSetVolumes(SceNgsHPatch hPatchHandle, const s32 nOutputChannel, vm::ptr<const float> pVolumes, const s32 nVols)
+s32 sceNgsVoicePatchSetVolumes(SceNgsHPatch hPatchHandle, const s32 nOutputChannel, vm::cptr<float> pVolumes, const s32 nVols)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsVoicePatchSetVolumesMatrix(SceNgsHPatch hPatchHandle, vm::ptr<const SceNgsVolumeMatrix> pMatrix)
+s32 sceNgsVoicePatchSetVolumesMatrix(SceNgsHPatch hPatchHandle, vm::cptr<SceNgsVolumeMatrix> pMatrix)
 {
 	throw __FUNCTION__;
 }
@@ -204,72 +204,72 @@ s32 sceNgsModuleGetPreset(SceNgsHSynSystem hSystemHandle, const u32 uModuleID, c
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetCompressorBuss()
+vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetCompressorBuss()
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetCompressorSideChainBuss()
+vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetCompressorSideChainBuss()
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetDelayBuss()
+vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetDelayBuss()
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetDistortionBuss()
+vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetDistortionBuss()
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetEnvelopeBuss()
+vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetEnvelopeBuss()
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetEqBuss()
+vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetEqBuss()
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetMasterBuss()
+vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetMasterBuss()
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetMixerBuss()
+vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetMixerBuss()
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetPauserBuss()
+vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetPauserBuss()
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetReverbBuss()
+vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetReverbBuss()
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetSasEmuVoice()
+vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetSasEmuVoice()
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetSimpleVoice()
+vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetSimpleVoice()
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetTemplate1()
+vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetTemplate1()
 {
 	throw __FUNCTION__;
 }
 
-vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetAtrac9Voice()
+vm::cptr<SceNgsVoiceDefinition> sceNgsVoiceDefGetAtrac9Voice()
 {
 	throw __FUNCTION__;
 }
@@ -279,12 +279,12 @@ s32 sceSulphaNgsGetDefaultConfig(vm::ptr<SceSulphaNgsConfig> config)
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaNgsGetNeededMemory(vm::ptr<const SceSulphaNgsConfig> config, vm::ptr<u32> sizeInBytes)
+s32 sceSulphaNgsGetNeededMemory(vm::cptr<SceSulphaNgsConfig> config, vm::ptr<u32> sizeInBytes)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaNgsInit(vm::ptr<const SceSulphaNgsConfig> config, vm::ptr<void> buffer, u32 sizeInBytes)
+s32 sceSulphaNgsInit(vm::cptr<SceSulphaNgsConfig> config, vm::ptr<void> buffer, u32 sizeInBytes)
 {
 	throw __FUNCTION__;
 }
@@ -294,27 +294,27 @@ s32 sceSulphaNgsShutdown()
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaNgsSetSynthName(SceNgsHSynSystem synthHandle, vm::ptr<const char> name)
+s32 sceSulphaNgsSetSynthName(SceNgsHSynSystem synthHandle, vm::cptr<char> name)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaNgsSetRackName(SceNgsHRack rackHandle, vm::ptr<const char> name)
+s32 sceSulphaNgsSetRackName(SceNgsHRack rackHandle, vm::cptr<char> name)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaNgsSetVoiceName(SceNgsHVoice voiceHandle, vm::ptr<const char> name)
+s32 sceSulphaNgsSetVoiceName(SceNgsHVoice voiceHandle, vm::cptr<char> name)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaNgsSetSampleName(vm::ptr<const void> location, u32 length, vm::ptr<const char> name)
+s32 sceSulphaNgsSetSampleName(vm::cptr<void> location, u32 length, vm::cptr<char> name)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaNgsTrace(vm::ptr<const char> message)
+s32 sceSulphaNgsTrace(vm::cptr<char> message)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceNgs.h

@@ -46,7 +46,7 @@ struct SceNgsSystemInitParams
 
 struct SceNgsRackDescription
 {
-	vm::lptr<const SceNgsVoiceDefinition> pVoiceDefn;
+	vm::lcptr<SceNgsVoiceDefinition> pVoiceDefn;
 	le_t<s32> nVoices;
 	le_t<s32> nChannelsPerVoice;
 	le_t<s32> nMaxPatchesPerInput;

rpcs3/Emu/ARMv7/Modules/sceNpBasic.cpp

@@ -14,7 +14,7 @@ s32 sceNpBasicTerm(ARMv7Context&)
 	throw __FUNCTION__;
 }
 
-s32 sceNpBasicRegisterHandler(vm::ptr<const SceNpBasicEventHandlers> handlers, vm::ptr<const SceNpCommunicationId> context, vm::ptr<void> userdata)
+s32 sceNpBasicRegisterHandler(vm::cptr<SceNpBasicEventHandlers> handlers, vm::cptr<SceNpCommunicationId> context, vm::ptr<void> userdata)
 {
 	throw __FUNCTION__;
 }
@@ -29,12 +29,12 @@ s32 sceNpBasicCheckCallback()
 	throw __FUNCTION__;
 }
 
-s32 sceNpBasicGetFriendOnlineStatus(vm::ptr<const SceNpId> friendId, vm::ptr<SceNpBasicFriendOnlineStatus> status)
+s32 sceNpBasicGetFriendOnlineStatus(vm::cptr<SceNpId> friendId, vm::ptr<SceNpBasicFriendOnlineStatus> status)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpBasicGetGamePresenceOfFriend(vm::ptr<const SceNpId> friendId, vm::ptr<SceNpBasicGamePresence> presence)
+s32 sceNpBasicGetGamePresenceOfFriend(vm::cptr<SceNpId> friendId, vm::ptr<SceNpBasicGamePresence> presence)
 {
 	throw __FUNCTION__;
 }
@@ -59,12 +59,12 @@ s32 sceNpBasicGetBlockListEntries(u32 startIndex, vm::ptr<SceNpId> entries, u32
 	throw __FUNCTION__;
 }
 
-s32 sceNpBasicCheckIfPlayerIsBlocked(vm::ptr<const SceNpId> player, vm::ptr<u8> playerIsBlocked)
+s32 sceNpBasicCheckIfPlayerIsBlocked(vm::cptr<SceNpId> player, vm::ptr<u8> playerIsBlocked)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpBasicSetInGamePresence(vm::ptr<const SceNpBasicInGamePresence> presence)
+s32 sceNpBasicSetInGamePresence(vm::cptr<SceNpBasicInGamePresence> presence)
 {
 	throw __FUNCTION__;
 }
@@ -74,12 +74,12 @@ s32 sceNpBasicUnsetInGamePresence()
 	throw __FUNCTION__;
 }
 
-s32 sceNpBasicSendInGameDataMessage(vm::ptr<const SceNpId> to, vm::ptr<const SceNpBasicInGameDataMessage> message)
+s32 sceNpBasicSendInGameDataMessage(vm::cptr<SceNpId> to, vm::cptr<SceNpBasicInGameDataMessage> message)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpBasicRecordPlaySessionLog(vm::ptr<const SceNpId> withWhom, vm::ptr<const SceNpBasicPlaySessionLogDescription> description)
+s32 sceNpBasicRecordPlaySessionLog(vm::cptr<SceNpId> withWhom, vm::cptr<SceNpBasicPlaySessionLogDescription> description)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceNpCommon.cpp

@@ -14,7 +14,7 @@ s32 sceNpAuthTerm()
 	throw __FUNCTION__;
 }
 
-s32 sceNpAuthCreateStartRequest(vm::ptr<const SceNpAuthRequestParameter> param)
+s32 sceNpAuthCreateStartRequest(vm::cptr<SceNpAuthRequestParameter> param)
 {
 	throw __FUNCTION__;
 }
@@ -34,27 +34,27 @@ s32 sceNpAuthGetTicket(s32 id, vm::ptr<void> buf, u32 len)
 	throw __FUNCTION__;
 }
 
-s32 sceNpAuthGetTicketParam(vm::ptr<const u8> ticket, u32 ticketSize, s32 paramId, vm::ptr<SceNpTicketParam> param)
+s32 sceNpAuthGetTicketParam(vm::cptr<u8> ticket, u32 ticketSize, s32 paramId, vm::ptr<SceNpTicketParam> param)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpAuthGetEntitlementIdList(vm::ptr<const u8> ticket, u32 ticketSize, vm::ptr<SceNpEntitlementId> entIdList, u32 entIdListNum)
+s32 sceNpAuthGetEntitlementIdList(vm::cptr<u8> ticket, u32 ticketSize, vm::ptr<SceNpEntitlementId> entIdList, u32 entIdListNum)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpAuthGetEntitlementById(vm::ptr<const u8> ticket, u32 ticketSize, vm::ptr<const char> entId, vm::ptr<SceNpEntitlement> ent)
+s32 sceNpAuthGetEntitlementById(vm::cptr<u8> ticket, u32 ticketSize, vm::cptr<char> entId, vm::ptr<SceNpEntitlement> ent)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpCmpNpId(vm::ptr<const SceNpId> npid1, vm::ptr<const SceNpId> npid2)
+s32 sceNpCmpNpId(vm::cptr<SceNpId> npid1, vm::cptr<SceNpId> npid2)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpCmpNpIdInOrder(vm::ptr<const SceNpId> npid1, vm::ptr<const SceNpId> npid2, vm::ptr<s32> order)
+s32 sceNpCmpNpIdInOrder(vm::cptr<SceNpId> npid1, vm::cptr<SceNpId> npid2, vm::ptr<s32> order)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceNpCommon.h

@@ -28,9 +28,9 @@ struct SceNpCommunicationSignature
 
 struct SceNpCommunicationConfig
 {
-	vm::lptr<const SceNpCommunicationId> commId;
+	vm::lcptr<SceNpCommunicationId> commId;
-	vm::lptr<const SceNpCommunicationPassphrase> commPassphrase;
+	vm::lcptr<SceNpCommunicationPassphrase> commPassphrase;
-	vm::lptr<const SceNpCommunicationSignature> commSignature;
+	vm::lcptr<SceNpCommunicationSignature> commSignature;
 };
 
 struct SceNpCountryCode
@@ -123,10 +123,10 @@ struct SceNpAuthRequestParameter
 {
 	le_t<u32> size;
 	SceNpTicketVersion version;
-	vm::lptr<const char> serviceId;
+	vm::lcptr<char> serviceId;
-	vm::lptr<const void> cookie;
+	vm::lcptr<void> cookie;
 	le_t<u32> cookieSize;
-	vm::lptr<const char> entitlementId;
+	vm::lcptr<char> entitlementId;
 	le_t<u32> consumedCount;
 	vm::lptr<SceNpAuthCallback> ticketCb;
 	vm::lptr<void> cbArg;

rpcs3/Emu/ARMv7/Modules/sceNpManager.cpp

@@ -4,7 +4,7 @@
 
 #include "sceNpManager.h"
 
-s32 sceNpInit(vm::ptr<const SceNpCommunicationConfig> commConf, vm::ptr<SceNpOptParam> opt)
+s32 sceNpInit(vm::cptr<SceNpCommunicationConfig> commConf, vm::ptr<SceNpOptParam> opt)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceNpMatching.cpp

@@ -17,9 +17,9 @@ s32 sceNpMatching2Term()
 }
 
 s32 sceNpMatching2CreateContext(
-	vm::ptr<const SceNpId> npId,
+	vm::cptr<SceNpId> npId,
-	vm::ptr<const SceNpCommunicationId> commId,
+	vm::cptr<SceNpCommunicationId> commId,
-	vm::ptr<const SceNpCommunicationPassphrase> passPhrase,
+	vm::cptr<SceNpCommunicationPassphrase> passPhrase,
 	vm::ptr<u16> ctxId)
 {
 	throw __FUNCTION__;
@@ -45,7 +45,7 @@ s32 sceNpMatching2ContextStop(u16 ctxId)
 	throw __FUNCTION__;
 }
 
-s32 sceNpMatching2SetDefaultRequestOptParam(u16 ctxId, vm::ptr<const SceNpMatching2RequestOptParam> optParam)
+s32 sceNpMatching2SetDefaultRequestOptParam(u16 ctxId, vm::cptr<SceNpMatching2RequestOptParam> optParam)
 {
 	throw __FUNCTION__;
 }
@@ -87,8 +87,8 @@ s32 sceNpMatching2GetServerLocal(u16 ctxId, vm::ptr<SceNpMatching2Server> server
 
 s32 sceNpMatching2GetWorldInfoList(
 	u16 ctxId,
-	vm::ptr<const SceNpMatching2GetWorldInfoListRequest> reqParam,
+	vm::cptr<SceNpMatching2GetWorldInfoListRequest> reqParam,
-	vm::ptr<const SceNpMatching2RequestOptParam> optParam,
+	vm::cptr<SceNpMatching2RequestOptParam> optParam,
 	vm::ptr<u32> assignedReqId)
 {
 	throw __FUNCTION__;
@@ -96,8 +96,8 @@ s32 sceNpMatching2GetWorldInfoList(
 
 s32 sceNpMatching2CreateJoinRoom(
 	u16 ctxId,
-	vm::ptr<const SceNpMatching2CreateJoinRoomRequest> reqParam,
+	vm::cptr<SceNpMatching2CreateJoinRoomRequest> reqParam,
-	vm::ptr<const SceNpMatching2RequestOptParam> optParam,
+	vm::cptr<SceNpMatching2RequestOptParam> optParam,
 	vm::ptr<u32> assignedReqId)
 {
 	throw __FUNCTION__;
@@ -105,8 +105,8 @@ s32 sceNpMatching2CreateJoinRoom(
 
 s32 sceNpMatching2SearchRoom(
 	u16 ctxId,
-	vm::ptr<const SceNpMatching2SearchRoomRequest> reqParam,
+	vm::cptr<SceNpMatching2SearchRoomRequest> reqParam,
-	vm::ptr<const SceNpMatching2RequestOptParam> optParam,
+	vm::cptr<SceNpMatching2RequestOptParam> optParam,
 	vm::ptr<u32> assignedReqId)
 {
 	throw __FUNCTION__;
@@ -114,8 +114,8 @@ s32 sceNpMatching2SearchRoom(
 
 s32 sceNpMatching2JoinRoom(
 	u16 ctxId,
-	vm::ptr<const SceNpMatching2JoinRoomRequest> reqParam,
+	vm::cptr<SceNpMatching2JoinRoomRequest> reqParam,
-	vm::ptr<const SceNpMatching2RequestOptParam> optParam,
+	vm::cptr<SceNpMatching2RequestOptParam> optParam,
 	vm::ptr<u32> assignedReqId)
 {
 	throw __FUNCTION__;
@@ -123,8 +123,8 @@ s32 sceNpMatching2JoinRoom(
 
 s32 sceNpMatching2LeaveRoom(
 	u16 ctxId,
-	vm::ptr<const SceNpMatching2LeaveRoomRequest> reqParam,
+	vm::cptr<SceNpMatching2LeaveRoomRequest> reqParam,
-	vm::ptr<const SceNpMatching2RequestOptParam> optParam,
+	vm::cptr<SceNpMatching2RequestOptParam> optParam,
 	vm::ptr<u32> assignedReqId)
 {
 	throw __FUNCTION__;
@@ -140,8 +140,8 @@ s32 sceNpMatching2GetSignalingOptParamLocal(
 
 s32 sceNpMatching2SetRoomDataExternal(
 	u16 ctxId,
-	vm::ptr<const SceNpMatching2SetRoomDataExternalRequest> reqParam,
+	vm::cptr<SceNpMatching2SetRoomDataExternalRequest> reqParam,
-	vm::ptr<const SceNpMatching2RequestOptParam> optParam,
+	vm::cptr<SceNpMatching2RequestOptParam> optParam,
 	vm::ptr<u32> assignedReqId)
 {
 	throw __FUNCTION__;
@@ -149,8 +149,8 @@ s32 sceNpMatching2SetRoomDataExternal(
 
 s32 sceNpMatching2KickoutRoomMember(
 	u16 ctxId,
-	vm::ptr<const SceNpMatching2KickoutRoomMemberRequest> reqParam,
+	vm::cptr<SceNpMatching2KickoutRoomMemberRequest> reqParam,
-	vm::ptr<const SceNpMatching2RequestOptParam> optParam,
+	vm::cptr<SceNpMatching2RequestOptParam> optParam,
 	vm::ptr<u32> assignedReqId)
 {
 	throw __FUNCTION__;
@@ -158,8 +158,8 @@ s32 sceNpMatching2KickoutRoomMember(
 
 s32 sceNpMatching2SendRoomChatMessage(
 	u16 ctxId,
-	vm::ptr<const SceNpMatching2SendRoomChatMessageRequest> reqParam,
+	vm::cptr<SceNpMatching2SendRoomChatMessageRequest> reqParam,
-	vm::ptr<const SceNpMatching2RequestOptParam> optParam,
+	vm::cptr<SceNpMatching2RequestOptParam> optParam,
 	vm::ptr<u32> assignedReqId)
 {
 	throw __FUNCTION__;
@@ -167,8 +167,8 @@ s32 sceNpMatching2SendRoomChatMessage(
 
 s32 sceNpMatching2SendRoomMessage(
 	u16 ctxId,
-	vm::ptr<const SceNpMatching2SendRoomMessageRequest> reqParam,
+	vm::cptr<SceNpMatching2SendRoomMessageRequest> reqParam,
-	vm::ptr<const SceNpMatching2RequestOptParam> optParam,
+	vm::cptr<SceNpMatching2RequestOptParam> optParam,
 	vm::ptr<u32> assignedReqId)
 {
 	throw __FUNCTION__;

rpcs3/Emu/ARMv7/Modules/sceNpMatching.h

@@ -472,7 +472,7 @@ struct SceNpMatching2GetRoomDataExternalListRequest
 {
 	vm::lptr<u64> roomId;
 	le_t<u32> roomIdNum;
-	vm::lptr<const u16> attrId;
+	vm::lcptr<u16> attrId;
 	le_t<u32> attrIdNum;
 };
 
@@ -629,7 +629,7 @@ struct SceNpMatching2SendRoomChatMessageRequest
 	u8 castType;
 	u8 padding[3];
 	SceNpMatching2RoomMessageDestination dst;
-	vm::lptr<const void> msg;
+	vm::lcptr<void> msg;
 	le_t<u32> msgLen;
 	le_t<s32> option;
 };

rpcs3/Emu/ARMv7/Modules/sceNpScore.cpp

@@ -14,7 +14,7 @@ s32 sceNpScoreTerm(ARMv7Context&)
 	throw __FUNCTION__;
 }
 
-s32 sceNpScoreCreateTitleCtx(vm::ptr<const SceNpCommunicationId> titleId, vm::ptr<const SceNpCommunicationPassphrase> passphrase, vm::ptr<const SceNpId> selfNpId)
+s32 sceNpScoreCreateTitleCtx(vm::cptr<SceNpCommunicationId> titleId, vm::cptr<SceNpCommunicationPassphrase> passphrase, vm::cptr<SceNpId> selfNpId)
 {
 	throw __FUNCTION__;
 }
@@ -58,10 +58,10 @@ s32 sceNpScoreRecordScore(
 	s32 reqId,
 	u32 boardId,
 	s64 score,
-	vm::ptr<const SceNpScoreComment> scoreComment,
+	vm::cptr<SceNpScoreComment> scoreComment,
-	vm::ptr<const SceNpScoreGameInfo> gameInfo,
+	vm::cptr<SceNpScoreGameInfo> gameInfo,
 	vm::ptr<u32> tmpRank,
-	vm::ptr<const u64> compareDate,
+	vm::cptr<u64> compareDate,
 	vm::ptr<void> option)
 {
 	throw __FUNCTION__;
@@ -73,7 +73,7 @@ s32 sceNpScoreRecordGameData(
 	s64 score,
 	u32 totalSize,
 	u32 sendSize,
-	vm::ptr<const void> data,
+	vm::cptr<void> data,
 	vm::ptr<void> option)
 {
 	throw __FUNCTION__;
@@ -82,7 +82,7 @@ s32 sceNpScoreRecordGameData(
 s32 sceNpScoreGetGameData(
 	s32 reqId,
 	u32 boardId,
-	vm::ptr<const SceNpId> npId,
+	vm::cptr<SceNpId> npId,
 	vm::ptr<u32> totalSize,
 	u32 recvSize,
 	vm::ptr<void> data,
@@ -94,7 +94,7 @@ s32 sceNpScoreGetGameData(
 s32 sceNpScoreGetRankingByNpId(
 	s32 reqId,
 	u32 boardId,
-	vm::ptr<const SceNpId> npIdArray,
+	vm::cptr<SceNpId> npIdArray,
 	u32 npIdArraySize,
 	vm::ptr<SceNpScorePlayerRankData> rankArray,
 	u32 rankArraySize,
@@ -132,7 +132,7 @@ s32 sceNpScoreGetRankingByRange(
 s32 sceNpScoreGetRankingByNpIdPcId(
 	s32 reqId,
 	u32 boardId,
-	vm::ptr<const SceNpScoreNpIdPcId> idArray,
+	vm::cptr<SceNpScoreNpIdPcId> idArray,
 	u32 idArraySize,
 	vm::ptr<SceNpScorePlayerRankData> rankArray,
 	u32 rankArraySize,
@@ -148,12 +148,12 @@ s32 sceNpScoreGetRankingByNpIdPcId(
 	throw __FUNCTION__;
 }
 
-s32 sceNpScoreCensorComment(s32 reqId, vm::ptr<const char> comment, vm::ptr<void> option)
+s32 sceNpScoreCensorComment(s32 reqId, vm::cptr<char> comment, vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpScoreSanitizeComment(s32 reqId, vm::ptr<const char> comment, vm::ptr<char> sanitizedComment, vm::ptr<void> option)
+s32 sceNpScoreSanitizeComment(s32 reqId, vm::cptr<char> comment, vm::ptr<char> sanitizedComment, vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
@@ -177,10 +177,10 @@ s32 sceNpScoreRecordScoreAsync(
 	s32 reqId,
 	u32 boardId,
 	s64 score,
-	vm::ptr<const SceNpScoreComment> scoreComment,
+	vm::cptr<SceNpScoreComment> scoreComment,
-	vm::ptr<const SceNpScoreGameInfo> gameInfo,
+	vm::cptr<SceNpScoreGameInfo> gameInfo,
 	vm::ptr<u32> tmpRank,
-	vm::ptr<const u64> compareDate,
+	vm::cptr<u64> compareDate,
 	vm::ptr<void> option)
 {
 	throw __FUNCTION__;
@@ -192,7 +192,7 @@ s32 sceNpScoreRecordGameDataAsync(
 	s64 score,
 	u32 totalSize,
 	u32 sendSize,
-	vm::ptr<const void> data,
+	vm::cptr<void> data,
 	vm::ptr<void> option)
 {
 	throw __FUNCTION__;
@@ -201,7 +201,7 @@ s32 sceNpScoreRecordGameDataAsync(
 s32 sceNpScoreGetGameDataAsync(
 	s32 reqId,
 	u32 boardId,
-	vm::ptr<const SceNpId> npId,
+	vm::cptr<SceNpId> npId,
 	vm::ptr<u32> totalSize,
 	u32 recvSize,
 	vm::ptr<void> data,
@@ -213,7 +213,7 @@ s32 sceNpScoreGetGameDataAsync(
 s32 sceNpScoreGetRankingByNpIdAsync(
 	s32 reqId,
 	u32 boardId,
-	vm::ptr<const SceNpId> npIdArray,
+	vm::cptr<SceNpId> npIdArray,
 	u32 npIdArraySize,
 	vm::ptr<SceNpScorePlayerRankData> rankArray,
 	u32 rankArraySize,
@@ -250,7 +250,7 @@ s32 sceNpScoreGetRankingByRangeAsync(
 s32 sceNpScoreGetRankingByNpIdPcIdAsync(
 	s32 reqId,
 	u32 boardId,
-	vm::ptr<const SceNpScoreNpIdPcId> idArray,
+	vm::cptr<SceNpScoreNpIdPcId> idArray,
 	u32 idArraySize,
 	vm::ptr<SceNpScorePlayerRankData> rankArray,
 	u32 rankArraySize,
@@ -266,12 +266,12 @@ s32 sceNpScoreGetRankingByNpIdPcIdAsync(
 	throw __FUNCTION__;
 }
 
-s32 sceNpScoreCensorCommentAsync(s32 reqId, vm::ptr<const char> comment, vm::ptr<void> option)
+s32 sceNpScoreCensorCommentAsync(s32 reqId, vm::cptr<char> comment, vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpScoreSanitizeCommentAsync(s32 reqId, vm::ptr<const char> comment, vm::ptr<char> sanitizedComment, vm::ptr<void> option)
+s32 sceNpScoreSanitizeCommentAsync(s32 reqId, vm::cptr<char> comment, vm::ptr<char> sanitizedComment, vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceNpUtility.cpp

@@ -14,7 +14,7 @@ s32 sceNpLookupTerm(ARMv7Context&)
 	throw __FUNCTION__;
 }
 
-s32 sceNpLookupCreateTitleCtx(vm::ptr<const SceNpCommunicationId> titleId, vm::ptr<const SceNpId> selfNpId)
+s32 sceNpLookupCreateTitleCtx(vm::cptr<SceNpCommunicationId> titleId, vm::cptr<SceNpId> selfNpId)
 {
 	throw __FUNCTION__;
 }
@@ -54,12 +54,12 @@ s32 sceNpLookupPollAsync(s32 reqId, vm::ptr<s32> result)
 	throw __FUNCTION__;
 }
 
-s32 sceNpLookupNpId(s32 reqId, vm::ptr<const SceNpOnlineId> onlineId, vm::ptr<SceNpId> npId, vm::ptr<void> option)
+s32 sceNpLookupNpId(s32 reqId, vm::cptr<SceNpOnlineId> onlineId, vm::ptr<SceNpId> npId, vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpLookupNpIdAsync(s32 reqId, vm::ptr<const SceNpOnlineId> onlineId, vm::ptr<SceNpId> npId, vm::ptr<void> option)
+s32 sceNpLookupNpIdAsync(s32 reqId, vm::cptr<SceNpOnlineId> onlineId, vm::ptr<SceNpId> npId, vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
@@ -67,7 +67,7 @@ s32 sceNpLookupNpIdAsync(s32 reqId, vm::ptr<const SceNpOnlineId> onlineId, vm::p
 s32 sceNpLookupUserProfile(
 	s32 reqId,
 	s32 avatarSizeType,
-	vm::ptr<const SceNpId> npId,
+	vm::cptr<SceNpId> npId,
 	vm::ptr<SceNpUserInformation> userInfo,
 	vm::ptr<SceNpAboutMe> aboutMe,
 	vm::ptr<SceNpMyLanguages> languages,
@@ -83,7 +83,7 @@ s32 sceNpLookupUserProfile(
 s32 sceNpLookupUserProfileAsync(
 	s32 reqId,
 	s32 avatarSizeType,
-	vm::ptr<const SceNpId> npId,
+	vm::cptr<SceNpId> npId,
 	vm::ptr<SceNpUserInformation> userInfo,
 	vm::ptr<SceNpAboutMe> aboutMe,
 	vm::ptr<SceNpMyLanguages> languages,
@@ -96,12 +96,12 @@ s32 sceNpLookupUserProfileAsync(
 	throw __FUNCTION__;
 }
 
-s32 sceNpLookupAvatarImage(s32 reqId, vm::ptr<const SceNpAvatarUrl> avatarUrl, vm::ptr<SceNpAvatarImage> avatarImage, vm::ptr<void> option)
+s32 sceNpLookupAvatarImage(s32 reqId, vm::cptr<SceNpAvatarUrl> avatarUrl, vm::ptr<SceNpAvatarImage> avatarImage, vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpLookupAvatarImageAsync(s32 reqId, vm::ptr<const SceNpAvatarUrl> avatarUrl, vm::ptr<SceNpAvatarImage> avatarImage, vm::ptr<void> option)
+s32 sceNpLookupAvatarImageAsync(s32 reqId, vm::cptr<SceNpAvatarUrl> avatarUrl, vm::ptr<SceNpAvatarImage> avatarImage, vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/scePhotoExport.cpp

@@ -5,9 +5,9 @@
 #include "scePhotoExport.h"
 
 s32 scePhotoExportFromData(
-	vm::ptr<const void> photodata,
+	vm::cptr<void> photodata,
 	s32 photodataSize,
-	vm::ptr<const ScePhotoExportParam> param,
+	vm::cptr<ScePhotoExportParam> param,
 	vm::ptr<void> workMemory,
 	vm::ptr<ScePhotoExportCancelFunc> cancelFunc,
 	vm::ptr<void> userdata,
@@ -18,8 +18,8 @@ s32 scePhotoExportFromData(
 }
 
 s32 scePhotoExportFromFile(
-	vm::ptr<const char> photodataPath,
+	vm::cptr<char> photodataPath,
-	vm::ptr<const ScePhotoExportParam> param,
+	vm::cptr<ScePhotoExportParam> param,
 	vm::ptr<void> workMemory,
 	vm::ptr<ScePhotoExportCancelFunc> cancelFunc,
 	vm::ptr<void> userdata,

rpcs3/Emu/ARMv7/Modules/sceRazorCapture.cpp

@@ -4,12 +4,12 @@
 
 #include "sceRazorCapture.h"
 
-void sceRazorCaptureSetTrigger(u32 frameIndex, vm::ptr<const char> captureFilename)
+void sceRazorCaptureSetTrigger(u32 frameIndex, vm::cptr<char> captureFilename)
 {
 	throw __FUNCTION__;
 }
 
-void sceRazorCaptureSetTriggerNextFrame(vm::ptr<const char> captureFilename)
+void sceRazorCaptureSetTriggerNextFrame(vm::cptr<char> captureFilename)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceRtc.cpp

@@ -29,12 +29,12 @@ s32 sceRtcGetCurrentNetworkTick(vm::ptr<u64> pTick)
 	throw __FUNCTION__;
 }
 
-s32 sceRtcConvertUtcToLocalTime(vm::ptr<const u64> pUtc, vm::ptr<u64> pLocalTime)
+s32 sceRtcConvertUtcToLocalTime(vm::cptr<u64> pUtc, vm::ptr<u64> pLocalTime)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcConvertLocalTimeToUtc(vm::ptr<const u64> pLocalTime, vm::ptr<u64> pUtc)
+s32 sceRtcConvertLocalTimeToUtc(vm::cptr<u64> pLocalTime, vm::ptr<u64> pUtc)
 {
 	throw __FUNCTION__;
 }
@@ -54,7 +54,7 @@ s32 sceRtcGetDayOfWeek(s32 year, s32 month, s32 day)
 	throw __FUNCTION__;
 }
 
-s32 sceRtcCheckValid(vm::ptr<const SceDateTime> pTime)
+s32 sceRtcCheckValid(vm::cptr<SceDateTime> pTime)
 {
 	throw __FUNCTION__;
 }
@@ -69,12 +69,12 @@ s32 sceRtcSetTime64_t(vm::ptr<SceDateTime> pTime, u64 ullTime)
 	throw __FUNCTION__;
 }
 
-s32 sceRtcGetTime_t(vm::ptr<const SceDateTime> pTime, vm::ptr<u32> piTime)
+s32 sceRtcGetTime_t(vm::cptr<SceDateTime> pTime, vm::ptr<u32> piTime)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcGetTime64_t(vm::ptr<const SceDateTime> pTime, vm::ptr<u64> pullTime)
+s32 sceRtcGetTime64_t(vm::cptr<SceDateTime> pTime, vm::ptr<u64> pullTime)
 {
 	throw __FUNCTION__;
 }
@@ -84,7 +84,7 @@ s32 sceRtcSetDosTime(vm::ptr<SceDateTime> pTime, u32 uiDosTime)
 	throw __FUNCTION__;
 }
 
-s32 sceRtcGetDosTime(vm::ptr<const SceDateTime> pTime, vm::ptr<u32> puiDosTime)
+s32 sceRtcGetDosTime(vm::cptr<SceDateTime> pTime, vm::ptr<u32> puiDosTime)
 {
 	throw __FUNCTION__;
 }
@@ -94,97 +94,97 @@ s32 sceRtcSetWin32FileTime(vm::ptr<SceDateTime> pTime, u64 ulWin32Time)
 	throw __FUNCTION__;
 }
 
-s32 sceRtcGetWin32FileTime(vm::ptr<const SceDateTime> pTime, vm::ptr<u64> ulWin32Time)
+s32 sceRtcGetWin32FileTime(vm::cptr<SceDateTime> pTime, vm::ptr<u64> ulWin32Time)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcSetTick(vm::ptr<SceDateTime> pTime, vm::ptr<const u64> pTick)
+s32 sceRtcSetTick(vm::ptr<SceDateTime> pTime, vm::cptr<u64> pTick)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcGetTick(vm::ptr<const SceDateTime> pTime, vm::ptr<u64> pTick)
+s32 sceRtcGetTick(vm::cptr<SceDateTime> pTime, vm::ptr<u64> pTick)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcCompareTick(vm::ptr<const u64> pTick1, vm::ptr<const u64> pTick2)
+s32 sceRtcCompareTick(vm::cptr<u64> pTick1, vm::cptr<u64> pTick2)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcTickAddTicks(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, u64 lAdd)
+s32 sceRtcTickAddTicks(vm::ptr<u64> pTick0, vm::cptr<u64> pTick1, u64 lAdd)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcTickAddMicroseconds(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, u64 lAdd)
+s32 sceRtcTickAddMicroseconds(vm::ptr<u64> pTick0, vm::cptr<u64> pTick1, u64 lAdd)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcTickAddSeconds(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, u64 lAdd)
+s32 sceRtcTickAddSeconds(vm::ptr<u64> pTick0, vm::cptr<u64> pTick1, u64 lAdd)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcTickAddMinutes(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, u64 lAdd)
+s32 sceRtcTickAddMinutes(vm::ptr<u64> pTick0, vm::cptr<u64> pTick1, u64 lAdd)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcTickAddHours(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, s32 lAdd)
+s32 sceRtcTickAddHours(vm::ptr<u64> pTick0, vm::cptr<u64> pTick1, s32 lAdd)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcTickAddDays(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, s32 lAdd)
+s32 sceRtcTickAddDays(vm::ptr<u64> pTick0, vm::cptr<u64> pTick1, s32 lAdd)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcTickAddWeeks(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, s32 lAdd)
+s32 sceRtcTickAddWeeks(vm::ptr<u64> pTick0, vm::cptr<u64> pTick1, s32 lAdd)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcTickAddMonths(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, s32 lAdd)
+s32 sceRtcTickAddMonths(vm::ptr<u64> pTick0, vm::cptr<u64> pTick1, s32 lAdd)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcTickAddYears(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, s32 lAdd)
+s32 sceRtcTickAddYears(vm::ptr<u64> pTick0, vm::cptr<u64> pTick1, s32 lAdd)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcFormatRFC2822(vm::ptr<char> pszDateTime, vm::ptr<const u64> pUtc, s32 iTimeZoneMinutes)
+s32 sceRtcFormatRFC2822(vm::ptr<char> pszDateTime, vm::cptr<u64> pUtc, s32 iTimeZoneMinutes)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcFormatRFC2822LocalTime(vm::ptr<char> pszDateTime, vm::ptr<const u64> pUtc)
+s32 sceRtcFormatRFC2822LocalTime(vm::ptr<char> pszDateTime, vm::cptr<u64> pUtc)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcFormatRFC3339(vm::ptr<char> pszDateTime, vm::ptr<const u64> pUtc, s32 iTimeZoneMinutes)
+s32 sceRtcFormatRFC3339(vm::ptr<char> pszDateTime, vm::cptr<u64> pUtc, s32 iTimeZoneMinutes)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcFormatRFC3339LocalTime(vm::ptr<char> pszDateTime, vm::ptr<const u64> pUtc)
+s32 sceRtcFormatRFC3339LocalTime(vm::ptr<char> pszDateTime, vm::cptr<u64> pUtc)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcParseDateTime(vm::ptr<u64> pUtc, vm::ptr<const char> pszDateTime)
+s32 sceRtcParseDateTime(vm::ptr<u64> pUtc, vm::cptr<char> pszDateTime)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcParseRFC3339(vm::ptr<u64> pUtc, vm::ptr<const char> pszDateTime)
+s32 sceRtcParseRFC3339(vm::ptr<u64> pUtc, vm::cptr<char> pszDateTime)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceSas.cpp

@@ -4,17 +4,17 @@
 
 #include "sceSas.h"
 
-s32 sceSasGetNeededMemorySize(vm::ptr<const char> config, vm::ptr<u32> outSize)
+s32 sceSasGetNeededMemorySize(vm::cptr<char> config, vm::ptr<u32> outSize)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSasInit(vm::ptr<const char> config, vm::ptr<void> buffer, u32 bufferSize)
+s32 sceSasInit(vm::cptr<char> config, vm::ptr<void> buffer, u32 bufferSize)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSasInitWithGrain(vm::ptr<const char> config, u32 grain, vm::ptr<void> buffer, u32 bufferSize)
+s32 sceSasInitWithGrain(vm::cptr<char> config, u32 grain, vm::ptr<void> buffer, u32 bufferSize)
 {
 	throw __FUNCTION__;
 }
@@ -54,12 +54,12 @@ s32 sceSasCoreWithMix(vm::ptr<s16> inOut, s32 lvol, s32 rvol)
 	throw __FUNCTION__;
 }
 
-s32 sceSasSetVoice(s32 iVoiceNum, vm::ptr<const void> vagBuf, u32 size, u32 loopflag)
+s32 sceSasSetVoice(s32 iVoiceNum, vm::cptr<void> vagBuf, u32 size, u32 loopflag)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSasSetVoicePCM(s32 iVoiceNum, vm::ptr<const void> pcmBuf, u32 size, s32 loopsize)
+s32 sceSasSetVoicePCM(s32 iVoiceNum, vm::cptr<void> pcmBuf, u32 size, s32 loopsize)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceScreenShot.cpp

@@ -4,12 +4,12 @@
 
 #include "sceScreenShot.h"
 
-s32 sceScreenShotSetParam(vm::ptr<const SceScreenShotParam> param)
+s32 sceScreenShotSetParam(vm::cptr<SceScreenShotParam> param)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceScreenShotSetOverlayImage(vm::ptr<const char> filePath, s32 offsetX, s32 offsetY)
+s32 sceScreenShotSetOverlayImage(vm::cptr<char> filePath, s32 offsetX, s32 offsetY)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceSsl.cpp

@@ -19,7 +19,7 @@ s32 sceSslGetMemoryPoolStats(vm::ptr<SceSslMemoryPoolStats> currentStat)
 	throw __FUNCTION__;
 }
 
-s32 sceSslGetSerialNumber(vm::ptr<SceSslCert> sslCert, vm::pptr<const u8> sboData, vm::ptr<u32> sboLen)
+s32 sceSslGetSerialNumber(vm::ptr<SceSslCert> sslCert, vm::cpptr<u8> sboData, vm::ptr<u32> sboLen)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceSulpha.cpp

@@ -19,12 +19,12 @@ s32 sceSulphaGetDefaultConfig(vm::ptr<SceSulphaConfig> config)
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaGetNeededMemory(vm::ptr<const SceSulphaConfig> config, vm::ptr<u32> sizeInBytes)
+s32 sceSulphaGetNeededMemory(vm::cptr<SceSulphaConfig> config, vm::ptr<u32> sizeInBytes)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaInit(vm::ptr<const SceSulphaConfig> config, vm::ptr<void> buffer, u32 sizeInBytes)
+s32 sceSulphaInit(vm::cptr<SceSulphaConfig> config, vm::ptr<void> buffer, u32 sizeInBytes)
 {
 	throw __FUNCTION__;
 }
@@ -39,7 +39,7 @@ s32 sceSulphaUpdate()
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaFileConnect(vm::ptr<const char> filename)
+s32 sceSulphaFileConnect(vm::cptr<char> filename)
 {
 	throw __FUNCTION__;
 }
@@ -49,22 +49,22 @@ s32 sceSulphaFileDisconnect()
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaSetBookmark(vm::ptr<const char> name, s32 id)
+s32 sceSulphaSetBookmark(vm::cptr<char> name, s32 id)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaAgentsGetNeededMemory(vm::ptr<const SceSulphaAgentsRegister> config, vm::ptr<u32> sizeInBytes)
+s32 sceSulphaAgentsGetNeededMemory(vm::cptr<SceSulphaAgentsRegister> config, vm::ptr<u32> sizeInBytes)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaAgentsRegister(vm::ptr<const SceSulphaAgentsRegister> config, vm::ptr<void> buffer, u32 sizeInBytes, vm::ptr<SceSulphaHandle> handles)
+s32 sceSulphaAgentsRegister(vm::cptr<SceSulphaAgentsRegister> config, vm::ptr<void> buffer, u32 sizeInBytes, vm::ptr<SceSulphaHandle> handles)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaAgentsUnregister(vm::ptr<const SceSulphaHandle> handles, u32 agentCount)
+s32 sceSulphaAgentsUnregister(vm::cptr<SceSulphaHandle> handles, u32 agentCount)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceSystemGesture.cpp

@@ -19,7 +19,7 @@ s32 sceSystemGestureResetPrimitiveTouchRecognizer()
 	throw __FUNCTION__;
 }
 
-s32 sceSystemGestureUpdatePrimitiveTouchRecognizer(vm::ptr<const SceTouchData> pFrontData, vm::ptr<const SceTouchData> pBackData)
+s32 sceSystemGestureUpdatePrimitiveTouchRecognizer(vm::cptr<SceTouchData> pFrontData, vm::cptr<SceTouchData> pBackData)
 {
 	throw __FUNCTION__;
 }
@@ -44,12 +44,12 @@ s32 sceSystemGestureGetPrimitiveTouchEventByPrimitiveID(const u16 primitiveID, v
 	throw __FUNCTION__;
 }
 
-s32 sceSystemGestureCreateTouchRecognizer(vm::ptr<SceSystemGestureTouchRecognizer> touchRecognizer, const SceSystemGestureType gestureType, const u8 touchPanelPortID, vm::ptr<const SceSystemGestureRectangle> rectangle, vm::ptr<const SceSystemGestureTouchRecognizerParameter> touchRecognizerParameter)
+s32 sceSystemGestureCreateTouchRecognizer(vm::ptr<SceSystemGestureTouchRecognizer> touchRecognizer, const SceSystemGestureType gestureType, const u8 touchPanelPortID, vm::cptr<SceSystemGestureRectangle> rectangle, vm::cptr<SceSystemGestureTouchRecognizerParameter> touchRecognizerParameter)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSystemGestureGetTouchRecognizerInformation(vm::ptr<const SceSystemGestureTouchRecognizer> touchRecognizer, vm::ptr<SceSystemGestureTouchRecognizerInformation> information)
+s32 sceSystemGestureGetTouchRecognizerInformation(vm::cptr<SceSystemGestureTouchRecognizer> touchRecognizer, vm::ptr<SceSystemGestureTouchRecognizerInformation> information)
 {
 	throw __FUNCTION__;
 }
@@ -64,27 +64,27 @@ s32 sceSystemGestureUpdateTouchRecognizer(vm::ptr<SceSystemGestureTouchRecognize
 	throw __FUNCTION__;
 }
 
-s32 sceSystemGestureUpdateTouchRecognizerRectangle(vm::ptr<SceSystemGestureTouchRecognizer> touchRecognizer, vm::ptr<const SceSystemGestureRectangle> rectangle)
+s32 sceSystemGestureUpdateTouchRecognizerRectangle(vm::ptr<SceSystemGestureTouchRecognizer> touchRecognizer, vm::cptr<SceSystemGestureRectangle> rectangle)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSystemGestureGetTouchEvents(vm::ptr<const SceSystemGestureTouchRecognizer> touchRecognizer, vm::ptr<SceSystemGestureTouchEvent> eventBuffer, const u32 capacityOfBuffer, vm::ptr<u32> numberOfEvent)
+s32 sceSystemGestureGetTouchEvents(vm::cptr<SceSystemGestureTouchRecognizer> touchRecognizer, vm::ptr<SceSystemGestureTouchEvent> eventBuffer, const u32 capacityOfBuffer, vm::ptr<u32> numberOfEvent)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSystemGestureGetTouchEventsCount(vm::ptr<const SceSystemGestureTouchRecognizer> touchRecognizer)
+s32 sceSystemGestureGetTouchEventsCount(vm::cptr<SceSystemGestureTouchRecognizer> touchRecognizer)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSystemGestureGetTouchEventByIndex(vm::ptr<const SceSystemGestureTouchRecognizer> touchRecognizer, const u32 index, vm::ptr<SceSystemGestureTouchEvent> touchEvent)
+s32 sceSystemGestureGetTouchEventByIndex(vm::cptr<SceSystemGestureTouchRecognizer> touchRecognizer, const u32 index, vm::ptr<SceSystemGestureTouchEvent> touchEvent)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSystemGestureGetTouchEventByEventID(vm::ptr<const SceSystemGestureTouchRecognizer> touchRecognizer, const u32 eventID, vm::ptr<SceSystemGestureTouchEvent> touchEvent)
+s32 sceSystemGestureGetTouchEventByEventID(vm::cptr<SceSystemGestureTouchRecognizer> touchRecognizer, const u32 eventID, vm::ptr<SceSystemGestureTouchEvent> touchEvent)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceUlt.cpp

@@ -18,11 +18,11 @@ u32 sceUltWaitingQueueResourcePoolGetWorkAreaSize(u32 numThreads, u32 numSyncObj
 
 s32 _sceUltWaitingQueueResourcePoolCreate(
 	vm::ptr<SceUltWaitingQueueResourcePool> pool,
-	vm::ptr<const char> name,
+	vm::cptr<char> name,
 	u32 numThreads,
 	u32 numSyncObjects,
 	vm::ptr<void> workArea,
-	vm::ptr<const SceUltWaitingQueueResourcePoolOptParam> optParam,
+	vm::cptr<SceUltWaitingQueueResourcePoolOptParam> optParam,
 	u32 buildVersion)
 {
 	throw __FUNCTION__;
@@ -45,13 +45,13 @@ u32 sceUltQueueDataResourcePoolGetWorkAreaSize(u32 numData, u32 dataSize, u32 nu
 
 s32 _sceUltQueueDataResourcePoolCreate(
 	vm::ptr<SceUltQueueDataResourcePool> pool,
-	vm::ptr<const char> name,
+	vm::cptr<char> name,
 	u32 numData,
 	u32 dataSize,
 	u32 numQueueObject,
 	vm::ptr<SceUltWaitingQueueResourcePool> waitingQueueResourcePool,
 	vm::ptr<void> workArea,
-	vm::ptr<const SceUltQueueDataResourcePoolOptParam> optParam,
+	vm::cptr<SceUltQueueDataResourcePoolOptParam> optParam,
 	u32 buildVersion)
 {
 	throw __FUNCTION__;
@@ -74,9 +74,9 @@ s32 _sceUltMutexOptParamInitialize(vm::ptr<SceUltMutexOptParam> optParam, u32 bu
 
 s32 _sceUltMutexCreate(
 	vm::ptr<SceUltMutex> mutex,
-	vm::ptr<const char> name,
+	vm::cptr<char> name,
 	vm::ptr<SceUltWaitingQueueResourcePool> waitingQueueResourcePool,
-	vm::ptr<const SceUltMutexOptParam> optParam,
+	vm::cptr<SceUltMutexOptParam> optParam,
 	u32 buildVersion)
 {
 	throw __FUNCTION__;
@@ -84,11 +84,11 @@ s32 _sceUltMutexCreate(
 
 s32 _sceUltMutexCreateStandalone(
 	vm::ptr<SceUltMutex> mutex,
-	vm::ptr<const char> name,
+	vm::cptr<char> name,
 	u32 numConditionVariable,
 	u32 maxNumThreads,
 	vm::ptr<void> workArea,
-	vm::ptr<const SceUltMutexOptParam> optParam,
+	vm::cptr<SceUltMutexOptParam> optParam,
 	u32 buildVersion)
 {
 	throw __FUNCTION__;
@@ -121,9 +121,9 @@ s32 _sceUltConditionVariableOptParamInitialize(vm::ptr<SceUltConditionVariableOp
 
 s32 _sceUltConditionVariableCreate(
 	vm::ptr<SceUltConditionVariable> conditionVariable,
-	vm::ptr<const char> name,
+	vm::cptr<char> name,
 	vm::ptr<SceUltMutex> mutex,
-	vm::ptr<const SceUltConditionVariableOptParam> optParam,
+	vm::cptr<SceUltConditionVariableOptParam> optParam,
 	u32 buildVersion)
 {
 	throw __FUNCTION__;
@@ -163,11 +163,11 @@ u32 sceUltQueueGetStandaloneWorkAreaSize(u32 queueDepth,
 
 s32 _sceUltQueueCreate(
 	vm::ptr<SceUltQueue> queue,
-	vm::ptr<const char> _name,
+	vm::cptr<char> _name,
 	u32 dataSize,
 	vm::ptr<SceUltWaitingQueueResourcePool> resourcePool,
 	vm::ptr<SceUltQueueDataResourcePool> queueResourcePool,
-	vm::ptr<const SceUltQueueOptParam> optParam,
+	vm::cptr<SceUltQueueOptParam> optParam,
 	u32 buildVersion)
 {
 	throw __FUNCTION__;
@@ -175,23 +175,23 @@ s32 _sceUltQueueCreate(
 
 s32 _sceUltQueueCreateStandalone(
 	vm::ptr<SceUltQueue> queue,
-	vm::ptr<const char> name,
+	vm::cptr<char> name,
 	u32 queueDepth,
 	u32 dataSize,
 	u32 waitingQueueLength,
 	vm::ptr<void> workArea,
-	vm::ptr<const SceUltQueueOptParam> optParam,
+	vm::cptr<SceUltQueueOptParam> optParam,
 	u32 buildVersion)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceUltQueuePush(vm::ptr<SceUltQueue> queue, vm::ptr<const void> data)
+s32 sceUltQueuePush(vm::ptr<SceUltQueue> queue, vm::cptr<void> data)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceUltQueueTryPush(vm::ptr<SceUltQueue> queue, vm::ptr<const void> data)
+s32 sceUltQueueTryPush(vm::ptr<SceUltQueue> queue, vm::cptr<void> data)
 {
 	throw __FUNCTION__;
 }
@@ -218,9 +218,9 @@ s32 _sceUltReaderWriterLockOptParamInitialize(vm::ptr<SceUltReaderWriterLockOptP
 
 s32 _sceUltReaderWriterLockCreate(
 	vm::ptr<SceUltReaderWriterLock> rwlock,
-	vm::ptr<const char> name,
+	vm::cptr<char> name,
 	vm::ptr<SceUltWaitingQueueResourcePool> waitingQueueResourcePool,
-	vm::ptr<const SceUltReaderWriterLockOptParam> optParam,
+	vm::cptr<SceUltReaderWriterLockOptParam> optParam,
 	u32 buildVersion)
 {
 	throw __FUNCTION__;
@@ -228,10 +228,10 @@ s32 _sceUltReaderWriterLockCreate(
 
 s32 _sceUltReaderWriterLockCreateStandalone(
 	vm::ptr<SceUltReaderWriterLock> rwlock,
-	vm::ptr<const char> name,
+	vm::cptr<char> name,
 	u32 waitingQueueDepth,
 	vm::ptr<void> workArea,
-	vm::ptr<const SceUltReaderWriterLockOptParam> optParam,
+	vm::cptr<SceUltReaderWriterLockOptParam> optParam,
 	u32 buildVersion)
 {
 	throw __FUNCTION__;
@@ -284,10 +284,10 @@ s32 _sceUltSemaphoreOptParamInitialize(vm::ptr<SceUltSemaphoreOptParam> optParam
 
 s32 _sceUltSemaphoreCreate(
 	vm::ptr<SceUltSemaphore> semaphore,
-	vm::ptr<const char> name,
+	vm::cptr<char> name,
 	s32 numInitialResource,
 	vm::ptr<SceUltWaitingQueueResourcePool> waitingQueueResourcePool,
-	vm::ptr<const SceUltSemaphoreOptParam> optParam,
+	vm::cptr<SceUltSemaphoreOptParam> optParam,
 	u32 buildVersion)
 {
 	throw __FUNCTION__;
@@ -325,11 +325,11 @@ u32 sceUltUlthreadRuntimeGetWorkAreaSize(u32 numMaxUlthread, u32 numWorkerThread
 
 s32 _sceUltUlthreadRuntimeCreate(
 	vm::ptr<SceUltUlthreadRuntime> runtime,
-	vm::ptr<const char> name,
+	vm::cptr<char> name,
 	u32 numMaxUlthread,
 	u32 numWorkerThread,
 	vm::ptr<void> workArea,
-	vm::ptr<const SceUltUlthreadRuntimeOptParam> optParam,
+	vm::cptr<SceUltUlthreadRuntimeOptParam> optParam,
 	u32 buildVersion)
 {
 	throw __FUNCTION__;
@@ -347,13 +347,13 @@ s32 _sceUltUlthreadOptParamInitialize(vm::ptr<SceUltUlthreadOptParam> optParam,
 
 s32 _sceUltUlthreadCreate(
 	vm::ptr<SceUltUlthread> ulthread,
-	vm::ptr<const char> name,
+	vm::cptr<char> name,
 	vm::ptr<SceUltUlthreadEntry> entry,
 	u32 arg,
 	vm::ptr<void> context,
 	u32 sizeContext,
 	vm::ptr<SceUltUlthreadRuntime> runtime,
-	vm::ptr<const SceUltUlthreadOptParam> optParam,
+	vm::cptr<SceUltUlthreadOptParam> optParam,
 	u32 buildVersion)
 {
 	throw __FUNCTION__;

rpcs3/Emu/ARMv7/Modules/sceVideodec.cpp

@@ -4,7 +4,7 @@
 
 #include "sceVideodec.h"
 
-s32 sceVideodecInitLibrary(u32 codecType, vm::ptr<const SceVideodecQueryInitInfo> pInitInfo)
+s32 sceVideodecInitLibrary(u32 codecType, vm::cptr<SceVideodecQueryInitInfo> pInitInfo)
 {
 	throw __FUNCTION__;
 }
@@ -14,12 +14,12 @@ s32 sceVideodecTermLibrary(u32 codecType)
 	throw __FUNCTION__;
 }
 
-s32 sceAvcdecQueryDecoderMemSize(u32 codecType, vm::ptr<const SceAvcdecQueryDecoderInfo> pDecoderInfo, vm::ptr<SceAvcdecDecoderInfo> pMemInfo)
+s32 sceAvcdecQueryDecoderMemSize(u32 codecType, vm::cptr<SceAvcdecQueryDecoderInfo> pDecoderInfo, vm::ptr<SceAvcdecDecoderInfo> pMemInfo)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAvcdecCreateDecoder(u32 codecType, vm::ptr<SceAvcdecCtrl> pCtrl, vm::ptr<const SceAvcdecQueryDecoderInfo> pDecoderInfo)
+s32 sceAvcdecCreateDecoder(u32 codecType, vm::ptr<SceAvcdecCtrl> pCtrl, vm::cptr<SceAvcdecQueryDecoderInfo> pDecoderInfo)
 {
 	throw __FUNCTION__;
 }
@@ -34,7 +34,7 @@ s32 sceAvcdecDecodeAvailableSize(vm::ptr<SceAvcdecCtrl> pCtrl)
 	throw __FUNCTION__;
 }
 
-s32 sceAvcdecDecode(vm::ptr<SceAvcdecCtrl> pCtrl, vm::ptr<const SceAvcdecAu> pAu, vm::ptr<SceAvcdecArrayPicture> pArrayPicture)
+s32 sceAvcdecDecode(vm::ptr<SceAvcdecCtrl> pCtrl, vm::cptr<SceAvcdecAu> pAu, vm::ptr<SceAvcdecArrayPicture> pArrayPicture)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceVoice.cpp

@@ -29,12 +29,12 @@ s32 sceVoiceResetPort(u32 portId)
 	throw __FUNCTION__;
 }
 
-s32 sceVoiceCreatePort(vm::ptr<u32> portId, vm::ptr<const SceVoicePortParam> pArg)
+s32 sceVoiceCreatePort(vm::ptr<u32> portId, vm::cptr<SceVoicePortParam> pArg)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceVoiceUpdatePort(u32 portId, vm::ptr<const SceVoicePortParam> pArg)
+s32 sceVoiceUpdatePort(u32 portId, vm::cptr<SceVoicePortParam> pArg)
 {
 	throw __FUNCTION__;
 }
@@ -54,7 +54,7 @@ s32 sceVoiceDeletePort(u32 portId)
 	throw __FUNCTION__;
 }
 
-s32 sceVoiceWriteToIPort(u32 ips, vm::ptr<const void> data, vm::ptr<u32> size, s16 frameGaps)
+s32 sceVoiceWriteToIPort(u32 ips, vm::cptr<void> data, vm::ptr<u32> size, s16 frameGaps)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceVoiceQoS.cpp

@@ -54,7 +54,7 @@ s32 sceVoiceQoSGetRemoteEndpoint(s32 connectionId, vm::ptr<s32> pRemoteId)
 	throw __FUNCTION__;
 }
 
-s32 sceVoiceQoSSetLocalEndpointAttribute(s32 localId, SceVoiceQoSAttributeId attributeId, vm::ptr<const void> pAttributeValue, s32 attributeSize)
+s32 sceVoiceQoSSetLocalEndpointAttribute(s32 localId, SceVoiceQoSAttributeId attributeId, vm::cptr<void> pAttributeValue, s32 attributeSize)
 {
 	throw __FUNCTION__;
 }
@@ -64,7 +64,7 @@ s32 sceVoiceQoSGetLocalEndpointAttribute(s32 localId, SceVoiceQoSAttributeId att
 	throw __FUNCTION__;
 }
 
-s32 sceVoiceQoSSetConnectionAttribute(s32 connectionId, SceVoiceQoSAttributeId attributeId, vm::ptr<const void> pAttributeValue, s32 attributeSize)
+s32 sceVoiceQoSSetConnectionAttribute(s32 connectionId, SceVoiceQoSAttributeId attributeId, vm::cptr<void> pAttributeValue, s32 attributeSize)
 {
 	throw __FUNCTION__;
 }
@@ -79,7 +79,7 @@ s32 sceVoiceQoSGetStatus(s32 connectionId, SceVoiceQoSStatusId statusId, vm::ptr
 	throw __FUNCTION__;
 }
 
-s32 sceVoiceQoSWritePacket(s32 connectionId, vm::ptr<const void> pData, vm::ptr<u32> pSize)
+s32 sceVoiceQoSWritePacket(s32 connectionId, vm::cptr<void> pData, vm::ptr<u32> pSize)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/Memory/vm_ptr.h

@@ -171,6 +171,9 @@ namespace vm
 
 		// BE pointer to const BE data
 		template<typename T, typename AT = u32> using bcptr = bptr<const T, AT>;
+
+		template<typename T, typename AT = u32> using cpptr = pptr<const T, AT>;
+		template<typename T, typename AT = u32> using bcpptr = bpptr<const T, AT>;
 	}
 
 	namespace psv
@@ -192,6 +195,9 @@ namespace vm
 
 		// LE pointer to const LE data
 		template<typename T> using lcptr = lptr<const T>;
+
+		template<typename T> using cpptr = pptr<const T>;
+		template<typename T> using lcpptr = lpptr<const T>;
 	}
 
 	struct null_t
@@ -224,7 +230,7 @@ namespace vm
 		return{ other.m_addr };
 	}
 
-	// perform const_cast (for example, vm::ptr<const char> to vm::ptr<char>)
+	// perform const_cast (for example, vm::cptr<char> to vm::ptr<char>)
 	template<typename CT, typename T, typename AT, typename = decltype(const_cast<CT*>(std::declval<T*>()))> inline _ptr_base<CT, AT> const_ptr_cast(const _ptr_base<T, AT>& other)
 	{
 		return{ other.m_addr };

rpcs3/Emu/SysCalls/Modules.cpp

@@ -478,7 +478,7 @@ void hook_ppu_funcs(vm::ptr<u32> base, u32 size)
 
 bool patch_ppu_import(u32 addr, u32 index)
 {
-	const auto data = vm::ptr<const u32>::make(addr);
+	const auto data = vm::cptr<u32>::make(addr);
 
 	using namespace PPU_instr;
 
@@ -512,7 +512,7 @@ bool patch_ppu_import(u32 addr, u32 index)
 		(data[1] & 0xffff0000) == ORIS(r0, r0, 0) &&
 		(data[2] & 0xfc000003) == B(0, 0, 0))
 	{
-		const auto sub = vm::ptr<const u32>::make(addr + 8 + ((s32)data[2] << 6 >> 8 << 2));
+		const auto sub = vm::cptr<u32>::make(addr + 8 + ((s32)data[2] << 6 >> 8 << 2));
 
 		if (vm::check_addr(sub.addr(), 60) &&
 			sub[0x0] == STDU(r1, r1, -0x80) &&

rpcs3/Emu/SysCalls/Modules/cellAdec.cpp

@@ -605,7 +605,7 @@ s32 cellAdecStartSeq(u32 handle, u32 param)
 	case CELL_ADEC_TYPE_ATRACX_6CH:
 	case CELL_ADEC_TYPE_ATRACX_8CH:
 	{
-		const auto atx = vm::ptr<const CellAdecParamAtracX>::make(param);
+		const auto atx = vm::cptr<CellAdecParamAtracX>::make(param);
 
 		task.at3p.sample_rate = atx->sampling_freq;
 		task.at3p.channel_config = atx->ch_config_idx;
@@ -621,7 +621,7 @@ s32 cellAdecStartSeq(u32 handle, u32 param)
 	}
 	case CELL_ADEC_TYPE_MP3:
 	{
-		const auto mp3 = vm::ptr<const CellAdecParamMP3>::make(param);
+		const auto mp3 = vm::cptr<CellAdecParamMP3>::make(param);
 
 		cellAdec.Todo("*** CellAdecParamMP3: bw_pcm=%d", mp3->bw_pcm);
 		break;

rpcs3/Emu/SysCalls/Modules/cellDmux.cpp

@@ -284,7 +284,7 @@ void dmuxQueryAttr(u32 info_addr /* may be 0 */, vm::ptr<CellDmuxAttr> attr)
 	attr->memSize = 0x10000; // 0x3e8e6 from ps3
 }
 
-void dmuxQueryEsAttr(u32 info /* may be 0 */, vm::ptr<const CellCodecEsFilterId> esFilterId, u32 esSpecificInfo, vm::ptr<CellDmuxEsAttr> attr)
+void dmuxQueryEsAttr(u32 info /* may be 0 */, vm::cptr<CellCodecEsFilterId> esFilterId, u32 esSpecificInfo, vm::ptr<CellDmuxEsAttr> attr)
 {
 	if (esFilterId->filterIdMajor >= 0xe0)
 	{
@@ -772,7 +772,7 @@ void dmuxOpen(u32 dmux_id) // TODO: call from the constructor
 	});
 }
 
-s32 cellDmuxQueryAttr(vm::ptr<const CellDmuxType> type, vm::ptr<CellDmuxAttr> attr)
+s32 cellDmuxQueryAttr(vm::cptr<CellDmuxType> type, vm::ptr<CellDmuxAttr> attr)
 {
 	cellDmux.Warning("cellDmuxQueryAttr(type=*0x%x, attr=*0x%x)", type, attr);
 
@@ -785,7 +785,7 @@ s32 cellDmuxQueryAttr(vm::ptr<const CellDmuxType> type, vm::ptr<CellDmuxAttr> at
 	return CELL_OK;
 }
 
-s32 cellDmuxQueryAttr2(vm::ptr<const CellDmuxType2> type2, vm::ptr<CellDmuxAttr> attr)
+s32 cellDmuxQueryAttr2(vm::cptr<CellDmuxType2> type2, vm::ptr<CellDmuxAttr> attr)
 {
 	cellDmux.Warning("cellDmuxQueryAttr2(demuxerType2=*0x%x, demuxerAttr=*0x%x)", type2, attr);
 
@@ -798,7 +798,7 @@ s32 cellDmuxQueryAttr2(vm::ptr<const CellDmuxType2> type2, vm::ptr<CellDmuxAttr>
 	return CELL_OK;
 }
 
-s32 cellDmuxOpen(vm::ptr<const CellDmuxType> type, vm::ptr<const CellDmuxResource> res, vm::ptr<const CellDmuxCb> cb, vm::ptr<u32> handle)
+s32 cellDmuxOpen(vm::cptr<CellDmuxType> type, vm::cptr<CellDmuxResource> res, vm::cptr<CellDmuxCb> cb, vm::ptr<u32> handle)
 {
 	cellDmux.Warning("cellDmuxOpen(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle);
 
@@ -814,7 +814,7 @@ s32 cellDmuxOpen(vm::ptr<const CellDmuxType> type, vm::ptr<const CellDmuxResourc
 	return CELL_OK;
 }
 
-s32 cellDmuxOpenEx(vm::ptr<const CellDmuxType> type, vm::ptr<const CellDmuxResourceEx> resEx, vm::ptr<const CellDmuxCb> cb, vm::ptr<u32> handle)
+s32 cellDmuxOpenEx(vm::cptr<CellDmuxType> type, vm::cptr<CellDmuxResourceEx> resEx, vm::cptr<CellDmuxCb> cb, vm::ptr<u32> handle)
 {
 	cellDmux.Warning("cellDmuxOpenEx(type=*0x%x, resEx=*0x%x, cb=*0x%x, handle=*0x%x)", type, resEx, cb, handle);
 
@@ -830,12 +830,12 @@ s32 cellDmuxOpenEx(vm::ptr<const CellDmuxType> type, vm::ptr<const CellDmuxResou
 	return CELL_OK;
 }
 
-s32 _nid_e075fabc(vm::ptr<const CellDmuxType> type, vm::ptr<const CellDmuxResourceEx> resEx, vm::ptr<const CellDmuxCb> cb, vm::ptr<u32> handle)
+s32 _nid_e075fabc(vm::cptr<CellDmuxType> type, vm::cptr<CellDmuxResourceEx> resEx, vm::cptr<CellDmuxCb> cb, vm::ptr<u32> handle)
 {
 	return cellDmuxOpenEx(type, resEx, cb, handle);
 }
 
-s32 cellDmuxOpen2(vm::ptr<const CellDmuxType2> type2, vm::ptr<const CellDmuxResource2> res2, vm::ptr<const CellDmuxCb> cb, vm::ptr<u32> handle)
+s32 cellDmuxOpen2(vm::cptr<CellDmuxType2> type2, vm::cptr<CellDmuxResource2> res2, vm::cptr<CellDmuxCb> cb, vm::ptr<u32> handle)
 {
 	cellDmux.Warning("cellDmuxOpen2(type2=*0x%x, res2=*0x%x, cb=*0x%x, handle=*0x%x)", type2, res2, cb, handle);
 
@@ -957,7 +957,7 @@ s32 cellDmuxResetStreamAndWaitDone(u32 handle)
 	return CELL_OK;
 }
 
-s32 cellDmuxQueryEsAttr(vm::ptr<const CellDmuxType> type, vm::ptr<const CellCodecEsFilterId> esFilterId, u32 esSpecificInfo, vm::ptr<CellDmuxEsAttr> esAttr)
+s32 cellDmuxQueryEsAttr(vm::cptr<CellDmuxType> type, vm::cptr<CellCodecEsFilterId> esFilterId, u32 esSpecificInfo, vm::ptr<CellDmuxEsAttr> esAttr)
 {
 	cellDmux.Warning("cellDmuxQueryEsAttr(demuxerType=*0x%x, esFilterId=*0x%x, esSpecificInfo=*0x%x, esAttr=*0x%x)", type, esFilterId, esSpecificInfo, esAttr);
 
@@ -971,7 +971,7 @@ s32 cellDmuxQueryEsAttr(vm::ptr<const CellDmuxType> type, vm::ptr<const CellCode
 	return CELL_OK;
 }
 
-s32 cellDmuxQueryEsAttr2(vm::ptr<const CellDmuxType2> type2, vm::ptr<const CellCodecEsFilterId> esFilterId, u32 esSpecificInfo, vm::ptr<CellDmuxEsAttr> esAttr)
+s32 cellDmuxQueryEsAttr2(vm::cptr<CellDmuxType2> type2, vm::cptr<CellCodecEsFilterId> esFilterId, u32 esSpecificInfo, vm::ptr<CellDmuxEsAttr> esAttr)
 {
 	cellDmux.Warning("cellDmuxQueryEsAttr2(type2=*0x%x, esFilterId=*0x%x, esSpecificInfo=*0x%x, esAttr=*0x%x)", type2, esFilterId, esSpecificInfo, esAttr);
 
@@ -985,7 +985,7 @@ s32 cellDmuxQueryEsAttr2(vm::ptr<const CellDmuxType2> type2, vm::ptr<const CellC
 	return CELL_OK;
 }
 
-s32 cellDmuxEnableEs(u32 handle, vm::ptr<const CellCodecEsFilterId> esFilterId, vm::ptr<const CellDmuxEsResource> esResourceInfo, vm::ptr<const CellDmuxEsCb> esCb, u32 esSpecificInfo, vm::ptr<u32> esHandle)
+s32 cellDmuxEnableEs(u32 handle, vm::cptr<CellCodecEsFilterId> esFilterId, vm::cptr<CellDmuxEsResource> esResourceInfo, vm::cptr<CellDmuxEsCb> esCb, u32 esSpecificInfo, vm::ptr<u32> esHandle)
 {
 	cellDmux.Warning("cellDmuxEnableEs(handle=0x%x, esFilterId=*0x%x, esResourceInfo=*0x%x, esCb=*0x%x, esSpecificInfo=*0x%x, esHandle=*0x%x)", handle, esFilterId, esResourceInfo, esCb, esSpecificInfo, esHandle);
 

rpcs3/Emu/SysCalls/Modules/cellFont.cpp

@@ -83,7 +83,7 @@ int cellFontOpenFontMemory(vm::ptr<CellFontLibrary> library, u32 fontAddr, u32 f
 	return CELL_FONT_OK;
 }
 
-int cellFontOpenFontFile(vm::ptr<CellFontLibrary> library, vm::ptr<const char> fontPath, u32 subNum, s32 uniqueId, vm::ptr<CellFont> font)
+int 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_addr=0x%x, fontPath=\"%s\", subNum=%d, uniqueId=%d, font_addr=0x%x)",

rpcs3/Emu/SysCalls/Modules/cellFs.cpp

@@ -15,7 +15,7 @@
 
 extern Module cellFs;
 
-s32 cellFsOpen(vm::ptr<const char> path, s32 flags, vm::ptr<u32> fd, vm::ptr<const void> arg, u64 size)
+s32 cellFsOpen(vm::cptr<char> path, s32 flags, vm::ptr<u32> fd, vm::cptr<void> arg, u64 size)
 {
 	cellFs.Warning("cellFsOpen(path=*0x%x, flags=%#o, fd=*0x%x, arg=*0x%x, size=0x%llx) -> sys_fs_open()", path, flags, fd, arg, size);
 
@@ -33,7 +33,7 @@ s32 cellFsRead(PPUThread& CPU, u32 fd, vm::ptr<void> buf, u64 nbytes, vm::ptr<u6
 	return sys_fs_read(fd, buf, nbytes, nread ? nread : vm::stackvar<be_t<u64>>(CPU));
 }
 
-s32 cellFsWrite(PPUThread& CPU, u32 fd, vm::ptr<const void> buf, u64 nbytes, vm::ptr<u64> nwrite)
+s32 cellFsWrite(PPUThread& CPU, u32 fd, vm::cptr<void> buf, u64 nbytes, vm::ptr<u64> nwrite)
 {
 	cellFs.Log("cellFsWrite(fd=0x%x, buf=*0x%x, nbytes=0x%llx, nwrite=*0x%x)", fd, buf, nbytes, nwrite);
 
@@ -49,7 +49,7 @@ s32 cellFsClose(u32 fd)
 	return sys_fs_close(fd);
 }
 
-s32 cellFsOpendir(vm::ptr<const char> path, vm::ptr<u32> fd)
+s32 cellFsOpendir(vm::cptr<char> path, vm::ptr<u32> fd)
 {
 	cellFs.Warning("cellFsOpendir(path=*0x%x, fd=*0x%x) -> sys_fs_opendir()", path, fd);
 
@@ -75,7 +75,7 @@ s32 cellFsClosedir(u32 fd)
 	return sys_fs_closedir(fd);
 }
 
-s32 cellFsStat(vm::ptr<const char> path, vm::ptr<CellFsStat> sb)
+s32 cellFsStat(vm::cptr<char> path, vm::ptr<CellFsStat> sb)
 {
 	cellFs.Warning("cellFsStat(path=*0x%x, sb=*0x%x) -> sys_fs_stat()", path, sb);
 
@@ -93,7 +93,7 @@ s32 cellFsFstat(u32 fd, vm::ptr<CellFsStat> sb)
 	return sys_fs_fstat(fd, sb);
 }
 
-s32 cellFsMkdir(vm::ptr<const char> path, s32 mode)
+s32 cellFsMkdir(vm::cptr<char> path, s32 mode)
 {
 	cellFs.Warning("cellFsMkdir(path=*0x%x, mode=%#o) -> sys_fs_mkdir()", path, mode);
 
@@ -103,7 +103,7 @@ s32 cellFsMkdir(vm::ptr<const char> path, s32 mode)
 	return sys_fs_mkdir(path, mode);
 }
 
-s32 cellFsRename(vm::ptr<const char> from, vm::ptr<const char> to)
+s32 cellFsRename(vm::cptr<char> from, vm::cptr<char> to)
 {
 	cellFs.Warning("cellFsRename(from=*0x%x, to=*0x%x) -> sys_fs_rename()", from, to);
 
@@ -113,7 +113,7 @@ s32 cellFsRename(vm::ptr<const char> from, vm::ptr<const char> to)
 	return sys_fs_rename(from, to);
 }
 
-s32 cellFsRmdir(vm::ptr<const char> path)
+s32 cellFsRmdir(vm::cptr<char> path)
 {
 	cellFs.Warning("cellFsRmdir(path=*0x%x) -> sys_fs_rmdir()", path);
 
@@ -123,7 +123,7 @@ s32 cellFsRmdir(vm::ptr<const char> path)
 	return sys_fs_rmdir(path);
 }
 
-s32 cellFsUnlink(vm::ptr<const char> path)
+s32 cellFsUnlink(vm::cptr<char> path)
 {
 	cellFs.Warning("cellFsUnlink(path=*0x%x) -> sys_fs_unlink()", path);
 
@@ -156,7 +156,7 @@ s32 cellFsFGetBlockSize(PPUThread& CPU, u32 fd, vm::ptr<u64> sector_size, vm::pt
 	return sector_size && block_size ? sys_fs_fget_block_size(fd, sector_size, block_size, vm::stackvar<be_t<u64>>(CPU), vm::stackvar<be_t<u64>>(CPU)) : CELL_FS_EFAULT;
 }
 
-s32 cellFsGetBlockSize(PPUThread& CPU, vm::ptr<const char> path, vm::ptr<u64> sector_size, vm::ptr<u64> block_size)
+s32 cellFsGetBlockSize(PPUThread& CPU, vm::cptr<char> path, vm::ptr<u64> sector_size, vm::ptr<u64> block_size)
 {
 	cellFs.Warning("cellFsGetBlockSize(path=*0x%x, sector_size=*0x%x, block_size=*0x%x) -> sys_fs_get_block_size()", path, sector_size, block_size);
 
@@ -166,7 +166,7 @@ s32 cellFsGetBlockSize(PPUThread& CPU, vm::ptr<const char> path, vm::ptr<u64> se
 	return sys_fs_get_block_size(path, sector_size, block_size, vm::stackvar<be_t<u64>>(CPU));
 }
 
-s32 cellFsTruncate(vm::ptr<const char> path, u64 size)
+s32 cellFsTruncate(vm::cptr<char> path, u64 size)
 {
 	cellFs.Warning("cellFsTruncate(path=*0x%x, size=0x%llx) -> sys_fs_truncate()", path, size);
 
@@ -184,7 +184,7 @@ s32 cellFsFtruncate(u32 fd, u64 size)
 	return sys_fs_ftruncate(fd, size);
 }
 
-s32 cellFsChmod(vm::ptr<const char> path, s32 mode)
+s32 cellFsChmod(vm::cptr<char> path, s32 mode)
 {
 	cellFs.Warning("cellFsChmod(path=*0x%x, mode=%#o) -> sys_fs_chmod()", path, mode);
 
@@ -194,7 +194,7 @@ s32 cellFsChmod(vm::ptr<const char> path, s32 mode)
 	return sys_fs_chmod(path, mode);
 }
 
-s32 cellFsGetFreeSize(vm::ptr<const char> path, vm::ptr<u32> block_size, vm::ptr<u64> block_count)
+s32 cellFsGetFreeSize(vm::cptr<char> path, vm::ptr<u32> block_size, vm::ptr<u64> block_count)
 {
 	cellFs.Warning("cellFsGetFreeSize(path=*0x%x, block_size=*0x%x, block_count=*0x%x)", path, block_size, block_count);
 	cellFs.Warning("*** path = '%s'", path.get_ptr());
@@ -280,7 +280,7 @@ s32 cellFsReadWithOffset(u32 fd, u64 offset, vm::ptr<void> buf, u64 buffer_size,
 	return CELL_OK;
 }
 
-s32 cellFsWriteWithOffset(u32 fd, u64 offset, vm::ptr<const void> buf, u64 data_size, vm::ptr<u64> nwrite)
+s32 cellFsWriteWithOffset(u32 fd, u64 offset, vm::cptr<void> buf, u64 data_size, vm::ptr<u64> nwrite)
 {
 	cellFs.Log("cellFsWriteWithOffset(fd=0x%x, offset=0x%llx, buf=*0x%x, data_size=0x%llx, nwrite=*0x%x)", fd, offset, buf, data_size, nwrite);
 
@@ -311,7 +311,7 @@ s32 cellFsWriteWithOffset(u32 fd, u64 offset, vm::ptr<const void> buf, u64 data_
 	return CELL_OK;
 }
 
-s32 cellFsStReadInit(u32 fd, vm::ptr<const CellFsRingBuffer> ringbuf)
+s32 cellFsStReadInit(u32 fd, vm::cptr<CellFsRingBuffer> ringbuf)
 {
 	cellFs.Warning("cellFsStReadInit(fd=0x%x, ringbuf=*0x%x)", fd, ringbuf);
 
@@ -831,7 +831,7 @@ int sdata_unpack(const std::string& packed_file, const std::string& unpacked_fil
 	return CELL_OK;
 }
 
-s32 cellFsSdataOpen(PPUThread& CPU, vm::ptr<const char> path, s32 flags, vm::ptr<u32> fd, vm::ptr<const void> arg, u64 size)
+s32 cellFsSdataOpen(PPUThread& CPU, vm::cptr<char> path, s32 flags, vm::ptr<u32> fd, vm::cptr<void> arg, u64 size)
 {
 	cellFs.Log("cellFsSdataOpen(path=*0x%x, flags=%#o, fd=*0x%x, arg=*0x%x, size=0x%llx)", path, flags, fd, arg, size);
 
@@ -861,7 +861,7 @@ s32 cellFsSdataOpen(PPUThread& CPU, vm::ptr<const char> path, s32 flags, vm::ptr
 	*/
 }
 
-s32 cellFsSdataOpenByFd(u32 mself_fd, s32 flags, vm::ptr<u32> sdata_fd, u64 offset, vm::ptr<const void> arg, u64 size)
+s32 cellFsSdataOpenByFd(u32 mself_fd, s32 flags, vm::ptr<u32> sdata_fd, u64 offset, vm::cptr<void> arg, u64 size)
 {
 	cellFs.Todo("cellFsSdataOpenByFd(mself_fd=0x%x, flags=%#o, sdata_fd=*0x%x, offset=0x%llx, arg=*0x%x, size=0x%llx)", mself_fd, flags, sdata_fd, offset, arg, size);
 
@@ -905,7 +905,7 @@ void fsAio(vm::ptr<CellFsAio> aio, bool write, s32 xid, fs_aio_cb_t func)
 	});
 }
 
-s32 cellFsAioInit(vm::ptr<const char> mount_point)
+s32 cellFsAioInit(vm::cptr<char> mount_point)
 {
 	cellFs.Warning("cellFsAioInit(mount_point=*0x%x)", mount_point);
 	cellFs.Warning("*** mount_point = '%s'", mount_point.get_ptr());
@@ -915,7 +915,7 @@ s32 cellFsAioInit(vm::ptr<const char> mount_point)
 	return CELL_OK;
 }
 
-s32 cellFsAioFinish(vm::ptr<const char> mount_point)
+s32 cellFsAioFinish(vm::cptr<char> mount_point)
 {
 	cellFs.Warning("cellFsAioFinish(mount_point=*0x%x)", mount_point);
 	cellFs.Warning("*** mount_point = '%s'", mount_point.get_ptr());

rpcs3/Emu/SysCalls/Modules/cellGame.cpp

@@ -17,7 +17,7 @@ std::string contentInfo;
 std::string usrdir;
 bool path_set = false;
 
-s32 cellHddGameCheck(PPUThread& CPU, u32 version, vm::ptr<const char> dirName, u32 errDialog, vm::ptr<CellHddGameStatCallback> funcStat, u32 container)
+s32 cellHddGameCheck(PPUThread& CPU, u32 version, vm::cptr<char> dirName, u32 errDialog, vm::ptr<CellHddGameStatCallback> funcStat, u32 container)
 {
 	cellGame.Warning("cellHddGameCheck(version=%d, dirName=*0x%x, errDialog=%d, funcStat=*0x%x, container=%d)", version, dirName, errDialog, funcStat, container);
 
@@ -188,7 +188,7 @@ s32 cellGamePatchCheck(vm::ptr<CellGameContentSize> size, vm::ptr<void> reserved
 	return CELL_GAME_RET_OK;
 }
 
-s32 cellGameDataCheck(u32 type, vm::ptr<const char> dirName, vm::ptr<CellGameContentSize> size)
+s32 cellGameDataCheck(u32 type, vm::cptr<char> dirName, vm::ptr<CellGameContentSize> size)
 {
 	cellGame.Warning("cellGameDataCheck(type=%d, dirName=*0x%x, size=*0x%x)", type, dirName, size);
 
@@ -283,7 +283,7 @@ s32 cellGameContentPermit(vm::ptr<char[CELL_GAME_PATH_MAX]> contentInfoPath, vm:
 	return CELL_GAME_RET_OK;
 }
 
-s32 cellGameDataCheckCreate2(PPUThread& CPU, u32 version, vm::ptr<const char> dirName, u32 errDialog, vm::ptr<CellGameDataStatCallback> funcStat, u32 container)
+s32 cellGameDataCheckCreate2(PPUThread& CPU, u32 version, vm::cptr<char> dirName, u32 errDialog, vm::ptr<CellGameDataStatCallback> funcStat, u32 container)
 {
 	cellGame.Warning("cellGameDataCheckCreate2(version=0x%x, dirName=*0x%x, errDialog=0x%x, funcStat=*0x%x, container=%d)", version, dirName, errDialog, funcStat, container);
 
@@ -380,7 +380,7 @@ s32 cellGameDataCheckCreate2(PPUThread& CPU, u32 version, vm::ptr<const char> di
 	}
 }
 
-s32 cellGameDataCheckCreate(PPUThread& CPU, u32 version, vm::ptr<const char> dirName, u32 errDialog, vm::ptr<CellGameDataStatCallback> funcStat, u32 container)
+s32 cellGameDataCheckCreate(PPUThread& CPU, u32 version, vm::cptr<char> dirName, u32 errDialog, vm::ptr<CellGameDataStatCallback> funcStat, u32 container)
 {
 	cellGame.Warning("cellGameDataCheckCreate(version=0x%x, dirName=*0x%x, errDialog=0x%x, funcStat=*0x%x, container=%d)", version, dirName, errDialog, funcStat, container);
 
@@ -528,7 +528,7 @@ s32 cellGameGetLocalWebContentPath()
 	return CELL_OK;
 }
 
-s32 cellGameContentErrorDialog(s32 type, s32 errNeedSizeKB, vm::ptr<const char> dirName)
+s32 cellGameContentErrorDialog(s32 type, s32 errNeedSizeKB, vm::cptr<char> dirName)
 {
 	cellGame.Warning("cellGameContentErrorDialog(type=%d, errNeedSizeKB=%d, dirName=*0x%x)", type, errNeedSizeKB, dirName);
 

rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp

@@ -20,7 +20,7 @@ extern Module cellGifDec;
 
 s32 cellGifDecCreate(
 	vm::ptr<CellGifDecMainHandle> mainHandle,
-	vm::ptr<const CellGifDecThreadInParam> threadInParam,
+	vm::cptr<CellGifDecThreadInParam> threadInParam,
 	vm::ptr<CellGifDecThreadOutParam> threadOutParam)
 {
 	UNIMPLEMENTED_FUNC(cellGifDec);
@@ -29,9 +29,9 @@ s32 cellGifDecCreate(
 
 s32 cellGifDecExtCreate(
 	vm::ptr<CellGifDecMainHandle> mainHandle,
-	vm::ptr<const CellGifDecThreadInParam> threadInParam,
+	vm::cptr<CellGifDecThreadInParam> threadInParam,
 	vm::ptr<CellGifDecThreadOutParam> threadOutParam,
-	vm::ptr<const CellGifDecExtThreadInParam> extThreadInParam,
+	vm::cptr<CellGifDecExtThreadInParam> extThreadInParam,
 	vm::ptr<CellGifDecExtThreadOutParam> extThreadOutParam)
 {
 	UNIMPLEMENTED_FUNC(cellGifDec);
@@ -41,7 +41,7 @@ s32 cellGifDecExtCreate(
 s32 cellGifDecOpen(
 	CellGifDecMainHandle mainHandle,
 	vm::ptr<CellGifDecSubHandle> subHandle,
-	vm::ptr<const CellGifDecSrc> src,
+	vm::cptr<CellGifDecSrc> src,
 	vm::ptr<CellGifDecOpnInfo> openInfo)
 {
 	cellGifDec.Warning("cellGifDecOpen(mainHandle=0x%x, subHandle=*0x%x, src=*0x%x, openInfo=*0x%x)", mainHandle, subHandle, src, openInfo);
@@ -134,7 +134,7 @@ s32 cellGifDecReadHeader(
 s32 cellGifDecSetParameter(
 	CellGifDecMainHandle mainHandle,
 	CellGifDecSubHandle subHandle,
-	vm::ptr<const CellGifDecInParam> inParam,
+	vm::cptr<CellGifDecInParam> inParam,
 	vm::ptr<CellGifDecOutParam> outParam)
 {
 	cellGifDec.Warning("cellGifDecSetParameter(mainHandle=0x%x, subHandle=0x%x, inParam=*0x%x, outParam=*0x%x)", mainHandle, subHandle, inParam, outParam);
@@ -171,7 +171,7 @@ s32 cellGifDecDecodeData(
 	CellGifDecMainHandle mainHandle,
 	CellGifDecSubHandle subHandle,
 	vm::ptr<u8> data,
-	vm::ptr<const CellGifDecDataCtrlParam> dataCtrlParam,
+	vm::cptr<CellGifDecDataCtrlParam> dataCtrlParam,
 	vm::ptr<CellGifDecDataOutInfo> dataOutInfo)
 {
 	cellGifDec.Warning("cellGifDecDecodeData(mainHandle=0x%x, subHandle=0x%x, data=*0x%x, dataCtrlParam=*0x%x, dataOutInfo=*0x%x)", mainHandle, subHandle, data, dataCtrlParam, dataOutInfo);

rpcs3/Emu/SysCalls/Modules/cellGifDec.h

@@ -92,7 +92,7 @@ struct CellGifDecExtThreadOutParam
 struct CellGifDecSrc
 {
 	be_t<s32> srcSelect; // CellGifDecStreamSrcSel
-	vm::bptr<const char> fileName;
+	vm::bcptr<char> fileName;
 	be_t<s64> fileOffset;
 	be_t<u32> fileSize;
 	vm::bptr<void> streamPtr;

rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp

@@ -157,7 +157,7 @@ s32 cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, vm::ptr<CellJpgDecInfo>
 	return CELL_OK;
 }
 
-s32 cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, vm::ptr<const CellJpgDecDataCtrlParam> dataCtrlParam, vm::ptr<CellJpgDecDataOutInfo> dataOutInfo)
+s32 cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, vm::cptr<CellJpgDecDataCtrlParam> dataCtrlParam, vm::ptr<CellJpgDecDataOutInfo> dataOutInfo)
 {
 	cellJpgDec.Log("cellJpgDecDecodeData(mainHandle=0x%x, subHandle=0x%x, data=*0x%x, dataCtrlParam=*0x%x, dataOutInfo=*0x%x)", mainHandle, subHandle, data, dataCtrlParam, dataOutInfo);
 
@@ -293,7 +293,7 @@ s32 cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, vm::pt
 	return CELL_OK;
 }
 
-s32 cellJpgDecSetParameter(u32 mainHandle, u32 subHandle, vm::ptr<const CellJpgDecInParam> inParam, vm::ptr<CellJpgDecOutParam> outParam)
+s32 cellJpgDecSetParameter(u32 mainHandle, u32 subHandle, vm::cptr<CellJpgDecInParam> inParam, vm::ptr<CellJpgDecOutParam> outParam)
 {
 	cellJpgDec.Log("cellJpgDecSetParameter(mainHandle=0x%x, subHandle=0x%x, inParam=*0x%x, outParam=*0x%x)", mainHandle, subHandle, inParam, outParam);
 

rpcs3/Emu/SysCalls/Modules/cellJpgDec.h

@@ -58,7 +58,7 @@ struct CellJpgDecInfo
 struct CellJpgDecSrc
 {
 	be_t<u32> srcSelect;       // CellJpgDecStreamSrcSel
-	vm::bptr<const char> fileName;
+	vm::bcptr<char> fileName;
 	be_t<u64> fileOffset;      // int64_t
 	be_t<u32> fileSize;
 	be_t<u32> streamPtr;

rpcs3/Emu/SysCalls/Modules/cellL10n.cpp

@@ -13,7 +13,7 @@
 
 extern Module cellL10n;
 
-s32 UTF16stoUTF8s(vm::ptr<const char16_t> utf16, vm::ref<u32> utf16_len, vm::ptr<char> utf8, vm::ref<u32> utf8_len)
+s32 UTF16stoUTF8s(vm::cptr<char16_t> utf16, vm::ref<u32> utf16_len, vm::ptr<char> utf8, vm::ref<u32> utf8_len)
 {
 	cellL10n.Todo("UTF16stoUTF8s(utf16=*0x%x, utf16_len=*0x%x, utf8=*0x%x, utf8_len=*0x%x)", utf16, utf16_len, utf8, utf8_len);
 
@@ -55,7 +55,7 @@ s32 UTF16stoUTF8s(vm::ptr<const char16_t> utf16, vm::ref<u32> utf16_len, vm::ptr
 	return ConversionOK;
 }
 
-s32 jstrchk(vm::ptr<const char> jstr)
+s32 jstrchk(vm::cptr<char> jstr)
 {
 	cellL10n.Warning("jstrchk(jstr_addr=0x%x) -> utf8", jstr.addr());
 
@@ -297,7 +297,7 @@ s32 _L10nConvertStr(s32 src_code, const void* src, size_t * src_len, s32 dst_cod
 #endif
 
 //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::ptr<const void> src, vm::ptr<u32> src_len, s32 dst_code, vm::ptr<void> dst, vm::ptr<u32> dst_len)
+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)",
 		src_code, src.addr(), src_len.addr(), dst_code, dst.addr(), dst_len.addr());

rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp

@@ -24,7 +24,7 @@ void MsgDialogInstance::Close()
 	wait_until = get_system_time();
 }
 
-s32 cellMsgDialogOpen2(u32 type, vm::ptr<const char> msgString, vm::ptr<CellMsgDialogCallback> callback, vm::ptr<void> userData, vm::ptr<void> extParam)
+s32 cellMsgDialogOpen2(u32 type, vm::cptr<char> msgString, vm::ptr<CellMsgDialogCallback> callback, vm::ptr<void> userData, vm::ptr<void> extParam)
 {
 	cellSysutil.Warning("cellMsgDialogOpen2(type=0x%x, msgString=*0x%x, callback=*0x%x, userData=*0x%x, extParam=*0x%x)", type, msgString, callback, userData, extParam);
 
@@ -293,7 +293,7 @@ s32 cellMsgDialogAbort()
 	return CELL_OK;
 }
 
-s32 cellMsgDialogProgressBarSetMsg(u32 progressBarIndex, vm::ptr<const char> msgString)
+s32 cellMsgDialogProgressBarSetMsg(u32 progressBarIndex, vm::cptr<char> msgString)
 {
 	cellSysutil.Warning("cellMsgDialogProgressBarSetMsg(progressBarIndex=%d, msgString=*0x%x)", progressBarIndex, msgString);
 

rpcs3/Emu/SysCalls/Modules/cellOvis.cpp

@@ -14,7 +14,7 @@ enum
 	CELL_OVIS_ERROR_ALIGN = 0x80410410,
 };
 
-int cellOvisGetOverlayTableSize(vm::ptr<const char> elf)
+int cellOvisGetOverlayTableSize(vm::cptr<char> elf)
 {
 	cellOvis.Todo("cellOvisGetOverlayTableSize(elf_addr=0x%x)", elf.addr());
 	return CELL_OK;

rpcs3/Emu/SysCalls/Modules/cellPamf.cpp

@@ -214,7 +214,7 @@ s32 cellPamfVerify(vm::ptr<PamfHeader> pAddr, u64 fileSize)
 	return CELL_OK;
 }
 
-s32 cellPamfReaderInitialize(vm::ptr<CellPamfReader> pSelf, vm::ptr<const PamfHeader> pAddr, u64 fileSize, u32 attribute)
+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);
 	

rpcs3/Emu/SysCalls/Modules/cellPamf.h

@@ -386,7 +386,7 @@ CHECK_SIZE(PamfEpHeader, 12);
 // not directly accessed by virtual CPU, fields are unknown
 struct CellPamfReader
 {
-	vm::ptr<const PamfHeader> pAddr;
+	vm::cptr<PamfHeader> pAddr;
 	s32 stream;
 	u64 fileSize;
 	u32 internalData[28];
@@ -394,4 +394,4 @@ struct CellPamfReader
 
 CHECK_SIZE(CellPamfReader, 128);
 
-s32 cellPamfReaderInitialize(vm::ptr<CellPamfReader> pSelf, vm::ptr<const PamfHeader> pAddr, u64 fileSize, u32 attribute);
+s32 cellPamfReaderInitialize(vm::ptr<CellPamfReader> pSelf, vm::cptr<PamfHeader> pAddr, u64 fileSize, u32 attribute);

rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp

@@ -19,8 +19,8 @@ extern Module cellPngDec;
 
 s32 pngDecCreate(
 	vm::ptr<CellPngDecMainHandle> mainHandle,
-	vm::ptr<const CellPngDecThreadInParam> param,
+	vm::cptr<CellPngDecThreadInParam> param,
-	vm::ptr<const CellPngDecExtThreadInParam> ext = vm::null)
+	vm::cptr<CellPngDecExtThreadInParam> ext = vm::null)
 {
 	// alloc memory (should probably use param->cbCtrlMallocFunc)
 	auto dec = CellPngDecMainHandle::make(Memory.Alloc(sizeof(PngDecoder), 128));
@@ -59,10 +59,10 @@ s32 pngDecDestroy(CellPngDecMainHandle dec)
 s32 pngDecOpen(
 	CellPngDecMainHandle dec,
 	vm::ptr<CellPngDecSubHandle> subHandle,
-	vm::ptr<const CellPngDecSrc> src,
+	vm::cptr<CellPngDecSrc> src,
 	vm::ptr<CellPngDecOpnInfo> openInfo,
-	vm::ptr<const CellPngDecCbCtrlStrm> cb = vm::null,
+	vm::cptr<CellPngDecCbCtrlStrm> cb = vm::null,
-	vm::ptr<const CellPngDecOpnParam> param = vm::null)
+	vm::cptr<CellPngDecOpnParam> param = vm::null)
 {
 	// alloc memory (should probably use dec->malloc)
 	auto stream = CellPngDecSubHandle::make(Memory.Alloc(sizeof(PngStream), 128));
@@ -192,9 +192,9 @@ s32 pngReadHeader(
 
 s32 pngDecSetParameter(
 	CellPngDecSubHandle stream,
-	vm::ptr<const CellPngDecInParam> inParam,
+	vm::cptr<CellPngDecInParam> inParam,
 	vm::ptr<CellPngDecOutParam> outParam,
-	vm::ptr<const CellPngDecExtInParam> extInParam = vm::null,
+	vm::cptr<CellPngDecExtInParam> extInParam = vm::null,
 	vm::ptr<CellPngDecExtOutParam> extOutParam = vm::null)
 {
 	CellPngDecInfo& current_info = stream->info;
@@ -238,9 +238,9 @@ s32 pngDecSetParameter(
 s32 pngDecodeData(
 	CellPngDecSubHandle stream,
 	vm::ptr<u8> data,
-	vm::ptr<const CellPngDecDataCtrlParam> dataCtrlParam,
+	vm::cptr<CellPngDecDataCtrlParam> dataCtrlParam,
 	vm::ptr<CellPngDecDataOutInfo> dataOutInfo,
-	vm::ptr<const CellPngDecCbCtrlDisp> cbCtrlDisp = vm::null,
+	vm::cptr<CellPngDecCbCtrlDisp> cbCtrlDisp = vm::null,
 	vm::ptr<CellPngDecDispParam> dispParam = vm::null)
 {
 	dataOutInfo->status = CELL_PNGDEC_DEC_STATUS_STOP;
@@ -368,7 +368,7 @@ s32 pngDecodeData(
 
 s32 cellPngDecCreate(
 	vm::ptr<CellPngDecMainHandle> mainHandle,
-	vm::ptr<const CellPngDecThreadInParam> threadInParam,
+	vm::cptr<CellPngDecThreadInParam> threadInParam,
 	vm::ptr<CellPngDecThreadOutParam> threadOutParam)
 {
 	cellPngDec.Warning("cellPngDecCreate(mainHandle=**0x%x, threadInParam=*0x%x, threadOutParam=*0x%x)", mainHandle, threadInParam, threadOutParam);
@@ -384,9 +384,9 @@ s32 cellPngDecCreate(
 
 s32 cellPngDecExtCreate(
 	vm::ptr<CellPngDecMainHandle> mainHandle,
-	vm::ptr<const CellPngDecThreadInParam> threadInParam,
+	vm::cptr<CellPngDecThreadInParam> threadInParam,
 	vm::ptr<CellPngDecThreadOutParam> threadOutParam,
-	vm::ptr<const CellPngDecExtThreadInParam> extThreadInParam,
+	vm::cptr<CellPngDecExtThreadInParam> extThreadInParam,
 	vm::ptr<CellPngDecExtThreadOutParam> extThreadOutParam)
 {
 	cellPngDec.Warning("cellPngDecCreate(mainHandle=**0x%x, threadInParam=*0x%x, threadOutParam=*0x%x, extThreadInParam=*0x%x, extThreadOutParam=*0x%x)",
@@ -414,7 +414,7 @@ s32 cellPngDecDestroy(CellPngDecMainHandle mainHandle)
 s32 cellPngDecOpen(
 	CellPngDecMainHandle mainHandle,
 	vm::ptr<CellPngDecSubHandle> subHandle,
-	vm::ptr<const CellPngDecSrc> src,
+	vm::cptr<CellPngDecSrc> src,
 	vm::ptr<CellPngDecOpnInfo> openInfo)
 {
 	cellPngDec.Warning("cellPngDecOpen(mainHandle=*0x%x, subHandle=**0x%x, src=*0x%x, openInfo=*0x%x)", mainHandle, subHandle, src, openInfo);
@@ -426,10 +426,10 @@ s32 cellPngDecOpen(
 s32 cellPngDecExtOpen(
 	CellPngDecMainHandle mainHandle,
 	vm::ptr<CellPngDecSubHandle> subHandle,
-	vm::ptr<const CellPngDecSrc> src,
+	vm::cptr<CellPngDecSrc> src,
 	vm::ptr<CellPngDecOpnInfo> openInfo,
-	vm::ptr<const CellPngDecCbCtrlStrm> cbCtrlStrm,
+	vm::cptr<CellPngDecCbCtrlStrm> cbCtrlStrm,
-	vm::ptr<const CellPngDecOpnParam> opnParam)
+	vm::cptr<CellPngDecOpnParam> opnParam)
 {
 	cellPngDec.Warning("cellPngDecExtOpen(mainHandle=*0x%x, subHandle=**0x%x, src=*0x%x, openInfo=*0x%x, cbCtrlStrm=*0x%x, opnParam=*0x%x)", mainHandle, subHandle, src, openInfo, cbCtrlStrm, opnParam);
 
@@ -465,7 +465,7 @@ s32 cellPngDecExtReadHeader(
 s32 cellPngDecSetParameter(
 	CellPngDecMainHandle mainHandle,
 	CellPngDecSubHandle subHandle,
-	vm::ptr<const CellPngDecInParam> inParam,
+	vm::cptr<CellPngDecInParam> inParam,
 	vm::ptr<CellPngDecOutParam> outParam)
 {
 	cellPngDec.Warning("cellPngDecSetParameter(mainHandle=*0x%x, subHandle=*0x%x, inParam=*0x%x, outParam=*0x%x)", mainHandle, subHandle, inParam, outParam);
@@ -476,9 +476,9 @@ s32 cellPngDecSetParameter(
 s32 cellPngDecExtSetParameter(
 	CellPngDecMainHandle mainHandle,
 	CellPngDecSubHandle subHandle,
-	vm::ptr<const CellPngDecInParam> inParam,
+	vm::cptr<CellPngDecInParam> inParam,
 	vm::ptr<CellPngDecOutParam> outParam,
-	vm::ptr<const CellPngDecExtInParam> extInParam,
+	vm::cptr<CellPngDecExtInParam> extInParam,
 	vm::ptr<CellPngDecExtOutParam> extOutParam)
 {
 	cellPngDec.Warning("cellPngDecExtSetParameter(mainHandle=*0x%x, subHandle=*0x%x, inParam=*0x%x, outParam=*0x%x, extInParam=*0x%x, extOutParam=*0x%x", mainHandle, subHandle, inParam, outParam, extInParam, extOutParam);
@@ -490,7 +490,7 @@ s32 cellPngDecDecodeData(
 	CellPngDecMainHandle mainHandle,
 	CellPngDecSubHandle subHandle,
 	vm::ptr<u8> data,
-	vm::ptr<const CellPngDecDataCtrlParam> dataCtrlParam,
+	vm::cptr<CellPngDecDataCtrlParam> dataCtrlParam,
 	vm::ptr<CellPngDecDataOutInfo> dataOutInfo)
 {
 	cellPngDec.Warning("cellPngDecDecodeData(mainHandle=*0x%x, subHandle=*0x%x, data=*0x%x, dataCtrlParam=*0x%x, dataOutInfo=*0x%x)",
@@ -503,9 +503,9 @@ s32 cellPngDecExtDecodeData(
 	CellPngDecMainHandle mainHandle,
 	CellPngDecSubHandle subHandle,
 	vm::ptr<u8> data,
-	vm::ptr<const CellPngDecDataCtrlParam> dataCtrlParam,
+	vm::cptr<CellPngDecDataCtrlParam> dataCtrlParam,
 	vm::ptr<CellPngDecDataOutInfo> dataOutInfo,
-	vm::ptr<const CellPngDecCbCtrlDisp> cbCtrlDisp,
+	vm::cptr<CellPngDecCbCtrlDisp> cbCtrlDisp,
 	vm::ptr<CellPngDecDispParam> dispParam)
 {
 	cellPngDec.Warning("cellPngDecExtDecodeData(mainHandle=*0x%x, subHandle=*0x%x, data=*0x%x, dataCtrlParam=*0x%x, dataOutInfo=*0x%x, cbCtrlDisp=*0x%x, dispParam=*0x%x)",

rpcs3/Emu/SysCalls/Modules/cellPngDec.h

@@ -123,7 +123,7 @@ struct CellPngDecExtThreadOutParam
 struct CellPngDecSrc
 {
 	be_t<s32> srcSelect; // CellPngDecStreamSrcSel
-	vm::bptr<const char> fileName;
+	vm::bcptr<char> fileName;
 	be_t<s64> fileOffset;
 	be_t<u32> fileSize;
 	vm::bptr<void> streamPtr;

rpcs3/Emu/SysCalls/Modules/cellRtc.cpp

@@ -133,7 +133,7 @@ int cellRtcFormatRfc3339LocalTime(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick
 	return CELL_OK;
 }
 
-int cellRtcParseDateTime(vm::ptr<CellRtcTick> pUtc, vm::ptr<const char> pszDateTime)
+int cellRtcParseDateTime(vm::ptr<CellRtcTick> pUtc, vm::cptr<char> pszDateTime)
 {
 	cellRtc.Log("cellRtcParseDateTime(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.addr(), pszDateTime.addr());
 
@@ -146,7 +146,7 @@ int cellRtcParseDateTime(vm::ptr<CellRtcTick> pUtc, vm::ptr<const char> pszDateT
 	return CELL_OK;
 }
 
-int cellRtcParseRfc3339(vm::ptr<CellRtcTick> pUtc, vm::ptr<const char> pszDateTime)
+int cellRtcParseRfc3339(vm::ptr<CellRtcTick> pUtc, vm::cptr<char> pszDateTime)
 {
 	cellRtc.Log("cellRtcParseRfc3339(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.addr(), pszDateTime.addr());
 

rpcs3/Emu/SysCalls/Modules/cellSail.cpp

@@ -632,7 +632,7 @@ int cellSailPlayerAddDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailD
 	return CELL_OK;
 }
 
-int cellSailPlayerCreateDescriptor(vm::ptr<CellSailPlayer> pSelf, s32 streamType, vm::ptr<u32> pMediaInfo, vm::ptr<const char> pUri, vm::ptr<u32> ppDesc)
+int cellSailPlayerCreateDescriptor(vm::ptr<CellSailPlayer> pSelf, s32 streamType, vm::ptr<u32> pMediaInfo, vm::cptr<char> pUri, vm::ptr<u32> ppDesc)
 {
 	cellSail.Warning("cellSailPlayerCreateDescriptor(pSelf_addr=0x%x, streamType=%d, pMediaInfo_addr=0x%x, pUri_addr=0x%x, ppDesc_addr=0x%x)", pSelf.addr(), streamType,
 					pMediaInfo.addr(), pUri.addr(), ppDesc.addr());
@@ -657,7 +657,7 @@ int cellSailPlayerCreateDescriptor(vm::ptr<CellSailPlayer> pSelf, s32 streamType
 				if (f.Open(path)) {
 					u64 size = f.GetSize();
 					u32 buf_ = Memory.Alloc(size, 1);
-					auto bufPtr = vm::ptr<const PamfHeader>::make(buf_);
+					auto bufPtr = vm::cptr<PamfHeader>::make(buf_);
 					PamfHeader *buf = const_cast<PamfHeader*>(bufPtr.get_ptr());
 					assert(f.Read(buf, size) == size);
 					u32 sp_ = Memory.Alloc(sizeof(CellPamfReader), 1);
@@ -944,7 +944,6 @@ Module cellSail("cellSail", []()
 	REG_FUNC(cellSail, cellSailSourceNotifyStreamOut);
 	REG_FUNC(cellSail, cellSailSourceNotifySessionError);
 	REG_FUNC(cellSail, cellSailSourceNotifyMediaStateChanged);
-	//cellSail.AddFunc(, cellSailSourceCheck);
 	REG_FUNC(cellSail, cellSailSourceNotifyOpenCompleted);
 	REG_FUNC(cellSail, cellSailSourceNotifyStartCompleted);
 	REG_FUNC(cellSail, cellSailSourceNotifyStopCompleted);
@@ -961,7 +960,6 @@ Module cellSail("cellSail", []()
 	REG_FUNC(cellSail, cellSailMp4TrackGetTrackInfo);
 	REG_FUNC(cellSail, cellSailMp4TrackGetTrackReferenceCount);
 	REG_FUNC(cellSail, cellSailMp4TrackGetTrackReference);
-	//cellSail.AddFunc(, cellSailMp4ConvertTimeScale);
 
 	REG_FUNC(cellSail, cellSailAviMovieGetMovieInfo);
 	REG_FUNC(cellSail, cellSailAviMovieGetStreamByIndex);

rpcs3/Emu/SysCalls/Modules/cellSaveData.cpp

@@ -37,7 +37,7 @@ never_inline s32 savedata_op(
 	PPUThread& CPU,
 	u32 operation,
 	u32 version,
-	vm::ptr<const char> dirName,
+	vm::cptr<char> dirName,
 	u32 errDialog,
 	vm::ptr<CellSaveDataSetList> setList,
 	vm::ptr<CellSaveDataSetBuf> setBuf,
@@ -685,7 +685,7 @@ s32 cellSaveDataFixedLoad2(
 s32 cellSaveDataAutoSave2(
 	PPUThread& CPU,
 	u32 version,
-	vm::ptr<const char> dirName,
+	vm::cptr<char> dirName,
 	u32 errDialog,
 	vm::ptr<CellSaveDataSetBuf> setBuf,
 	vm::ptr<CellSaveDataStatCallback> funcStat,
@@ -702,7 +702,7 @@ s32 cellSaveDataAutoSave2(
 s32 cellSaveDataAutoLoad2(
 	PPUThread& CPU,
 	u32 version,
-	vm::ptr<const char> dirName,
+	vm::cptr<char> dirName,
 	u32 errDialog,
 	vm::ptr<CellSaveDataSetBuf> setBuf,
 	vm::ptr<CellSaveDataStatCallback> funcStat,
@@ -850,7 +850,7 @@ s32 cellSaveDataUserAutoSave(
 	PPUThread& CPU,
 	u32 version,
 	u32 userId,
-	vm::ptr<const char> dirName,
+	vm::cptr<char> dirName,
 	u32 errDialog,
 	vm::ptr<CellSaveDataSetBuf> setBuf,
 	vm::ptr<CellSaveDataStatCallback> funcStat,
@@ -868,7 +868,7 @@ s32 cellSaveDataUserAutoLoad(
 	PPUThread& CPU,
 	u32 version,
 	u32 userId,
-	vm::ptr<const char> dirName,
+	vm::cptr<char> dirName,
 	u32 errDialog,
 	vm::ptr<CellSaveDataSetBuf> setBuf,
 	vm::ptr<CellSaveDataStatCallback> funcStat,
@@ -987,7 +987,7 @@ s32 cellSaveDataListExport(
 
 s32 cellSaveDataFixedImport(
 	PPUThread& CPU,
-	vm::ptr<const char> dirName,
+	vm::cptr<char> dirName,
 	u32 maxSizeKB,
 	vm::ptr<CellSaveDataDoneCallback> funcDone,
 	u32 container,
@@ -1000,7 +1000,7 @@ s32 cellSaveDataFixedImport(
 
 s32 cellSaveDataFixedExport(
 	PPUThread& CPU,
-	vm::ptr<const char> dirName,
+	vm::cptr<char> dirName,
 	u32 maxSizeKB,
 	vm::ptr<CellSaveDataDoneCallback> funcDone,
 	u32 container,
@@ -1012,7 +1012,7 @@ s32 cellSaveDataFixedExport(
 }
 
 s32 cellSaveDataGetListItem(
-	vm::ptr<const char> dirName,
+	vm::cptr<char> dirName,
 	vm::ptr<CellSaveDataDirStat> dir,
 	vm::ptr<CellSaveDataSystemFileParam> sysFileParam,
 	vm::ptr<u32> bind,
@@ -1069,7 +1069,7 @@ s32 cellSaveDataUserListExport(
 s32 cellSaveDataUserFixedImport(
 	PPUThread& CPU,
 	u32 userId,
-	vm::ptr<const char> dirName,
+	vm::cptr<char> dirName,
 	u32 maxSizeKB,
 	vm::ptr<CellSaveDataDoneCallback> funcDone,
 	u32 container,
@@ -1083,7 +1083,7 @@ s32 cellSaveDataUserFixedImport(
 s32 cellSaveDataUserFixedExport(
 	PPUThread& CPU,
 	u32 userId,
-	vm::ptr<const char> dirName,
+	vm::cptr<char> dirName,
 	u32 maxSizeKB,
 	vm::ptr<CellSaveDataDoneCallback> funcDone,
 	u32 container,
@@ -1096,7 +1096,7 @@ s32 cellSaveDataUserFixedExport(
 
 s32 cellSaveDataUserGetListItem(
 	u32 userId,
-	vm::ptr<const char> dirName,
+	vm::cptr<char> dirName,
 	vm::ptr<CellSaveDataDirStat> dir,
 	vm::ptr<CellSaveDataSystemFileParam> sysFileParam,
 	vm::ptr<u32> bind,

rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp

@@ -388,7 +388,7 @@ s32 cellSpursInitialize(vm::ptr<CellSpurs> spurs, s32 nSpus, s32 spuPriority, s3
 		0);
 }
 
-s32 cellSpursInitializeWithAttribute(vm::ptr<CellSpurs> spurs, vm::ptr<const CellSpursAttribute> attr)
+s32 cellSpursInitializeWithAttribute(vm::ptr<CellSpurs> spurs, vm::cptr<CellSpursAttribute> attr)
 {
 	cellSpurs.Warning("cellSpursInitializeWithAttribute(spurs_addr=0x%x, attr_addr=0x%x)", spurs.addr(), attr.addr());
 
@@ -421,7 +421,7 @@ s32 cellSpursInitializeWithAttribute(vm::ptr<CellSpurs> spurs, vm::ptr<const Cel
 		attr->swlIsPreem);
 }
 
-s32 cellSpursInitializeWithAttribute2(vm::ptr<CellSpurs> spurs, vm::ptr<const CellSpursAttribute> attr)
+s32 cellSpursInitializeWithAttribute2(vm::ptr<CellSpurs> spurs, vm::cptr<CellSpursAttribute> attr)
 {
 	cellSpurs.Warning("cellSpursInitializeWithAttribute2(spurs_addr=0x%x, attr_addr=0x%x)", spurs.addr(), attr.addr());
 
@@ -501,7 +501,7 @@ s32 cellSpursAttributeSetMemoryContainerForSpuThread(vm::ptr<CellSpursAttribute>
 	return CELL_OK;
 }
 
-s32 cellSpursAttributeSetNamePrefix(vm::ptr<CellSpursAttribute> attr, vm::ptr<const char> prefix, u32 size)
+s32 cellSpursAttributeSetNamePrefix(vm::ptr<CellSpursAttribute> attr, vm::cptr<char> prefix, u32 size)
 {
 	cellSpurs.Warning("cellSpursAttributeSetNamePrefix(attr_addr=0x%x, prefix_addr=0x%x, size=%d)", attr.addr(), prefix.addr(), size);
 
@@ -573,7 +573,7 @@ s32 cellSpursAttributeSetSpuThreadGroupType(vm::ptr<CellSpursAttribute> attr, s3
 	return CELL_OK;
 }
 
-s32 cellSpursAttributeEnableSystemWorkload(vm::ptr<CellSpursAttribute> attr, vm::ptr<const u8[8]> priority, u32 maxSpu, vm::ptr<const bool[8]> isPreemptible)
+s32 cellSpursAttributeEnableSystemWorkload(vm::ptr<CellSpursAttribute> attr, vm::cptr<u8[8]> priority, u32 maxSpu, vm::cptr<bool[8]> isPreemptible)
 {
 	cellSpurs.Warning("cellSpursAttributeEnableSystemWorkload(attr_addr=0x%x, priority_addr=0x%x, maxSpu=%d, isPreemptible_addr=0x%x)",
 		attr.addr(), priority.addr(), maxSpu, isPreemptible.addr());
@@ -794,13 +794,13 @@ s32 cellSpursSetMaxContention(vm::ptr<CellSpurs> spurs, u32 workloadId, u32 maxC
 	return CELL_OK;
 }
 
-s32 cellSpursSetPriorities(vm::ptr<CellSpurs> spurs, u32 workloadId, vm::ptr<const u8> priorities)
+s32 cellSpursSetPriorities(vm::ptr<CellSpurs> spurs, u32 workloadId, vm::cptr<u8> priorities)
 {
 	UNIMPLEMENTED_FUNC(cellSpurs);
 	return CELL_OK;
 }
 
-s32 cellSpursSetPreemptionVictimHints(vm::ptr<CellSpurs> spurs, vm::ptr<const bool> isPreemptible)
+s32 cellSpursSetPreemptionVictimHints(vm::ptr<CellSpurs> spurs, vm::cptr<bool> isPreemptible)
 {
 	UNIMPLEMENTED_FUNC(cellSpurs);
 	return CELL_OK;
@@ -874,14 +874,14 @@ s32 cellSpursWakeUp(PPUThread& CPU, vm::ptr<CellSpurs> spurs)
 s32 spursAddWorkload(
 	vm::ptr<CellSpurs> spurs,
 	vm::ptr<u32> wid,
-	vm::ptr<const void> pm,
+	vm::cptr<void> pm,
 	u32 size,
 	u64 data,
 	const u8 priorityTable[],
 	u32 minContention,
 	u32 maxContention,
-	vm::ptr<const char> nameClass,
+	vm::cptr<char> nameClass,
-	vm::ptr<const char> nameInstance,
+	vm::cptr<char> nameInstance,
 	vm::ptr<CellSpursShutdownCompletionEventHook> hook,
 	vm::ptr<void> hookArg)
 {
@@ -1039,10 +1039,10 @@ s32 spursAddWorkload(
 s32 cellSpursAddWorkload(
 	vm::ptr<CellSpurs> spurs,
 	vm::ptr<u32> wid,
-	vm::ptr<const void> pm,
+	vm::cptr<void> pm,
 	u32 size,
 	u64 data,
-	vm::ptr<const u8[8]> priorityTable,
+	vm::cptr<u8[8]> priorityTable,
 	u32 minContention,
 	u32 maxContention)
 {
@@ -1068,10 +1068,10 @@ s32 _cellSpursWorkloadAttributeInitialize(
 	vm::ptr<CellSpursWorkloadAttribute> attr,
 	u32 revision,
 	u32 sdkVersion,
-	vm::ptr<const void> pm,
+	vm::cptr<void> pm,
 	u32 size,
 	u64 data,
-	vm::ptr<const u8[8]> priorityTable,
+	vm::cptr<u8[8]> priorityTable,
 	u32 minContention,
 	u32 maxContention)
 {
@@ -1111,7 +1111,7 @@ s32 _cellSpursWorkloadAttributeInitialize(
 	return CELL_OK;
 }
 
-s32 cellSpursWorkloadAttributeSetName(vm::ptr<CellSpursWorkloadAttribute> attr, vm::ptr<const char> nameClass, vm::ptr<const char> nameInstance)
+s32 cellSpursWorkloadAttributeSetName(vm::ptr<CellSpursWorkloadAttribute> attr, vm::cptr<char> nameClass, vm::cptr<char> nameInstance)
 {
 	cellSpurs.Warning("%s(attr_addr=0x%x, nameClass_addr=0x%x, nameInstance_addr=0x%x)", __FUNCTION__, attr.addr(), nameClass.addr(), nameInstance.addr());
 
@@ -1147,7 +1147,7 @@ s32 cellSpursWorkloadAttributeSetShutdownCompletionEventHook(vm::ptr<CellSpursWo
 	return CELL_OK;
 }
 
-s32 cellSpursAddWorkloadWithAttribute(vm::ptr<CellSpurs> spurs, const vm::ptr<u32> wid, vm::ptr<const CellSpursWorkloadAttribute> attr)
+s32 cellSpursAddWorkloadWithAttribute(vm::ptr<CellSpurs> spurs, const vm::ptr<u32> wid, vm::cptr<CellSpursWorkloadAttribute> attr)
 {
 	cellSpurs.Warning("%s(spurs_addr=0x%x, wid_addr=0x%x, attr_addr=0x%x)", __FUNCTION__, spurs.addr(), wid.addr(), attr.addr());
 
@@ -1552,7 +1552,7 @@ s32 cellSpursEventFlagAttachLv2EventQueue(vm::ptr<CellSpursEventFlag> eventFlag)
 	if (eventFlag->direction == CELL_SPURS_EVENT_FLAG_ANY2ANY)
 	{
 		vm::var<be_t<u32>> eventPortId;
-		rc = sys_event_port_create(vm::ref<u32>::make(eventPortId.addr()), SYS_EVENT_PORT_LOCAL, 0);
+		rc = sys_event_port_create(vm::ptr<u32>::make(eventPortId.addr()), SYS_EVENT_PORT_LOCAL, 0);
 		if (rc == CELL_OK)
 		{
 			rc = sys_event_port_connect_local(eventPortId.value(), eventQueueId);
@@ -2160,8 +2160,8 @@ s32 cellSpursJobChainGetSpursAddress()
 	return CELL_OK;
 }
 
-s32 spursCreateTaskset(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, u64 args, vm::ptr<const u8[8]> priority,
+s32 spursCreateTaskset(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, u64 args, vm::cptr<u8[8]> priority,
-	u32 max_contention, vm::ptr<const char> name, u32 size, s32 enable_clear_ls)
+	u32 max_contention, vm::cptr<char> name, u32 size, s32 enable_clear_ls)
 {
 	if (!spurs || !taskset)
 	{
@@ -2181,7 +2181,7 @@ s32 spursCreateTaskset(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> tasks
 	taskset->size = size;
 
 	vm::var<CellSpursWorkloadAttribute> wkl_attr;
-	_cellSpursWorkloadAttributeInitialize(wkl_attr, 1 /*revision*/, 0x33 /*sdk_version*/, vm::ptr<const void>::make(SPURS_IMG_ADDR_TASKSET_PM), 0x1E40 /*pm_size*/,
+	_cellSpursWorkloadAttributeInitialize(wkl_attr, 1 /*revision*/, 0x33 /*sdk_version*/, vm::cptr<void>::make(SPURS_IMG_ADDR_TASKSET_PM), 0x1E40 /*pm_size*/,
 		taskset.addr(), priority, 8 /*min_contention*/, max_contention);
 	// TODO: Check return code
 
@@ -2222,8 +2222,8 @@ s32 cellSpursCreateTasksetWithAttribute(vm::ptr<CellSpurs> spurs, vm::ptr<CellSp
 		return CELL_SPURS_TASK_ERROR_INVAL;
 	}
 
-	auto rc = spursCreateTaskset(spurs, taskset, attr->args, vm::ptr<const u8[8]>::make(attr.addr() + offsetof(CellSpursTasksetAttribute, priority)),
+	auto rc = spursCreateTaskset(spurs, taskset, attr->args, vm::cptr<u8[8]>::make(attr.addr() + offsetof(CellSpursTasksetAttribute, priority)),
-		attr->max_contention, vm::ptr<const char>::make(attr->name.addr()), attr->taskset_size, attr->enable_clear_ls);
+		attr->max_contention, vm::cptr<char>::make(attr->name.addr()), attr->taskset_size, attr->enable_clear_ls);
 
 	if (attr->taskset_size >= sizeof32(CellSpursTaskset2))
 	{
@@ -2233,7 +2233,7 @@ s32 cellSpursCreateTasksetWithAttribute(vm::ptr<CellSpurs> spurs, vm::ptr<CellSp
 	return rc;
 }
 
-s32 cellSpursCreateTaskset(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, u64 args, vm::ptr<const u8[8]> priority, u32 maxContention)
+s32 cellSpursCreateTaskset(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, u64 args, vm::cptr<u8[8]> priority, u32 maxContention)
 {
 	cellSpurs.Warning("cellSpursCreateTaskset(spurs_addr=0x%x, taskset_addr=0x%x, args=0x%llx, priority_addr=0x%x, maxContention=%d)",
 		spurs.addr(), taskset.addr(), args, priority.addr(), maxContention);
@@ -2503,7 +2503,7 @@ s32 cellSpursCreateTaskWithAttribute()
 	return CELL_OK;
 }
 
-s32 cellSpursTasksetAttributeSetName(vm::ptr<CellSpursTasksetAttribute> attr, vm::ptr<const char> name)
+s32 cellSpursTasksetAttributeSetName(vm::ptr<CellSpursTasksetAttribute> attr, vm::cptr<char> name)
 {
 	cellSpurs.Warning("%s(attr=0x%x, name=0x%x)", __FUNCTION__, attr.addr(), name.addr());
 
@@ -2667,7 +2667,7 @@ s32 cellSpursCreateTaskset2(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset2>
 	}
 
 	auto rc = spursCreateTaskset(spurs, vm::ptr<CellSpursTaskset>::make(taskset.addr()), attr->args,
-		vm::ptr<const u8[8]>::make(attr.addr() + offsetof(CellSpursTasksetAttribute, priority)),
+		vm::cptr<u8[8]>::make(attr.addr() + offsetof(CellSpursTasksetAttribute, priority)),
 		attr->max_contention, attr->name, sizeof32(CellSpursTaskset2), (u8)attr->enable_clear_ls);
 
 	if (rc != CELL_OK)
@@ -2788,7 +2788,7 @@ s32 cellSpursLookUpTasksetAddress(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTas
 	return CELL_OK;
 }
 
-s32 cellSpursTasksetGetSpursAddress(vm::ptr<const CellSpursTaskset> taskset, vm::ptr<u32> spurs)
+s32 cellSpursTasksetGetSpursAddress(vm::cptr<CellSpursTaskset> taskset, vm::ptr<u32> spurs)
 {
 	cellSpurs.Warning("%s(taskset=0x%x, spurs=0x%x)", __FUNCTION__, taskset.addr(), spurs.addr());
 
@@ -2817,7 +2817,7 @@ s32 cellSpursGetTasksetInfo()
 	return CELL_OK;
 }
 
-s32 _cellSpursTasksetAttributeInitialize(vm::ptr<CellSpursTasksetAttribute> attribute, u32 revision, u32 sdk_version, u64 args, vm::ptr<const u8> priority, u32 max_contention)
+s32 _cellSpursTasksetAttributeInitialize(vm::ptr<CellSpursTasksetAttribute> attribute, u32 revision, u32 sdk_version, u64 args, vm::cptr<u8> priority, u32 max_contention)
 {
 	cellSpurs.Warning("%s(attribute=0x%x, revision=%d, skd_version=%d, args=0x%llx, priority=0x%x, max_contention=%d)",
 		__FUNCTION__, attribute.addr(), revision, sdk_version, args, priority.addr(), max_contention);

rpcs3/Emu/SysCalls/Modules/cellSpurs.h

@@ -827,7 +827,7 @@ struct SpursKernelContext
 	vm::bptr<CellSpurs, u64> spurs;                 // 0x1C0
 	be_t<u32> spuNum;                               // 0x1C8
 	be_t<u32> dmaTagId;                             // 0x1CC
-	vm::bptr<const void, u64> wklCurrentAddr;       // 0x1D0
+	vm::bcptr<void, u64> wklCurrentAddr;            // 0x1D0
 	be_t<u32> wklCurrentUniqueId;                   // 0x1D8
 	be_t<u32> wklCurrentId;                         // 0x1DC
 	be_t<u32> exitToKernelAddr;                     // 0x1E0

rpcs3/Emu/SysCalls/Modules/cellSync.cpp

@@ -403,7 +403,7 @@ s32 syncRwmTryWriteBeginOp(CellSyncRwm::data_t& rwm)
 	return CELL_OK;
 }
 
-s32 cellSyncRwmWrite(vm::ptr<CellSyncRwm> rwm, vm::ptr<const void> buffer)
+s32 cellSyncRwmWrite(vm::ptr<CellSyncRwm> rwm, vm::cptr<void> buffer)
 {
 	cellSync.Log("cellSyncRwmWrite(rwm=*0x%x, buffer=*0x%x)", rwm, buffer);
 
@@ -438,7 +438,7 @@ s32 cellSyncRwmWrite(vm::ptr<CellSyncRwm> rwm, vm::ptr<const void> buffer)
 	return CELL_OK;
 }
 
-s32 cellSyncRwmTryWrite(vm::ptr<CellSyncRwm> rwm, vm::ptr<const void> buffer)
+s32 cellSyncRwmTryWrite(vm::ptr<CellSyncRwm> rwm, vm::cptr<void> buffer)
 {
 	cellSync.Log("cellSyncRwmTryWrite(rwm=*0x%x, buffer=*0x%x)", rwm, buffer);
 
@@ -525,7 +525,7 @@ s32 syncQueueTryPushOp(CellSyncQueue::data_t& queue, u32 depth, u32& position)
 	return CELL_OK;
 }
 
-s32 cellSyncQueuePush(vm::ptr<CellSyncQueue> queue, vm::ptr<const void> buffer)
+s32 cellSyncQueuePush(vm::ptr<CellSyncQueue> queue, vm::cptr<void> buffer)
 {
 	cellSync.Log("cellSyncQueuePush(queue=*0x%x, buffer=*0x%x)", queue, buffer);
 
@@ -563,7 +563,7 @@ s32 cellSyncQueuePush(vm::ptr<CellSyncQueue> queue, vm::ptr<const void> buffer)
 	return CELL_OK;
 }
 
-s32 cellSyncQueueTryPush(vm::ptr<CellSyncQueue> queue, vm::ptr<const void> buffer)
+s32 cellSyncQueueTryPush(vm::ptr<CellSyncQueue> queue, vm::cptr<void> buffer)
 {
 	cellSync.Log("cellSyncQueueTryPush(queue=*0x%x, buffer=*0x%x)", queue, buffer);
 
@@ -1298,7 +1298,7 @@ s32 _cellSyncLFQueueCompletePushPointer2(vm::ptr<CellSyncLFQueue> queue, s32 poi
 	return syncLFQueueCompletePushPointer2(queue, pointer, fpSendSignal);
 }
 
-s32 _cellSyncLFQueuePushBody(PPUThread& CPU, vm::ptr<CellSyncLFQueue> queue, vm::ptr<const void> buffer, u32 isBlocking)
+s32 _cellSyncLFQueuePushBody(PPUThread& CPU, vm::ptr<CellSyncLFQueue> queue, vm::cptr<void> buffer, u32 isBlocking)
 {
 	// cellSyncLFQueuePush has 1 in isBlocking param, cellSyncLFQueueTryPush has 0
 	cellSync.Warning("_cellSyncLFQueuePushBody(queue=*0x%x, buffer=*0x%x, isBlocking=%d)", queue, buffer, isBlocking);
@@ -1811,7 +1811,7 @@ s32 cellSyncLFQueueDepth(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u32> depth)
 	return CELL_OK;
 }
 
-s32 _cellSyncLFQueueGetSignalAddress(vm::ptr<const CellSyncLFQueue> queue, vm::pptr<void> ppSignal)
+s32 _cellSyncLFQueueGetSignalAddress(vm::cptr<CellSyncLFQueue> queue, vm::pptr<void> ppSignal)
 {
 	cellSync.Log("_cellSyncLFQueueGetSignalAddress(queue=*0x%x, ppSignal=**0x%x)", queue, ppSignal);
 
@@ -1829,7 +1829,7 @@ s32 _cellSyncLFQueueGetSignalAddress(vm::ptr<const CellSyncLFQueue> queue, vm::p
 	return CELL_OK;
 }
 
-s32 cellSyncLFQueueGetDirection(vm::ptr<const CellSyncLFQueue> queue, vm::ptr<CellSyncQueueDirection> direction)
+s32 cellSyncLFQueueGetDirection(vm::cptr<CellSyncLFQueue> queue, vm::ptr<CellSyncQueueDirection> direction)
 {
 	cellSync.Log("cellSyncLFQueueGetDirection(queue=*0x%x, direction=*0x%x)", queue, direction);
 
@@ -1846,7 +1846,7 @@ s32 cellSyncLFQueueGetDirection(vm::ptr<const CellSyncLFQueue> queue, vm::ptr<Ce
 	return CELL_OK;
 }
 
-s32 cellSyncLFQueueGetEntrySize(vm::ptr<const CellSyncLFQueue> queue, vm::ptr<u32> entry_size)
+s32 cellSyncLFQueueGetEntrySize(vm::cptr<CellSyncLFQueue> queue, vm::ptr<u32> entry_size)
 {
 	cellSync.Log("cellSyncLFQueueGetEntrySize(queue=*0x%x, entry_size=*0x%x)", queue, entry_size);
 

rpcs3/Emu/SysCalls/Modules/cellSync2.cpp

@@ -22,7 +22,7 @@ s32 _cellSync2MutexAttributeInitialize(vm::ptr<CellSync2MutexAttribute> attr, u3
 	return CELL_OK;
 }
 
-s32 cellSync2MutexEstimateBufferSize(vm::ptr<const CellSync2MutexAttribute> attr, vm::ptr<u32> bufferSize)
+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());
 
@@ -73,7 +73,7 @@ s32 _cellSync2CondAttributeInitialize(vm::ptr<CellSync2CondAttribute> attr, u32
 	return CELL_OK;
 }
 
-s32 cellSync2CondEstimateBufferSize(vm::ptr<const CellSync2CondAttribute> attr, vm::ptr<u32> bufferSize)
+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());
 
@@ -127,7 +127,7 @@ s32 _cellSync2SemaphoreAttributeInitialize(vm::ptr<CellSync2SemaphoreAttribute>
 	return CELL_OK;
 }
 
-s32 cellSync2SemaphoreEstimateBufferSize(vm::ptr<const CellSync2SemaphoreAttribute> attr, vm::ptr<u32> bufferSize)
+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());
 
@@ -190,7 +190,7 @@ s32 _cellSync2QueueAttributeInitialize(vm::ptr<CellSync2QueueAttribute> attr, u3
 	return CELL_OK;
 }
 
-s32 cellSync2QueueEstimateBufferSize(vm::ptr<const CellSync2QueueAttribute> attr, vm::ptr<u32> bufferSize)
+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());
 

rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp

@@ -753,7 +753,7 @@ int cellSysutilGetBgmPlaybackStatus2(vm::ptr<CellSysutilBgmPlaybackStatus2> stat
 	return CELL_OK;
 }
 
-int cellWebBrowserEstimate2(const vm::ptr<const CellWebBrowserConfig2> config, vm::ptr<u32> memSize)
+int cellWebBrowserEstimate2(const vm::cptr<CellWebBrowserConfig2> config, vm::ptr<u32> memSize)
 {
 	cellSysutil.Warning("cellWebBrowserEstimate2(config_addr=0x%x, memSize_addr=0x%x)", config.addr(), memSize.addr());
 

rpcs3/Emu/SysCalls/Modules/cellSysutil.h

@@ -80,7 +80,7 @@ enum
 	CELL_SYSUTIL_SYSCHAT_VOICE_STREAMING_PAUSED  = 0x0164,
 };
 
-typedef void(CellSysutilCallback)(u64 status, u64 param, vm::ptr<void> userdata);
+using CellSysutilCallback = func_def<void(u64 status, u64 param, vm::ptr<void> userdata)>;
 
 void sysutilSendSystemCommand(u64 status, u64 param);
 
@@ -154,22 +154,20 @@ enum
 	CELL_SYSCACHE_ERROR_NOTMOUNTED    = 0x8002bc04, // We don't really need to simulate the mounting, so this is probably useless
 };
 
-typedef s32 CellWebBrowserId;
+using CellWebBrowserCallback = func_def<void(s32 cb_type, vm::ptr<void> client_session, vm::ptr<void> usrdata)>;
-typedef vm::ptr<void> CellWebBrowserClientSession;
+using CellWebComponentCallback = func_def<void(s32 web_browser_id, s32 cb_type, vm::ptr<void> client_session, vm::ptr<void> usrdata)>;
-typedef void(CellWebBrowserCallback)(s32 cb_type, CellWebBrowserClientSession, vm::ptr<void> usrdata);
+using CellWebBrowserSystemCallback = func_def<void(s32 cb_type, vm::ptr<void> usrdata)>;
-typedef void(CellWebComponentCallback)(CellWebBrowserId, s32 cb_type, CellWebBrowserClientSession, vm::ptr<void> usrdata);
-typedef void(CellWebBrowserSystemCallback)(s32 cb_type, vm::ptr<void> usrdata);
 
-typedef void(CellWebBrowserMIMETypeCallback)(vm::ptr<const char> mimetype, vm::ptr<const char> url, vm::ptr<void> usrdata);
+using CellWebBrowserMIMETypeCallback = func_def<void(vm::cptr<char> mimetype, vm::cptr<char> url, vm::ptr<void> usrdata)>;
-typedef void(CellWebBrowserErrorCallback)(s32 err_type, vm::ptr<void> usrdata);
+using CellWebBrowserErrorCallback = func_def<void(s32 err_type, vm::ptr<void> usrdata)>;
-typedef void(CellWebBrowserStatusCallback)(s32 err_type, vm::ptr<void> usrdata);
+using CellWebBrowserStatusCallback = func_def<void(s32 err_type, vm::ptr<void> usrdata)>;
-typedef void(CellWebBrowserNotify)(vm::ptr<const char> message, vm::ptr<void> usrdata);
+using CellWebBrowserNotify = func_def<void(vm::cptr<char> message, vm::ptr<void> usrdata)>;
-typedef void(CellWebBrowserUsrdata)(vm::ptr<void> usrdata);
+using CellWebBrowserUsrdata = func_def<void(vm::ptr<void> usrdata)>;
 
 struct CellWebBrowserMimeSet
 {
-	const vm::bptr<const char> type;
+	vm::bcptr<char> type;
-	const vm::bptr<const char> directory;
+	vm::bcptr<char> directory;
 };
 
 struct CellWebBrowserPos
@@ -194,7 +192,7 @@ struct CellWebBrowserConfig
 {
 	be_t<s32> version;
 	be_t<s32> heap_size;
-	vm::bptr<const CellWebBrowserMimeSet> mimesets;
+	vm::bcptr<CellWebBrowserMimeSet> mimesets;
 	be_t<s32> mimeset_num;
 	be_t<s32> functions;
 	be_t<s32> tab_count;

rpcs3/Emu/SysCalls/Modules/cellVdec.cpp

@@ -550,21 +550,21 @@ void vdecOpen(u32 vdec_id) // TODO: call from the constructor
 	});
 }
 
-s32 cellVdecQueryAttr(vm::ptr<const CellVdecType> type, vm::ptr<CellVdecAttr> attr)
+s32 cellVdecQueryAttr(vm::cptr<CellVdecType> type, vm::ptr<CellVdecAttr> attr)
 {
 	cellVdec.Warning("cellVdecQueryAttr(type=*0x%x, attr=*0x%x)", type, attr);
 
 	return vdecQueryAttr(type->codecType, type->profileLevel, 0, attr);
 }
 
-s32 cellVdecQueryAttrEx(vm::ptr<const CellVdecTypeEx> type, vm::ptr<CellVdecAttr> attr)
+s32 cellVdecQueryAttrEx(vm::cptr<CellVdecTypeEx> type, vm::ptr<CellVdecAttr> attr)
 {
 	cellVdec.Warning("cellVdecQueryAttrEx(type=*0x%x, attr=*0x%x)", type, attr);
 
 	return vdecQueryAttr(type->codecType, type->profileLevel, type->codecSpecificInfo_addr, attr);
 }
 
-s32 cellVdecOpen(vm::ptr<const CellVdecType> type, vm::ptr<const CellVdecResource> res, vm::ptr<const CellVdecCb> cb, vm::ptr<u32> handle)
+s32 cellVdecOpen(vm::cptr<CellVdecType> type, vm::cptr<CellVdecResource> res, vm::cptr<CellVdecCb> cb, vm::ptr<u32> handle)
 {
 	cellVdec.Warning("cellVdecOpen(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle);
 
@@ -573,7 +573,7 @@ s32 cellVdecOpen(vm::ptr<const CellVdecType> type, vm::ptr<const CellVdecResourc
 	return CELL_OK;
 }
 
-s32 cellVdecOpenEx(vm::ptr<const CellVdecTypeEx> type, vm::ptr<const CellVdecResourceEx> res, vm::ptr<const CellVdecCb> cb, vm::ptr<u32> handle)
+s32 cellVdecOpenEx(vm::cptr<CellVdecTypeEx> type, vm::cptr<CellVdecResourceEx> res, vm::cptr<CellVdecCb> cb, vm::ptr<u32> handle)
 {
 	cellVdec.Warning("cellVdecOpenEx(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle);
 
@@ -641,7 +641,7 @@ s32 cellVdecEndSeq(u32 handle)
 	return CELL_OK;
 }
 
-s32 cellVdecDecodeAu(u32 handle, CellVdecDecodeMode mode, vm::ptr<const CellVdecAuInfo> auInfo)
+s32 cellVdecDecodeAu(u32 handle, CellVdecDecodeMode mode, vm::cptr<CellVdecAuInfo> auInfo)
 {
 	cellVdec.Log("cellVdecDecodeAu(handle=0x%x, mode=%d, auInfo=*0x%x)", handle, mode, auInfo);
 
@@ -671,7 +671,7 @@ s32 cellVdecDecodeAu(u32 handle, CellVdecDecodeMode mode, vm::ptr<const CellVdec
 	return CELL_OK;
 }
 
-s32 cellVdecGetPicture(u32 handle, vm::ptr<const CellVdecPicFormat> format, vm::ptr<u8> outBuff)
+s32 cellVdecGetPicture(u32 handle, vm::cptr<CellVdecPicFormat> format, vm::ptr<u8> outBuff)
 {
 	cellVdec.Log("cellVdecGetPicture(handle=0x%x, format=*0x%x, outBuff=*0x%x)", handle, format, outBuff);
 
@@ -778,7 +778,7 @@ s32 cellVdecGetPicture(u32 handle, vm::ptr<const CellVdecPicFormat> format, vm::
 	return CELL_OK;
 }
 
-s32 _nid_a21aa896(PPUThread& CPU, u32 handle, vm::ptr<const CellVdecPicFormat2> format2, vm::ptr<u8> outBuff, u32 arg4)
+s32 _nid_a21aa896(PPUThread& CPU, u32 handle, vm::cptr<CellVdecPicFormat2> format2, vm::ptr<u8> outBuff, u32 arg4)
 {
 	cellVdec.Warning("_nid_a21aa896(handle=0x%x, format2=*0x%x, outBuff=*0x%x, arg4=*0x%x)", handle, format2, outBuff, arg4);
 

rpcs3/Emu/SysCalls/Modules/cellVpost.cpp

@@ -13,7 +13,7 @@ extern "C"
 
 extern Module cellVpost;
 
-s32 cellVpostQueryAttr(vm::ptr<const CellVpostCfgParam> cfgParam, vm::ptr<CellVpostAttr> attr)
+s32 cellVpostQueryAttr(vm::cptr<CellVpostCfgParam> cfgParam, vm::ptr<CellVpostAttr> attr)
 {
 	cellVpost.Warning("cellVpostQueryAttr(cfgParam=*0x%x, attr=*0x%x)", cfgParam, attr);
 
@@ -27,7 +27,7 @@ s32 cellVpostQueryAttr(vm::ptr<const CellVpostCfgParam> cfgParam, vm::ptr<CellVp
 	return CELL_OK;
 }
 
-s32 cellVpostOpen(vm::ptr<const CellVpostCfgParam> cfgParam, vm::ptr<const CellVpostResource> resource, vm::ptr<u32> handle)
+s32 cellVpostOpen(vm::cptr<CellVpostCfgParam> cfgParam, vm::cptr<CellVpostResource> resource, vm::ptr<u32> handle)
 {
 	cellVpost.Warning("cellVpostOpen(cfgParam=*0x%x, resource=*0x%x, handle=*0x%x)", cfgParam, resource, handle);
 
@@ -36,7 +36,7 @@ s32 cellVpostOpen(vm::ptr<const CellVpostCfgParam> cfgParam, vm::ptr<const CellV
 	return CELL_OK;
 }
 
-s32 cellVpostOpenEx(vm::ptr<const CellVpostCfgParam> cfgParam, vm::ptr<const CellVpostResourceEx> resource, vm::ptr<u32> handle)
+s32 cellVpostOpenEx(vm::cptr<CellVpostCfgParam> cfgParam, vm::cptr<CellVpostResourceEx> resource, vm::ptr<u32> handle)
 {
 	cellVpost.Warning("cellVpostOpenEx(cfgParam=*0x%x, resource=*0x%x, handle=*0x%x)", cfgParam, resource, handle);
 
@@ -60,7 +60,7 @@ s32 cellVpostClose(u32 handle)
 	return CELL_OK;
 }
 
-s32 cellVpostExec(u32 handle, vm::ptr<const u8> inPicBuff, vm::ptr<const CellVpostCtrlParam> ctrlParam, vm::ptr<u8> outPicBuff, vm::ptr<CellVpostPictureInfo> picInfo)
+s32 cellVpostExec(u32 handle, vm::cptr<u8> inPicBuff, vm::cptr<CellVpostCtrlParam> ctrlParam, vm::ptr<u8> outPicBuff, vm::ptr<CellVpostPictureInfo> picInfo)
 {
 	cellVpost.Log("cellVpostExec(handle=0x%x, inPicBuff=*0x%x, ctrlParam=*0x%x, outPicBuff=*0x%x, picInfo=*0x%x)", handle, inPicBuff, ctrlParam, outPicBuff, picInfo);
 

rpcs3/Emu/SysCalls/Modules/libmixer.cpp

@@ -292,7 +292,7 @@ int cellSSPlayerGetState(u32 handle)
 	return CELL_SSPLAYER_STATE_OFF;
 }
 
-int cellSurMixerCreate(vm::ptr<const CellSurMixerConfig> config)
+int cellSurMixerCreate(vm::cptr<CellSurMixerConfig> config)
 {
 	libmixer.Warning("cellSurMixerCreate(config_addr=0x%x)", config.addr());
 

rpcs3/Emu/SysCalls/Modules/sceNp.cpp

@@ -80,7 +80,7 @@ int sceNp2Term()
 	return CELL_OK;
 }
 
-int npDrmIsAvailable(u32 k_licensee_addr, vm::ptr<const char> drm_path)
+int npDrmIsAvailable(u32 k_licensee_addr, vm::cptr<char> drm_path)
 {
 	if (!Emu.GetVFS().ExistsFile(drm_path.get_ptr()))
 	{
@@ -146,28 +146,28 @@ int npDrmIsAvailable(u32 k_licensee_addr, vm::ptr<const char> drm_path)
 	return CELL_OK;
 }
 
-int sceNpDrmIsAvailable(u32 k_licensee_addr, vm::ptr<const char> drm_path)
+int sceNpDrmIsAvailable(u32 k_licensee_addr, vm::cptr<char> drm_path)
 {
 	sceNp.Warning("sceNpDrmIsAvailable(k_licensee_addr=0x%x, drm_path_addr=0x%x('%s'))", k_licensee_addr, drm_path.addr(), drm_path.get_ptr());
 
 	return npDrmIsAvailable(k_licensee_addr, drm_path);
 }
 
-int sceNpDrmIsAvailable2(u32 k_licensee_addr, vm::ptr<const char> drm_path)
+int sceNpDrmIsAvailable2(u32 k_licensee_addr, vm::cptr<char> drm_path)
 {
 	sceNp.Warning("sceNpDrmIsAvailable2(k_licensee_addr=0x%x, drm_path_addr=0x%x('%s'))", k_licensee_addr, drm_path.addr(), drm_path.get_ptr());
 
 	return npDrmIsAvailable(k_licensee_addr, drm_path);
 }
 
-int sceNpDrmVerifyUpgradeLicense(vm::ptr<const char> content_id)
+int sceNpDrmVerifyUpgradeLicense(vm::cptr<char> content_id)
 {
 	sceNp.Todo("sceNpDrmVerifyUpgradeLicense(content_id_addr=0x%x)", content_id.addr());
 
 	return CELL_OK;
 }
 
-int sceNpDrmVerifyUpgradeLicense2(vm::ptr<const char> content_id)
+int sceNpDrmVerifyUpgradeLicense2(vm::cptr<char> content_id)
 {
 	sceNp.Todo("sceNpDrmVerifyUpgradeLicense2(content_id_addr=0x%x)", content_id.addr());
 
@@ -189,7 +189,7 @@ int sceNpDrmGetTimelimit(vm::ptr<const char> path, vm::ptr<u64> time_remain)
 	return CELL_OK;
 }
 
-int sceNpDrmProcessExitSpawn(vm::ptr<const char> path, u32 argv_addr, u32 envp_addr, u32 data_addr, u32 data_size, u32 prio, u64 flags)
+int sceNpDrmProcessExitSpawn(vm::cptr<char> path, u32 argv_addr, u32 envp_addr, u32 data_addr, u32 data_size, u32 prio, u64 flags)
 {
 	sceNp.Warning("sceNpDrmProcessExitSpawn()");
 	sceNp.Warning("path: %s", path.get_ptr());
@@ -205,7 +205,7 @@ int sceNpDrmProcessExitSpawn(vm::ptr<const char> path, u32 argv_addr, u32 envp_a
 	return CELL_OK;
 }
 
-int sceNpDrmProcessExitSpawn2(vm::ptr<const char> path, u32 argv_addr, u32 envp_addr, u32 data_addr, u32 data_size, u32 prio, u64 flags)
+int sceNpDrmProcessExitSpawn2(vm::cptr<char> path, u32 argv_addr, u32 envp_addr, u32 data_addr, u32 data_size, u32 prio, u64 flags)
 {
 	sceNp.Warning("sceNpDrmProcessExitSpawn2()");
 	sceNp.Warning("path: %s", path.get_ptr());

rpcs3/Emu/SysCalls/Modules/sceNpClans.cpp

@@ -80,7 +80,7 @@ int sceNpClansAbortRequest(vm::ptr<SceNpClansRequestHandle> handle)
 	return CELL_OK;
 }
 
-int sceNpClansCreateClan(vm::ptr<SceNpClansRequestHandle> handle, vm::ptr<const char> name, vm::ptr<const char> tag, vm::ptr<u32> clanId)
+int sceNpClansCreateClan(vm::ptr<SceNpClansRequestHandle> handle, vm::cptr<char> name, vm::cptr<char> tag, vm::ptr<u32> clanId)
 {
 	UNIMPLEMENTED_FUNC(sceNpClans);
 
@@ -100,7 +100,7 @@ int sceNpClansDisbandClan(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId)
 	return CELL_OK;
 }
 
-int sceNpClansGetClanList(vm::ptr<SceNpClansRequestHandle> handle, vm::ptr<const SceNpClansPagingRequest> paging, vm::ptr<SceNpClansEntry> clanList, vm::ptr<SceNpClansPagingResult> pageResult)
+int sceNpClansGetClanList(vm::ptr<SceNpClansRequestHandle> handle, vm::cptr<SceNpClansPagingRequest> paging, vm::ptr<SceNpClansEntry> clanList, vm::ptr<SceNpClansPagingResult> pageResult)
 {
 	UNIMPLEMENTED_FUNC(sceNpClans);
 

rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp

@@ -91,7 +91,7 @@ int sceNpTrophyInit(u32 pool_addr, u32 poolSize, u32 containerId, u64 options)
 	return CELL_OK;
 }
 
-int sceNpTrophyCreateContext(vm::ptr<u32> context, vm::ptr<const SceNpCommunicationId> commID, vm::ptr<const SceNpCommunicationSignature> commSign, u64 options)
+int sceNpTrophyCreateContext(vm::ptr<u32> context, vm::cptr<SceNpCommunicationId> commID, vm::cptr<SceNpCommunicationSignature> commSign, u64 options)
 {
 	sceNpTrophy.Warning("sceNpTrophyCreateContext(context=*0x%x, commID=*0x%x, commSign=*0x%x, options=0x%llx)", context, commID, commSign, options);
 

rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp

@@ -629,7 +629,7 @@ s32 sys_lwcond_wait(PPUThread& CPU, vm::ptr<sys_lwcond_t> lwcond, u64 timeout)
 	return res;
 }
 
-std::string ps3_fmt(PPUThread& context, vm::ptr<const char> fmt, u32 g_count, u32 f_count, u32 v_count)
+std::string ps3_fmt(PPUThread& context, vm::cptr<char> fmt, u32 g_count, u32 f_count, u32 v_count)
 {
 	std::string result;
 
@@ -743,7 +743,7 @@ std::string ps3_fmt(PPUThread& context, vm::ptr<const char> fmt, u32 g_count, u3
 			case 's':
 			{
 				// string
-				auto string = vm::ptr<const char>::make(context.get_next_gpr_arg(g_count, f_count, v_count));
+				auto string = vm::cptr<char>::make(context.get_next_gpr_arg(g_count, f_count, v_count));
 
 				if (plus_sign || minus_sign || space_sign || number_sign || zero_padding || width || prec) break;
 
@@ -762,7 +762,7 @@ std::string ps3_fmt(PPUThread& context, vm::ptr<const char> fmt, u32 g_count, u3
 	return result;
 }
 
-u32 _sys_heap_create_heap(vm::ptr<const char> name, u32 arg2, u32 arg3, u32 arg4)
+u32 _sys_heap_create_heap(vm::cptr<char> name, u32 arg2, u32 arg3, u32 arg4)
 {
 	sysPrxForUser.Warning("_sys_heap_create_heap(name=*0x%x, arg2=0x%x, arg3=0x%x, arg4=0x%x)", name, arg2, arg3, arg4);
 
@@ -860,7 +860,7 @@ s32 sys_spu_image_close(vm::ptr<sys_spu_image> img)
 	return CELL_OK;
 }
 
-s32 sys_raw_spu_load(s32 id, vm::ptr<const char> path, vm::ptr<u32> entry)
+s32 sys_raw_spu_load(s32 id, vm::cptr<char> path, vm::ptr<u32> entry)
 {
 	sysPrxForUser.Warning("sys_raw_spu_load(id=%d, path=*0x%x, entry=*0x%x)", id, path, entry);
 	sysPrxForUser.Warning("*** path = '%s'", path.get_ptr());
@@ -938,7 +938,7 @@ vm::ptr<void> _sys_memset(vm::ptr<void> dst, s32 value, u32 size)
 	return dst;
 }
 
-vm::ptr<void> _sys_memcpy(vm::ptr<void> dst, vm::ptr<const void> src, u32 size)
+vm::ptr<void> _sys_memcpy(vm::ptr<void> dst, vm::cptr<void> src, u32 size)
 {
 	sysPrxForUser.Log("_sys_memcpy(dst=*0x%x, src=*0x%x, size=0x%x)", dst, src, size);
 
@@ -947,35 +947,35 @@ vm::ptr<void> _sys_memcpy(vm::ptr<void> dst, vm::ptr<const void> src, u32 size)
 	return dst;
 }
 
-s32 _sys_memcmp(vm::ptr<const void> buf1, vm::ptr<const void> buf2, u32 size)
+s32 _sys_memcmp(vm::cptr<void> buf1, vm::cptr<void> buf2, u32 size)
 {
 	sysPrxForUser.Log("_sys_memcmp(buf1=*0x%x, buf2=*0x%x, size=%d)", buf1, buf2, size);
 
 	return memcmp(buf1.get_ptr(), buf2.get_ptr(), size);
 }
 
-s64 _sys_strlen(vm::ptr<const char> str)
+s64 _sys_strlen(vm::cptr<char> str)
 {
 	sysPrxForUser.Log("_sys_strlen(str=*0x%x)", str);
 
 	return strlen(str.get_ptr());
 }
 
-s32 _sys_strcmp(vm::ptr<const char> str1, vm::ptr<const char> str2)
+s32 _sys_strcmp(vm::cptr<char> str1, vm::cptr<char> str2)
 {
 	sysPrxForUser.Log("_sys_strcmp(str1=*0x%x, str2=*0x%x)", str1, str2);
 
 	return strcmp(str1.get_ptr(), str2.get_ptr());
 }
 
-s32 _sys_strncmp(vm::ptr<const char> str1, vm::ptr<const char> str2, s32 max)
+s32 _sys_strncmp(vm::cptr<char> str1, vm::cptr<char> str2, s32 max)
 {
 	sysPrxForUser.Log("_sys_strncmp(str1=*0x%x, str2=*0x%x, max=%d)", str1, str2, max);
 
 	return strncmp(str1.get_ptr(), str2.get_ptr(), max);
 }
 
-vm::ptr<char> _sys_strcat(vm::ptr<char> dest, vm::ptr<const char> source)
+vm::ptr<char> _sys_strcat(vm::ptr<char> dest, vm::cptr<char> source)
 {
 	sysPrxForUser.Log("_sys_strcat(dest=*0x%x, source=*0x%x)", dest, source);
 
@@ -987,14 +987,14 @@ vm::ptr<char> _sys_strcat(vm::ptr<char> dest, vm::ptr<const char> source)
 	return dest;
 }
 
-vm::ptr<const char> _sys_strchr(vm::ptr<const char> str, s32 ch)
+vm::cptr<char> _sys_strchr(vm::cptr<char> str, s32 ch)
 {
 	sysPrxForUser.Log("_sys_strchr(str=*0x%x, ch=0x%x)", str, ch);
 
-	return vm::ptr<const char>::make(vm::get_addr(strchr(str.get_ptr(), ch)));
+	return vm::cptr<char>::make(vm::get_addr(strchr(str.get_ptr(), ch)));
 }
 
-vm::ptr<char> _sys_strncat(vm::ptr<char> dest, vm::ptr<const char> source, u32 len)
+vm::ptr<char> _sys_strncat(vm::ptr<char> dest, vm::cptr<char> source, u32 len)
 {
 	sysPrxForUser.Log("_sys_strncat(dest=*0x%x, source=*0x%x, len=%d)", dest, source, len);
 
@@ -1006,7 +1006,7 @@ vm::ptr<char> _sys_strncat(vm::ptr<char> dest, vm::ptr<const char> source, u32 l
 	return dest;
 }
 
-vm::ptr<char> _sys_strcpy(vm::ptr<char> dest, vm::ptr<const char> source)
+vm::ptr<char> _sys_strcpy(vm::ptr<char> dest, vm::cptr<char> source)
 {
 	sysPrxForUser.Log("_sys_strcpy(dest=*0x%x, source=*0x%x)", dest, source);
 
@@ -1018,7 +1018,7 @@ vm::ptr<char> _sys_strcpy(vm::ptr<char> dest, vm::ptr<const char> source)
 	return dest;
 }
 
-vm::ptr<char> _sys_strncpy(vm::ptr<char> dest, vm::ptr<const char> source, u32 len)
+vm::ptr<char> _sys_strncpy(vm::ptr<char> dest, vm::cptr<char> source, u32 len)
 {
 	sysPrxForUser.Log("_sys_strncpy(dest=*0x%x, source=*0x%x, len=%d)", dest, source, len);
 
@@ -1134,7 +1134,7 @@ s32 _sys_free(u32 addr)
 	return CELL_OK;
 }
 
-s32 _sys_snprintf(PPUThread& CPU, vm::ptr<char> dst, u32 count, vm::ptr<const char> fmt) // va_args...
+s32 _sys_snprintf(PPUThread& CPU, vm::ptr<char> dst, u32 count, vm::cptr<char> fmt) // va_args...
 {
 	sysPrxForUser.Warning("_sys_snprintf(dst=*0x%x, count=%d, fmt=*0x%x, ...)", dst, count, fmt);
 
@@ -1156,7 +1156,7 @@ s32 _sys_snprintf(PPUThread& CPU, vm::ptr<char> dst, u32 count, vm::ptr<const ch
 	}
 }
 
-s32 _sys_printf(vm::ptr<const char> fmt) // va_args...
+s32 _sys_printf(vm::cptr<char> fmt) // va_args...
 {
 	sysPrxForUser.Todo("_sys_printf(fmt=*0x%x, ...)", fmt);
 
@@ -1222,7 +1222,7 @@ void sys_spinlock_unlock(vm::ptr<atomic_be_t<u32>> lock)
 	g_sys_spinlock_wm.notify(lock.addr());
 }
 
-s32 sys_ppu_thread_create(PPUThread& CPU, vm::ptr<u64> thread_id, u32 entry, u64 arg, s32 prio, u32 stacksize, u64 flags, vm::ptr<const char> threadname)
+s32 sys_ppu_thread_create(PPUThread& CPU, vm::ptr<u64> thread_id, u32 entry, u64 arg, s32 prio, u32 stacksize, u64 flags, vm::cptr<char> threadname)
 {
 	sysPrxForUser.Warning("sys_ppu_thread_create(thread_id=*0x%x, entry=0x%x, arg=0x%llx, prio=%d, stacksize=0x%x, flags=0x%llx, threadname=*0x%x)", thread_id, entry, arg, prio, stacksize, flags, threadname);
 

rpcs3/Emu/SysCalls/Modules/sys_libc.cpp

@@ -10,7 +10,7 @@ extern Module sys_libc;
 
 namespace sys_libc_func
 {
-	void memcpy(vm::ptr<void> dst, vm::ptr<const void> src, u32 size)
+	void memcpy(vm::ptr<void> dst, vm::cptr<void> src, u32 size)
 	{
 		sys_libc.Log("memcpy(dst=0x%x, src=0x%x, size=0x%x)", dst, src, size);
 

rpcs3/Emu/SysCalls/Modules/sys_net.cpp

@@ -171,7 +171,7 @@ namespace sys_net_func
 		return CELL_OK;
 	}
 
-	s32 inet_addr(vm::ptr<const char> cp)
+	s32 inet_addr(vm::cptr<char> cp)
 	{
 		sys_net.Warning("inet_addr(cp_addr=0x%x['%s'])", cp.addr(), cp.get_ptr());
 		return htonl(::inet_addr(cp.get_ptr())); // return a big-endian IP address (WTF? function should return LITTLE-ENDIAN value)
@@ -219,7 +219,7 @@ namespace sys_net_func
 		return CELL_OK;
 	}
 
-	s32 inet_pton(s32 af, vm::ptr<const char> src, vm::ptr<char> dst)
+	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());
 
@@ -264,7 +264,7 @@ namespace sys_net_func
 		return CELL_OK;
 	}
 
-	s32 send(s32 s, vm::ptr<const char> buf, u32 len, s32 flags)
+	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);
 
@@ -279,7 +279,7 @@ namespace sys_net_func
 		return CELL_OK;
 	}
 
-	s32 sendto(s32 s, vm::ptr<const char> buf, u32 len, s32 flags, vm::ptr<sys_net_sockaddr> addr, u32 addrlen)
+	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)",
 			s, buf.addr(), len, flags, addr.addr(), addrlen);
@@ -292,7 +292,7 @@ namespace sys_net_func
 		return ret;
 	}
 
-	s32 setsockopt(s32 s, s32 level, s32 optname, vm::ptr<const char> optval, u32 optlen)
+	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);
 

rpcs3/Emu/SysCalls/lv2/sys_cond.cpp

@@ -13,7 +13,7 @@
 
 SysCallBase sys_cond("sys_cond");
 
-s32 sys_cond_create(vm::ref<u32> cond_id, u32 mutex_id, vm::ptr<sys_cond_attribute_t> attr)
+s32 sys_cond_create(vm::ptr<u32> cond_id, u32 mutex_id, vm::ptr<sys_cond_attribute_t> attr)
 {
 	sys_cond.Warning("sys_cond_create(cond_id=*0x%x, mutex_id=0x%x, attr=*0x%x)", cond_id, mutex_id, attr);
 
@@ -37,7 +37,7 @@ s32 sys_cond_create(vm::ref<u32> cond_id, u32 mutex_id, vm::ptr<sys_cond_attribu
 		throw __FUNCTION__;
 	}
 
-	cond_id = Emu.GetIdManager().make<lv2_cond_t>(mutex, attr->name_u64);
+	*cond_id = Emu.GetIdManager().make<lv2_cond_t>(mutex, attr->name_u64);
 
 	return CELL_OK;
 }

rpcs3/Emu/SysCalls/lv2/sys_cond.h

@@ -42,7 +42,7 @@ REG_ID_TYPE(lv2_cond_t, 0x86); // SYS_COND_OBJECT
 class PPUThread;
 
 // SysCalls
-s32 sys_cond_create(vm::ref<u32> cond_id, u32 mutex_id, vm::ptr<sys_cond_attribute_t> attr);
+s32 sys_cond_create(vm::ptr<u32> cond_id, u32 mutex_id, vm::ptr<sys_cond_attribute_t> attr);
 s32 sys_cond_destroy(u32 cond_id);
 s32 sys_cond_wait(PPUThread& CPU, u32 cond_id, u64 timeout);
 s32 sys_cond_signal(u32 cond_id);

rpcs3/Emu/SysCalls/lv2/sys_event.cpp

@@ -13,7 +13,7 @@
 
 SysCallBase sys_event("sys_event");
 
-s32 sys_event_queue_create(vm::ref<u32> equeue_id, vm::ptr<sys_event_queue_attr> attr, u64 event_queue_key, s32 size)
+s32 sys_event_queue_create(vm::ptr<u32> equeue_id, vm::ptr<sys_event_queue_attr> attr, u64 event_queue_key, s32 size)
 {
 	sys_event.Warning("sys_event_queue_create(equeue_id=*0x%x, attr=*0x%x, event_queue_key=0x%llx, size=%d)", equeue_id, attr, event_queue_key, size);
 
@@ -47,7 +47,7 @@ s32 sys_event_queue_create(vm::ref<u32> equeue_id, vm::ptr<sys_event_queue_attr>
 		return CELL_EEXIST;
 	}
 
-	equeue_id = Emu.GetIdManager().add(std::move(queue));
+	*equeue_id = Emu.GetIdManager().add(std::move(queue));
 	
 	return CELL_OK;
 }
@@ -91,7 +91,7 @@ s32 sys_event_queue_destroy(u32 equeue_id, s32 mode)
 	return CELL_OK;
 }
 
-s32 sys_event_queue_tryreceive(u32 equeue_id, vm::ptr<sys_event_t> event_array, s32 size, vm::ref<u32> number)
+s32 sys_event_queue_tryreceive(u32 equeue_id, vm::ptr<sys_event_t> event_array, s32 size, vm::ptr<u32> number)
 {
 	sys_event.Log("sys_event_queue_tryreceive(equeue_id=0x%x, event_array=*0x%x, size=%d, number=*0x%x)", equeue_id, event_array, size, number);
 
@@ -129,7 +129,7 @@ s32 sys_event_queue_tryreceive(u32 equeue_id, vm::ptr<sys_event_t> event_array,
 		queue->events.pop_front();
 	}
 
-	number = count;
+	*number = count;
 
 	return CELL_OK;
 }
@@ -211,7 +211,7 @@ s32 sys_event_queue_drain(u32 equeue_id)
 	return CELL_OK;
 }
 
-s32 sys_event_port_create(vm::ref<u32> eport_id, s32 port_type, u64 name)
+s32 sys_event_port_create(vm::ptr<u32> eport_id, s32 port_type, u64 name)
 {
 	sys_event.Warning("sys_event_port_create(eport_id=*0x%x, port_type=%d, name=0x%llx)", eport_id, port_type, name);
 
@@ -221,7 +221,7 @@ s32 sys_event_port_create(vm::ref<u32> eport_id, s32 port_type, u64 name)
 		return CELL_EINVAL;
 	}
 
-	eport_id = Emu.GetIdManager().make<lv2_event_port_t>(port_type, name);
+	*eport_id = Emu.GetIdManager().make<lv2_event_port_t>(port_type, name);
 
 	return CELL_OK;
 }

rpcs3/Emu/SysCalls/lv2/sys_event.h

@@ -130,13 +130,13 @@ REG_ID_TYPE(lv2_event_port_t, 0x0E); // SYS_EVENT_PORT_OBJECT
 class PPUThread;
 
 // SysCalls
-s32 sys_event_queue_create(vm::ref<u32> equeue_id, vm::ptr<sys_event_queue_attr> attr, u64 event_queue_key, s32 size);
+s32 sys_event_queue_create(vm::ptr<u32> equeue_id, vm::ptr<sys_event_queue_attr> attr, u64 event_queue_key, s32 size);
 s32 sys_event_queue_destroy(u32 equeue_id, s32 mode);
 s32 sys_event_queue_receive(PPUThread& CPU, u32 equeue_id, vm::ptr<sys_event_t> dummy_event, u64 timeout);
-s32 sys_event_queue_tryreceive(u32 equeue_id, vm::ptr<sys_event_t> event_array, s32 size, vm::ref<u32> number);
+s32 sys_event_queue_tryreceive(u32 equeue_id, vm::ptr<sys_event_t> event_array, s32 size, vm::ptr<u32> number);
 s32 sys_event_queue_drain(u32 event_queue_id);
 
-s32 sys_event_port_create(vm::ref<u32> eport_id, s32 port_type, u64 name);
+s32 sys_event_port_create(vm::ptr<u32> eport_id, s32 port_type, u64 name);
 s32 sys_event_port_destroy(u32 eport_id);
 s32 sys_event_port_connect_local(u32 event_port_id, u32 event_queue_id);
 s32 sys_event_port_disconnect(u32 eport_id);

rpcs3/Emu/SysCalls/lv2/sys_fs.cpp

@@ -20,7 +20,7 @@ s32 sys_fs_test(u32 arg1, u32 arg2, vm::ptr<u32> arg3, u32 arg4, vm::ptr<char> a
 	return CELL_OK;
 }
 
-s32 sys_fs_open(vm::ptr<const char> path, s32 flags, vm::ptr<u32> fd, s32 mode, vm::ptr<const void> arg, u64 size)
+s32 sys_fs_open(vm::cptr<char> path, s32 flags, vm::ptr<u32> fd, s32 mode, vm::cptr<void> arg, u64 size)
 {
 	sys_fs.Warning("sys_fs_open(path=*0x%x, flags=%#o, fd=*0x%x, mode=%#o, arg=*0x%x, size=0x%llx)", path, flags, fd, mode, arg, size);
 	sys_fs.Warning("*** path = '%s'", path.get_ptr());
@@ -137,7 +137,7 @@ s32 sys_fs_read(u32 fd, vm::ptr<void> buf, u64 nbytes, vm::ptr<u64> nread)
 	return CELL_OK;
 }
 
-s32 sys_fs_write(u32 fd, vm::ptr<const void> buf, u64 nbytes, vm::ptr<u64> nwrite)
+s32 sys_fs_write(u32 fd, vm::cptr<void> buf, u64 nbytes, vm::ptr<u64> nwrite)
 {
 	sys_fs.Log("sys_fs_write(fd=0x%x, buf=*0x%x, nbytes=0x%llx, nwrite=*0x%x)", fd, buf, nbytes, nwrite);
 
@@ -175,7 +175,7 @@ s32 sys_fs_close(u32 fd)
 	return CELL_OK;
 }
 
-s32 sys_fs_opendir(vm::ptr<const char> path, vm::ptr<u32> fd)
+s32 sys_fs_opendir(vm::cptr<char> path, vm::ptr<u32> fd)
 {
 	sys_fs.Warning("sys_fs_opendir(path=*0x%x, fd=*0x%x)", path, fd);
 	sys_fs.Warning("*** path = '%s'", path.get_ptr());
@@ -237,7 +237,7 @@ s32 sys_fs_closedir(u32 fd)
 	return CELL_OK;
 }
 
-s32 sys_fs_stat(vm::ptr<const char> path, vm::ptr<CellFsStat> sb)
+s32 sys_fs_stat(vm::cptr<char> path, vm::ptr<CellFsStat> sb)
 {
 	sys_fs.Warning("sys_fs_stat(path=*0x%x, sb=*0x%x)", path, sb);
 	sys_fs.Warning("*** path = '%s'", path.get_ptr());
@@ -310,7 +310,7 @@ s32 sys_fs_fstat(u32 fd, vm::ptr<CellFsStat> sb)
 	return CELL_OK;
 }
 
-s32 sys_fs_mkdir(vm::ptr<const char> path, s32 mode)
+s32 sys_fs_mkdir(vm::cptr<char> path, s32 mode)
 {
 	sys_fs.Warning("sys_fs_mkdir(path=*0x%x, mode=%#o)", path, mode);
 	sys_fs.Warning("*** path = '%s'", path.get_ptr());
@@ -331,7 +331,7 @@ s32 sys_fs_mkdir(vm::ptr<const char> path, s32 mode)
 	return CELL_OK;
 }
 
-s32 sys_fs_rename(vm::ptr<const char> from, vm::ptr<const char> to)
+s32 sys_fs_rename(vm::cptr<char> from, vm::cptr<char> to)
 {
 	sys_fs.Warning("sys_fs_rename(from=*0x%x, to=*0x%x)", from, to);
 	sys_fs.Warning("*** from = '%s'", from.get_ptr());
@@ -364,7 +364,7 @@ s32 sys_fs_rename(vm::ptr<const char> from, vm::ptr<const char> to)
 	return CELL_FS_ENOENT;
 }
 
-s32 sys_fs_rmdir(vm::ptr<const char> path)
+s32 sys_fs_rmdir(vm::cptr<char> path)
 {
 	sys_fs.Warning("sys_fs_rmdir(path=*0x%x)", path);
 	sys_fs.Warning("*** path = '%s'", path.get_ptr());
@@ -385,7 +385,7 @@ s32 sys_fs_rmdir(vm::ptr<const char> path)
 	return CELL_OK;
 }
 
-s32 sys_fs_unlink(vm::ptr<const char> path)
+s32 sys_fs_unlink(vm::cptr<char> path)
 {
 	sys_fs.Warning("sys_fs_unlink(path=*0x%x)", path);
 	sys_fs.Warning("*** path = '%s'", path.get_ptr());
@@ -454,7 +454,7 @@ s32 sys_fs_fget_block_size(u32 fd, vm::ptr<u64> sector_size, vm::ptr<u64> block_
 	return CELL_OK;
 }
 
-s32 sys_fs_get_block_size(vm::ptr<const char> path, vm::ptr<u64> sector_size, vm::ptr<u64> block_size, vm::ptr<u64> arg4)
+s32 sys_fs_get_block_size(vm::cptr<char> path, vm::ptr<u64> sector_size, vm::ptr<u64> block_size, vm::ptr<u64> arg4)
 {
 	sys_fs.Todo("sys_fs_get_block_size(path=*0x%x, sector_size=*0x%x, block_size=*0x%x, arg4=*0x%x, arg5=*0x%x)", path, sector_size, block_size, arg4);
 	sys_fs.Todo("*** path = '%s'", path.get_ptr());
@@ -465,7 +465,7 @@ s32 sys_fs_get_block_size(vm::ptr<const char> path, vm::ptr<u64> sector_size, vm
 	return CELL_OK;
 }
 
-s32 sys_fs_truncate(vm::ptr<const char> path, u64 size)
+s32 sys_fs_truncate(vm::cptr<char> path, u64 size)
 {
 	sys_fs.Warning("sys_fs_truncate(path=*0x%x, size=0x%llx)", path, size);
 	sys_fs.Warning("*** path = '%s'", path.get_ptr());
@@ -514,7 +514,7 @@ s32 sys_fs_ftruncate(u32 fd, u64 size)
 	return CELL_OK;
 }
 
-s32 sys_fs_chmod(vm::ptr<const char> path, s32 mode)
+s32 sys_fs_chmod(vm::cptr<char> path, s32 mode)
 {
 	sys_fs.Todo("sys_fs_chmod(path=*0x%x, mode=%#o) -> CELL_OK", path, mode);
 	sys_fs.Todo("*** path = '%s'", path.get_ptr());

rpcs3/Emu/SysCalls/lv2/sys_fs.h

@@ -213,23 +213,23 @@ REG_ID_TYPE(lv2_dir_t, 0x73); // SYS_FS_FD_OBJECT
 
 // SysCalls
 s32 sys_fs_test(u32 arg1, u32 arg2, vm::ptr<u32> arg3, u32 arg4, vm::ptr<char> arg5, u32 arg6);
-s32 sys_fs_open(vm::ptr<const char> path, s32 flags, vm::ptr<u32> fd, s32 mode, vm::ptr<const void> arg, u64 size);
+s32 sys_fs_open(vm::cptr<char> path, s32 flags, vm::ptr<u32> fd, s32 mode, vm::cptr<void> arg, u64 size);
 s32 sys_fs_read(u32 fd, vm::ptr<void> buf, u64 nbytes, vm::ptr<u64> nread);
-s32 sys_fs_write(u32 fd, vm::ptr<const void> buf, u64 nbytes, vm::ptr<u64> nwrite);
+s32 sys_fs_write(u32 fd, vm::cptr<void> buf, u64 nbytes, vm::ptr<u64> nwrite);
 s32 sys_fs_close(u32 fd);
-s32 sys_fs_opendir(vm::ptr<const char> path, vm::ptr<u32> fd);
+s32 sys_fs_opendir(vm::cptr<char> path, vm::ptr<u32> fd);
 s32 sys_fs_readdir(u32 fd, vm::ptr<CellFsDirent> dir, vm::ptr<u64> nread);
 s32 sys_fs_closedir(u32 fd);
-s32 sys_fs_stat(vm::ptr<const char> path, vm::ptr<CellFsStat> sb);
+s32 sys_fs_stat(vm::cptr<char> path, vm::ptr<CellFsStat> sb);
 s32 sys_fs_fstat(u32 fd, vm::ptr<CellFsStat> sb);
-s32 sys_fs_mkdir(vm::ptr<const char> path, s32 mode);
+s32 sys_fs_mkdir(vm::cptr<char> path, s32 mode);
-s32 sys_fs_rename(vm::ptr<const char> from, vm::ptr<const char> to);
+s32 sys_fs_rename(vm::cptr<char> from, vm::cptr<char> to);
-s32 sys_fs_rmdir(vm::ptr<const char> path);
+s32 sys_fs_rmdir(vm::cptr<char> path);
-s32 sys_fs_unlink(vm::ptr<const char> path);
+s32 sys_fs_unlink(vm::cptr<char> path);
 s32 sys_fs_fcntl(u32 fd, s32 flags, u32 addr, u32 arg4, u32 arg5, u32 arg6);
 s32 sys_fs_lseek(u32 fd, s64 offset, s32 whence, vm::ptr<u64> pos);
 s32 sys_fs_fget_block_size(u32 fd, vm::ptr<u64> sector_size, vm::ptr<u64> block_size, vm::ptr<u64> arg4, vm::ptr<u64> arg5);
-s32 sys_fs_get_block_size(vm::ptr<const char> path, vm::ptr<u64> sector_size, vm::ptr<u64> block_size, vm::ptr<u64> arg4);
+s32 sys_fs_get_block_size(vm::cptr<char> path, vm::ptr<u64> sector_size, vm::ptr<u64> block_size, vm::ptr<u64> arg4);
-s32 sys_fs_truncate(vm::ptr<const char> path, u64 size);
+s32 sys_fs_truncate(vm::cptr<char> path, u64 size);
 s32 sys_fs_ftruncate(u32 fd, u64 size);
-s32 sys_fs_chmod(vm::ptr<const char> path, s32 mode);
+s32 sys_fs_chmod(vm::cptr<char> path, s32 mode);

rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.cpp

@@ -186,7 +186,7 @@ u32 ppu_thread_create(u32 entry, u64 arg, s32 prio, u32 stacksize, bool is_joina
 	return ppu.GetId();
 }
 
-s32 _sys_ppu_thread_create(vm::ptr<u64> thread_id, vm::ptr<ppu_thread_param_t> param, u64 arg, u64 unk, s32 prio, u32 stacksize, u64 flags, vm::ptr<const char> threadname)
+s32 _sys_ppu_thread_create(vm::ptr<u64> thread_id, vm::ptr<ppu_thread_param_t> param, u64 arg, u64 unk, s32 prio, u32 stacksize, u64 flags, vm::cptr<char> threadname)
 {
 	sys_ppu_thread.Warning("_sys_ppu_thread_create(thread_id=*0x%x, param=*0x%x, arg=0x%llx, unk=0x%llx, prio=%d, stacksize=0x%x, flags=0x%llx, threadname=*0x%x)",
 		thread_id, param, arg, unk, prio, stacksize, flags, threadname);
@@ -244,7 +244,7 @@ s32 sys_ppu_thread_start(u32 thread_id)
 	return CELL_OK;
 }
 
-s32 sys_ppu_thread_rename(u32 thread_id, vm::ptr<const char> name)
+s32 sys_ppu_thread_rename(u32 thread_id, vm::cptr<char> name)
 {
 	sys_ppu_thread.Error("sys_ppu_thread_rename(thread_id=0x%x, name=*0x%x)", thread_id, name);
 

rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.h

@@ -43,6 +43,6 @@ s32 sys_ppu_thread_get_priority(u32 thread_id, vm::ptr<s32> priop);
 s32 sys_ppu_thread_get_stack_information(PPUThread& CPU, vm::ptr<sys_ppu_thread_stack_t> sp);
 s32 sys_ppu_thread_stop(u32 thread_id);
 s32 sys_ppu_thread_restart(u32 thread_id);
-s32 _sys_ppu_thread_create(vm::ptr<u64> thread_id, vm::ptr<ppu_thread_param_t> param, u64 arg, u64 arg4, s32 prio, u32 stacksize, u64 flags, vm::ptr<const char> threadname);
+s32 _sys_ppu_thread_create(vm::ptr<u64> thread_id, vm::ptr<ppu_thread_param_t> param, u64 arg, u64 arg4, s32 prio, u32 stacksize, u64 flags, vm::cptr<char> threadname);
 s32 sys_ppu_thread_start(u32 thread_id);
-s32 sys_ppu_thread_rename(u32 thread_id, vm::ptr<const char> name);
+s32 sys_ppu_thread_rename(u32 thread_id, vm::cptr<char> name);

rpcs3/Emu/SysCalls/lv2/sys_process.cpp

@@ -54,7 +54,7 @@ s32 sys_process_exit(s32 status)
 	return CELL_OK;
 }
 
-void sys_game_process_exitspawn(vm::ptr<const char> path, u32 argv_addr, u32 envp_addr, u32 data_addr, u32 data_size, u32 prio, u64 flags)
+void sys_game_process_exitspawn(vm::cptr<char> path, u32 argv_addr, u32 envp_addr, u32 data_addr, u32 data_size, u32 prio, u64 flags)
 {
 	std::string _path = path.get_ptr();
 	const std::string& from = "//";
@@ -80,7 +80,7 @@ void sys_game_process_exitspawn(vm::ptr<const char> path, u32 argv_addr, u32 env
 
 	if (argv_addr)
 	{
-		auto argvp = vm::pptr<const char>::make(argv_addr);
+		auto argvp = vm::cpptr<char>::make(argv_addr);
 		while (argvp && *argvp)
 		{
 			argv.push_back(argvp[0].get_ptr());
@@ -94,7 +94,7 @@ void sys_game_process_exitspawn(vm::ptr<const char> path, u32 argv_addr, u32 env
 
 	if (envp_addr)
 	{
-		auto envp = vm::pptr<const char>::make(envp_addr);
+		auto envp = vm::cpptr<char>::make(envp_addr);
 		while (envp && *envp)
 		{
 			env.push_back(envp[0].get_ptr());
@@ -128,7 +128,7 @@ void sys_game_process_exitspawn(vm::ptr<const char> path, u32 argv_addr, u32 env
 	return;
 }
 
-void sys_game_process_exitspawn2(vm::ptr<const char> path, u32 argv_addr, u32 envp_addr, u32 data_addr, u32 data_size, u32 prio, u64 flags)
+void sys_game_process_exitspawn2(vm::cptr<char> path, u32 argv_addr, u32 envp_addr, u32 data_addr, u32 data_size, u32 prio, u64 flags)
 {
 	std::string _path = path.get_ptr();
 	const std::string& from = "//";
@@ -154,7 +154,7 @@ void sys_game_process_exitspawn2(vm::ptr<const char> path, u32 argv_addr, u32 en
 
 	if (argv_addr)
 	{
-		auto argvp = vm::pptr<const char>::make(argv_addr);
+		auto argvp = vm::cpptr<char>::make(argv_addr);
 		while (argvp && *argvp)
 		{
 			argv.push_back(argvp[0].get_ptr());
@@ -169,7 +169,7 @@ void sys_game_process_exitspawn2(vm::ptr<const char> path, u32 argv_addr, u32 en
 
 	if (envp_addr)
 	{
-		auto envp = vm::pptr<const char>::make(envp_addr);
+		auto envp = vm::cpptr<char>::make(envp_addr);
 		while (envp && *envp)
 		{
 			env.push_back(envp[0].get_ptr());

rpcs3/Emu/SysCalls/lv2/sys_process.h

@@ -44,7 +44,5 @@ s32 sys_process_kill(u32 pid);
 s32 sys_process_wait_for_child(u32 pid, vm::ptr<u32> status, u64 unk);
 s32 sys_process_wait_for_child2(u64 unk1, u64 unk2, u64 unk3, u64 unk4, u64 unk5, u64 unk6);
 s32 sys_process_detach_child(u64 unk);
-void sys_game_process_exitspawn(vm::ptr<const char> path, u32 argv_addr, u32 envp_addr,
+void sys_game_process_exitspawn(vm::cptr<char> path, u32 argv_addr, u32 envp_addr, u32 data_addr, u32 data_size, u32 prio, u64 flags);
-								u32 data_addr, u32 data_size, u32 prio, u64 flags);
+void sys_game_process_exitspawn2(vm::cptr<char> path, u32 argv_addr, u32 envp_addr, u32 data_addr, u32 data_size, u32 prio, u64 flags);
-void sys_game_process_exitspawn2(vm::ptr<const char> path, u32 argv_addr, u32 envp_addr,
-								u32 data_addr, u32 data_size, u32 prio, u64 flags);

rpcs3/Emu/SysCalls/lv2/sys_prx.cpp

@@ -133,14 +133,14 @@ s32 prx_load_module(std::string path, u64 flags, vm::ptr<sys_prx_load_module_opt
 	return Emu.GetIdManager().add(std::move(prx));
 }
 
-s32 sys_prx_load_module(vm::ptr<const char> path, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt)
+s32 sys_prx_load_module(vm::cptr<char> path, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt)
 {
 	sys_prx.Warning("sys_prx_load_module(path=*0x%x, flags=0x%llx, pOpt=*0x%x)", path, flags, pOpt);
 
 	return prx_load_module(path.get_ptr(), flags, pOpt);
 }
 
-s32 sys_prx_load_module_list(s32 count, vm::pptr<const char> path_list, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt, vm::ptr<u32> id_list)
+s32 sys_prx_load_module_list(s32 count, vm::cpptr<char> path_list, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt, vm::ptr<u32> id_list)
 {
 	sys_prx.Warning("sys_prx_load_module_list(count=%d, path_list=*0x%x, flags=0x%llx, pOpt=*0x%x, id_list=*0x%x)", count, path_list, flags, pOpt, id_list);
 

rpcs3/Emu/SysCalls/lv2/sys_prx.h

@@ -39,7 +39,7 @@ struct sys_stub
 	be_t<u16> s_imports;
 	be_t<u32> s_unk2; // = 0x0
 	be_t<u32> s_unk3; // = 0x0
-	vm::bptr<const char> s_modulename;
+	vm::bcptr<char> s_modulename;
 	vm::bptr<u32> s_nid;
 	vm::bptr<u32> s_text;
 	be_t<u32> s_unk4; // = 0x0
@@ -169,8 +169,8 @@ struct lv2_prx_t
 REG_ID_TYPE(lv2_prx_t, 0x23); // SYS_PRX_OBJECT
 
 // SysCalls
-s32 sys_prx_load_module(vm::ptr<const char> path, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt);
+s32 sys_prx_load_module(vm::cptr<char> path, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt);
-s32 sys_prx_load_module_list(s32 count, vm::pptr<const char> path_list, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt, vm::ptr<u32> id_list);
+s32 sys_prx_load_module_list(s32 count, vm::cpptr<char> path_list, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt, vm::ptr<u32> id_list);
 s32 sys_prx_load_module_on_memcontainer();
 s32 sys_prx_load_module_by_fd();
 s32 sys_prx_load_module_on_memcontainer_by_fd();

rpcs3/Emu/SysCalls/lv2/sys_spu.cpp

@@ -58,7 +58,7 @@ s32 sys_spu_initialize(u32 max_usable_spu, u32 max_raw_spu)
 	return CELL_OK;
 }
 
-s32 sys_spu_image_open(vm::ptr<sys_spu_image> img, vm::ptr<const char> path)
+s32 sys_spu_image_open(vm::ptr<sys_spu_image> img, vm::cptr<char> path)
 {
 	sys_spu.Warning("sys_spu_image_open(img_addr=0x%x, path_addr=0x%x [%s])", img.addr(), path.addr(), path.get_ptr());
 

rpcs3/Emu/SysCalls/lv2/sys_spu.h

@@ -59,7 +59,7 @@ enum : s32
 struct sys_spu_thread_group_attribute
 {
 	be_t<u32> nsize; // name length including NULL terminator
-	vm::bptr<const char> name;
+	vm::bcptr<char> name;
 	be_t<s32> type;
 	be_t<u32> ct; // memory container id
 };
@@ -73,7 +73,7 @@ enum : u32
 
 struct sys_spu_thread_attribute
 {
-	vm::bptr<const char> name;
+	vm::bcptr<char> name;
 	be_t<u32> name_len;
 	be_t<u32> option;
 };
@@ -219,7 +219,7 @@ u32 spu_thread_initialize(u32 group, u32 spu_num, vm::ptr<sys_spu_image> img, co
 
 // SysCalls
 s32 sys_spu_initialize(u32 max_usable_spu, u32 max_raw_spu);
-s32 sys_spu_image_open(vm::ptr<sys_spu_image> img, vm::ptr<const char> path);
+s32 sys_spu_image_open(vm::ptr<sys_spu_image> img, vm::cptr<char> path);
 s32 sys_spu_thread_initialize(vm::ptr<u32> thread, u32 group, u32 spu_num, vm::ptr<sys_spu_image> img, vm::ptr<sys_spu_thread_attribute> attr, vm::ptr<sys_spu_thread_argument> arg);
 s32 sys_spu_thread_set_argument(u32 id, vm::ptr<sys_spu_thread_argument> arg);
 s32 sys_spu_thread_group_create(vm::ptr<u32> id, u32 num, s32 prio, vm::ptr<sys_spu_thread_group_attribute> attr);

rpcs3/Emu/SysCalls/lv2/sys_timer.cpp

@@ -59,11 +59,11 @@ lv2_timer_t::~lv2_timer_t()
 	thread.join();
 }
 
-s32 sys_timer_create(vm::ref<u32> timer_id)
+s32 sys_timer_create(vm::ptr<u32> timer_id)
 {
 	sys_timer.Warning("sys_timer_create(timer_id=*0x%x)", timer_id);
 
-	timer_id = Emu.GetIdManager().make<lv2_timer_t>();
+	*timer_id = Emu.GetIdManager().make<lv2_timer_t>();
 
 	return CELL_OK;
 }

rpcs3/Emu/SysCalls/lv2/sys_timer.h

@@ -40,7 +40,7 @@ struct lv2_timer_t
 
 REG_ID_TYPE(lv2_timer_t, 0x11); // SYS_TIMER_OBJECT
 
-s32 sys_timer_create(vm::ref<u32> timer_id);
+s32 sys_timer_create(vm::ptr<u32> timer_id);
 s32 sys_timer_destroy(u32 timer_id);
 s32 sys_timer_get_information(u32 timer_id, vm::ptr<sys_timer_information_t> info);
 s32 _sys_timer_start(u32 timer_id, u64 basetime, u64 period); // basetime type changed from s64

rpcs3/Emu/SysCalls/lv2/sys_tty.cpp

@@ -18,7 +18,7 @@ s32 sys_tty_read(s32 ch, vm::ptr<void> buf, u32 len, vm::ptr<u32> preadlen)
 	return CELL_OK;
 }
 
-s32 sys_tty_write(s32 ch, vm::ptr<const void> buf, u32 len, vm::ptr<u32> pwritelen)
+s32 sys_tty_write(s32 ch, vm::cptr<void> buf, u32 len, vm::ptr<u32> pwritelen)
 {
 	sys_tty.Log("sys_tty_write(ch=%d, buf_addr=0x%x, len=%d, preadlen_addr=0x%x)", ch, buf.addr(), len, pwritelen.addr());
 

rpcs3/Emu/SysCalls/lv2/sys_tty.h

@@ -26,4 +26,4 @@ enum
 
 // SysCalls
 s32 sys_tty_read(s32 ch, vm::ptr<void> buf, u32 len, vm::ptr<u32> preadlen);
-s32 sys_tty_write(s32 ch, vm::ptr<const void> buf, u32 len, vm::ptr<u32> pwritelen);
+s32 sys_tty_write(s32 ch, vm::cptr<void> buf, u32 len, vm::ptr<u32> pwritelen);

rpcs3/Loader/ELF32.cpp

@@ -299,7 +299,7 @@ namespace loader
 
 						u32 data = 0;
 
-						for (auto code = vm::ptr<const u32>::make(shdr.data_le.sh_addr); code.addr() < shdr.data_le.sh_addr + shdr.data_le.sh_size; code++)
+						for (auto code = vm::cptr<u32>::make(shdr.data_le.sh_addr); code.addr() < shdr.data_le.sh_addr + shdr.data_le.sh_size; code++)
 						{
 							switch (*code)
 							{

rpcs3/Loader/ELF64.cpp

@@ -365,7 +365,7 @@ namespace loader
 							{
 								for (auto &e : m.second.exports)
 								{
-									auto code = vm::ptr<const u32>::make(vm::check_addr(e.second, 8) ? vm::read32(e.second) : 0);
+									auto code = vm::cptr<u32>::make(vm::check_addr(e.second, 8) ? vm::read32(e.second) : 0);
 
 									bool is_empty = !code || (code[0] == 0x38600000 && code[1] == BLR());