mirrors/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-04-21 20:15:27 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

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

Browse source
This commit is contained in:
Nekotekina 2015-06-22 01:27:58 +03:00
parent e896da8064
commit 317417d541
97 changed files with 781 additions and 781 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
rpcs3/Emu/ARMv7/Modules/sceAppUtil.cpp
View file

@ -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__;
}

2
rpcs3/Emu/ARMv7/Modules/sceAppUtil.h
View file

@ -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;

16
rpcs3/Emu/ARMv7/Modules/sceCommonDialog.cpp
View file

@ -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__;
}

18
rpcs3/Emu/ARMv7/Modules/sceCommonDialog.h
View file

@ -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::lptr<const char> appSubDir;
vm::lcptr<SceAppUtilSaveDataMountPoint> mountPoint;
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;

2
rpcs3/Emu/ARMv7/Modules/sceCtrl.cpp
View file

@ -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__;
}

4
rpcs3/Emu/ARMv7/Modules/sceDbg.cpp
View file

@ -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__;
}

4
rpcs3/Emu/ARMv7/Modules/sceDeci4p.cpp
View file

@ -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__;
}

26
rpcs3/Emu/ARMv7/Modules/sceDeflt.cpp
View file

@ -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__;
}

2
rpcs3/Emu/ARMv7/Modules/sceDisplay.cpp
View file

@ -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__;
}

2
rpcs3/Emu/ARMv7/Modules/sceFiber.cpp
View file

@ -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__;
}

166
rpcs3/Emu/ARMv7/Modules/sceFios.cpp
View file

@ -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__;
}

244
rpcs3/Emu/ARMv7/Modules/sceGxm.cpp
View file

@ -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__;
}

38
rpcs3/Emu/ARMv7/Modules/sceHttp.cpp
View file

@ -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__;
}

4
rpcs3/Emu/ARMv7/Modules/sceIme.cpp
View file

@ -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__;
}

8
rpcs3/Emu/ARMv7/Modules/sceJpeg.cpp
View file

@ -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,

4
rpcs3/Emu/ARMv7/Modules/sceJpegEnc.cpp
View file

@ -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)
{

64
rpcs3/Emu/ARMv7/Modules/sceLibKernel.cpp
View file

@ -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__;
}

4
rpcs3/Emu/ARMv7/Modules/sceMd5.cpp
View file

@ -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__;
}

32
rpcs3/Emu/ARMv7/Modules/sceNet.cpp
View file

@ -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__;
}

62
rpcs3/Emu/ARMv7/Modules/sceNgs.cpp
View file

@ -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__;
}

2
rpcs3/Emu/ARMv7/Modules/sceNgs.h
View file

@ -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;

14
rpcs3/Emu/ARMv7/Modules/sceNpBasic.cpp
View file

@ -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__;
}

12
rpcs3/Emu/ARMv7/Modules/sceNpCommon.cpp
View file

@ -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__;
}

12
rpcs3/Emu/ARMv7/Modules/sceNpCommon.h
View file

@ -28,9 +28,9 @@ struct SceNpCommunicationSignature
struct SceNpCommunicationConfig
{
vm::lptr<const SceNpCommunicationId> commId;
vm::lptr<const SceNpCommunicationPassphrase> commPassphrase;
vm::lptr<const SceNpCommunicationSignature> commSignature;
vm::lcptr<SceNpCommunicationId> commId;
vm::lcptr<SceNpCommunicationPassphrase> commPassphrase;
vm::lcptr<SceNpCommunicationSignature> commSignature;
};
struct SceNpCountryCode
@ -123,10 +123,10 @@ struct SceNpAuthRequestParameter
{
le_t<u32> size;
SceNpTicketVersion version;
vm::lptr<const char> serviceId;
vm::lptr<const void> cookie;
vm::lcptr<char> serviceId;
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;

2
rpcs3/Emu/ARMv7/Modules/sceNpManager.cpp
View file

@ -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__;
}

44
rpcs3/Emu/ARMv7/Modules/sceNpMatching.cpp
View file

@ -17,9 +17,9 @@ s32 sceNpMatching2Term()
}
s32 sceNpMatching2CreateContext(
vm::ptr<const SceNpId> npId,
vm::ptr<const SceNpCommunicationId> commId,
vm::ptr<const SceNpCommunicationPassphrase> passPhrase,
vm::cptr<SceNpId> npId,
vm::cptr<SceNpCommunicationId> commId,
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::ptr<const SceNpMatching2RequestOptParam> optParam,
vm::cptr<SceNpMatching2GetWorldInfoListRequest> reqParam,
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::ptr<const SceNpMatching2RequestOptParam> optParam,
vm::cptr<SceNpMatching2CreateJoinRoomRequest> reqParam,
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::ptr<const SceNpMatching2RequestOptParam> optParam,
vm::cptr<SceNpMatching2SearchRoomRequest> reqParam,
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::ptr<const SceNpMatching2RequestOptParam> optParam,
vm::cptr<SceNpMatching2JoinRoomRequest> reqParam,
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::ptr<const SceNpMatching2RequestOptParam> optParam,
vm::cptr<SceNpMatching2LeaveRoomRequest> reqParam,
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::ptr<const SceNpMatching2RequestOptParam> optParam,
vm::cptr<SceNpMatching2SetRoomDataExternalRequest> reqParam,
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::ptr<const SceNpMatching2RequestOptParam> optParam,
vm::cptr<SceNpMatching2KickoutRoomMemberRequest> reqParam,
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::ptr<const SceNpMatching2RequestOptParam> optParam,
vm::cptr<SceNpMatching2SendRoomChatMessageRequest> reqParam,
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::ptr<const SceNpMatching2RequestOptParam> optParam,
vm::cptr<SceNpMatching2SendRoomMessageRequest> reqParam,
vm::cptr<SceNpMatching2RequestOptParam> optParam,
vm::ptr<u32> assignedReqId)
{
throw __FUNCTION__;

4
rpcs3/Emu/ARMv7/Modules/sceNpMatching.h
View file

@ -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;
};

38
rpcs3/Emu/ARMv7/Modules/sceNpScore.cpp
View file

@ -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::ptr<const SceNpScoreGameInfo> gameInfo,
vm::cptr<SceNpScoreComment> scoreComment,
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::ptr<const SceNpScoreGameInfo> gameInfo,
vm::cptr<SceNpScoreComment> scoreComment,
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__;
}

14
rpcs3/Emu/ARMv7/Modules/sceNpUtility.cpp
View file

@ -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__;
}

8
rpcs3/Emu/ARMv7/Modules/scePhotoExport.cpp
View file

@ -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::ptr<const ScePhotoExportParam> param,
vm::cptr<char> photodataPath,
vm::cptr<ScePhotoExportParam> param,
vm::ptr<void> workMemory,
vm::ptr<ScePhotoExportCancelFunc> cancelFunc,
vm::ptr<void> userdata,

4
rpcs3/Emu/ARMv7/Modules/sceRazorCapture.cpp
View file

@ -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__;
}

50
rpcs3/Emu/ARMv7/Modules/sceRtc.cpp
View file

@ -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__;
}

10
rpcs3/Emu/ARMv7/Modules/sceSas.cpp
View file

@ -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__;
}

4
rpcs3/Emu/ARMv7/Modules/sceScreenShot.cpp
View file

@ -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__;
}

2
rpcs3/Emu/ARMv7/Modules/sceSsl.cpp
View file

@ -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__;
}

14
rpcs3/Emu/ARMv7/Modules/sceSulpha.cpp
View file

@ -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__;
}

16
rpcs3/Emu/ARMv7/Modules/sceSystemGesture.cpp
View file

@ -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__;
}

52
rpcs3/Emu/ARMv7/Modules/sceUlt.cpp
View file

@ -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__;

8
rpcs3/Emu/ARMv7/Modules/sceVideodec.cpp
View file

@ -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__;
}

6
rpcs3/Emu/ARMv7/Modules/sceVoice.cpp
View file

@ -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__;
}

6
rpcs3/Emu/ARMv7/Modules/sceVoiceQoS.cpp
View file

@ -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__;
}

8
rpcs3/Emu/Memory/vm_ptr.h
View file

@ -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 };

4
rpcs3/Emu/SysCalls/Modules.cpp
View file

@ -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) &&

4
rpcs3/Emu/SysCalls/Modules/cellAdec.cpp
View file

@ -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;

20
rpcs3/Emu/SysCalls/Modules/cellDmux.cpp
View file

@ -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);

2
rpcs3/Emu/SysCalls/Modules/cellFont.cpp
View file

@ -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)",

36
rpcs3/Emu/SysCalls/Modules/cellFs.cpp
View file

@ -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());

10
rpcs3/Emu/SysCalls/Modules/cellGame.cpp
View file

@ -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);

12
rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
View file

@ -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);

2
rpcs3/Emu/SysCalls/Modules/cellGifDec.h
View file

@ -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;

4
rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
View file

@ -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);

2
rpcs3/Emu/SysCalls/Modules/cellJpgDec.h
View file

@ -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;

6
rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
View file

@ -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());

4
rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp
View file

@ -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);

2
rpcs3/Emu/SysCalls/Modules/cellOvis.cpp
View file

@ -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;

2
rpcs3/Emu/SysCalls/Modules/cellPamf.cpp
View file

@ -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);

4
rpcs3/Emu/SysCalls/Modules/cellPamf.h
View file

@ -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);

44
rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
View file

@ -19,8 +19,8 @@ extern Module cellPngDec;
s32 pngDecCreate(
vm::ptr<CellPngDecMainHandle> mainHandle,
vm::ptr<const CellPngDecThreadInParam> param,
vm::ptr<const CellPngDecExtThreadInParam> ext = vm::null)
vm::cptr<CellPngDecThreadInParam> param,
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::ptr<const CellPngDecOpnParam> param = vm::null)
vm::cptr<CellPngDecCbCtrlStrm> cb = 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::ptr<const CellPngDecOpnParam> opnParam)
vm::cptr<CellPngDecCbCtrlStrm> cbCtrlStrm,
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)",

2
rpcs3/Emu/SysCalls/Modules/cellPngDec.h
View file

@ -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;

4
rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
View file

@ -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());

6
rpcs3/Emu/SysCalls/Modules/cellSail.cpp
View file

@ -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);

22
rpcs3/Emu/SysCalls/Modules/cellSaveData.cpp
View file

@ -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,

52
rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
View file

@ -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::ptr<const char> nameInstance,
vm::cptr<char> nameClass,
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,
u32 max_contention, vm::ptr<const char> name, u32 size, s32 enable_clear_ls)
s32 spursCreateTaskset(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, u64 args, vm::cptr<u8[8]> priority,
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)),
attr->max_contention, vm::ptr<const char>::make(attr->name.addr()), attr->taskset_size, attr->enable_clear_ls);
auto rc = spursCreateTaskset(spurs, taskset, attr->args, vm::cptr<u8[8]>::make(attr.addr() + offsetof(CellSpursTasksetAttribute, priority)),
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);

2
rpcs3/Emu/SysCalls/Modules/cellSpurs.h
View file

@ -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

16
rpcs3/Emu/SysCalls/Modules/cellSync.cpp
View file

@ -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);

8
rpcs3/Emu/SysCalls/Modules/cellSync2.cpp
View file

@ -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());

2
rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
View file

@ -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());

26
rpcs3/Emu/SysCalls/Modules/cellSysutil.h
View file

@ -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;
typedef vm::ptr<void> CellWebBrowserClientSession;
typedef void(CellWebBrowserCallback)(s32 cb_type, CellWebBrowserClientSession, 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);
using CellWebBrowserCallback = func_def<void(s32 cb_type, vm::ptr<void> client_session, vm::ptr<void> usrdata)>;
using CellWebComponentCallback = func_def<void(s32 web_browser_id, s32 cb_type, vm::ptr<void> client_session, vm::ptr<void> usrdata)>;
using CellWebBrowserSystemCallback = func_def<void(s32 cb_type, vm::ptr<void> usrdata)>;
typedef void(CellWebBrowserMIMETypeCallback)(vm::ptr<const char> mimetype, vm::ptr<const char> url, vm::ptr<void> usrdata);
typedef void(CellWebBrowserErrorCallback)(s32 err_type, vm::ptr<void> usrdata);
typedef void(CellWebBrowserStatusCallback)(s32 err_type, vm::ptr<void> usrdata);
typedef void(CellWebBrowserNotify)(vm::ptr<const char> message, vm::ptr<void> usrdata);
typedef void(CellWebBrowserUsrdata)(vm::ptr<void> usrdata);
using CellWebBrowserMIMETypeCallback = func_def<void(vm::cptr<char> mimetype, vm::cptr<char> url, vm::ptr<void> usrdata)>;
using CellWebBrowserErrorCallback = func_def<void(s32 err_type, vm::ptr<void> usrdata)>;
using CellWebBrowserStatusCallback = func_def<void(s32 err_type, vm::ptr<void> usrdata)>;
using CellWebBrowserNotify = func_def<void(vm::cptr<char> message, vm::ptr<void> usrdata)>;
using CellWebBrowserUsrdata = func_def<void(vm::ptr<void> usrdata)>;
struct CellWebBrowserMimeSet
{
const vm::bptr<const char> type;
const vm::bptr<const char> directory;
vm::bcptr<char> type;
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;

14
rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
View file

@ -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);

8
rpcs3/Emu/SysCalls/Modules/cellVpost.cpp
View file

@ -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);

2
rpcs3/Emu/SysCalls/Modules/libmixer.cpp
View file

@ -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());

14
rpcs3/Emu/SysCalls/Modules/sceNp.cpp
View file

@ -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());

4
rpcs3/Emu/SysCalls/Modules/sceNpClans.cpp
View file

@ -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);

2
rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
View file

@ -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);

36
rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
View file

@ -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);

2
rpcs3/Emu/SysCalls/Modules/sys_libc.cpp
View file

@ -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);

10
rpcs3/Emu/SysCalls/Modules/sys_net.cpp
View file

@ -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);

4
rpcs3/Emu/SysCalls/lv2/sys_cond.cpp
View file

@ -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;
}

2
rpcs3/Emu/SysCalls/lv2/sys_cond.h
View file

@ -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);

12
rpcs3/Emu/SysCalls/lv2/sys_event.cpp
View file

@ -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;
}

6
rpcs3/Emu/SysCalls/lv2/sys_event.h
View file

@ -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);

22
rpcs3/Emu/SysCalls/lv2/sys_fs.cpp
View file

@ -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());

22
rpcs3/Emu/SysCalls/lv2/sys_fs.h
View file

@ -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_rename(vm::ptr<const char> from, vm::ptr<const char> to);
s32 sys_fs_rmdir(vm::ptr<const char> path);
s32 sys_fs_unlink(vm::ptr<const char> path);
s32 sys_fs_mkdir(vm::cptr<char> path, s32 mode);
s32 sys_fs_rename(vm::cptr<char> from, vm::cptr<char> to);
s32 sys_fs_rmdir(vm::cptr<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_truncate(vm::ptr<const char> path, u64 size);
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::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);

4
rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.cpp
View file

@ -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);

4
rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.h
View file

@ -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);

12
rpcs3/Emu/SysCalls/lv2/sys_process.cpp
View file

@ -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());

6
rpcs3/Emu/SysCalls/lv2/sys_process.h
View file

@ -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,
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);
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);
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);

4
rpcs3/Emu/SysCalls/lv2/sys_prx.cpp
View file

@ -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);

6
rpcs3/Emu/SysCalls/lv2/sys_prx.h
View file

@ -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_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(vm::cptr<char> path, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt);
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();

2
rpcs3/Emu/SysCalls/lv2/sys_spu.cpp
View file

@ -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());

6
rpcs3/Emu/SysCalls/lv2/sys_spu.h
View file

@ -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);

4
rpcs3/Emu/SysCalls/lv2/sys_timer.cpp
View file

@ -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;
}

2
rpcs3/Emu/SysCalls/lv2/sys_timer.h
View file

@ -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

2
rpcs3/Emu/SysCalls/lv2/sys_tty.cpp
View file

@ -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());

2
rpcs3/Emu/SysCalls/lv2/sys_tty.h
View file

@ -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);

2
rpcs3/Loader/ELF32.cpp
View file

@ -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)
{

2
rpcs3/Loader/ELF64.cpp
View file

@ -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());