ShuriZma
/
rpcs3
mirror of https://github.com/RPCS3/rpcs3.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/master' into spurs_taskset 

Conflicts:
	rpcs3/emucore.vcxproj.filters
This commit is contained in:
S Gopal Rajagopal 2015-02-03 23:12:26 +05:30
parent 0191955ab6 32fd9223ff
commit d1a7c85e95
184 changed files with 24421 additions and 5225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
README.md
View File

@ -2,11 +2,14 @@ RPCS3
=====
[![Build Status](https://travis-ci.org/DHrpcs3/rpcs3.svg?branch=master)](https://travis-ci.org/DHrpcs3/rpcs3)
<a href="https://scan.coverity.com/projects/3960">
<img alt="Coverity Scan Build Status"
src="https://scan.coverity.com/projects/3960/badge.svg"/>
</a>
[![Coverage Status](https://coveralls.io/repos/DHrpcs3/rpcs3/badge.svg)](https://coveralls.io/r/DHrpcs3/rpcs3)
An open-source PlayStation 3 emulator/debugger written in C++.
You can find some basic information in the [FAQ](https://github.com/DHrpcs3/rpcs3/wiki/FAQ). For discussion about this emulator and PS3 emulation please visit the [official forums](http://www.emunewz.net/forum/forumdisplay.php?fid=162).

48
Utilities/BEType.h
View File

@ -708,7 +708,7 @@ class to_be_t
public:
//true if need swap endianes for be
static const bool value = (sizeof(T2) > 1) && (std::is_arithmetic<T>::value || std::is_enum<T>::value);
static const bool value = std::is_arithmetic<T>::value || std::is_enum<T>::value;
//be_t<T, size> if need swap endianes, T otherwise
typedef typename _be_type_selector< T, T2, value >::type type;
@ -716,26 +716,58 @@ public:
typedef typename _be_type_selector< T, T2, !is_be_t<T, T2>::value >::type forced_type;
};
template<typename T, typename T2>
class to_be_t<T, const T2>
{
public:
static const bool value = to_be_t<T, T2>::value;
typedef const typename to_be_t<T, T2>::type type;
typedef const typename to_be_t<T, T2>::forced_type forced_type;
};
template<typename T>
class to_be_t<T, void>
{
public:
//true if need swap endianes for be
static const bool value = false;
//be_t<T, size> if need swap endianes, T otherwise
typedef void type;
typedef void forced_type;
};
template<typename T>
class to_be_t<T, const void>
class to_be_t<T, u8>
{
public:
//true if need swap endianes for be
static const bool value = false;
typedef u8 type;
typedef u8 forced_type;
};
//be_t<T, size> if need swap endianes, T otherwise
typedef const void type;
template<typename T>
class to_be_t<T, s8>
{
public:
static const bool value = false;
typedef s8 type;
typedef s8 forced_type;
};
template<typename T>
class to_be_t<T, char>
{
public:
static const bool value = false;
typedef char type;
typedef char forced_type;
};
template<typename T>
class to_be_t<T, bool>
{
public:
static const bool value = false;
typedef bool type;
typedef bool forced_type;
};
template<typename T, typename T2 = T>

6
Utilities/GNU.h
View File

@ -14,6 +14,12 @@
#define __noinline __attribute__((noinline))
#endif
#ifdef _WIN32
#define __safebuffers __declspec(safebuffers)
#else
#define __safebuffers
#endif
template<size_t size>
void strcpy_trunc(char(&dst)[size], const std::string& src)
{

2
Utilities/Log.h
View File

@ -132,5 +132,5 @@ void log_message(Log::LogType type, Log::LogSeverity sev, std::string text);
template<typename... Targs>
__noinline void log_message(Log::LogType type, Log::LogSeverity sev, const char* fmt, Targs... args)
{
log_message(type, sev, fmt::detail::format(fmt, strlen(fmt), fmt::do_unveil(args)...));
log_message(type, sev, fmt::detail::format(fmt, fmt::do_unveil(args)...));
}

16
Utilities/StrFmt.cpp
View File

@ -96,9 +96,9 @@ size_t fmt::detail::get_fmt_len(const char* fmt, size_t len)
fmt += 2;
len -= 2;
if (fmt[1] == '1')
if (fmt[0] == '1')
{
assert(len >= 3 && fmt[2] - '0' < 7);
assert(len >= 3 && fmt[1] - '0' < 7);
res++;
fmt++;
len--;
@ -144,8 +144,9 @@ size_t fmt::detail::get_fmt_precision(const char* fmt, size_t len)
return 1;
}
std::string fmt::detail::format(const char* fmt, size_t len)
std::string fmt::detail::format(const char* fmt)
{
const size_t len = strlen(fmt);
const size_t fmt_start = get_fmt_start(fmt, len);
if (fmt_start != len)
{
@ -157,7 +158,7 @@ std::string fmt::detail::format(const char* fmt, size_t len)
extern const std::string fmt::placeholder = "???";
std::string replace_first(const std::string& src, const std::string& from, const std::string& to)
std::string fmt::replace_first(const std::string& src, const std::string& from, const std::string& to)
{
auto pos = src.find(from);
@ -169,11 +170,12 @@ std::string replace_first(const std::string& src, const std::string& from, const
return (pos ? src.substr(0, pos) + to : to) + std::string(src.c_str() + pos + from.length());
}
std::string replace_all(std::string src, const std::string& from, const std::string& to)
std::string fmt::replace_all(const std::string &src, const std::string& from, const std::string& to)
{
for (auto pos = src.find(from); pos != std::string::npos; src.find(from, pos + 1))
std::string target = src;
for (auto pos = target.find(from); pos != std::string::npos; pos = target.find(from, pos + 1))
{
src = (pos ? src.substr(0, pos) + to : to) + std::string(src.c_str() + pos + from.length());
target = (pos ? target.substr(0, pos) + to : to) + std::string(target.c_str() + pos + from.length());
pos += to.length();
}

137
Utilities/StrFmt.h
View File

@ -123,7 +123,7 @@ namespace fmt
}
std::string replace_first(const std::string& src, const std::string& from, const std::string& to);
std::string replace_all(std::string src, const std::string& from, const std::string& to);
std::string replace_all(const std::string &src, const std::string& from, const std::string& to);
template<size_t list_size>
std::string replace_all(std::string src, const std::pair<std::string, std::string>(&list)[list_size])
@ -198,7 +198,7 @@ namespace fmt
{
return to_hex(arg, get_fmt_precision(fmt, len));
}
else if (fmt[len - 1] == 'd')
else if (fmt[len - 1] == 'd' || fmt[len - 1] == 'u')
{
return to_udec(arg);
}
@ -206,8 +206,6 @@ namespace fmt
{
throw "Invalid formatting (u8): " + std::string(fmt, len);
}
return{};
}
};
@ -220,7 +218,7 @@ namespace fmt
{
return to_hex(arg, get_fmt_precision(fmt, len));
}
else if (fmt[len - 1] == 'd')
else if (fmt[len - 1] == 'd' || fmt[len - 1] == 'u')
{
return to_udec(arg);
}
@ -228,8 +226,6 @@ namespace fmt
{
throw "Invalid formatting (u16): " + std::string(fmt, len);
}
return{};
}
};
@ -242,7 +238,7 @@ namespace fmt
{
return to_hex(arg, get_fmt_precision(fmt, len));
}
else if (fmt[len - 1] == 'd')
else if (fmt[len - 1] == 'd' || fmt[len - 1] == 'u')
{
return to_udec(arg);
}
@ -250,8 +246,6 @@ namespace fmt
{
throw "Invalid formatting (u32): " + std::string(fmt, len);
}
return{};
}
};
@ -264,7 +258,7 @@ namespace fmt
{
return to_hex(arg, get_fmt_precision(fmt, len));
}
else if (fmt[len - 1] == 'd')
else if (fmt[len - 1] == 'd' || fmt[len - 1] == 'u')
{
return to_udec(arg);
}
@ -272,8 +266,6 @@ namespace fmt
{
throw "Invalid formatting (u64): " + std::string(fmt, len);
}
return{};
}
};
@ -294,8 +286,6 @@ namespace fmt
{
throw "Invalid formatting (s8): " + std::string(fmt, len);
}
return{};
}
};
@ -316,8 +306,6 @@ namespace fmt
{
throw "Invalid formatting (s16): " + std::string(fmt, len);
}
return{};
}
};
@ -338,8 +326,6 @@ namespace fmt
{
throw "Invalid formatting (s32): " + std::string(fmt, len);
}
return{};
}
};
@ -360,8 +346,6 @@ namespace fmt
{
throw "Invalid formatting (s64): " + std::string(fmt, len);
}
return{};
}
};
@ -382,8 +366,6 @@ namespace fmt
{
throw "Invalid formatting (float): " + std::string(fmt, len);
}
return{};
}
};
@ -404,8 +386,6 @@ namespace fmt
{
throw "Invalid formatting (double): " + std::string(fmt, len);
}
return{};
}
};
@ -418,7 +398,7 @@ namespace fmt
{
return to_hex(arg, get_fmt_precision(fmt, len));
}
else if (fmt[len - 1] == 'd')
else if (fmt[len - 1] == 'd' || fmt[len - 1] == 'u')
{
return arg ? "1" : "0";
}
@ -430,26 +410,6 @@ namespace fmt
{
throw "Invalid formatting (bool): " + std::string(fmt, len);
}
return{};
}
};
template<>
struct get_fmt<char*>
{
static std::string text(const char* fmt, size_t len, char* arg)
{
if (fmt[len - 1] == 's')
{
return arg;
}
else
{
throw "Invalid formatting (char*): " + std::string(fmt, len);
}
return{};
}
};
@ -466,75 +426,20 @@ namespace fmt
{
throw "Invalid formatting (const char*): " + std::string(fmt, len);
}
return{};
}
};
//template<size_t size>
//struct get_fmt<char[size], false>
//{
// static std::string text(const char* fmt, size_t len, const char(&arg)[size])
// {
// if (fmt[len - 1] == 's')
// {
// return std::string(arg, size);
// }
// else
// {
// throw "Invalid formatting (char[size]): " + std::string(fmt, len);
// }
// return{};
// }
//};
//template<size_t size>
//struct get_fmt<const char[size], false>
//{
// static std::string text(const char* fmt, size_t len, const char(&arg)[size])
// {
// if (fmt[len - 1] == 's')
// {
// return std::string(arg, size);
// }
// else
// {
// throw "Invalid formatting (const char[size]): " + std::string(fmt, len);
// }
// return{};
// }
//};
template<>
struct get_fmt<std::string>
{
static std::string text(const char* fmt, size_t len, const std::string& arg)
{
if (fmt[len - 1] == 's')
{
return arg;
}
else
{
throw "Invalid formatting (std::string): " + std::string(fmt, len);
}
return{};
}
};
std::string format(const char* fmt, size_t len); // terminator
std::string format(const char* fmt); // terminator
template<typename T, typename... Args>
std::string format(const char* fmt, size_t len, const T& arg, Args... args)
std::string format(const char* fmt, const T& arg, Args... args)
{
const size_t len = strlen(fmt);
const size_t fmt_start = get_fmt_start(fmt, len);
const size_t fmt_len = get_fmt_len(fmt + fmt_start, len - fmt_start);
const size_t fmt_end = fmt_start + fmt_len;
return std::string(fmt, fmt_start) + get_fmt<T>::text(fmt + fmt_start, fmt_len, arg) + format(fmt + fmt_end, len - fmt_end, args...);
return std::string(fmt, fmt_start) + get_fmt<T>::text(fmt + fmt_start, fmt_len, arg) + format(fmt + fmt_end, args...);
}
};
@ -549,6 +454,17 @@ namespace fmt
}
};
template<>
struct unveil<char*, false>
{
typedef const char* result_type;
__forceinline static result_type get_value(const char* arg)
{
return arg;
}
};
template<size_t N>
struct unveil<const char[N], false>
{
@ -563,11 +479,11 @@ namespace fmt
template<>
struct unveil<std::string, false>
{
typedef const std::string& result_type;
typedef const char* result_type;
__forceinline static result_type get_value(const std::string& arg)
{
return arg;
return arg.c_str();
}
};
@ -613,8 +529,9 @@ namespace fmt
float (%x, %f)
double (%x, %f)
bool (%x, %d, %s)
char*, const char*, std::string (%s)
char* (%s)
std::string forced to .c_str() (fmt::unveil)
be_t<> of any appropriate type in this list (fmt::unveil)
enum of any appropriate type in this list (fmt::unveil)
@ -635,9 +552,9 @@ namespace fmt
Other features are not supported.
*/
template<typename... Args>
__forceinline std::string format(const char* fmt, Args... args)
__forceinline __safebuffers std::string format(const char* fmt, Args... args)
{
return detail::format(fmt, strlen(fmt), do_unveil(args)...);
return detail::format(fmt, do_unveil(args)...);
}
//convert a wxString to a std::string encoded in utf8

1
Utilities/rFile.cpp
View File

@ -1,5 +1,6 @@
#include "stdafx.h"
#include "Log.h"
#pragma warning(disable : 4996)
#include <wx/dir.h>
#include <wx/file.h>
#include <wx/filename.h>

1
Utilities/rMsgBox.cpp
View File

@ -1,5 +1,6 @@
#include "stdafx.h"
#include "restore_new.h"
#pragma warning(disable : 4996)
#include <wx/msgdlg.h>
#include "define_new_memleakdetect.h"
#include "rMsgBox.h"

1
Utilities/rPlatform.cpp
View File

@ -1,5 +1,6 @@
#include "stdafx.h"
#include "restore_new.h"
#pragma warning(disable : 4996)
#include <wx/image.h>
#include "define_new_memleakdetect.h"

2
Utilities/rTime.cpp
View File

@ -1,6 +1,6 @@
#include "stdafx.h"
#include "rTime.h"
#pragma warning(disable : 4996)
#include <wx/datetime.h>
std::string rDefaultDateTimeFormat = "%c";

1
rpcs3/Crypto/unpkg.cpp
View File

@ -5,6 +5,7 @@
#include "key_vault.h"
#include "unpkg.h"
#include "restore_new.h"
#pragma warning(disable : 4996)
#include <wx/progdlg.h>
#include "define_new_memleakdetect.h"

2
rpcs3/Crypto/unself.cpp
View File

@ -6,7 +6,7 @@
#include "utils.h"
#include "Emu/FS/vfsLocalFile.h"
#include "unself.h"
#pragma warning(disable : 4996)
#include <wx/mstream.h>
#include <wx/zstream.h>

18
rpcs3/Emu/ARMv7/ARMv7Callback.h Normal file
View File

@ -0,0 +1,18 @@
#pragma once
#include "Emu/Memory/Memory.h"
#include "Emu/ARMv7/PSVFuncList.h"
namespace vm
{
template<typename AT, typename RT, typename... T>
__forceinline RT _ptr_base<RT(T...), 1, AT>::operator()(ARMv7Context& context, T... args) const
{
return psv_func_detail::func_caller<RT, T...>::call(context, vm::cast(this->addr()), args...);
}
}
template<typename RT, typename... T>
__forceinline RT cb_call(ARMv7Context& context, u32 addr, T... args)
{
return psv_func_detail::func_caller<RT, T...>::call(context, addr, args...);
}

299
rpcs3/Emu/ARMv7/ARMv7Context.h Normal file
View File

@ -0,0 +1,299 @@
#pragma once
class ARMv7Thread;
enum ARMv7InstructionSet
{
ARM,
Thumb,
Jazelle,
ThumbEE
};
struct ARMv7Context
{
ARMv7Thread& thread;
ARMv7Context(ARMv7Thread& thread) : thread(thread) {}
void write_pc(u32 value);
u32 read_pc();
u32 get_stack_arg(u32 pos);
void fast_call(u32 addr);
union
{
u32 GPR[15];
struct
{
u32 pad[13];
union
{
u32 SP;
struct { u16 SP_main, SP_process; };
};
u32 LR;
union
{
struct
{
u32 reserved0 : 16;
u32 GE : 4;
u32 reserved1 : 4;
u32 dummy : 3;
u32 Q : 1; // Set to 1 if an SSAT or USAT instruction changes (saturates) the input value for the signed or unsigned range of the result
u32 V : 1; // Overflow condition code flag
u32 C : 1; // Carry condition code flag
u32 Z : 1; // Zero condition code flag
u32 N : 1; // Negative condition code flag
};
u32 APSR;
} APSR;
};
struct
{
u64 GPR_D[8];
};
};
union
{
struct
{
u32 dummy : 24;
u32 exception : 8;
};
u32 IPSR;
} IPSR;
ARMv7InstructionSet ISET;
union
{
struct
{
u8 shift_state : 5;
u8 cond_base : 3;
};
struct
{
u8 check_state : 4;
u8 condition : 4;
};
u8 IT;
u32 advance()
{
const u32 res = check_state ? condition : 0xe /* always true */;
shift_state <<= 1;
if (!check_state)
{
IT = 0; // clear
}
return res;
}
operator bool() const
{
return check_state;
}
} ITSTATE;
u32 TLS;
u32 R_ADDR;
u64 R_DATA;
struct perf_counter
{
u32 event;
u32 value;
};
std::array<perf_counter, 6> counters;
void write_gpr(u32 n, u32 value)
{
assert(n < 16);
if (n < 15)
{
GPR[n] = value;
}
else
{
write_pc(value);
}
}
u32 read_gpr(u32 n)
{
assert(n < 16);
if (n < 15)
{
return GPR[n];
}
return read_pc();
}
// function for processing va_args in printf-like functions
u32 get_next_gpr_arg(u32& g_count, u32& f_count, u32& v_count)
{
assert(!f_count && !v_count); // not supported
if (g_count < 4)
{
return GPR[g_count++];
}
else
{
return get_stack_arg(g_count++);
}
}
};
template<typename T, bool is_enum = std::is_enum<T>::value>
struct cast_armv7_gpr
{
static_assert(is_enum, "Invalid type for cast_armv7_gpr");
typedef typename std::underlying_type<T>::type underlying_type;
__forceinline static u32 to_gpr(const T& value)
{
return cast_armv7_gpr<underlying_type>::to_gpr(static_cast<underlying_type>(value));
}
__forceinline static T from_gpr(const u32 reg)
{
return static_cast<T>(cast_armv7_gpr<underlying_type>::from_gpr(reg));
}
};
template<>
struct cast_armv7_gpr<u8, false>
{
__forceinline static u32 to_gpr(const u8& value)
{
return value;
}
__forceinline static u8 from_gpr(const u32 reg)
{
return static_cast<u8>(reg);
}
};
template<>
struct cast_armv7_gpr<u16, false>
{
__forceinline static u32 to_gpr(const u16& value)
{
return value;
}
__forceinline static u16 from_gpr(const u32 reg)
{
return static_cast<u16>(reg);
}
};
template<>
struct cast_armv7_gpr<u32, false>
{
__forceinline static u32 to_gpr(const u32& value)
{
return value;
}
__forceinline static u32 from_gpr(const u32 reg)
{
return reg;
}
};
template<>
struct cast_armv7_gpr<s8, false>
{
__forceinline static u32 to_gpr(const s8& value)
{
return value;
}
__forceinline static s8 from_gpr(const u32 reg)
{
return static_cast<s8>(reg);
}
};
template<>
struct cast_armv7_gpr<s16, false>
{
__forceinline static u32 to_gpr(const s16& value)
{
return value;
}
__forceinline static s16 from_gpr(const u32 reg)
{
return static_cast<s16>(reg);
}
};
template<>
struct cast_armv7_gpr<s32, false>
{
__forceinline static u32 to_gpr(const s32& value)
{
return value;
}
__forceinline static s32 from_gpr(const u32 reg)
{
return static_cast<s32>(reg);
}
};
template<>
struct cast_armv7_gpr<bool, false>
{
__forceinline static u32 to_gpr(const bool& value)
{
return value;
}
__forceinline static bool from_gpr(const u32& reg)
{
return reinterpret_cast<const bool&>(reg);
}
};
template<typename T>
__forceinline u32 cast_to_armv7_gpr(const T& value)
{
return cast_armv7_gpr<T>::to_gpr(value);
}
template<typename T>
__forceinline T cast_from_armv7_gpr(const u32 reg)
{
return cast_armv7_gpr<T>::from_gpr(reg);
}

1363
rpcs3/Emu/ARMv7/ARMv7Decoder.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

44
rpcs3/Emu/ARMv7/ARMv7Decoder.h
View File

@ -1,48 +1,18 @@
#pragma once
#include "Emu/CPU/CPUDecoder.h"
#include "ARMv7Thread.h"
#include "ARMv7Interpreter.h"
#include "ARMv7Opcodes.h"
#include "Utilities/Log.h"
struct ARMv7Context;
class ARMv7Decoder : public CPUDecoder
{
ARMv7Thread& m_thr;
ARMv7Context& m_ctx;
public:
ARMv7Decoder(ARMv7Thread& thr) : m_thr(thr)
ARMv7Decoder(ARMv7Context& context) : m_ctx(context)
{
}
virtual u8 DecodeMemory(const u32 address)
{
m_thr.update_code(address & ~1);
virtual u32 DecodeMemory(const u32 address);
};
// LOG_NOTICE(GENERAL, "code0 = 0x%04x, code1 = 0x%04x, data = 0x%08x", m_thr.code.code0, m_thr.code.code1, m_thr.code.data);
// LOG_NOTICE(GENERAL, "arg = 0x%08x", m_thr.m_arg);
// Emu.Pause();
// old decoding algorithm
/*
for (auto& opcode : ARMv7_opcode_table)
{
if ((opcode.type < A1) == ((address & 0x1) == 0) && (m_thr.m_arg & opcode.mask) == opcode.code)
{
m_thr.code.data = opcode.length == 2 ? m_thr.code.code0 : m_thr.m_arg;
(*opcode.func)(&m_thr, opcode.type);
// LOG_NOTICE(GENERAL, "%s, %d \n\n", opcode.name, opcode.length);
return opcode.length;
}
}
ARMv7_instrs::UNK(&m_thr);
return address & 0x1 ? 4 : 2;
*/
execute_main_group(&m_thr);
// LOG_NOTICE(GENERAL, "%s, %d \n\n", m_thr.m_last_instr_name, m_thr.m_last_instr_size);
m_thr.m_last_instr_name = "Unknown";
return m_thr.m_last_instr_size;
}
};
void armv7_decoder_initialize(u32 addr, u32 end_addr, bool dump = false);

3
rpcs3/Emu/ARMv7/ARMv7DisAsm.cpp
View File

@ -1,4 +1,5 @@
#include "stdafx.h"
#if 0
#include "ARMv7DisAsm.h"
void ARMv7DisAsm::UNK(const u32 data)
@ -1119,4 +1120,4 @@ void ARMv7DisAsm::UXTH(const u32 data, const ARMv7_encoding type)
{
Write(__FUNCTION__);
}
#endif

11
rpcs3/Emu/ARMv7/ARMv7DisAsm.h
View File

@ -1,5 +1,4 @@
#pragma once
#include "Emu/ARMv7/ARMv7Opcodes.h"
#include "Emu/CPU/CPUDisAsm.h"
static const char* g_arm_cond_name[16] =
@ -10,6 +9,14 @@ static const char* g_arm_cond_name[16] =
"gt", "le", "al", "al",
};
static const char* g_arm_reg_name[16] =
{
"r0", "r1", "r2", "r3",
"r4", "r5", "r6", "r7",
"r8", "r9", "r10", "r11",
"r12", "sp", "lr", "pc",
};
class ARMv7DisAsm
: public CPUDisAsm
{
@ -24,6 +31,7 @@ protected:
return (u32)dump_pc + imm;
}
#if 0
std::string GetRegsListString(u16 regs_list)
{
std::string regs_str;
@ -316,4 +324,5 @@ protected:
virtual void UXTB(const u32 data, const ARMv7_encoding type);
virtual void UXTB16(const u32 data, const ARMv7_encoding type);
virtual void UXTH(const u32 data, const ARMv7_encoding type);
#endif
};

4646
rpcs3/Emu/ARMv7/ARMv7Interpreter.cpp
View File

File diff suppressed because it is too large Load Diff

1091
rpcs3/Emu/ARMv7/ARMv7Interpreter.h
View File

File diff suppressed because it is too large Load Diff

272
rpcs3/Emu/ARMv7/ARMv7Opcodes.h
View File

@ -1,36 +1,25 @@
#pragma once
#if 0
#include "Emu/ARMv7/ARMv7Thread.h"
#include "Emu/ARMv7/ARMv7Interpreter.h"
#include "Emu/System.h"
#include "Utilities/Log.h"
static const char* g_arm_reg_name[16] =
{
"r0", "r1", "r2", "r3",
"r4", "r5", "r6", "r7",
"r8", "r9", "r10", "r11",
"r12", "sp", "lr", "pc",
};
using namespace ARMv7_instrs;
struct ARMv7_Instruction
{
void(*func)(ARMv7Thread* thr, const ARMv7_encoding type);
void(*func)(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
u8 size;
ARMv7_encoding type;
const char* name;
};
#define ARMv7_OP_2(func, type) { func, 2, type, #func "_" #type }
#define ARMv7_OP_4(func, type) { func, 4, type, #func "_" #type }
#define ARMv7_NULL_OP { NULL_OP, 2, T1, "NULL_OP" }
// 0x1...
static void group_0x1(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0x1(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static const ARMv7_Instruction g_table_0x1_main[] =
{
@ -56,7 +45,7 @@ static const ARMv7_Instruction g_table_0x1[] =
{ group_0x1 }
};
static void group_0x1(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0x1(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code0 & 0x0e00) >> 8;
@ -69,7 +58,7 @@ static void group_0x1(ARMv7Thread* thr, const ARMv7_encoding type)
}
// 0x2...
static void group_0x2(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0x2(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static const ARMv7_Instruction g_table_0x2_main[] =
{
@ -89,7 +78,7 @@ static const ARMv7_Instruction g_table_0x2[] =
{ group_0x2 }
};
static void group_0x2(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0x2(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code0 & 0x0800) >> 8;
thr->m_last_instr_name = g_table_0x2_main[index].name;
@ -99,7 +88,7 @@ static void group_0x2(ARMv7Thread* thr, const ARMv7_encoding type)
}
// 0x3...
static void group_0x3(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0x3(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static const ARMv7_Instruction g_table_0x3_main[] =
{
@ -119,7 +108,7 @@ static const ARMv7_Instruction g_table_0x3[] =
{ group_0x3 }
};
static void group_0x3(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0x3(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code0 & 0x0800) >> 8;
thr->m_last_instr_name = g_table_0x3_main[index].name;
@ -129,13 +118,13 @@ static void group_0x3(ARMv7Thread* thr, const ARMv7_encoding type)
}
// 0x4...
static void group_0x4(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0x40(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0x41(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0x42(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0x43(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0x44(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0x47(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0x4(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0x40(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0x41(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0x42(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0x43(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0x44(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0x47(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static const ARMv7_Instruction g_table_0x4[] =
{
@ -160,7 +149,7 @@ static const ARMv7_Instruction g_table_0x40[] =
ARMv7_OP_2(LSR_REG, T1) // C 0xffc0
};
static void group_0x40(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0x40(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code0 & 0x00c0) >> 4;
thr->m_last_instr_name = g_table_0x40[index].name;
@ -186,7 +175,7 @@ static const ARMv7_Instruction g_table_0x41[] =
ARMv7_OP_2(ROR_REG, T1) // C 0xffc0
};
static void group_0x41(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0x41(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code0 & 0x00c0) >> 4;
thr->m_last_instr_name = g_table_0x41[index].name;
@ -211,7 +200,7 @@ static const ARMv7_Instruction g_table_0x42[] =
ARMv7_OP_2(CMN_REG, T1) // C 0xffc0
};
static void group_0x42(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0x42(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code0 & 0x00c0) >> 4;
thr->m_last_instr_name = g_table_0x42[index].name;
@ -237,7 +226,7 @@ static const ARMv7_Instruction g_table_0x43[] =
ARMv7_OP_2(MVN_REG, T1) // C 0xffc0
};
static void group_0x43(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0x43(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code0 & 0x00c0) >> 4;
thr->m_last_instr_name = g_table_0x43[index].name;
@ -258,7 +247,7 @@ static const ARMv7_Instruction g_table_0x44[] =
ARMv7_OP_2(ADD_SPR, T2) // 8 0xff87
};
static void group_0x44(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0x44(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code0 & 0x0080) >> 4;
@ -284,7 +273,7 @@ static const ARMv7_Instruction g_table_0x47[] =
ARMv7_OP_2(BLX, T1) // 8 0xff80
};
static void group_0x47(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0x47(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code0 & 0x0080) >> 4;
thr->m_last_instr_name = g_table_0x47[index].name;
@ -306,7 +295,7 @@ static const ARMv7_Instruction g_table_0x4_main[] =
ARMv7_OP_2(LDR_LIT, T1) // 8 0xf800
};
static void group_0x4(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0x4(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code0 & 0x0f00) >> 8;
@ -319,7 +308,7 @@ static void group_0x4(ARMv7Thread* thr, const ARMv7_encoding type)
}
// 0x5...
static void group_0x5(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0x5(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static const ARMv7_Instruction g_table_0x5_main[] =
{
@ -345,7 +334,7 @@ static const ARMv7_Instruction g_table_0x5[] =
{ group_0x5 }
};
static void group_0x5(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0x5(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code0 & 0x0e00) >> 8;
thr->m_last_instr_name = g_table_0x5_main[index].name;
@ -355,7 +344,7 @@ static void group_0x5(ARMv7Thread* thr, const ARMv7_encoding type)
}
// 0x6...
static void group_0x6(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0x6(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static const ARMv7_Instruction g_table_0x6_main[] =
{
@ -375,7 +364,7 @@ static const ARMv7_Instruction g_table_0x6[] =
{ group_0x6 }
};
static void group_0x6(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0x6(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code0 & 0x0800) >> 8;
thr->m_last_instr_name = g_table_0x6_main[index].name;
@ -385,7 +374,7 @@ static void group_0x6(ARMv7Thread* thr, const ARMv7_encoding type)
}
// 0x7...
static void group_0x7(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0x7(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static const ARMv7_Instruction g_table_0x7_main[] =
{
@ -405,7 +394,7 @@ static const ARMv7_Instruction g_table_0x7[] =
{ group_0x7 }
};
static void group_0x7(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0x7(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code0 & 0x0800) >> 8;
thr->m_last_instr_name = g_table_0x7_main[index].name;
@ -415,7 +404,7 @@ static void group_0x7(ARMv7Thread* thr, const ARMv7_encoding type)
}
// 0x8...
static void group_0x8(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0x8(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static const ARMv7_Instruction g_table_0x8_main[] =
{
@ -427,7 +416,7 @@ static const ARMv7_Instruction g_table_0x8[] =
{ group_0x8 }
};
static void group_0x8(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0x8(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code0 & 0x0800) >> 8;
thr->m_last_instr_name = g_table_0x8_main[index].name;
@ -437,7 +426,7 @@ static void group_0x8(ARMv7Thread* thr, const ARMv7_encoding type)
}
// 0x9...
static void group_0x9(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0x9(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static const ARMv7_Instruction g_table_0x9_main[] =
{
@ -457,7 +446,7 @@ static const ARMv7_Instruction g_table_0x9[] =
{ group_0x9 }
};
static void group_0x9(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0x9(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code0 & 0x0800) >> 8;
thr->m_last_instr_name = g_table_0x9_main[index].name;
@ -467,7 +456,7 @@ static void group_0x9(ARMv7Thread* thr, const ARMv7_encoding type)
}
// 0xa...
static void group_0xa(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xa(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static const ARMv7_Instruction g_table_0xa_main[] =
{
@ -487,7 +476,7 @@ static const ARMv7_Instruction g_table_0xa[] =
{ group_0xa }
};
static void group_0xa(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xa(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code0 & 0x0800) >> 8;
thr->m_last_instr_name = g_table_0xa_main[index].name;
@ -497,9 +486,9 @@ static void group_0xa(ARMv7Thread* thr, const ARMv7_encoding type)
}
// 0xb...
static void group_0xb(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xb0(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xba(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xb(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xb0(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xba(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static const ARMv7_Instruction g_table_0xb0[] =
{
@ -514,7 +503,7 @@ static const ARMv7_Instruction g_table_0xb0[] =
ARMv7_OP_2(SUB_SPI, T1) // 8 0xff80
};
static void group_0xb0(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xb0(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code0 & 0x0080) >> 4;
thr->m_last_instr_name = g_table_0xb0[index].name;
@ -540,7 +529,7 @@ static const ARMv7_Instruction g_table_0xba[] =
ARMv7_OP_2(REVSH, T1) // C 0xffc0
};
static void group_0xba(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xba(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code0 & 0x00c0) >> 4; // mask 0xffc0
thr->m_last_instr_name = g_table_0xba[index].name;
@ -575,7 +564,7 @@ static const ARMv7_Instruction g_table_0xb[] =
{ group_0xb }
};
static void group_0xb(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xb(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code0 & 0x0e00) >> 8;
@ -591,7 +580,7 @@ static void group_0xb(ARMv7Thread* thr, const ARMv7_encoding type)
}
// 0xc...
static void group_0xc(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xc(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static const ARMv7_Instruction g_table_0xc_main[] =
{
@ -611,7 +600,7 @@ static const ARMv7_Instruction g_table_0xc[] =
{ group_0xc }
};
static void group_0xc(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xc(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code0 & 0x0800) >> 8;
thr->m_last_instr_name = g_table_0xc_main[index].name;
@ -621,7 +610,7 @@ static void group_0xc(ARMv7Thread* thr, const ARMv7_encoding type)
}
// 0xd...
static void group_0xd(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xd(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static const ARMv7_Instruction g_table_0xd_main[] =
{
@ -648,7 +637,7 @@ static const ARMv7_Instruction g_table_0xd[] =
{ group_0xd }
};
static void group_0xd(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xd(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
//u32 index = (thr->code.code0 & 0x0f00) >> 8;
//if ((thr->code.code0 & 0xf000) == 0xd000) index = 0;
@ -661,19 +650,19 @@ static void group_0xd(ARMv7Thread* thr, const ARMv7_encoding type)
}
// 0xe...
static void group_0xe(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xe85(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xe8(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xe9(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xea(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xea4(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xea4f(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xea4f0000(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xea4f0030(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xea6(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xeb(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xeb0(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xeba(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xe(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xe85(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xe8(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xe9(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xea(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xea4(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xea4f(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xea4f0000(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xea4f0030(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xea6(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xeb(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xeb0(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xeba(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static const ARMv7_Instruction g_table_0xe85[] =
@ -696,7 +685,7 @@ static const ARMv7_Instruction g_table_0xe85[] =
ARMv7_OP_4(LDRD_LIT, T1) // F 0xfe7f, 0x0000
};
static void group_0xe85(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xe85(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
//u32 index = thr->code.code0 & 0x000f;
//if ((thr->code.code0 & 0xfe50) == 0xe850) index = 0x0;
@ -726,7 +715,7 @@ static const ARMv7_Instruction g_table_0xe8[] =
ARMv7_OP_4(TB_, T1) // D 0xfff0, 0xffe0
};
static void group_0xe8(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xe8(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code0 & 0x00f0) >> 4;
@ -747,7 +736,7 @@ static const ARMv7_Instruction g_table_0xe9[] =
ARMv7_OP_4(PUSH, T2) // 2 0xffff, 0x0000
};
static void group_0xe9(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xe9(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code0 & 0x00d0) >> 4;
@ -779,7 +768,7 @@ static const ARMv7_Instruction g_table_0xea4[] =
{ group_0xea4f } // F
};
static void group_0xea4(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xea4(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = 0x0;
if ((thr->code.code0 & 0xffef) == 0xea4f) index = 0xf; // check me
@ -798,7 +787,7 @@ static const ARMv7_Instruction g_table_0xea4f[] =
{ group_0xea4f0030 } // 3
};
static void group_0xea4f(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xea4f(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code1 & 0x0030) >> 4;
thr->m_last_instr_name = g_table_0xea4f[index].name;
@ -813,7 +802,7 @@ static const ARMv7_Instruction g_table_0xea4f0000[] =
ARMv7_OP_4(LSL_IMM, T2) // 1 0xffef, 0x8030
};
static void group_0xea4f0000(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xea4f0000(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = thr->code.code1 & 0x8030 ? 0x0 : 0x1;
thr->m_last_instr_name = g_table_0xea4f0000[index].name;
@ -828,7 +817,7 @@ static const ARMv7_Instruction g_table_0xea4f0030[] =
ARMv7_OP_4(ROR_IMM, T1) // 2 0xffef, 0x8030
};
static void group_0xea4f0030(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xea4f0030(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = thr->code.code1 & 0x8030 ? 0x0 : 0x1;
thr->m_last_instr_name = g_table_0xea4f0030[index].name;
@ -857,7 +846,7 @@ static const ARMv7_Instruction g_table_0xea6[] =
ARMv7_OP_4(MVN_REG, T2) // F 0xffef, 0x8000
};
static void group_0xea6(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xea6(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = thr->code.code0 & 0x000f;
@ -886,7 +875,7 @@ static const ARMv7_Instruction g_table_0xea[] =
ARMv7_OP_4(PKH, T1) // C 0xfff0, 0x8010
};
static void group_0xea(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xea(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code0 & 0x00e0) >> 4;
@ -918,7 +907,7 @@ static const ARMv7_Instruction g_table_0xeb0[] =
ARMv7_OP_4(ADD_SPR, T3) // D 0xffef, 0x8000
};
static void group_0xeb0(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xeb0(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = thr->code.code0 & 0x000f;
@ -948,7 +937,7 @@ static const ARMv7_Instruction g_table_0xeba[] =
ARMv7_OP_4(SUB_SPR, T1) // D 0xffef, 0x8000
};
static void group_0xeba(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xeba(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = thr->code.code0 & 0x000f;
@ -977,7 +966,7 @@ static const ARMv7_Instruction g_table_0xeb[] =
ARMv7_OP_4(RSB_REG, T1) // C 0xffe0, 0x8000
};
static void group_0xeb(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xeb(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code0 & 0x00e0) >> 4;
@ -1015,7 +1004,7 @@ static const ARMv7_Instruction g_table_0xe[] =
{ group_0xe }
};
static void group_0xe(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xe(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code0 & 0x0f00) >> 8;
@ -1028,36 +1017,36 @@ static void group_0xe(ARMv7Thread* thr, const ARMv7_encoding type)
}
// 0xf...
static void group_0xf(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf000(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf04(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf06(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf0(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf1(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf1a(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf10(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf20(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf2a(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf2(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf36(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf3(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf810(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf800(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf81(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf820(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf840(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf84(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf850(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf85(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf8(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf910(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf91(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf930(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf93(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf9(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xfa00(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xfa90(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xfa(ARMv7Thread* thr, const ARMv7_encoding type);
static void group_0xf(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf000(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf04(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf06(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf0(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf1(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf1a(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf10(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf20(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf2a(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf2(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf36(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf3(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf810(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf800(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf81(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf820(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf840(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf84(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf850(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf85(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf8(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf910(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf91(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf930(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf93(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xf9(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xfa00(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xfa90(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static void group_0xfa(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
static const ARMv7_Instruction g_table_0xf000[] =
{
@ -1077,7 +1066,7 @@ static const ARMv7_Instruction g_table_0xf000[] =
ARMv7_OP_4(BL, T1) // D 0xf800, 0xd000
};
static void group_0xf000(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf000(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code1 & 0xd000) >> 12;
@ -1110,7 +1099,7 @@ static const ARMv7_Instruction g_table_0xf04[] =
ARMv7_OP_4(MOV_IMM, T2) // F 0xfbef, 0x8000
};
static void group_0xf04(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf04(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = thr->code.code0 & 0x000f;
@ -1142,7 +1131,7 @@ static const ARMv7_Instruction g_table_0xf06[] =
ARMv7_OP_4(MVN_IMM, T1) // F 0xfbef, 0x8000
};
static void group_0xf06(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf06(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = thr->code.code0 & 0x000f;
@ -1194,7 +1183,7 @@ static const ARMv7_Instruction g_table_0xf0[] =
};
static void group_0xf0(ARMv7Thread* thr, const ARMv7_encoding type) // TODO: optimize this group
static void group_0xf0(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type) // TODO: optimize this group
{
u32 index = 0;
if ((thr->m_arg & 0xfbe08000) == 0xf0000000) index = 0x0;
@ -1242,7 +1231,7 @@ static const ARMv7_Instruction g_table_0xf10[] =
ARMv7_OP_4(ADD_SPI, T3) // D 0xfbef, 0x8000
};
static void group_0xf10(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf10(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = thr->code.code0 & 0x000f;
@ -1272,7 +1261,7 @@ static const ARMv7_Instruction g_table_0xf1a[] =
ARMv7_OP_4(SUB_SPI, T2) // D 0xfbef, 0x8000
};
static void group_0xf1a(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf1a(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = thr->code.code0 & 0x000f;
@ -1301,7 +1290,7 @@ static const ARMv7_Instruction g_table_0xf1[] =
ARMv7_OP_4(RSB_IMM, T2) // C 0xfbe0, 0x8000
};
static void group_0xf1(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf1(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code0 & 0x00e0) >> 4;
@ -1334,7 +1323,7 @@ static const ARMv7_Instruction g_table_0xf20[] =
ARMv7_OP_4(ADR, T3) // F 0xfbff, 0x8000
};
static void group_0xf20(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf20(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = thr->code.code0 & 0x000f;
@ -1366,7 +1355,7 @@ static const ARMv7_Instruction g_table_0xf2a[] =
ARMv7_OP_4(ADR, T2) // F 0xfbff, 0x8000
};
static void group_0xf2a(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf2a(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = thr->code.code0 & 0x000f;
@ -1395,7 +1384,7 @@ static const ARMv7_Instruction g_table_0xf2[] =
ARMv7_OP_4(MOVT, T1) // C 0xfbf0, 0x8000
};
static void group_0xf2(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf2(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code0 & 0x00f0) >> 4; // mask 0xfbf0
thr->m_last_instr_name = g_table_0xf2[index].name;
@ -1424,7 +1413,7 @@ static const ARMv7_Instruction g_table_0xf36[] =
ARMv7_OP_4(BFC, T1) // F 0xffff, 0x8020
};
static void group_0xf36(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf36(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = thr->code.code0 & 0x000f;
@ -1455,7 +1444,7 @@ static const ARMv7_Instruction g_table_0xf3[] =
ARMv7_OP_4(MRS, T1), // E 0xffff, 0xf0ff
};
static void group_0xf3(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf3(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code0 & 0x00f0) >> 4;
thr->m_last_instr_name = g_table_0xf3[index].name;
@ -1477,7 +1466,7 @@ static const ARMv7_Instruction g_table_0xf800[] =
ARMv7_OP_4(STRB_IMM, T3) // 8 0xfff0, 0x0800
};
static void group_0xf800(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf800(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code1 & 0x0f00) >> 8;
@ -1502,7 +1491,7 @@ static const ARMv7_Instruction g_table_0xf810[] =
ARMv7_OP_4(LDRB_IMM, T3) // 8 0xfff0, 0x0800
};
static void group_0xf810(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf810(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code1 & 0x0f00) >> 8;
@ -1534,7 +1523,7 @@ static const ARMv7_Instruction g_table_0xf81[] =
ARMv7_OP_4(LDRB_LIT, T1) // F 0xff7f, 0x0000
};
static void group_0xf81(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf81(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = thr->code.code0 & 0x000f;
@ -1559,7 +1548,7 @@ static const ARMv7_Instruction g_table_0xf820[] =
ARMv7_OP_4(STRH_IMM, T3) // 8 0xfff0, 0x0800
};
static void group_0xf820(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf820(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code1 & 0x0f00) >> 8;
@ -1584,7 +1573,7 @@ static const ARMv7_Instruction g_table_0xf840[] =
ARMv7_OP_4(STR_IMM, T4) // 8 0xfff0, 0x0800
};
static void group_0xf840(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf840(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code1 & 0x0f00) >> 8;
@ -1614,7 +1603,7 @@ static const ARMv7_Instruction g_table_0xf84[] =
ARMv7_OP_4(PUSH, T3) // D 0xffff, 0x0fff
};
static void group_0xf84(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf84(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = thr->code.code0 & 0x000f;
@ -1639,7 +1628,7 @@ static const ARMv7_Instruction g_table_0xf850[] =
ARMv7_OP_4(LDR_IMM, T4) // 8 0xfff0, 0x0800
};
static void group_0xf850(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf850(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code1 & 0x0f00) >> 8;
@ -1671,7 +1660,7 @@ static const ARMv7_Instruction g_table_0xf85[] =
ARMv7_OP_4(LDR_LIT, T2) // F 0xff7f, 0x0000
};
static void group_0xf85(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf85(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = thr->code.code0 & 0x000f;
@ -1701,7 +1690,7 @@ static const ARMv7_Instruction g_table_0xf8[] =
ARMv7_OP_4(LDR_IMM, T3) // D 0xfff0, 0x0000
};
static void group_0xf8(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf8(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code0 & 0x00f0) >> 4;
thr->m_last_instr_name = g_table_0xf8[index].name;
@ -1723,7 +1712,7 @@ static const ARMv7_Instruction g_table_0xf910[] =
ARMv7_OP_4(LDRSB_IMM, T2) // 8 0xfff0, 0x0800
};
static void group_0xf910(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf910(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code1 & 0x0f00) >> 8;
@ -1755,7 +1744,7 @@ static const ARMv7_Instruction g_table_0xf91[] =
ARMv7_OP_4(LDRSB_LIT, T1) // F 0xff7f, 0x0000
};
static void group_0xf91(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf91(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = thr->code.code0 & 0x000f;
@ -1780,7 +1769,7 @@ static const ARMv7_Instruction g_table_0xf930[] =
ARMv7_OP_4(LDRSH_IMM, T2) // 8 0xfff0, 0x0800
};
static void group_0xf930(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf930(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code1 & 0x0f00) >> 8;
@ -1812,7 +1801,7 @@ static const ARMv7_Instruction g_table_0xf93[] =
ARMv7_OP_4(LDRSH_LIT, T1) // F 0xff7f, 0x0000
};
static void group_0xf93(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf93(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = thr->code.code0 & 0x000f;
@ -1840,7 +1829,7 @@ static const ARMv7_Instruction g_table_0xf9[] =
ARMv7_OP_4(LDRSH_IMM, T1), // B 0xfff0, 0x0000
};
static void group_0xf9(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf9(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code0 & 0x00f0) >> 4;
@ -1873,7 +1862,7 @@ static const ARMv7_Instruction g_table_0xfa00[] =
ARMv7_OP_4(LSL_REG, T2) // F 0xffe0, 0xf0f0
};
static void group_0xfa00(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xfa00(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code1 & 0xf0f0) == 0xf000 ? 0xf : 0x0;
thr->m_last_instr_name = g_table_0xfa00[index].name;
@ -1898,7 +1887,7 @@ static const ARMv7_Instruction g_table_0xfa90[] =
ARMv7_OP_4(REVSH, T2) // B 0xfff0, 0xf0f0
};
static void group_0xfa90(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xfa90(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
const u32 index = (thr->code.code1 & 0x00f0) >> 4;
thr->m_last_instr_name = g_table_0xfa90[index].name;
@ -1923,7 +1912,7 @@ static const ARMv7_Instruction g_table_0xfa[] =
ARMv7_OP_4(CLZ, T1) // B 0xfff0, 0xf0f0
};
static void group_0xfa(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xfa(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code0 & 0x00e0) >> 4;
@ -1958,7 +1947,7 @@ static const ARMv7_Instruction g_table_0xf_main[] =
};
static void group_0xf(ARMv7Thread* thr, const ARMv7_encoding type)
static void group_0xf(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
{
u32 index = (thr->code.code0 & 0x0b00) >> 8;
@ -2023,3 +2012,4 @@ static void execute_main_group(ARMv7Thread* thr)
#undef ARMv7_OP_2
#undef ARMv7_OP_4
#undef ARMv7_NULL_OP
#endif

197
rpcs3/Emu/ARMv7/ARMv7Thread.cpp
View File

@ -10,36 +10,133 @@
#include "ARMv7DisAsm.h"
#include "ARMv7Interpreter.h"
void ARMv7Context::write_pc(u32 value)
{
ISET = value & 1 ? Thumb : ARM;
thread.SetBranch(value & ~1);
}
u32 ARMv7Context::read_pc()
{
return thread.PC;
}
u32 ARMv7Context::get_stack_arg(u32 pos)
{
return vm::psv::read32(SP + sizeof(u32) * (pos - 5));
}
void ARMv7Context::fast_call(u32 addr)
{
return thread.FastCall(addr);
}
#define TLS_MAX 128
u32 g_armv7_tls_start;
std::array<std::atomic<u32>, TLS_MAX> g_armv7_tls_owners;
void armv7_init_tls()
{
g_armv7_tls_start = Emu.GetTLSMemsz() ? vm::cast(Memory.PSV.RAM.AllocAlign(Emu.GetTLSMemsz() * TLS_MAX, 4096)) : 0;
for (auto& v : g_armv7_tls_owners)
{
v.store(0, std::memory_order_relaxed);
}
}
u32 armv7_get_tls(u32 thread)
{
if (!Emu.GetTLSMemsz() || !thread)
{
return 0;
}
for (u32 i = 0; i < TLS_MAX; i++)
{
if (g_armv7_tls_owners[i] == thread)
{
return g_armv7_tls_start + i * Emu.GetTLSMemsz(); // if already initialized, return TLS address
}
}
for (u32 i = 0; i < TLS_MAX; i++)
{
u32 old = 0;
if (g_armv7_tls_owners[i].compare_exchange_strong(old, thread))
{
const u32 addr = g_armv7_tls_start + i * Emu.GetTLSMemsz(); // get TLS address
memcpy(vm::get_ptr(addr), vm::get_ptr(Emu.GetTLSAddr()), Emu.GetTLSFilesz()); // initialize from TLS image
memset(vm::get_ptr(addr + Emu.GetTLSFilesz()), 0, Emu.GetTLSMemsz() - Emu.GetTLSFilesz()); // fill the rest with zeros
return addr;
}
}
throw "Out of TLS memory";
}
void armv7_free_tls(u32 thread)
{
if (!Emu.GetTLSMemsz())
{
return;
}
for (auto& v : g_armv7_tls_owners)
{
u32 old = thread;
if (v.compare_exchange_strong(old, 0))
{
return;
}
}
}
ARMv7Thread::ARMv7Thread()
: CPUThread(CPU_THREAD_ARMv7)
, m_arg(0)
, m_last_instr_size(0)
, m_last_instr_name("UNK")
, context(*this)
//, m_arg(0)
//, m_last_instr_size(0)
//, m_last_instr_name("UNK")
{
}
ARMv7Thread::~ARMv7Thread()
{
armv7_free_tls(GetId());
}
void ARMv7Thread::InitRegs()
{
memset(GPR, 0, sizeof(GPR[0]) * 15);
APSR.APSR = 0;
IPSR.IPSR = 0;
ISET = Thumb;
ITSTATE.IT = 0;
SP = m_stack_addr + m_stack_size;
memset(context.GPR, 0, sizeof(context.GPR));
context.APSR.APSR = 0;
context.IPSR.IPSR = 0;
context.ISET = PC & 1 ? Thumb : ARM; // select instruction set
context.thread.SetPc(PC & ~1); // and fix PC
context.ITSTATE.IT = 0;
context.SP = m_stack_addr + m_stack_size;
context.TLS = armv7_get_tls(GetId());
context.R_ADDR = 0;
}
void ARMv7Thread::InitStack()
{
if(!m_stack_addr)
if (!m_stack_addr)
{
m_stack_size = 0x10000;
m_stack_addr = (u32)Memory.Alloc(0x10000, 1);
assert(m_stack_size);
m_stack_addr = vm::cast(Memory.Alloc(m_stack_size, 4096));
}
}
u32 ARMv7Thread::GetStackArg(u32 pos)
void ARMv7Thread::CloseStack()
{
return vm::psv::read32(SP + sizeof(u32) * (pos - 5));
if (m_stack_addr)
{
Memory.Free(m_stack_addr);
m_stack_addr = 0;
}
}
std::string ARMv7Thread::RegsToString()
@ -47,16 +144,16 @@ std::string ARMv7Thread::RegsToString()
std::string result = "Registers:\n=========\n";
for(int i=0; i<15; ++i)
{
result += fmt::Format("%s\t= 0x%08x\n", g_arm_reg_name[i], GPR[i]);
result += fmt::Format("%s\t= 0x%08x\n", g_arm_reg_name[i], context.GPR[i]);
}
result += fmt::Format("APSR\t= 0x%08x [N: %d, Z: %d, C: %d, V: %d, Q: %d]\n",
APSR.APSR,
fmt::by_value(APSR.N),
fmt::by_value(APSR.Z),
fmt::by_value(APSR.C),
fmt::by_value(APSR.V),
fmt::by_value(APSR.Q));
context.APSR.APSR,
fmt::by_value(context.APSR.N),
fmt::by_value(context.APSR.Z),
fmt::by_value(context.APSR.C),
fmt::by_value(context.APSR.V),
fmt::by_value(context.APSR.Q));
return result;
}
@ -85,7 +182,7 @@ void ARMv7Thread::DoRun()
case 1:
case 2:
m_dec = new ARMv7Decoder(*this);
m_dec = new ARMv7Decoder(context);
break;
}
}
@ -110,21 +207,21 @@ void ARMv7Thread::FastCall(u32 addr)
{
auto old_status = m_status;
auto old_PC = PC;
auto old_stack = SP;
auto old_LR = LR;
auto old_stack = context.SP;
auto old_LR = context.LR;
auto old_thread = GetCurrentNamedThread();
m_status = Running;
PC = addr;
LR = Emu.GetCPUThreadStop();
context.LR = Emu.GetCPUThreadStop();
SetCurrentNamedThread(this);
CPUThread::Task();
m_status = old_status;
PC = old_PC;
SP = old_stack;
LR = old_LR;
context.SP = old_stack;
context.LR = old_LR;
SetCurrentNamedThread(old_thread);
}
@ -133,7 +230,7 @@ void ARMv7Thread::FastStop()
m_status = Stopped;
}
arm7_thread::arm7_thread(u32 entry, const std::string& name, u32 stack_size, u32 prio)
armv7_thread::armv7_thread(u32 entry, const std::string& name, u32 stack_size, u32 prio)
{
thread = &Emu.GetCPU().AddThread(CPU_THREAD_ARMv7);
@ -144,3 +241,47 @@ arm7_thread::arm7_thread(u32 entry, const std::string& name, u32 stack_size, u32
argc = 0;
}
cpu_thread& armv7_thread::args(std::initializer_list<std::string> values)
{
assert(argc == 0);
if (!values.size())
{
return *this;
}
std::vector<char> argv_data;
u32 argv_size = 0;
for (auto& arg : values)
{
const u32 arg_size = vm::cast(arg.size(), "arg.size()"); // get arg size
for (char c : arg)
{
argv_data.push_back(c); // append characters
}
argv_data.push_back('\0'); // append null terminator
argv_size += arg_size + 1;
argc++;
}
argv = vm::cast(Memory.PSV.RAM.AllocAlign(argv_size, 4096)); // allocate arg list
memcpy(vm::get_ptr(argv), argv_data.data(), argv_size); // copy arg list
return *this;
}
cpu_thread& armv7_thread::run()
{
thread->Run();
// set arguments
static_cast<ARMv7Thread*>(thread)->context.GPR[0] = argc;
static_cast<ARMv7Thread*>(thread)->context.GPR[1] = argv;
return *this;
}

312
rpcs3/Emu/ARMv7/ARMv7Thread.h
View File

@ -1,151 +1,19 @@
#pragma once
#include "Emu/CPU/CPUThread.h"
#include "Emu/Memory/Memory.h"
enum ARMv7InstructionSet
{
ARM,
Thumb,
Jazelle,
ThumbEE
};
#include "ARMv7Context.h"
class ARMv7Thread : public CPUThread
{
public:
u32 m_arg;
u8 m_last_instr_size;
const char* m_last_instr_name;
ARMv7Context context;
ARMv7Thread();
union
{
u32 GPR[15];
struct
{
u32 pad[13];
union
{
u32 SP;
struct { u16 SP_main, SP_process; };
};
u32 LR;
};
};
union
{
struct
{
u32 N : 1; //Negative condition code flag
u32 Z : 1; //Zero condition code flag
u32 C : 1; //Carry condition code flag
u32 V : 1; //Overflow condition code flag
u32 Q : 1; //Set to 1 if an SSAT or USAT instruction changes (saturates) the input value for the signed or unsigned range of the result
u32 : 27;
};
u32 APSR;
} APSR;
union
{
struct
{
u32 : 24;
u32 exception : 8;
};
u32 IPSR;
} IPSR;
union
{
struct
{
u32 code1 : 16;
u32 code0 : 16;
};
u32 data;
} code;
ARMv7InstructionSet ISET;
union
{
struct
{
u8 cond : 3;
u8 state : 5;
};
u8 IT;
u32 advance()
{
const u32 res = (state & 0xf) ? (cond << 1 | state >> 4) : 0xe /* true */;
state <<= 1;
if ((state & 0xf) == 0) // if no d
{
IT = 0; // clear ITSTATE
}
return res;
}
operator bool() const
{
return (state & 0xf) != 0;
}
} ITSTATE;
void write_gpr(u32 n, u32 value)
{
assert(n < 16);
if(n < 15)
{
GPR[n] = value;
}
else
{
SetBranch(value & ~1);
}
}
u32 read_gpr(u32 n)
{
assert(n < 16);
if(n < 15)
{
return GPR[n];
}
return PC;
}
void update_code(const u32 address)
{
code.code0 = vm::psv::read16(address & ~1);
code.code1 = vm::psv::read16(address + 2 & ~1);
m_arg = address & 0x1 ? code.code1 << 16 | code.code0 : code.data;
}
~ARMv7Thread();
public:
virtual void InitRegs();
virtual void InitStack();
virtual void CloseStack();
u32 GetStackArg(u32 pos);
void FastCall(u32 addr);
void FastStop();
@ -164,176 +32,16 @@ protected:
virtual void DoCode();
};
class arm7_thread : cpu_thread
class armv7_thread : cpu_thread
{
static const u32 stack_align = 0x10;
vm::ptr<u64> argv;
u32 argv;
u32 argc;
vm::ptr<u64> envp;
public:
arm7_thread(u32 entry, const std::string& name = "", u32 stack_size = 0, u32 prio = 0);
armv7_thread(u32 entry, const std::string& name = "", u32 stack_size = 0, u32 prio = 0);
cpu_thread& args(std::initializer_list<std::string> values) override
{
if (!values.size())
return *this;
cpu_thread& args(std::initializer_list<std::string> values) override;
//assert(argc == 0);
//envp.set(vm::alloc((u32)sizeof(envp), stack_align, vm::main));
//*envp = 0;
//argv.set(vm::alloc(u32(sizeof(argv)* values.size()), stack_align, vm::main));
for (auto &arg : values)
{
//u32 arg_size = align(u32(arg.size() + 1), stack_align);
//u32 arg_addr = vm::alloc(arg_size, stack_align, vm::main);
//std::strcpy(vm::get_ptr<char>(arg_addr), arg.c_str());
//argv[argc++] = arg_addr;
}
return *this;
}
cpu_thread& run() override
{
thread->Run();
//static_cast<ARMv7Thread*>(thread)->GPR[0] = argc;
//static_cast<ARMv7Thread*>(thread)->GPR[1] = argv.addr();
//static_cast<ARMv7Thread*>(thread)->GPR[2] = envp.addr();
return *this;
}
cpu_thread& run() override;
};
template<typename T, bool is_enum = std::is_enum<T>::value>
struct cast_armv7_gpr
{
static_assert(is_enum, "Invalid type for cast_armv7_gpr");
typedef typename std::underlying_type<T>::type underlying_type;
__forceinline static u32 to_gpr(const T& value)
{
return cast_armv7_gpr<underlying_type>::to_gpr(static_cast<underlying_type>(value));
}
__forceinline static T from_gpr(const u32 reg)
{
return static_cast<T>(cast_armv7_gpr<underlying_type>::from_gpr(reg));
}
};
template<>
struct cast_armv7_gpr<u8, false>
{
__forceinline static u32 to_gpr(const u8& value)
{
return value;
}
__forceinline static u8 from_gpr(const u32 reg)
{
return static_cast<u8>(reg);
}
};
template<>
struct cast_armv7_gpr<u16, false>
{
__forceinline static u32 to_gpr(const u16& value)
{
return value;
}
__forceinline static u16 from_gpr(const u32 reg)
{
return static_cast<u16>(reg);
}
};
template<>
struct cast_armv7_gpr<u32, false>
{
__forceinline static u32 to_gpr(const u32& value)
{
return value;
}
__forceinline static u32 from_gpr(const u32 reg)
{
return reg;
}
};
template<>
struct cast_armv7_gpr<s8, false>
{
__forceinline static u32 to_gpr(const s8& value)
{
return value;
}
__forceinline static s8 from_gpr(const u32 reg)
{
return static_cast<s8>(reg);
}
};
template<>
struct cast_armv7_gpr<s16, false>
{
__forceinline static u32 to_gpr(const s16& value)
{
return value;
}
__forceinline static s16 from_gpr(const u32 reg)
{
return static_cast<s16>(reg);
}
};
template<>
struct cast_armv7_gpr<s32, false>
{
__forceinline static u32 to_gpr(const s32& value)
{
return value;
}
__forceinline static s32 from_gpr(const u32 reg)
{
return static_cast<s32>(reg);
}
};
template<>
struct cast_armv7_gpr<bool, false>
{
__forceinline static u32 to_gpr(const bool& value)
{
return value;
}
__forceinline static bool from_gpr(const u32 reg)
{
return reinterpret_cast<const bool&>(reg);
}
};
template<typename T>
__forceinline u32 cast_to_armv7_gpr(const T& value)
{
return cast_armv7_gpr<T>::to_gpr(value);
}
template<typename T>
__forceinline T cast_from_armv7_gpr(const u32 reg)
{
return cast_armv7_gpr<T>::from_gpr(reg);
}

13
rpcs3/Emu/ARMv7/Modules/psv_event_flag.cpp Normal file
View File

@ -0,0 +1,13 @@
#include "stdafx.h"
#include "Emu/Memory/Memory.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "Emu/ARMv7/PSVObjectList.h"
#include "sceLibKernel.h"
#include "psv_event_flag.h"
psv_event_flag_t::psv_event_flag_t(const char* name, u32 attr, u32 pattern)
: attr(attr)
, pattern(pattern)
{
strcpy_trunc(this->name, name);
}

21
rpcs3/Emu/ARMv7/Modules/psv_event_flag.h Normal file
View File

@ -0,0 +1,21 @@
#pragma once
struct psv_event_flag_t
{
char name[32];
u32 attr;
u32 pattern;
private:
psv_event_flag_t() = delete;
psv_event_flag_t(const psv_event_flag_t&) = delete;
psv_event_flag_t(psv_event_flag_t&&) = delete;
psv_event_flag_t& operator =(const psv_event_flag_t&) = delete;
psv_event_flag_t& operator =(psv_event_flag_t&&) = delete;
public:
psv_event_flag_t(const char* name, u32 attr, u32 pattern);
};
extern psv_object_list_t<psv_event_flag_t, SCE_KERNEL_THREADMGR_UID_CLASS_EVENT_FLAG> g_psv_ef_list;

14
rpcs3/Emu/ARMv7/Modules/psv_sema.cpp Normal file
View File

@ -0,0 +1,14 @@
#include "stdafx.h"
#include "Emu/Memory/Memory.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "Emu/ARMv7/PSVObjectList.h"
#include "sceLibKernel.h"
#include "psv_sema.h"
psv_sema_t::psv_sema_t(const char* name, u32 attr, s32 init_value, s32 max_value)
: attr(attr)
, value(init_value)
, max(max_value)
{
strcpy_trunc(this->name, name);
}

23
rpcs3/Emu/ARMv7/Modules/psv_sema.h Normal file
View File

@ -0,0 +1,23 @@
#pragma once
struct psv_sema_t
{
char name[32];
u32 attr;
s32 value;
s32 max;
private:
psv_sema_t() = delete;
psv_sema_t(const psv_sema_t&) = delete;
psv_sema_t(psv_sema_t&&) = delete;
psv_sema_t& operator =(const psv_sema_t&) = delete;
psv_sema_t& operator =(psv_sema_t&&) = delete;
public:
psv_sema_t(const char* name, u32 attr, s32 init_value, s32 max_value);
};
extern psv_object_list_t<psv_sema_t, SCE_KERNEL_THREADMGR_UID_CLASS_SEMA> g_psv_sema_list;

48
rpcs3/Emu/ARMv7/Modules/sceAppMgr.cpp Normal file
View File

@ -0,0 +1,48 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceAppMgr;
struct SceAppMgrEvent
{
s32 event;
s32 appId;
char param[56];
};
s32 sceAppMgrReceiveEventNum(vm::psv::ptr<s32> eventNum)
{
throw __FUNCTION__;
}
s32 sceAppMgrReceiveEvent(vm::psv::ptr<SceAppMgrEvent> appEvent)
{
throw __FUNCTION__;
}
s32 sceAppMgrAcquireBgmPort()
{
throw __FUNCTION__;
}
s32 sceAppMgrReleaseBgmPort()
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceAppMgr, #name, name)
psv_log_base sceAppMgr("SceAppMgr", []()
{
sceAppMgr.on_load = nullptr;
sceAppMgr.on_unload = nullptr;
sceAppMgr.on_stop = nullptr;
REG_FUNC(0x47E5DD7D, sceAppMgrReceiveEventNum);
REG_FUNC(0xCFAD5A3A, sceAppMgrReceiveEvent);
REG_FUNC(0xF3D65520, sceAppMgrAcquireBgmPort);
REG_FUNC(0x96CBE713, sceAppMgrReleaseBgmPort);
//REG_FUNC(0x49255C91, sceAppMgrGetRunStatus);
});

94
rpcs3/Emu/ARMv7/Modules/sceAppUtil.cpp Normal file
View File

@ -0,0 +1,94 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceAppUtil.h"
s32 sceAppUtilInit(vm::psv::ptr<const SceAppUtilInitParam> initParam, vm::psv::ptr<SceAppUtilBootParam> bootParam)
{
throw __FUNCTION__;
}
s32 sceAppUtilShutdown()
{
throw __FUNCTION__;
}
s32 sceAppUtilSaveDataSlotCreate(u32 slotId, vm::psv::ptr<const SceAppUtilSaveDataSlotParam> param, vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
{
throw __FUNCTION__;
}
s32 sceAppUtilSaveDataSlotDelete(u32 slotId, vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
{
throw __FUNCTION__;
}
s32 sceAppUtilSaveDataSlotSetParam(u32 slotId, vm::psv::ptr<const SceAppUtilSaveDataSlotParam> param, vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
{
throw __FUNCTION__;
}
s32 sceAppUtilSaveDataSlotGetParam(u32 slotId, vm::psv::ptr<SceAppUtilSaveDataSlotParam> param, vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
{
throw __FUNCTION__;
}
s32 sceAppUtilSaveDataFileSave(vm::psv::ptr<const SceAppUtilSaveDataFileSlot> slot, vm::psv::ptr<const SceAppUtilSaveDataFile> files, u32 fileNum, vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint, vm::psv::ptr<u32> requiredSizeKB)
{
throw __FUNCTION__;
}
s32 sceAppUtilPhotoMount()
{
throw __FUNCTION__;
}
s32 sceAppUtilPhotoUmount()
{
throw __FUNCTION__;
}
s32 sceAppUtilSystemParamGetInt(u32 paramId, vm::psv::ptr<s32> value)
{
throw __FUNCTION__;
}
s32 sceAppUtilSystemParamGetString(u32 paramId, vm::psv::ptr<char> buf, u32 bufSize)
{
throw __FUNCTION__;
}
s32 sceAppUtilSaveSafeMemory(vm::psv::ptr<const void> buf, u32 bufSize, s64 offset)
{
throw __FUNCTION__;
}
s32 sceAppUtilLoadSafeMemory(vm::psv::ptr<void> buf, u32 bufSize, s64 offset)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceAppUtil, #name, name)
psv_log_base sceAppUtil("SceAppUtil", []()
{
sceAppUtil.on_load = nullptr;
sceAppUtil.on_unload = nullptr;
sceAppUtil.on_stop = nullptr;
REG_FUNC(0xDAFFE671, sceAppUtilInit);
REG_FUNC(0xB220B00B, sceAppUtilShutdown);
REG_FUNC(0x7E8FE96A, sceAppUtilSaveDataSlotCreate);
REG_FUNC(0x266A7646, sceAppUtilSaveDataSlotDelete);
REG_FUNC(0x98630136, sceAppUtilSaveDataSlotSetParam);
REG_FUNC(0x93F0D89F, sceAppUtilSaveDataSlotGetParam);
REG_FUNC(0x1E2A6158, sceAppUtilSaveDataFileSave);
REG_FUNC(0xEE85804D, sceAppUtilPhotoMount);
REG_FUNC(0x9651B941, sceAppUtilPhotoUmount);
REG_FUNC(0x5DFB9CA0, sceAppUtilSystemParamGetInt);
REG_FUNC(0x6E6AA267, sceAppUtilSystemParamGetString);
REG_FUNC(0x9D8AC677, sceAppUtilSaveSafeMemory);
REG_FUNC(0x3424D772, sceAppUtilLoadSafeMemory);
});

69
rpcs3/Emu/ARMv7/Modules/sceAppUtil.h Normal file
View File

@ -0,0 +1,69 @@
#pragma once
struct SceAppUtilInitParam
{
u32 workBufSize;
char reserved[60];
};
struct SceAppUtilBootParam
{
u32 attr;
u32 appVersion;
char reserved[32];
};
struct SceAppUtilSaveDataMountPoint
{
char data[16];
};
struct SceAppUtilSaveDataSlotParam
{
u32 status;
char title[64];
char subTitle[128];
char detail[512];
char iconPath[64];
s32 userParam;
u32 sizeKB;
SceDateTime modifiedTime;
char reserved[48];
};
struct SceAppUtilSaveDataSlotEmptyParam
{
vm::psv::ptr<char> title;
vm::psv::ptr<char> iconPath;
vm::psv::ptr<void> iconBuf;
u32 iconBufSize;
char reserved[32];
};
struct SceAppUtilSaveDataSlot
{
u32 id;
u32 status;
s32 userParam;
vm::psv::ptr<SceAppUtilSaveDataSlotEmptyParam> emptyParam;
};
struct SceAppUtilSaveDataFile
{
vm::psv::ptr<const char> filePath;
vm::psv::ptr<void> buf;
u32 bufSize;
s64 offset;
u32 mode;
u32 progDelta;
char reserved[32];
};
struct SceAppUtilSaveDataFileSlot
{
u32 id;
vm::psv::ptr<SceAppUtilSaveDataSlotParam> slotParam;
char reserved[32];
};
extern psv_log_base sceAppUtil;

65
rpcs3/Emu/ARMv7/Modules/sceAudio.cpp Normal file
View File

@ -0,0 +1,65 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceAudio;
s32 sceAudioOutOpenPort(s32 portType, s32 len, s32 freq, s32 param)
{
throw __FUNCTION__;
}
s32 sceAudioOutReleasePort(s32 port)
{
throw __FUNCTION__;
}
s32 sceAudioOutOutput(s32 port, vm::psv::ptr<void> ptr)
{
throw __FUNCTION__;
}
s32 sceAudioOutSetVolume(s32 port, s32 flag, vm::psv::ptr<s32> vol)
{
throw __FUNCTION__;
}
s32 sceAudioOutSetConfig(s32 port, s32 len, s32 freq, s32 param)
{
throw __FUNCTION__;
}
s32 sceAudioOutGetConfig(s32 port, s32 configType)
{
throw __FUNCTION__;
}
s32 sceAudioOutGetRestSample(s32 port)
{
throw __FUNCTION__;
}
s32 sceAudioOutGetAdopt(s32 portType)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceAudio, #name, name)
psv_log_base sceAudio("SceAudio", []()
{
sceAudio.on_load = nullptr;
sceAudio.on_unload = nullptr;
sceAudio.on_stop = nullptr;
REG_FUNC(0x5BC341E4, sceAudioOutOpenPort);
REG_FUNC(0x69E2E6B5, sceAudioOutReleasePort);
REG_FUNC(0x02DB3F5F, sceAudioOutOutput);
REG_FUNC(0x64167F11, sceAudioOutSetVolume);
REG_FUNC(0xB8BA0D07, sceAudioOutSetConfig);
REG_FUNC(0x9C8EDAEA, sceAudioOutGetConfig);
REG_FUNC(0x9A5370C4, sceAudioOutGetRestSample);
REG_FUNC(0x12FB1767, sceAudioOutGetAdopt);
//REG_FUNC(0xC6D8D775, sceAudioInRaw);
});

35
rpcs3/Emu/ARMv7/Modules/sceAudioIn.cpp Normal file
View File

@ -0,0 +1,35 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceAudioIn;
s32 sceAudioInOpenPort(s32 portType, s32 grain, s32 freq, s32 param)
{
throw __FUNCTION__;
}
s32 sceAudioInReleasePort(s32 port)
{
throw __FUNCTION__;
}
s32 sceAudioInInput(s32 port, vm::psv::ptr<void> destPtr)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceAudioIn, #name, name)
psv_log_base sceAudioIn("SceAudioIn", []()
{
sceAudioIn.on_load = nullptr;
sceAudioIn.on_unload = nullptr;
sceAudioIn.on_stop = nullptr;
REG_FUNC(0x638ADD2D, sceAudioInInput);
REG_FUNC(0x39B50DC1, sceAudioInOpenPort);
REG_FUNC(0x3A61B8C4, sceAudioInReleasePort);
//REG_FUNC(0x566AC433, sceAudioInGetAdopt);
});

138
rpcs3/Emu/ARMv7/Modules/sceAudiodec.cpp Normal file
View File

@ -0,0 +1,138 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceAudiodec;
struct SceAudiodecInitStreamParam
{
u32 size;
u32 totalStreams;
};
struct SceAudiodecInitChParam
{
u32 size;
u32 totalCh;
};
union SceAudiodecInitParam
{
u32 size;
SceAudiodecInitChParam at9;
SceAudiodecInitStreamParam mp3;
SceAudiodecInitStreamParam aac;
SceAudiodecInitStreamParam celp;
};
struct SceAudiodecInfoAt9
{
u32 size;
u8 configData[4];
u32 ch;
u32 bitRate;
u32 samplingRate;
u32 superFrameSize;
u32 framesInSuperFrame;
};
struct SceAudiodecInfoMp3
{
u32 size;
u32 ch;
u32 version;
};
struct SceAudiodecInfoAac
{
u32 size;
u32 isAdts;
u32 ch;
u32 samplingRate;
u32 isSbr;
};
struct SceAudiodecInfoCelp
{
u32 size;
u32 excitationMode;
u32 samplingRate;
u32 bitRate;
u32 lostCount;
};
union SceAudiodecInfo
{
u32 size;
SceAudiodecInfoAt9 at9;
SceAudiodecInfoMp3 mp3;
SceAudiodecInfoAac aac;
SceAudiodecInfoCelp celp;
};
struct SceAudiodecCtrl
{
u32 size;
s32 handle;
vm::psv::ptr<u8> pEs;
u32 inputEsSize;
u32 maxEsSize;
vm::psv::ptr<void> pPcm;
u32 outputPcmSize;
u32 maxPcmSize;
u32 wordLength;
vm::psv::ptr<SceAudiodecInfo> pInfo;
};
s32 sceAudiodecInitLibrary(u32 codecType, vm::psv::ptr<SceAudiodecInitParam> pInitParam)
{
throw __FUNCTION__;
}
s32 sceAudiodecTermLibrary(u32 codecType)
{
throw __FUNCTION__;
}
s32 sceAudiodecCreateDecoder(vm::psv::ptr<SceAudiodecCtrl> pCtrl, u32 codecType)
{
throw __FUNCTION__;
}
s32 sceAudiodecDeleteDecoder(vm::psv::ptr<SceAudiodecCtrl> pCtrl)
{
throw __FUNCTION__;
}
s32 sceAudiodecDecode(vm::psv::ptr<SceAudiodecCtrl> pCtrl)
{
throw __FUNCTION__;
}
s32 sceAudiodecClearContext(vm::psv::ptr<SceAudiodecCtrl> pCtrl)
{
throw __FUNCTION__;
}
s32 sceAudiodecGetInternalError(vm::psv::ptr<SceAudiodecCtrl> pCtrl, vm::psv::ptr<s32> pInternalError)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceAudiodec, #name, name)
psv_log_base sceAudiodec("SceAudiodec", []()
{
sceAudiodec.on_load = nullptr;
sceAudiodec.on_unload = nullptr;
sceAudiodec.on_stop = nullptr;
REG_FUNC(0x445C2CEF, sceAudiodecInitLibrary);
REG_FUNC(0x45719B9D, sceAudiodecTermLibrary);
REG_FUNC(0x4DFD3AAA, sceAudiodecCreateDecoder);
REG_FUNC(0xE7A24E16, sceAudiodecDeleteDecoder);
REG_FUNC(0xCCDABA04, sceAudiodecDecode);
REG_FUNC(0xF72F9B64, sceAudiodecClearContext);
REG_FUNC(0x883B0CF5, sceAudiodecGetInternalError);
});

121
rpcs3/Emu/ARMv7/Modules/sceAudioenc.cpp Normal file
View File

@ -0,0 +1,121 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceAudioenc;
struct SceAudioencInitStreamParam
{
u32 size;
u32 totalStreams;
};
struct SceAudioencInfoCelp
{
u32 size;
u32 excitationMode;
u32 samplingRate;
u32 bitRate;
};
struct SceAudioencOptInfoCelp
{
u32 size;
u8 header[32];
u32 headerSize;
u32 encoderVersion;
};
union SceAudioencInitParam
{
u32 size;
SceAudioencInitStreamParam celp;
};
union SceAudioencInfo
{
u32 size;
SceAudioencInfoCelp celp;
};
union SceAudioencOptInfo
{
u32 size;
SceAudioencOptInfoCelp celp;
};
struct SceAudioencCtrl
{
u32 size;
s32 handle;
vm::psv::ptr<u8> pInputPcm;
u32 inputPcmSize;
u32 maxPcmSize;
vm::psv::ptr<void> pOutputEs;
u32 outputEsSize;
u32 maxEsSize;
u32 wordLength;
vm::psv::ptr<SceAudioencInfo> pInfo;
vm::psv::ptr<SceAudioencOptInfo> pOptInfo;
};
s32 sceAudioencInitLibrary(u32 codecType, vm::psv::ptr<SceAudioencInitParam> pInitParam)
{
throw __FUNCTION__;
}
s32 sceAudioencTermLibrary(u32 codecType)
{
throw __FUNCTION__;
}
s32 sceAudioencCreateEncoder(vm::psv::ptr<SceAudioencCtrl> pCtrl, u32 codecType)
{
throw __FUNCTION__;
}
s32 sceAudioencDeleteEncoder(vm::psv::ptr<SceAudioencCtrl> pCtrl)
{
throw __FUNCTION__;
}
s32 sceAudioencEncode(vm::psv::ptr<SceAudioencCtrl> pCtrl)
{
throw __FUNCTION__;
}
s32 sceAudioencClearContext(vm::psv::ptr<SceAudioencCtrl> pCtrl)
{
throw __FUNCTION__;
}
s32 sceAudioencGetOptInfo(vm::psv::ptr<SceAudioencCtrl> pCtrl)
{
throw __FUNCTION__;
}
s32 sceAudioencGetInternalError(vm::psv::ptr<SceAudioencCtrl> pCtrl, vm::psv::ptr<s32> pInternalError)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceAudioenc, #name, name)
psv_log_base sceAudioenc("SceAudioenc", []()
{
sceAudioenc.on_load = nullptr;
sceAudioenc.on_unload = nullptr;
sceAudioenc.on_stop = nullptr;
REG_FUNC(0x76EE4DC6, sceAudioencInitLibrary);
REG_FUNC(0xAB32D022, sceAudioencTermLibrary);
REG_FUNC(0x64C04AE8, sceAudioencCreateEncoder);
REG_FUNC(0xC6BA5EE6, sceAudioencDeleteEncoder);
REG_FUNC(0xD85DB29C, sceAudioencEncode);
REG_FUNC(0x9386F42D, sceAudioencClearContext);
REG_FUNC(0xD01C63A3, sceAudioencGetOptInfo);
REG_FUNC(0x452246D0, sceAudioencGetInternalError);
});

299
rpcs3/Emu/ARMv7/Modules/sceCamera.cpp Normal file
View File

@ -0,0 +1,299 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceCamera;
struct SceCameraInfo
{
u32 sizeThis;
u32 wPriority;
u32 wFormat;
u32 wResolution;
u32 wFramerate;
u32 wWidth;
u32 wHeight;
u32 wRange;
u32 _padding_0;
u32 sizeIBase;
u32 sizeUBase;
u32 sizeVBase;
vm::psv::ptr<void> pvIBase;
vm::psv::ptr<void> pvUBase;
vm::psv::ptr<void> pvVBase;
u32 wPitch;
u32 wBuffer;
};
struct SceCameraRead
{
u32 sizeThis;
s32 dwMode;
s32 _padding_0;
s32 dwStatus;
u32 qwFrame;
u32 qwTimestamp;
u32 sizeIBase;
u32 sizeUBase;
u32 sizeVBase;
vm::psv::ptr<void> pvIBase;
vm::psv::ptr<void> pvUBase;
vm::psv::ptr<void> pvVBase;
};
s32 sceCameraOpen(s32 devnum, vm::psv::ptr<SceCameraInfo> pInfo)
{
throw __FUNCTION__;
}
s32 sceCameraClose(s32 devnum)
{
throw __FUNCTION__;
}
s32 sceCameraStart(s32 devnum)
{
throw __FUNCTION__;
}
s32 sceCameraStop(s32 devnum)
{
throw __FUNCTION__;
}
s32 sceCameraRead(s32 devnum, vm::psv::ptr<SceCameraRead> pRead)
{
throw __FUNCTION__;
}
s32 sceCameraIsActive(s32 devnum)
{
throw __FUNCTION__;
}
s32 sceCameraGetSaturation(s32 devnum, vm::psv::ptr<s32> pLevel)
{
throw __FUNCTION__;
}
s32 sceCameraSetSaturation(s32 devnum, s32 level)
{
throw __FUNCTION__;
}
s32 sceCameraGetBrightness(s32 devnum, vm::psv::ptr<s32> pLevel)
{
throw __FUNCTION__;
}
s32 sceCameraSetBrightness(s32 devnum, s32 level)
{
throw __FUNCTION__;
}
s32 sceCameraGetContrast(s32 devnum, vm::psv::ptr<s32> pLevel)
{
throw __FUNCTION__;
}
s32 sceCameraSetContrast(s32 devnum, s32 level)
{
throw __FUNCTION__;
}
s32 sceCameraGetSharpness(s32 devnum, vm::psv::ptr<s32> pLevel)
{
throw __FUNCTION__;
}
s32 sceCameraSetSharpness(s32 devnum, s32 level)
{
throw __FUNCTION__;
}
s32 sceCameraGetReverse(s32 devnum, vm::psv::ptr<s32> pMode)
{
throw __FUNCTION__;
}
s32 sceCameraSetReverse(s32 devnum, s32 mode)
{
throw __FUNCTION__;
}
s32 sceCameraGetEffect(s32 devnum, vm::psv::ptr<s32> pMode)
{
throw __FUNCTION__;
}
s32 sceCameraSetEffect(s32 devnum, s32 mode)
{
throw __FUNCTION__;
}
s32 sceCameraGetEV(s32 devnum, vm::psv::ptr<s32> pLevel)
{
throw __FUNCTION__;
}
s32 sceCameraSetEV(s32 devnum, s32 level)
{
throw __FUNCTION__;
}
s32 sceCameraGetZoom(s32 devnum, vm::psv::ptr<s32> pLevel)
{
throw __FUNCTION__;
}
s32 sceCameraSetZoom(s32 devnum, s32 level)
{
throw __FUNCTION__;
}
s32 sceCameraGetAntiFlicker(s32 devnum, vm::psv::ptr<s32> pMode)
{
throw __FUNCTION__;
}
s32 sceCameraSetAntiFlicker(s32 devnum, s32 mode)
{
throw __FUNCTION__;
}
s32 sceCameraGetISO(s32 devnum, vm::psv::ptr<s32> pMode)
{
throw __FUNCTION__;
}
s32 sceCameraSetISO(s32 devnum, s32 mode)
{
throw __FUNCTION__;
}
s32 sceCameraGetGain(s32 devnum, vm::psv::ptr<s32> pMode)
{
throw __FUNCTION__;
}
s32 sceCameraSetGain(s32 devnum, s32 mode)
{
throw __FUNCTION__;
}
s32 sceCameraGetWhiteBalance(s32 devnum, vm::psv::ptr<s32> pMode)
{
throw __FUNCTION__;
}
s32 sceCameraSetWhiteBalance(s32 devnum, s32 mode)
{
throw __FUNCTION__;
}
s32 sceCameraGetBacklight(s32 devnum, vm::psv::ptr<s32> pMode)
{
throw __FUNCTION__;
}
s32 sceCameraSetBacklight(s32 devnum, s32 mode)
{
throw __FUNCTION__;
}
s32 sceCameraGetNightmode(s32 devnum, vm::psv::ptr<s32> pMode)
{
throw __FUNCTION__;
}
s32 sceCameraSetNightmode(s32 devnum, s32 mode)
{
throw __FUNCTION__;
}
s32 sceCameraLedSwitch(s32 devnum, s32 iSwitch)
{
throw __FUNCTION__;
}
s32 sceCameraLedBlink(s32 devnum, s32 iOnCount, s32 iOffCount, s32 iBlinkCount)
{
throw __FUNCTION__;
}
s32 sceCameraGetNoiseReductionForDebug(s32 devnum, vm::psv::ptr<s32> pLevel)
{
throw __FUNCTION__;
}
s32 sceCameraSetNoiseReductionForDebug(s32 devnum, s32 level)
{
throw __FUNCTION__;
}
s32 sceCameraGetSharpnessOffForDebug(s32 devnum, vm::psv::ptr<s32> pLevel)
{
throw __FUNCTION__;
}
s32 sceCameraSetSharpnessOffForDebug(s32 devnum, s32 level)
{
throw __FUNCTION__;
}
void sceCameraUseCacheMemoryForTrial(s32 isCache)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceCamera, #name, name)
psv_log_base sceCamera("SceCamera", []()
{
sceCamera.on_load = nullptr;
sceCamera.on_unload = nullptr;
sceCamera.on_stop = nullptr;
REG_FUNC(0xA462F801, sceCameraOpen);
REG_FUNC(0xCD6E1CFC, sceCameraClose);
REG_FUNC(0xA8FEAE35, sceCameraStart);
REG_FUNC(0x1DD9C9CE, sceCameraStop);
REG_FUNC(0x79B5C2DE, sceCameraRead);
REG_FUNC(0x103A75B8, sceCameraIsActive);
REG_FUNC(0x624F7653, sceCameraGetSaturation);
REG_FUNC(0xF9F7CA3D, sceCameraSetSaturation);
REG_FUNC(0x85D5951D, sceCameraGetBrightness);
REG_FUNC(0x98D71588, sceCameraSetBrightness);
REG_FUNC(0x8FBE84BE, sceCameraGetContrast);
REG_FUNC(0x06FB2900, sceCameraSetContrast);
REG_FUNC(0xAA72C3DC, sceCameraGetSharpness);
REG_FUNC(0xD1A5BB0B, sceCameraSetSharpness);
REG_FUNC(0x44F6043F, sceCameraGetReverse);
REG_FUNC(0x1175F477, sceCameraSetReverse);
REG_FUNC(0x7E8EF3B2, sceCameraGetEffect);
REG_FUNC(0xE9D2CFB1, sceCameraSetEffect);
REG_FUNC(0x8B5E6147, sceCameraGetEV);
REG_FUNC(0x62AFF0B8, sceCameraSetEV);
REG_FUNC(0x06D3816C, sceCameraGetZoom);
REG_FUNC(0xF7464216, sceCameraSetZoom);
REG_FUNC(0x9FDACB99, sceCameraGetAntiFlicker);
REG_FUNC(0xE312958A, sceCameraSetAntiFlicker);
REG_FUNC(0x4EBD5C68, sceCameraGetISO);
REG_FUNC(0x3CF630A1, sceCameraSetISO);
REG_FUNC(0x2C36D6F3, sceCameraGetGain);
REG_FUNC(0xE65CFE86, sceCameraSetGain);
REG_FUNC(0xDBFFA1DA, sceCameraGetWhiteBalance);
REG_FUNC(0x4D4514AC, sceCameraSetWhiteBalance);
REG_FUNC(0x8DD1292B, sceCameraGetBacklight);
REG_FUNC(0xAE071044, sceCameraSetBacklight);
REG_FUNC(0x12B6FF26, sceCameraGetNightmode);
REG_FUNC(0x3F26233E, sceCameraSetNightmode);
REG_FUNC(0xD02CFA5C, sceCameraLedSwitch);
REG_FUNC(0x89B16030, sceCameraLedBlink);
REG_FUNC(0x7670474C, sceCameraUseCacheMemoryForTrial);
REG_FUNC(0x27BB0528, sceCameraGetNoiseReductionForDebug);
REG_FUNC(0x233C9E27, sceCameraSetNoiseReductionForDebug);
REG_FUNC(0xC387F4DC, sceCameraGetSharpnessOffForDebug);
REG_FUNC(0xE22C2375, sceCameraSetSharpnessOffForDebug);
});

46
rpcs3/Emu/ARMv7/Modules/sceCodecEngine.cpp Normal file
View File

@ -0,0 +1,46 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceCodecEngine;
struct SceCodecEnginePmonProcessorLoad
{
u32 size;
u32 average;
};
s32 sceCodecEnginePmonStart()
{
throw __FUNCTION__;
}
s32 sceCodecEnginePmonStop()
{
throw __FUNCTION__;
}
s32 sceCodecEnginePmonGetProcessorLoad(vm::psv::ptr<SceCodecEnginePmonProcessorLoad> pProcessorLoad)
{
throw __FUNCTION__;
}
s32 sceCodecEnginePmonReset()
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceCodecEngine, #name, name)
psv_log_base sceCodecEngine("SceCodecEngine", []()
{
sceCodecEngine.on_load = nullptr;
sceCodecEngine.on_unload = nullptr;
sceCodecEngine.on_stop = nullptr;
REG_FUNC(0x3E718890, sceCodecEnginePmonStart);
REG_FUNC(0x268B1EF5, sceCodecEnginePmonStop);
REG_FUNC(0x859E4A68, sceCodecEnginePmonGetProcessorLoad);
REG_FUNC(0xA097E4C8, sceCodecEnginePmonReset);
});

556
rpcs3/Emu/ARMv7/Modules/sceCommonDialog.cpp Normal file
View File

@ -0,0 +1,556 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceGxm.h"
#include "sceAppUtil.h"
#include "sceIme.h"
extern psv_log_base sceCommonDialog;
enum SceCommonDialogStatus : s32
{
SCE_COMMON_DIALOG_STATUS_NONE = 0,
SCE_COMMON_DIALOG_STATUS_RUNNING = 1,
SCE_COMMON_DIALOG_STATUS_FINISHED = 2
};
enum SceCommonDialogResult : s32
{
SCE_COMMON_DIALOG_RESULT_OK,
SCE_COMMON_DIALOG_RESULT_USER_CANCELED,
SCE_COMMON_DIALOG_RESULT_ABORTED
};
struct SceCommonDialogRenderTargetInfo
{
vm::psv::ptr<void> depthSurfaceData;
vm::psv::ptr<void> colorSurfaceData;
SceGxmColorSurfaceType surfaceType;
SceGxmColorFormat colorFormat;
u32 width;
u32 height;
u32 strideInPixels;
u8 reserved[32];
};
struct SceCommonDialogUpdateParam
{
SceCommonDialogRenderTargetInfo renderTarget;
vm::psv::ptr<SceGxmSyncObject> displaySyncObject;
u8 reserved[32];
};
struct SceMsgDialogUserMessageParam
{
s32 buttonType;
vm::psv::ptr<const char> msg;
char reserved[32];
};
struct SceMsgDialogSystemMessageParam
{
s32 sysMsgType;
s32 value;
char reserved[32];
};
struct SceMsgDialogErrorCodeParam
{
s32 errorCode;
char reserved[32];
};
struct SceMsgDialogProgressBarParam
{
s32 barType;
SceMsgDialogSystemMessageParam sysMsgParam;
vm::psv::ptr<const char> msg;
char reserved[32];
};
struct SceMsgDialogParam
{
u32 sdkVersion;
s32 mode;
vm::psv::ptr<SceMsgDialogUserMessageParam> userMsgParam;
vm::psv::ptr<SceMsgDialogSystemMessageParam> sysMsgParam;
vm::psv::ptr<SceMsgDialogErrorCodeParam> errorCodeParam;
vm::psv::ptr<SceMsgDialogProgressBarParam> progBarParam;
u32 flag;
char reserved[32];
};
struct SceMsgDialogResult
{
s32 mode;
s32 result;
s32 buttonId;
u8 reserved[32];
};
struct SceNetCheckDialogParam
{
u32 sdkVersion;
s32 mode;
u8 reserved[128];
};
struct SceNetCheckDialogResult
{
s32 result;
u8 reserved[128];
};
struct SceSaveDataDialogFixedParam
{
u32 targetSlot;
char reserved[32];
};
struct SceSaveDataDialogListParam
{
vm::psv::ptr<const u32> slotList;
u32 slotListSize;
s32 focusPos;
u32 focusId;
vm::psv::ptr<const char> listTitle;
char reserved[32];
};
struct SceSaveDataDialogUserMessageParam
{
s32 buttonType;
vm::psv::ptr<const char> msg;
u32 targetSlot;
char reserved[32];
};
struct SceSaveDataDialogSystemMessageParam
{
s32 sysMsgType;
s32 value;
u32 targetSlot;
char reserved[32];
};
struct SceSaveDataDialogErrorCodeParam
{
s32 errorCode;
u32 targetSlot;
char reserved[32];
};
struct SceSaveDataDialogProgressBarParam
{
s32 barType;
SceSaveDataDialogSystemMessageParam sysMsgParam;
vm::psv::ptr<const char> msg;
u32 targetSlot;
char reserved[32];
};
struct SceSaveDataDialogSlotConfigParam
{
vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint;
vm::psv::ptr<const char> appSubDir;
char reserved[32];
};
struct SceSaveDataDialogParam
{
u32 sdkVersion;
s32 mode;
s32 dispType;
vm::psv::ptr<SceSaveDataDialogFixedParam> fixedParam;
vm::psv::ptr<SceSaveDataDialogListParam> listParam;
vm::psv::ptr<SceSaveDataDialogUserMessageParam> userMsgParam;
vm::psv::ptr<SceSaveDataDialogSystemMessageParam> sysMsgParam;
vm::psv::ptr<SceSaveDataDialogErrorCodeParam> errorCodeParam;
vm::psv::ptr<SceSaveDataDialogProgressBarParam> progBarParam;
vm::psv::ptr<SceSaveDataDialogSlotConfigParam> slotConfParam;
u32 flag;
vm::psv::ptr<void> userdata;
char reserved[32];
};
struct SceSaveDataDialogFinishParam
{
u32 flag;
char reserved[32];
};
struct SceSaveDataDialogSlotInfo
{
u32 isExist;
vm::psv::ptr<SceAppUtilSaveDataSlotParam> slotParam;
u8 reserved[32];
};
struct SceSaveDataDialogResult
{
s32 mode;
s32 result;
s32 buttonId;
u32 slotId;
vm::psv::ptr<SceSaveDataDialogSlotInfo> slotInfo;
vm::psv::ptr<void> userdata;
char reserved[32];
};
struct SceImeDialogParam
{
u32 sdkVersion;
u32 inputMethod;
u64 supportedLanguages;
s32 languagesForced;
u32 type;
u32 option;
vm::psv::ptr<SceImeCharFilter> filter;
u32 dialogMode;
u32 textBoxMode;
vm::psv::ptr<const u16> title;
u32 maxTextLength;
vm::psv::ptr<u16> initialText;
vm::psv::ptr<u16> inputTextBuffer;
char reserved[32];
};
struct SceImeDialogResult
{
s32 result;
char reserved[32];
};
enum ScePhotoImportDialogFormatType : s32
{
SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_UNKNOWN = 0,
SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_JPEG,
SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_PNG,
SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_GIF,
SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_BMP,
SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_TIFF
};
enum ScePhotoImportDialogOrientation : s32
{
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_UNKNOWN = 0,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_TOP_LEFT,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_TOP_RIGHT,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_BOTTOM_RIGHT,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_BOTTOM_LEFT,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_LEFT_TOP,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_RIGHT_TOP,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_RIGHT_BOTTOM,
SCE_PHOTOIMPORT_DIALOG_ORIENTATION_LEFT_BOTTOM
};
struct ScePhotoImportDialogFileDataSub
{
u32 width;
u32 height;
ScePhotoImportDialogFormatType format;
ScePhotoImportDialogOrientation orientation;
char reserved[32];
};
struct ScePhotoImportDialogFileData
{
char fileName[1024];
char photoTitle[256];
char reserved[32];
};
struct ScePhotoImportDialogItemData
{
ScePhotoImportDialogFileData fileData;
ScePhotoImportDialogFileDataSub dataSub;
char reserved[32];
};
struct ScePhotoImportDialogResult
{
s32 result;
u32 importedItemNum;
char reserved[32];
};
struct ScePhotoImportDialogParam
{
u32 sdkVersion;
s32 mode;
u32 visibleCategory;
u32 itemCount;
vm::psv::ptr<ScePhotoImportDialogItemData> itemData;
char reserved[32];
};
struct ScePhotoReviewDialogParam
{
u32 sdkVersion;
s32 mode;
char fileName[1024];
vm::psv::ptr<void> workMemory;
u32 workMemorySize;
char reserved[32];
};
struct ScePhotoReviewDialogResult
{
s32 result;
char reserved[32];
};
s32 sceCommonDialogUpdate(vm::psv::ptr<const SceCommonDialogUpdateParam> updateParam)
{
throw __FUNCTION__;
}
s32 sceMsgDialogInit(vm::psv::ptr<const SceMsgDialogParam> param)
{
throw __FUNCTION__;
}
SceCommonDialogStatus sceMsgDialogGetStatus()
{
throw __FUNCTION__;
}
s32 sceMsgDialogAbort()
{
throw __FUNCTION__;
}
s32 sceMsgDialogGetResult(vm::psv::ptr<SceMsgDialogResult> result)
{
throw __FUNCTION__;
}
s32 sceMsgDialogTerm()
{
throw __FUNCTION__;
}
s32 sceMsgDialogClose()
{
throw __FUNCTION__;
}
s32 sceMsgDialogProgressBarInc(s32 target, u32 delta)
{
throw __FUNCTION__;
}
s32 sceMsgDialogProgressBarSetValue(s32 target, u32 rate)
{
throw __FUNCTION__;
}
s32 sceNetCheckDialogInit(vm::psv::ptr<SceNetCheckDialogParam> param)
{
throw __FUNCTION__;
}
SceCommonDialogStatus sceNetCheckDialogGetStatus()
{
throw __FUNCTION__;
}
s32 sceNetCheckDialogAbort()
{
throw __FUNCTION__;
}
s32 sceNetCheckDialogGetResult(vm::psv::ptr<SceNetCheckDialogResult> result)
{
throw __FUNCTION__;
}
s32 sceNetCheckDialogTerm()
{
throw __FUNCTION__;
}
s32 sceSaveDataDialogInit(vm::psv::ptr<const SceSaveDataDialogParam> param)
{
throw __FUNCTION__;
}
SceCommonDialogStatus sceSaveDataDialogGetStatus()
{
throw __FUNCTION__;
}
s32 sceSaveDataDialogAbort()
{
throw __FUNCTION__;
}
s32 sceSaveDataDialogGetResult(vm::psv::ptr<SceSaveDataDialogResult> result)
{
throw __FUNCTION__;
}
s32 sceSaveDataDialogTerm()
{
throw __FUNCTION__;
}
SceCommonDialogStatus sceSaveDataDialogGetSubStatus()
{
throw __FUNCTION__;
}
s32 sceSaveDataDialogSubClose()
{
throw __FUNCTION__;
}
s32 sceSaveDataDialogContinue(vm::psv::ptr<const SceSaveDataDialogParam> param)
{
throw __FUNCTION__;
}
s32 sceSaveDataDialogFinish(vm::psv::ptr<const SceSaveDataDialogFinishParam> param)
{
throw __FUNCTION__;
}
s32 sceSaveDataDialogProgressBarInc(s32 target, u32 delta)
{
throw __FUNCTION__;
}
s32 sceSaveDataDialogProgressBarSetValue(s32 target, u32 rate)
{
throw __FUNCTION__;
}
s32 sceImeDialogInit(vm::psv::ptr<const SceImeDialogParam> param)
{
throw __FUNCTION__;
}
SceCommonDialogStatus sceImeDialogGetStatus()
{
throw __FUNCTION__;
}
s32 sceImeDialogAbort()
{
throw __FUNCTION__;
}
s32 sceImeDialogGetResult(vm::psv::ptr<SceImeDialogResult> result)
{
throw __FUNCTION__;
}
s32 sceImeDialogTerm()
{
throw __FUNCTION__;
}
s32 scePhotoImportDialogInit(vm::psv::ptr<const ScePhotoImportDialogParam> param)
{
throw __FUNCTION__;
}
SceCommonDialogStatus scePhotoImportDialogGetStatus()
{
throw __FUNCTION__;
}
s32 scePhotoImportDialogGetResult(vm::psv::ptr<ScePhotoImportDialogResult> result)
{
throw __FUNCTION__;
}
s32 scePhotoImportDialogTerm()
{
throw __FUNCTION__;
}
s32 scePhotoImportDialogAbort()
{
throw __FUNCTION__;
}
s32 scePhotoReviewDialogInit(vm::psv::ptr<const ScePhotoReviewDialogParam> param)
{
throw __FUNCTION__;
}
SceCommonDialogStatus scePhotoReviewDialogGetStatus()
{
throw __FUNCTION__;
}
s32 scePhotoReviewDialogGetResult(vm::psv::ptr<ScePhotoReviewDialogResult> result)
{
throw __FUNCTION__;
}
s32 scePhotoReviewDialogTerm()
{
throw __FUNCTION__;
}
s32 scePhotoReviewDialogAbort()
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceCommonDialog, #name, name)
psv_log_base sceCommonDialog("SceCommonDialog", []()
{
sceCommonDialog.on_load = nullptr;
sceCommonDialog.on_unload = nullptr;
sceCommonDialog.on_stop = nullptr;
REG_FUNC(0x90530F2F, sceCommonDialogUpdate);
REG_FUNC(0x755FF270, sceMsgDialogInit);
REG_FUNC(0x4107019E, sceMsgDialogGetStatus);
REG_FUNC(0xC296D396, sceMsgDialogClose);
REG_FUNC(0x0CC66115, sceMsgDialogAbort);
REG_FUNC(0xBB3BFC89, sceMsgDialogGetResult);
REG_FUNC(0x81ACF695, sceMsgDialogTerm);
REG_FUNC(0x7BE0E08B, sceMsgDialogProgressBarInc);
REG_FUNC(0x9CDA5E0D, sceMsgDialogProgressBarSetValue);
REG_FUNC(0xA38A4A0D, sceNetCheckDialogInit);
REG_FUNC(0x8027292A, sceNetCheckDialogGetStatus);
REG_FUNC(0x2D8EDF09, sceNetCheckDialogAbort);
REG_FUNC(0xB05FCE9E, sceNetCheckDialogGetResult);
REG_FUNC(0x8BE51C15, sceNetCheckDialogTerm);
REG_FUNC(0xBF5248FA, sceSaveDataDialogInit);
REG_FUNC(0x6E258046, sceSaveDataDialogGetStatus);
REG_FUNC(0x013E7F74, sceSaveDataDialogAbort);
REG_FUNC(0xB2FF576E, sceSaveDataDialogGetResult);
REG_FUNC(0x2192A10A, sceSaveDataDialogTerm);
REG_FUNC(0x19192C8B, sceSaveDataDialogContinue);
REG_FUNC(0xBA0542CA, sceSaveDataDialogGetSubStatus);
REG_FUNC(0x415D6068, sceSaveDataDialogSubClose);
REG_FUNC(0x6C49924B, sceSaveDataDialogFinish);
REG_FUNC(0xBDE00A83, sceSaveDataDialogProgressBarInc);
REG_FUNC(0x5C322D1E, sceSaveDataDialogProgressBarSetValue);
REG_FUNC(0x1E7043BF, sceImeDialogInit);
REG_FUNC(0xCF0431FD, sceImeDialogGetStatus);
REG_FUNC(0x594A220E, sceImeDialogAbort);
REG_FUNC(0x2EB3D046, sceImeDialogGetResult);
REG_FUNC(0x838A3AF4, sceImeDialogTerm);
REG_FUNC(0x73EE7C9C, scePhotoImportDialogInit);
REG_FUNC(0x032206D8, scePhotoImportDialogGetStatus);
REG_FUNC(0xD855414C, scePhotoImportDialogGetResult);
REG_FUNC(0x7FE5BD77, scePhotoImportDialogTerm);
REG_FUNC(0x4B125581, scePhotoImportDialogAbort);
REG_FUNC(0xCD990375, scePhotoReviewDialogInit);
REG_FUNC(0xF4F600CA, scePhotoReviewDialogGetStatus);
REG_FUNC(0xFFA35858, scePhotoReviewDialogGetResult);
REG_FUNC(0xC700B2DF, scePhotoReviewDialogTerm);
REG_FUNC(0x74FF2A8B, scePhotoReviewDialogAbort);
});

85
rpcs3/Emu/ARMv7/Modules/sceCtrl.cpp Normal file
View File

@ -0,0 +1,85 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceCtrl;
struct SceCtrlData
{
u64 timeStamp;
u32 buttons;
u8 lx;
u8 ly;
u8 rx;
u8 ry;
u8 rsrv[16];
};
struct SceCtrlRapidFireRule
{
u32 uiMask;
u32 uiTrigger;
u32 uiTarget;
u32 uiDelay;
u32 uiMake;
u32 uiBreak;
};
s32 sceCtrlSetSamplingMode(u32 uiMode)
{
throw __FUNCTION__;
}
s32 sceCtrlGetSamplingMode(vm::psv::ptr<u32> puiMode)
{
throw __FUNCTION__;
}
s32 sceCtrlPeekBufferPositive(s32 port, vm::psv::ptr<SceCtrlData> pData, s32 nBufs)
{
throw __FUNCTION__;
}
s32 sceCtrlPeekBufferNegative(s32 port, vm::psv::ptr<SceCtrlData> pData, s32 nBufs)
{
throw __FUNCTION__;
}
s32 sceCtrlReadBufferPositive(s32 port, vm::psv::ptr<SceCtrlData> pData, s32 nBufs)
{
throw __FUNCTION__;
}
s32 sceCtrlReadBufferNegative(s32 port, vm::psv::ptr<SceCtrlData> pData, s32 nBufs)
{
throw __FUNCTION__;
}
s32 sceCtrlSetRapidFire(s32 port, s32 idx, vm::psv::ptr<const SceCtrlRapidFireRule> pRule)
{
throw __FUNCTION__;
}
s32 sceCtrlClearRapidFire(s32 port, s32 idx)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceCtrl, #name, name)
psv_log_base sceCtrl("SceCtrl", []()
{
sceCtrl.on_load = nullptr;
sceCtrl.on_unload = nullptr;
sceCtrl.on_stop = nullptr;
REG_FUNC(0xA497B150, sceCtrlSetSamplingMode);
REG_FUNC(0xEC752AAF, sceCtrlGetSamplingMode);
REG_FUNC(0xA9C3CED6, sceCtrlPeekBufferPositive);
REG_FUNC(0x104ED1A7, sceCtrlPeekBufferNegative);
REG_FUNC(0x67E7AB83, sceCtrlReadBufferPositive);
REG_FUNC(0x15F96FB0, sceCtrlReadBufferNegative);
REG_FUNC(0xE9CB69C8, sceCtrlSetRapidFire);
REG_FUNC(0xD8294C9C, sceCtrlClearRapidFire);
});

46
rpcs3/Emu/ARMv7/Modules/sceDbg.cpp Normal file
View File

@ -0,0 +1,46 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceDbg;
enum SceDbgBreakOnErrorState : s32
{
SCE_DBG_DISABLE_BREAK_ON_ERROR = 0,
SCE_DBG_ENABLE_BREAK_ON_ERROR
};
s32 sceDbgSetMinimumLogLevel(s32 minimumLogLevel)
{
throw __FUNCTION__;
}
s32 sceDbgSetBreakOnErrorState(SceDbgBreakOnErrorState state)
{
throw __FUNCTION__;
}
s32 sceDbgAssertionHandler(vm::psv::ptr<const char> pFile, s32 line, bool stop, vm::psv::ptr<const char> pComponent, vm::psv::ptr<const char> pMessage) // va_args...
{
throw __FUNCTION__;
}
s32 sceDbgLoggingHandler(vm::psv::ptr<const char> pFile, s32 line, s32 severity, vm::psv::ptr<const char> pComponent, vm::psv::ptr<const char> pMessage) // va_args...
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceDbg, #name, name)
psv_log_base sceDbg("SceDbg", []()
{
sceDbg.on_load = nullptr;
sceDbg.on_unload = nullptr;
sceDbg.on_stop = nullptr;
REG_FUNC(0x941622FA, sceDbgSetMinimumLogLevel);
REG_FUNC(0x1AF3678B, sceDbgAssertionHandler);
REG_FUNC(0x6605AB19, sceDbgLoggingHandler);
REG_FUNC(0xED4A00BA, sceDbgSetBreakOnErrorState);
});

48
rpcs3/Emu/ARMv7/Modules/sceDeci4p.cpp Normal file
View File

@ -0,0 +1,48 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceDeci4p;
typedef vm::psv::ptr<s32(s32 notifyId, s32 notifyCount, s32 notifyArg, vm::psv::ptr<void> pCommon)> SceKernelDeci4pCallback;
s32 sceKernelDeci4pOpen(vm::psv::ptr<const char> protoname, u32 protonum, u32 bufsize)
{
throw __FUNCTION__;
}
s32 sceKernelDeci4pClose(s32 socketid)
{
throw __FUNCTION__;
}
s32 sceKernelDeci4pRead(s32 socketid, vm::psv::ptr<void> buffer, u32 size, u32 reserved)
{
throw __FUNCTION__;
}
s32 sceKernelDeci4pWrite(s32 socketid, vm::psv::ptr<const void> buffer, u32 size, u32 reserved)
{
throw __FUNCTION__;
}
s32 sceKernelDeci4pRegisterCallback(s32 socketid, s32 cbid)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceDeci4p, #name, name)
psv_log_base sceDeci4p("SceDeci4pUserp", []()
{
sceDeci4p.on_load = nullptr;
sceDeci4p.on_unload = nullptr;
sceDeci4p.on_stop = nullptr;
REG_FUNC(0x28578FE8, sceKernelDeci4pOpen);
REG_FUNC(0x63B0C50F, sceKernelDeci4pClose);
REG_FUNC(0x971E1C66, sceKernelDeci4pRead);
REG_FUNC(0xCDA3AAAC, sceKernelDeci4pWrite);
REG_FUNC(0x73371F35, sceKernelDeci4pRegisterCallback);
});

93
rpcs3/Emu/ARMv7/Modules/sceDeflt.cpp Normal file
View File

@ -0,0 +1,93 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceDeflt;
s32 sceGzipIsValid(vm::psv::ptr<const void> pSrcGzip)
{
throw __FUNCTION__;
}
s32 sceGzipGetInfo(vm::psv::ptr<const void> pSrcGzip, vm::psv::ptr<vm::psv::ptr<const void>> ppvExtra, vm::psv::ptr<vm::psv::ptr<const char>> ppszName, vm::psv::ptr<vm::psv::ptr<const char>> ppszComment, vm::psv::ptr<u16> pusCrc, vm::psv::ptr<vm::psv::ptr<const void>> ppvData)
{
throw __FUNCTION__;
}
vm::psv::ptr<const char> sceGzipGetName(vm::psv::ptr<const void> pSrcGzip)
{
throw __FUNCTION__;
}
vm::psv::ptr<const char> sceGzipGetComment(vm::psv::ptr<const void> pSrcGzip)
{
throw __FUNCTION__;
}
vm::psv::ptr<const void> sceGzipGetCompressedData(vm::psv::ptr<const void> pSrcGzip)
{
throw __FUNCTION__;
}
s32 sceGzipDecompress(vm::psv::ptr<void> pDst, u32 uiBufSize, vm::psv::ptr<const void> pSrcGzip, vm::psv::ptr<u32> puiCrc32)
{
throw __FUNCTION__;
}
s32 sceZlibIsValid(vm::psv::ptr<const void> pSrcZlib)
{
throw __FUNCTION__;
}
s32 sceZlibGetInfo(vm::psv::ptr<const void> pSrcZlib, vm::psv::ptr<u8> pbCmf, vm::psv::ptr<u8> pbFlg, vm::psv::ptr<u32> puiDictId, vm::psv::ptr<vm::psv::ptr<const void>> ppvData)
{
throw __FUNCTION__;
}
vm::psv::ptr<const void> sceZlibGetCompressedData(vm::psv::ptr<const void> pSrcZlib)
{
throw __FUNCTION__;
}
s32 sceZlibDecompress(vm::psv::ptr<void> pDst, u32 uiBufSize, vm::psv::ptr<const void> pSrcZlib, vm::psv::ptr<u32> puiAdler32)
{
throw __FUNCTION__;
}
u32 sceZlibAdler32(u32 uiAdler, vm::psv::ptr<const u8> pSrc, u32 uiSize)
{
throw __FUNCTION__;
}
s32 sceDeflateDecompress(vm::psv::ptr<void> pDst, u32 uiBufSize, vm::psv::ptr<const void> pSrcDeflate, vm::psv::ptr<vm::psv::ptr<const void>> ppNext)
{
throw __FUNCTION__;
}
s32 sceZipGetInfo(vm::psv::ptr<const void> pSrc, vm::psv::ptr<vm::psv::ptr<const void>> ppvExtra, vm::psv::ptr<u32> puiCrc, vm::psv::ptr<vm::psv::ptr<const void>> ppvData)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceDeflt, #name, name)
psv_log_base sceDeflt("SceDeflt", []()
{
sceDeflt.on_load = nullptr;
sceDeflt.on_unload = nullptr;
sceDeflt.on_stop = nullptr;
REG_FUNC(0xCD83A464, sceZlibAdler32);
REG_FUNC(0x110D5050, sceDeflateDecompress);
REG_FUNC(0xE3CB51A3, sceGzipDecompress);
REG_FUNC(0xBABCF5CF, sceGzipGetComment);
REG_FUNC(0xE1844802, sceGzipGetCompressedData);
REG_FUNC(0x1B8E5862, sceGzipGetInfo);
REG_FUNC(0xAEBAABE6, sceGzipGetName);
REG_FUNC(0xDEDADC31, sceGzipIsValid);
REG_FUNC(0xE38F754D, sceZlibDecompress);
REG_FUNC(0xE680A65A, sceZlibGetCompressedData);
REG_FUNC(0x4C0A685D, sceZlibGetInfo);
REG_FUNC(0x14A0698D, sceZlibIsValid);
});

113
rpcs3/Emu/ARMv7/Modules/sceDisplay.cpp Normal file
View File

@ -0,0 +1,113 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceDisplay;
struct SceDisplayFrameBuf
{
u32 size;
vm::psv::ptr<void> base;
u32 pitch;
u32 pixelformat;
u32 width;
u32 height;
};
s32 sceDisplayGetRefreshRate(vm::psv::ptr<float> pFps)
{
throw __FUNCTION__;
}
s32 sceDisplaySetFrameBuf(vm::psv::ptr<const SceDisplayFrameBuf> pFrameBuf, s32 iUpdateTimingMode)
{
throw __FUNCTION__;
}
s32 sceDisplayGetFrameBuf(vm::psv::ptr<SceDisplayFrameBuf> pFrameBuf, s32 iUpdateTimingMode)
{
throw __FUNCTION__;
}
s32 sceDisplayGetVcount()
{
throw __FUNCTION__;
}
s32 sceDisplayWaitVblankStart()
{
throw __FUNCTION__;
}
s32 sceDisplayWaitVblankStartCB()
{
throw __FUNCTION__;
}
s32 sceDisplayWaitVblankStartMulti(u32 vcount)
{
throw __FUNCTION__;
}
s32 sceDisplayWaitVblankStartMultiCB(u32 vcount)
{
throw __FUNCTION__;
}
s32 sceDisplayWaitSetFrameBuf()
{
throw __FUNCTION__;
}
s32 sceDisplayWaitSetFrameBufCB()
{
throw __FUNCTION__;
}
s32 sceDisplayWaitSetFrameBufMulti(u32 vcount)
{
throw __FUNCTION__;
}
s32 sceDisplayWaitSetFrameBufMultiCB(u32 vcount)
{
throw __FUNCTION__;
}
s32 sceDisplayRegisterVblankStartCallback(s32 uid)
{
throw __FUNCTION__;
}
s32 sceDisplayUnregisterVblankStartCallback(s32 uid)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceDisplay, #name, name)
psv_log_base sceDisplay("SceDisplay", []()
{
sceDisplay.on_load = nullptr;
sceDisplay.on_unload = nullptr;
sceDisplay.on_stop = nullptr;
// SceDisplayUser
REG_FUNC(0x7A410B64, sceDisplaySetFrameBuf);
REG_FUNC(0x42AE6BBC, sceDisplayGetFrameBuf);
// SceDisplay
REG_FUNC(0xA08CA60D, sceDisplayGetRefreshRate);
REG_FUNC(0xB6FDE0BA, sceDisplayGetVcount);
REG_FUNC(0x5795E898, sceDisplayWaitVblankStart);
REG_FUNC(0x78B41B92, sceDisplayWaitVblankStartCB);
REG_FUNC(0xDD0A13B8, sceDisplayWaitVblankStartMulti);
REG_FUNC(0x05F27764, sceDisplayWaitVblankStartMultiCB);
REG_FUNC(0x9423560C, sceDisplayWaitSetFrameBuf);
REG_FUNC(0x814C90AF, sceDisplayWaitSetFrameBufCB);
REG_FUNC(0x7D9864A8, sceDisplayWaitSetFrameBufMulti);
REG_FUNC(0x3E796EF5, sceDisplayWaitSetFrameBufMultiCB);
REG_FUNC(0x6BDF4C4D, sceDisplayRegisterVblankStartCallback);
REG_FUNC(0x98436A80, sceDisplayUnregisterVblankStartCallback);
});

103
rpcs3/Emu/ARMv7/Modules/sceFiber.cpp Normal file
View File

@ -0,0 +1,103 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceFiber;
typedef vm::psv::ptr<void(u32 argOnInitialize, u32 argOnRun)> SceFiberEntry;
struct SceFiber
{
static const uint size = 128;
static const uint align = 8;
u64 padding[size / sizeof(u64)];
};
struct SceFiberOptParam
{
static const uint size = 128;
static const uint align = 8;
u64 padding[size / sizeof(u64)];
};
struct SceFiberInfo
{
static const uint size = 128;
static const uint align = 8;
union
{
u64 padding[size / sizeof(u64)];
struct
{
SceFiberEntry entry;
u32 argOnInitialize;
vm::psv::ptr<void> addrContext;
s32 sizeContext;
char name[32];
};
};
};
s32 _sceFiberInitializeImpl(vm::psv::ptr<SceFiber> fiber, vm::psv::ptr<const char> name, SceFiberEntry entry, u32 argOnInitialize, vm::psv::ptr<void> addrContext, u32 sizeContext, vm::psv::ptr<const SceFiberOptParam> optParam, u32 buildVersion)
{
throw __FUNCTION__;
}
s32 sceFiberOptParamInitialize(vm::psv::ptr<SceFiberOptParam> optParam)
{
throw __FUNCTION__;
}
s32 sceFiberFinalize(vm::psv::ptr<SceFiber> fiber)
{
throw __FUNCTION__;
}
s32 sceFiberRun(vm::psv::ptr<SceFiber> fiber, u32 argOnRunTo, vm::psv::ptr<u32> argOnReturn)
{
throw __FUNCTION__;
}
s32 sceFiberSwitch(vm::psv::ptr<SceFiber> fiber, u32 argOnRunTo, vm::psv::ptr<u32> argOnRun)
{
throw __FUNCTION__;
}
s32 sceFiberGetSelf(vm::psv::ptr<vm::psv::ptr<SceFiber>> fiber)
{
throw __FUNCTION__;
}
s32 sceFiberReturnToThread(u32 argOnReturn, vm::psv::ptr<u32> argOnRun)
{
throw __FUNCTION__;
}
s32 sceFiberGetInfo(vm::psv::ptr<SceFiber> fiber, vm::psv::ptr<SceFiberInfo> fiberInfo)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceFiber, #name, name)
psv_log_base sceFiber("SceFiber", []()
{
sceFiber.on_load = nullptr;
sceFiber.on_unload = nullptr;
sceFiber.on_stop = nullptr;
REG_FUNC(0xF24A298C, _sceFiberInitializeImpl);
//REG_FUNC(0xC6A3F9BB, _sceFiberInitializeWithInternalOptionImpl);
//REG_FUNC(0x7D0C7DDB, _sceFiberAttachContextAndRun);
//REG_FUNC(0xE00B9AFE, _sceFiberAttachContextAndSwitch);
REG_FUNC(0x801AB334, sceFiberOptParamInitialize);
REG_FUNC(0xE160F844, sceFiberFinalize);
REG_FUNC(0x7DF23243, sceFiberRun);
REG_FUNC(0xE4283144, sceFiberSwitch);
REG_FUNC(0x414D8CA5, sceFiberGetSelf);
REG_FUNC(0x3B42921F, sceFiberReturnToThread);
REG_FUNC(0x189599B4, sceFiberGetInfo);
});

945
rpcs3/Emu/ARMv7/Modules/sceFios.cpp Normal file
View File

@ -0,0 +1,945 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceFios;
typedef s64 SceFiosOffset;
typedef s64 SceFiosSize;
typedef u8 SceFiosOpEvent;
typedef s32 SceFiosHandle;
typedef SceFiosHandle SceFiosOp;
typedef SceFiosHandle SceFiosFH;
typedef SceFiosHandle SceFiosDH;
typedef s64 SceFiosTime;
typedef s8 SceFiosPriority;
typedef SceFiosTime SceFiosTimeInterval;
typedef u64 SceFiosDate;
typedef s32 SceFiosOverlayID;
typedef vm::psv::ptr<s32(vm::psv::ptr<void> pContext, SceFiosOp op, SceFiosOpEvent event, s32 err)> SceFiosOpCallback;
typedef vm::psv::ptr<s32(vm::psv::ptr<const char> fmt, va_list ap)> SceFiosVprintfCallback;
typedef vm::psv::ptr<vm::psv::ptr<void>(vm::psv::ptr<void> dst, vm::psv::ptr<const void> src, u32 len)> SceFiosMemcpyCallback;
enum SceFiosWhence : s32
{
SCE_FIOS_SEEK_SET = 0,
SCE_FIOS_SEEK_CUR = 1,
SCE_FIOS_SEEK_END = 2
};
struct SceFiosBuffer
{
vm::psv::ptr<void> pPtr;
u32 length;
};
struct SceFiosOpAttr
{
SceFiosTime deadline;
SceFiosOpCallback pCallback;
vm::psv::ptr<void> pCallbackContext;
s32 priority : 8;
u32 opflags : 24;
u32 userTag;
vm::psv::ptr<void> userPtr;
vm::psv::ptr<void> pReserved;
};
struct SceFiosDirEntry
{
SceFiosOffset fileSize;
u32 statFlags;
u16 nameLength;
u16 fullPathLength;
u16 offsetToName;
u16 reserved[3];
char fullPath[1024];
};
struct SceFiosStat
{
SceFiosOffset fileSize;
SceFiosDate accessDate;
SceFiosDate modificationDate;
SceFiosDate creationDate;
u32 statFlags;
u32 reserved;
s64 uid;
s64 gid;
s64 dev;
s64 ino;
s64 mode;
};
struct SceFiosOpenParams
{
u32 openFlags;
u32 reserved;
SceFiosBuffer buffer;
};
struct SceFiosTuple
{
SceFiosOffset offset;
SceFiosSize size;
char path[1024];
};
struct SceFiosParams
{
u32 initialized : 1;
u32 paramsSize : 14;
u32 pathMax : 16;
u32 profiling;
SceFiosBuffer opStorage;
SceFiosBuffer fhStorage;
SceFiosBuffer dhStorage;
SceFiosBuffer chunkStorage;
SceFiosVprintfCallback pVprintf;
SceFiosMemcpyCallback pMemcpy;
s32 threadPriority[2];
s32 threadAffinity[2];
};
struct SceFiosOverlay
{
u8 type;
u8 order;
u8 reserved[10];
SceFiosOverlayID id;
char dst[292];
char src[292];
};
typedef vm::psv::ptr<void()> SceFiosIOFilterCallback;
struct SceFiosPsarcDearchiverContext
{
u32 sizeOfContext;
u32 workBufferSize;
vm::psv::ptr<void> pWorkBuffer;
s32 reserved[4];
};
s32 sceFiosInitialize(vm::psv::ptr<const SceFiosParams> pParameters)
{
throw __FUNCTION__;
}
void sceFiosTerminate()
{
throw __FUNCTION__;
}
bool sceFiosIsInitialized(vm::psv::ptr<SceFiosParams> pOutParameters)
{
throw __FUNCTION__;
}
void sceFiosUpdateParameters(vm::psv::ptr<const SceFiosParams> pParameters)
{
throw __FUNCTION__;
}
void sceFiosSetGlobalDefaultOpAttr(vm::psv::ptr<const SceFiosOpAttr> pAttr)
{
throw __FUNCTION__;
}
bool sceFiosGetGlobalDefaultOpAttr(vm::psv::ptr<SceFiosOpAttr> pOutAttr)
{
throw __FUNCTION__;
}
void sceFiosSetThreadDefaultOpAttr(vm::psv::ptr<const SceFiosOpAttr> pAttr)
{
throw __FUNCTION__;
}
bool sceFiosGetThreadDefaultOpAttr(vm::psv::ptr<SceFiosOpAttr> pOutAttr)
{
throw __FUNCTION__;
}
void sceFiosGetDefaultOpAttr(vm::psv::ptr<SceFiosOpAttr> pOutAttr)
{
throw __FUNCTION__;
}
void sceFiosSuspend()
{
throw __FUNCTION__;
}
u32 sceFiosGetSuspendCount()
{
throw __FUNCTION__;
}
bool sceFiosIsSuspended()
{
throw __FUNCTION__;
}
void sceFiosResume()
{
throw __FUNCTION__;
}
void sceFiosShutdownAndCancelOps()
{
throw __FUNCTION__;
}
void sceFiosCancelAllOps()
{
throw __FUNCTION__;
}
void sceFiosCloseAllFiles()
{
throw __FUNCTION__;
}
bool sceFiosIsIdle()
{
throw __FUNCTION__;
}
u32 sceFiosGetAllFHs(vm::psv::ptr<SceFiosFH> pOutArray, u32 arraySize)
{
throw __FUNCTION__;
}
u32 sceFiosGetAllDHs(vm::psv::ptr<SceFiosDH> pOutArray, u32 arraySize)
{
throw __FUNCTION__;
}
u32 sceFiosGetAllOps(vm::psv::ptr<SceFiosOp> pOutArray, u32 arraySize)
{
throw __FUNCTION__;
}
bool sceFiosIsValidHandle(SceFiosHandle h)
{
throw __FUNCTION__;
}
s32 sceFiosPathcmp(vm::psv::ptr<const char> pA, vm::psv::ptr<const char> pB)
{
throw __FUNCTION__;
}
s32 sceFiosPathncmp(vm::psv::ptr<const char> pA, vm::psv::ptr<const char> pB, u32 n)
{
throw __FUNCTION__;
}
s32 sceFiosPrintf(vm::psv::ptr<const char> pFormat) // va_args...
{
throw __FUNCTION__;
}
s32 sceFiosVprintf(vm::psv::ptr<const char> pFormat) // va_list
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFileExists(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<bool> pOutExists)
{
throw __FUNCTION__;
}
bool sceFiosFileExistsSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFileGetSize(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<SceFiosSize> pOutSize)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFileGetSizeSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFileDelete(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
{
throw __FUNCTION__;
}
s32 sceFiosFileDeleteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosDirectoryExists(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<bool> pOutExists)
{
throw __FUNCTION__;
}
bool sceFiosDirectoryExistsSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosDirectoryCreate(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
{
throw __FUNCTION__;
}
s32 sceFiosDirectoryCreateSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosDirectoryDelete(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
{
throw __FUNCTION__;
}
s32 sceFiosDirectoryDeleteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosExists(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<bool> pOutExists)
{
throw __FUNCTION__;
}
bool sceFiosExistsSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosStat(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<SceFiosStat> pOutStatus)
{
throw __FUNCTION__;
}
s32 sceFiosStatSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<SceFiosStat> pOutStatus)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosDelete(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
{
throw __FUNCTION__;
}
s32 sceFiosDeleteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosResolve(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const SceFiosTuple> pInTuple, vm::psv::ptr<SceFiosTuple> pOutTuple)
{
throw __FUNCTION__;
}
s32 sceFiosResolveSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const SceFiosTuple> pInTuple, vm::psv::ptr<SceFiosTuple> pOutTuple)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosRename(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pOldPath, vm::psv::ptr<const char> pNewPath)
{
throw __FUNCTION__;
}
s32 sceFiosRenameSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pOldPath, vm::psv::ptr<const char> pNewPath)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFileRead(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<void> pBuf, SceFiosSize length, SceFiosOffset offset)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFileReadSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<void> pBuf, SceFiosSize length, SceFiosOffset offset)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFileWrite(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<const void> pBuf, SceFiosSize length, SceFiosOffset offset)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFileWriteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<const void> pBuf, SceFiosSize length, SceFiosOffset offset)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFileTruncate(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, SceFiosSize length)
{
throw __FUNCTION__;
}
s32 sceFiosFileTruncateSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, SceFiosSize length)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHOpen(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosFH> pOutFH, vm::psv::ptr<const char> pPath, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
{
throw __FUNCTION__;
}
s32 sceFiosFHOpenSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosFH> pOutFH, vm::psv::ptr<const char> pPath, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHStat(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<SceFiosStat> pOutStatus)
{
throw __FUNCTION__;
}
s32 sceFiosFHStatSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<SceFiosStat> pOutStatus)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHTruncate(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, SceFiosSize length)
{
throw __FUNCTION__;
}
s32 sceFiosFHTruncateSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, SceFiosSize length)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
{
throw __FUNCTION__;
}
s32 sceFiosFHSyncSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHRead(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<void> pBuf, SceFiosSize length)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFHReadSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<void> pBuf, SceFiosSize length)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHWrite(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const void> pBuf, SceFiosSize length)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFHWriteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const void> pBuf, SceFiosSize length)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHReadv(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFHReadvSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHWritev(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFHWritevSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHPread(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<void> pBuf, SceFiosSize length, SceFiosOffset offset)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFHPreadSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<void> pBuf, SceFiosSize length, SceFiosOffset offset)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHPwrite(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const void> pBuf, SceFiosSize length, SceFiosOffset offset)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFHPwriteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const void> pBuf, SceFiosSize length, SceFiosOffset offset)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHPreadv(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt, SceFiosOffset offset)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFHPreadvSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt, SceFiosOffset offset)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHPwritev(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt, SceFiosOffset offset)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFHPwritevSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt, SceFiosOffset offset)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosFHClose(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
{
throw __FUNCTION__;
}
s32 sceFiosFHCloseSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
{
throw __FUNCTION__;
}
SceFiosOffset sceFiosFHSeek(SceFiosFH fh, SceFiosOffset offset, SceFiosWhence whence)
{
throw __FUNCTION__;
}
SceFiosOffset sceFiosFHTell(SceFiosFH fh)
{
throw __FUNCTION__;
}
vm::psv::ptr<const char> sceFiosFHGetPath(SceFiosFH fh)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosFHGetSize(SceFiosFH fh)
{
throw __FUNCTION__;
}
vm::psv::ptr<SceFiosOpenParams> sceFiosFHGetOpenParams(SceFiosFH fh)
{
throw __FUNCTION__;
}
//SceFiosOp sceFiosDHOpen(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosDH> pOutDH, vm::psv::ptr<const char> pPath, SceFiosBuffer buf)
//{
// throw __FUNCTION__;
//}
//
//s32 sceFiosDHOpenSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosDH> pOutDH, vm::psv::ptr<const char> pPath, SceFiosBuffer buf)
//{
// throw __FUNCTION__;
//}
SceFiosOp sceFiosDHRead(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosDH dh, vm::psv::ptr<SceFiosDirEntry> pOutEntry)
{
throw __FUNCTION__;
}
s32 sceFiosDHReadSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosDH dh, vm::psv::ptr<SceFiosDirEntry> pOutEntry)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosDHClose(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosDH dh)
{
throw __FUNCTION__;
}
s32 sceFiosDHCloseSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosDH dh)
{
throw __FUNCTION__;
}
vm::psv::ptr<const char> sceFiosDHGetPath(SceFiosDH dh)
{
throw __FUNCTION__;
}
bool sceFiosOpIsDone(SceFiosOp op)
{
throw __FUNCTION__;
}
s32 sceFiosOpWait(SceFiosOp op)
{
throw __FUNCTION__;
}
s32 sceFiosOpWaitUntil(SceFiosOp op, SceFiosTime deadline)
{
throw __FUNCTION__;
}
void sceFiosOpDelete(SceFiosOp op)
{
throw __FUNCTION__;
}
s32 sceFiosOpSyncWait(SceFiosOp op)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosOpSyncWaitForIO(SceFiosOp op)
{
throw __FUNCTION__;
}
s32 sceFiosOpGetError(SceFiosOp op)
{
throw __FUNCTION__;
}
void sceFiosOpCancel(SceFiosOp op)
{
throw __FUNCTION__;
}
bool sceFiosOpIsCancelled(SceFiosOp op)
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceFiosOpAttr> sceFiosOpGetAttr(SceFiosOp op)
{
throw __FUNCTION__;
}
vm::psv::ptr<const char> sceFiosOpGetPath(SceFiosOp op)
{
throw __FUNCTION__;
}
vm::psv::ptr<void> sceFiosOpGetBuffer(SceFiosOp op)
{
throw __FUNCTION__;
}
SceFiosOffset sceFiosOpGetOffset(SceFiosOp op)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosOpGetRequestCount(SceFiosOp op)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosOpGetActualCount(SceFiosOp op)
{
throw __FUNCTION__;
}
void sceFiosOpReschedule(SceFiosOp op, SceFiosTime newDeadline)
{
throw __FUNCTION__;
}
SceFiosTime sceFiosTimeGetCurrent()
{
throw __FUNCTION__;
}
s64 sceFiosTimeIntervalToNanoseconds(SceFiosTimeInterval interval)
{
throw __FUNCTION__;
}
SceFiosTimeInterval sceFiosTimeIntervalFromNanoseconds(s64 ns)
{
throw __FUNCTION__;
}
SceFiosDate sceFiosDateGetCurrent()
{
throw __FUNCTION__;
}
SceFiosDate sceFiosDateFromComponents(const struct vm::psv::ptr<tm> pComponents)
{
throw __FUNCTION__;
}
struct vm::psv::ptr<tm> sceFiosDateToComponents(SceFiosDate date, struct vm::psv::ptr<tm> pOutComponents)
{
throw __FUNCTION__;
}
SceFiosDate sceFiosDateFromSceDateTime(vm::psv::ptr<const SceDateTime> pSceDateTime)
{
throw __FUNCTION__;
}
vm::psv::ptr<SceDateTime> sceFiosDateToSceDateTime(SceFiosDate date, vm::psv::ptr<SceDateTime> pSceDateTime)
{
throw __FUNCTION__;
}
s32 sceFiosOverlayAdd(vm::psv::ptr<const SceFiosOverlay> pOverlay, vm::psv::ptr<SceFiosOverlayID> pOutID)
{
throw __FUNCTION__;
}
s32 sceFiosOverlayRemove(SceFiosOverlayID id)
{
throw __FUNCTION__;
}
s32 sceFiosOverlayGetInfo(SceFiosOverlayID id, vm::psv::ptr<SceFiosOverlay> pOutOverlay)
{
throw __FUNCTION__;
}
s32 sceFiosOverlayModify(SceFiosOverlayID id, vm::psv::ptr<const SceFiosOverlay> pNewValue)
{
throw __FUNCTION__;
}
s32 sceFiosOverlayGetList(vm::psv::ptr<SceFiosOverlayID> pOutIDs, u32 maxIDs, vm::psv::ptr<u32> pActualIDs)
{
throw __FUNCTION__;
}
s32 sceFiosOverlayResolveSync(s32 resolveFlag, vm::psv::ptr<const char> pInPath, vm::psv::ptr<char> pOutPath, u32 maxPath)
{
throw __FUNCTION__;
}
SceFiosOp sceFiosArchiveGetMountBufferSize(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pArchivePath, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
{
throw __FUNCTION__;
}
SceFiosSize sceFiosArchiveGetMountBufferSizeSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pArchivePath, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
{
throw __FUNCTION__;
}
//SceFiosOp sceFiosArchiveMount(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosFH> pOutFH, vm::psv::ptr<const char> pArchivePath, vm::psv::ptr<const char> pMountPoint, SceFiosBuffer mountBuffer, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
//{
// throw __FUNCTION__;
//}
//
//s32 sceFiosArchiveMountSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosFH> pOutFH, vm::psv::ptr<const char> pArchivePath, vm::psv::ptr<const char> pMountPoint, SceFiosBuffer mountBuffer, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
//{
// throw __FUNCTION__;
//}
SceFiosOp sceFiosArchiveUnmount(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
{
throw __FUNCTION__;
}
s32 sceFiosArchiveUnmountSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
{
throw __FUNCTION__;
}
vm::psv::ptr<char> sceFiosDebugDumpError(s32 err, vm::psv::ptr<char> pBuffer, u32 bufferSize)
{
throw __FUNCTION__;
}
vm::psv::ptr<char> sceFiosDebugDumpOp(SceFiosOp op, vm::psv::ptr<char> pBuffer, u32 bufferSize)
{
throw __FUNCTION__;
}
vm::psv::ptr<char> sceFiosDebugDumpFH(SceFiosFH fh, vm::psv::ptr<char> pBuffer, u32 bufferSize)
{
throw __FUNCTION__;
}
vm::psv::ptr<char> sceFiosDebugDumpDH(SceFiosDH dh, vm::psv::ptr<char> pBuffer, u32 bufferSize)
{
throw __FUNCTION__;
}
vm::psv::ptr<char> sceFiosDebugDumpDate(SceFiosDate date, vm::psv::ptr<char> pBuffer, u32 bufferSize)
{
throw __FUNCTION__;
}
s32 sceFiosIOFilterAdd(s32 index, SceFiosIOFilterCallback pFilterCallback, vm::psv::ptr<void> pFilterContext)
{
throw __FUNCTION__;
}
s32 sceFiosIOFilterGetInfo(s32 index, vm::psv::ptr<SceFiosIOFilterCallback> pOutFilterCallback, vm::psv::ptr<vm::psv::ptr<void>> pOutFilterContext)
{
throw __FUNCTION__;
}
s32 sceFiosIOFilterRemove(s32 index)
{
throw __FUNCTION__;
}
void sceFiosIOFilterPsarcDearchiver()
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceFios, #name, name)
psv_log_base sceFios("SceFios2", []()
{
sceFios.on_load = nullptr;
sceFios.on_unload = nullptr;
sceFios.on_stop = nullptr;
REG_FUNC(0x15857180, sceFiosArchiveGetMountBufferSize);
REG_FUNC(0xDF3352FC, sceFiosArchiveGetMountBufferSizeSync);
//REG_FUNC(0x92E76BBD, sceFiosArchiveMount);
//REG_FUNC(0xC4822276, sceFiosArchiveMountSync);
REG_FUNC(0xFE1E1D28, sceFiosArchiveUnmount);
REG_FUNC(0xB26DC24D, sceFiosArchiveUnmountSync);
REG_FUNC(0x1E920B1D, sceFiosCancelAllOps);
REG_FUNC(0xF85C208B, sceFiosCloseAllFiles);
REG_FUNC(0xF6CACFC7, sceFiosDHClose);
REG_FUNC(0x1F3CC428, sceFiosDHCloseSync);
REG_FUNC(0x2B406DEB, sceFiosDHGetPath);
//REG_FUNC(0xEA9855BA, sceFiosDHOpen);
//REG_FUNC(0x34BC3713, sceFiosDHOpenSync);
REG_FUNC(0x72A0A851, sceFiosDHRead);
REG_FUNC(0xB7E79CAD, sceFiosDHReadSync);
REG_FUNC(0x280D284A, sceFiosDateFromComponents);
REG_FUNC(0x5C593C1E, sceFiosDateGetCurrent);
REG_FUNC(0x5CFF6EA0, sceFiosDateToComponents);
REG_FUNC(0x44B9F8EB, sceFiosDebugDumpDH);
REG_FUNC(0x159B1FA8, sceFiosDebugDumpDate);
REG_FUNC(0x51E677DF, sceFiosDebugDumpError);
REG_FUNC(0x5506ACAB, sceFiosDebugDumpFH);
REG_FUNC(0xE438D4F0, sceFiosDebugDumpOp);
REG_FUNC(0x764DFA7A, sceFiosDelete);
REG_FUNC(0xAAC54B44, sceFiosDeleteSync);
REG_FUNC(0x9198ED8B, sceFiosDirectoryCreate);
REG_FUNC(0xE037B076, sceFiosDirectoryCreateSync);
REG_FUNC(0xDA93677C, sceFiosDirectoryDelete);
REG_FUNC(0xB9573146, sceFiosDirectoryDeleteSync);
REG_FUNC(0x48D50D97, sceFiosDirectoryExists);
REG_FUNC(0x726E01BE, sceFiosDirectoryExistsSync);
REG_FUNC(0x6F12D8A5, sceFiosExists);
REG_FUNC(0x125EFD34, sceFiosExistsSync);
REG_FUNC(0xA88EDCA8, sceFiosFHClose);
REG_FUNC(0x45182328, sceFiosFHCloseSync);
REG_FUNC(0xC55DB73B, sceFiosFHGetOpenParams);
REG_FUNC(0x37143AE3, sceFiosFHGetPath);
REG_FUNC(0xC5C26581, sceFiosFHGetSize);
REG_FUNC(0xBF699BD4, sceFiosFHOpen);
REG_FUNC(0xC3E7C3DB, sceFiosFHOpenSync);
REG_FUNC(0x6A51E688, sceFiosFHPread);
REG_FUNC(0xE2805059, sceFiosFHPreadSync);
REG_FUNC(0x7C4E0C42, sceFiosFHPreadv);
REG_FUNC(0x4D42F95C, sceFiosFHPreadvSync);
REG_FUNC(0xCF1FAA6F, sceFiosFHPwrite);
REG_FUNC(0x1E962F57, sceFiosFHPwriteSync);
REG_FUNC(0xBBC9AFD5, sceFiosFHPwritev);
REG_FUNC(0x742ADDC4, sceFiosFHPwritevSync);
REG_FUNC(0xB09AFBDF, sceFiosFHRead);
REG_FUNC(0x76945919, sceFiosFHReadSync);
REG_FUNC(0x7DB0AFAF, sceFiosFHReadv);
REG_FUNC(0x1BC977FA, sceFiosFHReadvSync);
REG_FUNC(0xA75F3C4A, sceFiosFHSeek);
REG_FUNC(0xD97C4DF7, sceFiosFHStat);
REG_FUNC(0xF8BEAC88, sceFiosFHStatSync);
REG_FUNC(0xE485F35E, sceFiosFHSync);
REG_FUNC(0xA909CCE3, sceFiosFHSyncSync);
REG_FUNC(0xD7F33130, sceFiosFHTell);
REG_FUNC(0x2B39453B, sceFiosFHTruncate);
REG_FUNC(0xFEF940B7, sceFiosFHTruncateSync);
REG_FUNC(0xE663138E, sceFiosFHWrite);
REG_FUNC(0x984024E5, sceFiosFHWriteSync);
REG_FUNC(0x988DD7FF, sceFiosFHWritev);
REG_FUNC(0x267E6CE3, sceFiosFHWritevSync);
REG_FUNC(0xB647278B, sceFiosFileDelete);
REG_FUNC(0xB5302E30, sceFiosFileDeleteSync);
REG_FUNC(0x8758E62F, sceFiosFileExists);
REG_FUNC(0x233B070C, sceFiosFileExistsSync);
REG_FUNC(0x79D9BB50, sceFiosFileGetSize);
REG_FUNC(0x789215C3, sceFiosFileGetSizeSync);
REG_FUNC(0x84080161, sceFiosFileRead);
REG_FUNC(0x1C488B32, sceFiosFileReadSync);
REG_FUNC(0xC5513E13, sceFiosFileTruncate);
REG_FUNC(0x6E1252B8, sceFiosFileTruncateSync);
REG_FUNC(0x42C278E5, sceFiosFileWrite);
REG_FUNC(0x132B6DE6, sceFiosFileWriteSync);
REG_FUNC(0x681184A2, sceFiosGetAllDHs);
REG_FUNC(0x90AB9195, sceFiosGetAllFHs);
REG_FUNC(0x8F62832C, sceFiosGetAllOps);
REG_FUNC(0xC897F6A7, sceFiosGetDefaultOpAttr);
REG_FUNC(0x30583FCB, sceFiosGetGlobalDefaultOpAttr);
REG_FUNC(0x156EAFDC, sceFiosGetSuspendCount);
REG_FUNC(0xD55B8555, sceFiosIOFilterAdd);
REG_FUNC(0x7C9B14EB, sceFiosIOFilterGetInfo);
REG_FUNC(0x057252F2, sceFiosIOFilterPsarcDearchiver);
REG_FUNC(0x22E35018, sceFiosIOFilterRemove);
REG_FUNC(0x774C2C05, sceFiosInitialize);
REG_FUNC(0x29104BF3, sceFiosIsIdle);
REG_FUNC(0xF4F54E09, sceFiosIsInitialized);
REG_FUNC(0xD2466EA5, sceFiosIsSuspended);
REG_FUNC(0xB309E327, sceFiosIsValidHandle);
REG_FUNC(0x3904F205, sceFiosOpCancel);
REG_FUNC(0xE4EA92FA, sceFiosOpDelete);
REG_FUNC(0x218A43EE, sceFiosOpGetActualCount);
REG_FUNC(0xABFEE706, sceFiosOpGetAttr);
REG_FUNC(0x68C436E4, sceFiosOpGetBuffer);
REG_FUNC(0xBF099E16, sceFiosOpGetError);
REG_FUNC(0xF21213B9, sceFiosOpGetOffset);
REG_FUNC(0x157515CB, sceFiosOpGetPath);
REG_FUNC(0x9C1084C5, sceFiosOpGetRequestCount);
REG_FUNC(0x0C81D80E, sceFiosOpIsCancelled);
REG_FUNC(0x1B9A575E, sceFiosOpIsDone);
REG_FUNC(0x968CADBD, sceFiosOpReschedule);
REG_FUNC(0xE6A66C70, sceFiosOpSyncWait);
REG_FUNC(0x202079F9, sceFiosOpSyncWaitForIO);
REG_FUNC(0x2AC79DFC, sceFiosOpWait);
REG_FUNC(0xCC823B47, sceFiosOpWaitUntil);
REG_FUNC(0x27AE468B, sceFiosOverlayAdd);
REG_FUNC(0xF4C6B72A, sceFiosOverlayGetInfo);
REG_FUNC(0x1C0BCAD5, sceFiosOverlayGetList);
REG_FUNC(0x30F56704, sceFiosOverlayModify);
REG_FUNC(0xF3C84D0F, sceFiosOverlayRemove);
REG_FUNC(0x8A243E74, sceFiosOverlayResolveSync);
REG_FUNC(0x5E75937A, sceFiosPathcmp);
REG_FUNC(0xCC21C849, sceFiosPathncmp);
REG_FUNC(0xAF7FAADF, sceFiosPrintf);
REG_FUNC(0x25E399E5, sceFiosRename);
REG_FUNC(0x030306F4, sceFiosRenameSync);
REG_FUNC(0xD0B19C9F, sceFiosResolve);
REG_FUNC(0x7FF33797, sceFiosResolveSync);
REG_FUNC(0xBF2D3CC1, sceFiosResume);
REG_FUNC(0x4E2FD311, sceFiosSetGlobalDefaultOpAttr);
REG_FUNC(0x5B8D48C4, sceFiosShutdownAndCancelOps);
REG_FUNC(0xFF04AF72, sceFiosStat);
REG_FUNC(0xACBAF3E0, sceFiosStatSync);
REG_FUNC(0x510953DC, sceFiosSuspend);
REG_FUNC(0x2904B539, sceFiosTerminate);
REG_FUNC(0xE76C8EC3, sceFiosTimeGetCurrent);
REG_FUNC(0x35A82737, sceFiosTimeIntervalFromNanoseconds);
REG_FUNC(0x397BF626, sceFiosTimeIntervalToNanoseconds);
REG_FUNC(0x1915052A, sceFiosUpdateParameters);
REG_FUNC(0x5BA4BD6D, sceFiosVprintf);
});

29
rpcs3/Emu/ARMv7/Modules/sceFpu.cpp Normal file
View File

@ -0,0 +1,29 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceFpu;
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceFpu, #name, name)
psv_log_base sceFpu("SceFpu", []()
{
sceFpu.on_load = nullptr;
sceFpu.on_unload = nullptr;
sceFpu.on_stop = nullptr;
//REG_FUNC(0x33E1AC14, sceFpuSinf);
//REG_FUNC(0xDB66BA89, sceFpuCosf);
//REG_FUNC(0x6FBDA1C9, sceFpuTanf);
//REG_FUNC(0x53FF26AF, sceFpuAtanf);
//REG_FUNC(0xC8A4989B, sceFpuAtan2f);
//REG_FUNC(0x4D1AE0F1, sceFpuAsinf);
//REG_FUNC(0x64A8F9FE, sceFpuAcosf);
//REG_FUNC(0x936F0D27, sceFpuLogf);
//REG_FUNC(0x19881EC8, sceFpuLog2f);
//REG_FUNC(0xABBB6168, sceFpuLog10f);
//REG_FUNC(0xEFA16C6E, sceFpuExpf);
//REG_FUNC(0xA3A88AD0, sceFpuExp2f);
//REG_FUNC(0x35652326, sceFpuExp10f);
//REG_FUNC(0xDF622E56, sceFpuPowf);
});

1290
rpcs3/Emu/ARMv7/Modules/sceGxm.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

1244
rpcs3/Emu/ARMv7/Modules/sceGxm.h Normal file
View File

File diff suppressed because it is too large Load Diff

431
rpcs3/Emu/ARMv7/Modules/sceHttp.cpp Normal file
View File

@ -0,0 +1,431 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceSsl.h"
extern psv_log_base sceHttp;
enum SceHttpHttpVersion : s32
{
SCE_HTTP_VERSION_1_0 = 1,
SCE_HTTP_VERSION_1_1
};
enum SceHttpProxyMode : s32
{
SCE_HTTP_PROXY_AUTO,
SCE_HTTP_PROXY_MANUAL
};
enum SceHttpAddHeaderMode : s32
{
SCE_HTTP_HEADER_OVERWRITE,
SCE_HTTP_HEADER_ADD
};
enum SceHttpAuthType : s32
{
SCE_HTTP_AUTH_BASIC,
SCE_HTTP_AUTH_DIGEST,
SCE_HTTP_AUTH_RESERVED0,
SCE_HTTP_AUTH_RESERVED1,
SCE_HTTP_AUTH_RESERVED2
};
typedef vm::psv::ptr<s32(s32 request, SceHttpAuthType authType, vm::psv::ptr<const char> realm, vm::psv::ptr<char> username, vm::psv::ptr<char> password, s32 needEntity, vm::psv::ptr<vm::psv::ptr<u8>> entityBody, vm::psv::ptr<u32> entitySize, vm::psv::ptr<s32> save, vm::psv::ptr<void> userArg)> SceHttpAuthInfoCallback;
typedef vm::psv::ptr<s32(s32 request, s32 statusCode, vm::psv::ptr<s32> method, vm::psv::ptr<const char> location, vm::psv::ptr<void> userArg)> SceHttpRedirectCallback;
struct SceHttpMemoryPoolStats
{
u32 poolSize;
u32 maxInuseSize;
u32 currentInuseSize;
s32 reserved;
};
struct SceHttpUriElement
{
s32 opaque;
vm::psv::ptr<char> scheme;
vm::psv::ptr<char> username;
vm::psv::ptr<char> password;
vm::psv::ptr<char> hostname;
vm::psv::ptr<char> path;
vm::psv::ptr<char> query;
vm::psv::ptr<char> fragment;
u16 port;
u8 reserved[10];
};
typedef vm::psv::ptr<s32(s32 request, vm::psv::ptr<const char> url, vm::psv::ptr<const char> cookieHeader, u32 headerLen, vm::psv::ptr<void> userArg)> SceHttpCookieRecvCallback;
typedef vm::psv::ptr<s32(s32 request, vm::psv::ptr<const char> url, vm::psv::ptr<const char> cookieHeader, vm::psv::ptr<void> userArg)> SceHttpCookieSendCallback;
struct SceHttpsData
{
vm::psv::ptr<char> ptr;
u32 size;
};
struct SceHttpsCaList
{
vm::psv::ptr<vm::psv::ptr<SceSslCert>> caCerts;
s32 caNum;
};
typedef vm::psv::ptr<s32(u32 verifyEsrr, vm::psv::ptr<const vm::psv::ptr<SceSslCert>> sslCert, s32 certNum, vm::psv::ptr<void> userArg)> SceHttpsCallback;
s32 sceHttpInit(u32 poolSize)
{
throw __FUNCTION__;
}
s32 sceHttpTerm()
{
throw __FUNCTION__;
}
s32 sceHttpGetMemoryPoolStats(vm::psv::ptr<SceHttpMemoryPoolStats> currentStat)
{
throw __FUNCTION__;
}
s32 sceHttpCreateTemplate(vm::psv::ptr<const char> userAgent, s32 httpVer, s32 autoProxyConf)
{
throw __FUNCTION__;
}
s32 sceHttpDeleteTemplate(s32 tmplId)
{
throw __FUNCTION__;
}
s32 sceHttpCreateConnection(s32 tmplId, vm::psv::ptr<const char> serverName, vm::psv::ptr<const char> scheme, u16 port, s32 enableKeepalive)
{
throw __FUNCTION__;
}
s32 sceHttpCreateConnectionWithURL(s32 tmplId, vm::psv::ptr<const char> url, s32 enableKeepalive)
{
throw __FUNCTION__;
}
s32 sceHttpDeleteConnection(s32 connId)
{
throw __FUNCTION__;
}
s32 sceHttpCreateRequest(s32 connId, s32 method, vm::psv::ptr<const char> path, u64 contentLength)
{
throw __FUNCTION__;
}
s32 sceHttpCreateRequestWithURL(s32 connId, s32 method, vm::psv::ptr<const char> url, u64 contentLength)
{
throw __FUNCTION__;
}
s32 sceHttpDeleteRequest(s32 reqId)
{
throw __FUNCTION__;
}
s32 sceHttpSetResponseHeaderMaxSize(s32 id, u32 headerSize)
{
throw __FUNCTION__;
}
s32 sceHttpSetRecvBlockSize(s32 id, u32 blockSize)
{
throw __FUNCTION__;
}
s32 sceHttpSetRequestContentLength(s32 id, u64 contentLength)
{
throw __FUNCTION__;
}
s32 sceHttpSendRequest(s32 reqId, vm::psv::ptr<const void> postData, u32 size)
{
throw __FUNCTION__;
}
s32 sceHttpAbortRequest(s32 reqId)
{
throw __FUNCTION__;
}
s32 sceHttpGetResponseContentLength(s32 reqId, vm::psv::ptr<u64> contentLength)
{
throw __FUNCTION__;
}
s32 sceHttpGetStatusCode(s32 reqId, vm::psv::ptr<s32> statusCode)
{
throw __FUNCTION__;
}
s32 sceHttpGetAllResponseHeaders(s32 reqId, vm::psv::ptr<vm::psv::ptr<char>> header, vm::psv::ptr<u32> headerSize)
{
throw __FUNCTION__;
}
s32 sceHttpReadData(s32 reqId, vm::psv::ptr<void> data, u32 size)
{
throw __FUNCTION__;
}
s32 sceHttpAddRequestHeader(s32 id, vm::psv::ptr<const char> name, vm::psv::ptr<const char> value, u32 mode)
{
throw __FUNCTION__;
}
s32 sceHttpRemoveRequestHeader(s32 id, vm::psv::ptr<const char> name)
{
throw __FUNCTION__;
}
s32 sceHttpParseResponseHeader(vm::psv::ptr<const char> header, u32 headerLen, vm::psv::ptr<const char> fieldStr, vm::psv::ptr<vm::psv::ptr<const char>> fieldValue, vm::psv::ptr<u32> valueLen)
{
throw __FUNCTION__;
}
s32 sceHttpParseStatusLine(vm::psv::ptr<const char> statusLine, u32 lineLen, vm::psv::ptr<s32> httpMajorVer, vm::psv::ptr<s32> httpMinorVer, vm::psv::ptr<s32> responseCode, vm::psv::ptr<vm::psv::ptr<const char>> reasonPhrase, vm::psv::ptr<u32> phraseLen)
{
throw __FUNCTION__;
}
s32 sceHttpSetAuthInfoCallback(s32 id, SceHttpAuthInfoCallback cbfunc, vm::psv::ptr<void> userArg)
{
throw __FUNCTION__;
}
s32 sceHttpSetAuthEnabled(s32 id, s32 enable)
{
throw __FUNCTION__;
}
s32 sceHttpGetAuthEnabled(s32 id, vm::psv::ptr<s32> enable)
{
throw __FUNCTION__;
}
s32 sceHttpSetRedirectCallback(s32 id, SceHttpRedirectCallback cbfunc, vm::psv::ptr<void> userArg)
{
throw __FUNCTION__;
}
s32 sceHttpSetAutoRedirect(s32 id, s32 enable)
{
throw __FUNCTION__;
}
s32 sceHttpGetAutoRedirect(s32 id, vm::psv::ptr<s32> enable)
{
throw __FUNCTION__;
}
s32 sceHttpSetResolveTimeOut(s32 id, u32 usec)
{
throw __FUNCTION__;
}
s32 sceHttpSetResolveRetry(s32 id, s32 retry)
{
throw __FUNCTION__;
}
s32 sceHttpSetConnectTimeOut(s32 id, u32 usec)
{
throw __FUNCTION__;
}
s32 sceHttpSetSendTimeOut(s32 id, u32 usec)
{
throw __FUNCTION__;
}
s32 sceHttpSetRecvTimeOut(s32 id, u32 usec)
{
throw __FUNCTION__;
}
s32 sceHttpUriEscape(vm::psv::ptr<char> out, vm::psv::ptr<u32> require, u32 prepare, vm::psv::ptr<const char> in)
{
throw __FUNCTION__;
}
s32 sceHttpUriUnescape(vm::psv::ptr<char> out, vm::psv::ptr<u32> require, u32 prepare, vm::psv::ptr<const char> in)
{
throw __FUNCTION__;
}
s32 sceHttpUriParse(vm::psv::ptr<SceHttpUriElement> out, vm::psv::ptr<const char> srcUrl, vm::psv::ptr<void> pool, vm::psv::ptr<u32> require, u32 prepare)
{
throw __FUNCTION__;
}
s32 sceHttpUriBuild(vm::psv::ptr<char> out, vm::psv::ptr<u32> require, u32 prepare, vm::psv::ptr<const SceHttpUriElement> srcElement, u32 option)
{
throw __FUNCTION__;
}
s32 sceHttpUriMerge(vm::psv::ptr<char> mergedUrl, vm::psv::ptr<const char> url, vm::psv::ptr<const char> relativeUrl, vm::psv::ptr<u32> require, u32 prepare, u32 option)
{
throw __FUNCTION__;
}
s32 sceHttpUriSweepPath(vm::psv::ptr<char> dst, vm::psv::ptr<const char> src, u32 srcSize)
{
throw __FUNCTION__;
}
s32 sceHttpSetCookieEnabled(s32 id, s32 enable)
{
throw __FUNCTION__;
}
s32 sceHttpGetCookieEnabled(s32 id, vm::psv::ptr<s32> enable)
{
throw __FUNCTION__;
}
s32 sceHttpGetCookie(vm::psv::ptr<const char> url, vm::psv::ptr<char> cookie, vm::psv::ptr<u32> cookieLength, u32 prepare, s32 secure)
{
throw __FUNCTION__;
}
s32 sceHttpAddCookie(vm::psv::ptr<const char> url, vm::psv::ptr<const char> cookie, u32 cookieLength)
{
throw __FUNCTION__;
}
s32 sceHttpSetCookieRecvCallback(s32 id, SceHttpCookieRecvCallback cbfunc, vm::psv::ptr<void> userArg)
{
throw __FUNCTION__;
}
s32 sceHttpSetCookieSendCallback(s32 id, SceHttpCookieSendCallback cbfunc, vm::psv::ptr<void> userArg)
{
throw __FUNCTION__;
}
s32 sceHttpsLoadCert(s32 caCertNum, vm::psv::ptr<vm::psv::ptr<const SceHttpsData>> caList, vm::psv::ptr<const SceHttpsData> cert, vm::psv::ptr<const SceHttpsData> privKey)
{
throw __FUNCTION__;
}
s32 sceHttpsUnloadCert()
{
throw __FUNCTION__;
}
s32 sceHttpsEnableOption(u32 sslFlags)
{
throw __FUNCTION__;
}
s32 sceHttpsDisableOption(u32 sslFlags)
{
throw __FUNCTION__;
}
s32 sceHttpsGetSslError(s32 id, vm::psv::ptr<s32> errNum, vm::psv::ptr<u32> detail)
{
throw __FUNCTION__;
}
s32 sceHttpsSetSslCallback(s32 id, SceHttpsCallback cbfunc, vm::psv::ptr<void> userArg)
{
throw __FUNCTION__;
}
s32 sceHttpsGetCaList(vm::psv::ptr<SceHttpsCaList> caList)
{
throw __FUNCTION__;
}
s32 sceHttpsFreeCaList(vm::psv::ptr<SceHttpsCaList> caList)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceHttp, #name, name)
psv_log_base sceHttp("SceHttp", []()
{
sceHttp.on_load = nullptr;
sceHttp.on_unload = nullptr;
sceHttp.on_stop = nullptr;
REG_FUNC(0x214926D9, sceHttpInit);
REG_FUNC(0xC9076666, sceHttpTerm);
REG_FUNC(0xF98CDFA9, sceHttpGetMemoryPoolStats);
REG_FUNC(0x62241DAB, sceHttpCreateTemplate);
REG_FUNC(0xEC85ECFB, sceHttpDeleteTemplate);
REG_FUNC(0xC616C200, sceHttpCreateConnectionWithURL);
REG_FUNC(0xAEB3307E, sceHttpCreateConnection);
REG_FUNC(0xF0F65C15, sceHttpDeleteConnection);
REG_FUNC(0xBD5DA1D0, sceHttpCreateRequestWithURL);
REG_FUNC(0xB0284270, sceHttpCreateRequest);
REG_FUNC(0x3D3D29AD, sceHttpDeleteRequest);
REG_FUNC(0x9CA58B99, sceHttpSendRequest);
REG_FUNC(0x7EDE3979, sceHttpReadData);
REG_FUNC(0xF580D304, sceHttpGetResponseContentLength);
REG_FUNC(0x27071691, sceHttpGetStatusCode);
REG_FUNC(0xEA61662F, sceHttpAbortRequest);
REG_FUNC(0x7B51B122, sceHttpAddRequestHeader);
REG_FUNC(0x5EB5F548, sceHttpRemoveRequestHeader);
REG_FUNC(0x11F6C27F, sceHttpGetAllResponseHeaders);
REG_FUNC(0x03A6C89E, sceHttpParseResponseHeader);
REG_FUNC(0x179C56DB, sceHttpParseStatusLine);
REG_FUNC(0x1DA2A673, sceHttpUriEscape);
REG_FUNC(0x1274D318, sceHttpUriUnescape);
REG_FUNC(0x1D45F24E, sceHttpUriParse);
REG_FUNC(0x47664424, sceHttpUriBuild);
REG_FUNC(0x75027D1D, sceHttpUriMerge);
REG_FUNC(0x50737A3F, sceHttpUriSweepPath);
REG_FUNC(0x37C30C90, sceHttpSetRequestContentLength);
REG_FUNC(0x11EC42D0, sceHttpSetAuthEnabled);
REG_FUNC(0x6727874C, sceHttpGetAuthEnabled);
REG_FUNC(0x34891C3F, sceHttpSetAutoRedirect);
REG_FUNC(0x6EAD73EB, sceHttpGetAutoRedirect);
REG_FUNC(0xE0A3A88D, sceHttpSetAuthInfoCallback);
REG_FUNC(0x4E08167D, sceHttpSetRedirectCallback);
REG_FUNC(0x8455B5B3, sceHttpSetResolveTimeOut);
REG_FUNC(0x9AB56EA7, sceHttpSetResolveRetry);
REG_FUNC(0x237CA86E, sceHttpSetConnectTimeOut);
REG_FUNC(0x8AE3F008, sceHttpSetSendTimeOut);
REG_FUNC(0x94BF196E, sceHttpSetRecvTimeOut);
//REG_FUNC(0x27A98BDA, sceHttpSetNonblock);
//REG_FUNC(0xD65746BC, sceHttpGetNonblock);
//REG_FUNC(0x5CEB6554, sceHttpSetEpollId);
//REG_FUNC(0x9E031D7C, sceHttpGetEpollId);
//REG_FUNC(0x94F7256A, sceHttpWaitRequest);
//REG_FUNC(0x7C99AF67, sceHttpCreateEpoll);
//REG_FUNC(0x0F1FD1B3, sceHttpSetEpoll);
//REG_FUNC(0xCFB1DA4B, sceHttpUnsetEpoll);
//REG_FUNC(0x65FE983F, sceHttpGetEpoll);
//REG_FUNC(0x07D9F8BB, sceHttpDestroyEpoll);
REG_FUNC(0xAEE573A3, sceHttpSetCookieEnabled);
REG_FUNC(0x1B6EF66E, sceHttpGetCookieEnabled);
REG_FUNC(0x70220BFA, sceHttpGetCookie);
REG_FUNC(0xBEDB988D, sceHttpAddCookie);
//REG_FUNC(0x4259FB9E, sceHttpCookieExport);
//REG_FUNC(0x9DF48282, sceHttpCookieImport);
REG_FUNC(0xD4F32A23, sceHttpSetCookieRecvCallback);
REG_FUNC(0x11C03867, sceHttpSetCookieSendCallback);
REG_FUNC(0xAE8D7C33, sceHttpsLoadCert);
REG_FUNC(0x8577833F, sceHttpsUnloadCert);
REG_FUNC(0x9FBE2869, sceHttpsEnableOption);
REG_FUNC(0xC6D60403, sceHttpsDisableOption);
//REG_FUNC(0x72CB0741, sceHttpsEnableOptionPrivate);
//REG_FUNC(0x00659635, sceHttpsDisableOptionPrivate);
REG_FUNC(0x2B79BDE0, sceHttpsGetSslError);
REG_FUNC(0xA0926037, sceHttpsSetSslCallback);
REG_FUNC(0xF71AA58D, sceHttpsGetCaList);
REG_FUNC(0x56C95D94, sceHttpsFreeCaList);
});

46
rpcs3/Emu/ARMv7/Modules/sceIme.cpp Normal file
View File

@ -0,0 +1,46 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceIme.h"
s32 sceImeOpen(vm::psv::ptr<SceImeParam> param)
{
throw __FUNCTION__;
}
s32 sceImeUpdate()
{
throw __FUNCTION__;
}
s32 sceImeSetCaret(vm::psv::ptr<const SceImeCaret> caret)
{
throw __FUNCTION__;
}
s32 sceImeSetPreeditGeometry(vm::psv::ptr<const SceImePreeditGeometry> preedit)
{
throw __FUNCTION__;
}
s32 sceImeClose()
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceIme, #name, name)
psv_log_base sceIme("SceIme", []()
{
sceIme.on_load = nullptr;
sceIme.on_unload = nullptr;
sceIme.on_stop = nullptr;
REG_FUNC(0x0E050613, sceImeOpen);
REG_FUNC(0x71D6898A, sceImeUpdate);
REG_FUNC(0x889A8421, sceImeClose);
REG_FUNC(0xD8342D2A, sceImeSetCaret);
REG_FUNC(0x7B1EFAA5, sceImeSetPreeditGeometry);
});

70
rpcs3/Emu/ARMv7/Modules/sceIme.h Normal file
View File

@ -0,0 +1,70 @@
#pragma once
typedef s32(SceImeCharFilter)(u16 ch);
struct SceImeRect
{
u32 x;
u32 y;
u32 width;
u32 height;
};
struct SceImeEditText
{
u32 preeditIndex;
u32 preeditLength;
u32 caretIndex;
vm::psv::ptr<u16> str;
};
union SceImeEventParam
{
SceImeRect rect;
SceImeEditText text;
u32 caretIndex;
};
struct SceImeEvent
{
u32 id;
SceImeEventParam param;
};
struct SceImeCaret
{
u32 x;
u32 y;
u32 height;
u32 index;
};
struct SceImePreeditGeometry
{
u32 x;
u32 y;
u32 height;
};
typedef void(SceImeEventHandler)(vm::psv::ptr<void> arg, vm::psv::ptr<const SceImeEvent> e);
struct SceImeParam
{
u32 size;
u32 inputMethod;
u64 supportedLanguages;
s32 languagesForced;
u32 type;
u32 option;
vm::psv::ptr<void> work;
vm::psv::ptr<void> arg;
vm::psv::ptr<SceImeEventHandler> handler;
vm::psv::ptr<SceImeCharFilter> filter;
vm::psv::ptr<u32> initialText;
u32 maxTextLength;
vm::psv::ptr<u32> inputTextBuffer;
u32 reserved0;
u32 reserved1;
};
extern psv_log_base sceIme;

126
rpcs3/Emu/ARMv7/Modules/sceJpeg.cpp Normal file
View File

@ -0,0 +1,126 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceJpeg;
struct SceJpegOutputInfo
{
s32 colorSpace;
u16 imageWidth;
u16 imageHeight;
u32 outputBufferSize;
u32 tempBufferSize;
u32 coefBufferSize;
struct { u32 x, y; } pitch[4];
};
struct SceJpegSplitDecodeCtrl
{
vm::psv::ptr<u8> pStreamBuffer;
u32 streamBufferSize;
vm::psv::ptr<u8> pWriteBuffer;
u32 writeBufferSize;
s32 isEndOfStream;
s32 decodeMode;
SceJpegOutputInfo outputInfo;
vm::psv::ptr<void> pOutputBuffer;
vm::psv::ptr<void> pCoefBuffer;
u32 internalData[3];
};
s32 sceJpegInitMJpeg(s32 maxSplitDecoder)
{
throw __FUNCTION__;
}
s32 sceJpegFinishMJpeg()
{
throw __FUNCTION__;
}
s32 sceJpegDecodeMJpeg(
vm::psv::ptr<const u8> pJpeg,
u32 isize,
vm::psv::ptr<void> pRGBA,
u32 osize,
s32 decodeMode,
vm::psv::ptr<void> pTempBuffer,
u32 tempBufferSize,
vm::psv::ptr<void> pCoefBuffer,
u32 coefBufferSize)
{
throw __FUNCTION__;
}
s32 sceJpegDecodeMJpegYCbCr(
vm::psv::ptr<const u8> pJpeg,
u32 isize,
vm::psv::ptr<u8> pYCbCr,
u32 osize,
s32 decodeMode,
vm::psv::ptr<void> pCoefBuffer,
u32 coefBufferSize)
{
throw __FUNCTION__;
}
s32 sceJpegMJpegCsc(
vm::psv::ptr<void> pRGBA,
vm::psv::ptr<const u8> pYCbCr,
s32 xysize,
s32 iFrameWidth,
s32 colorOption,
s32 sampling)
{
throw __FUNCTION__;
}
s32 sceJpegGetOutputInfo(
vm::psv::ptr<const u8> pJpeg,
u32 isize,
s32 outputFormat,
s32 decodeMode,
vm::psv::ptr<SceJpegOutputInfo> pOutputInfo)
{
throw __FUNCTION__;
}
s32 sceJpegCreateSplitDecoder(vm::psv::ptr<SceJpegSplitDecodeCtrl> pCtrl)
{
throw __FUNCTION__;
}
s32 sceJpegDeleteSplitDecoder(vm::psv::ptr<SceJpegSplitDecodeCtrl> pCtrl)
{
throw __FUNCTION__;
}
s32 sceJpegSplitDecodeMJpeg(vm::psv::ptr<SceJpegSplitDecodeCtrl> pCtrl)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceJpeg, #name, name)
psv_log_base sceJpeg("SceJpeg", []()
{
sceJpeg.on_load = nullptr;
sceJpeg.on_unload = nullptr;
sceJpeg.on_stop = nullptr;
REG_FUNC(0xB030773B, sceJpegInitMJpeg);
REG_FUNC(0x62842598, sceJpegFinishMJpeg);
REG_FUNC(0x6215B095, sceJpegDecodeMJpeg);
REG_FUNC(0x2A769BD8, sceJpegDecodeMJpegYCbCr);
REG_FUNC(0xC2380E3A, sceJpegMJpegCsc);
REG_FUNC(0x353BA9B0, sceJpegGetOutputInfo);
REG_FUNC(0x123B4734, sceJpegCreateSplitDecoder);
REG_FUNC(0xDE8D5FA1, sceJpegDeleteSplitDecoder);
REG_FUNC(0x4598EC9C, sceJpegSplitDecodeMJpeg);
});

95
rpcs3/Emu/ARMv7/Modules/sceJpegEnc.cpp Normal file
View File

@ -0,0 +1,95 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceJpegEnc;
typedef vm::psv::ptr<void> SceJpegEncoderContext;
s32 sceJpegEncoderGetContextSize()
{
throw __FUNCTION__;
}
s32 sceJpegEncoderInit(
SceJpegEncoderContext context,
s32 iFrameWidth,
s32 iFrameHeight,
s32 pixelFormat,
vm::psv::ptr<void> pJpeg,
u32 oJpegbufSize)
{
throw __FUNCTION__;
}
s32 sceJpegEncoderEncode(
SceJpegEncoderContext context,
vm::psv::ptr<const void> pYCbCr)
{
throw __FUNCTION__;
}
s32 sceJpegEncoderEnd(SceJpegEncoderContext context)
{
throw __FUNCTION__;
}
s32 sceJpegEncoderSetValidRegion(
SceJpegEncoderContext context,
s32 iFrameWidth,
s32 iFrameHeight)
{
throw __FUNCTION__;
}
s32 sceJpegEncoderSetCompressionRatio(
SceJpegEncoderContext context,
s32 compratio)
{
throw __FUNCTION__;
}
s32 sceJpegEncoderSetHeaderMode(
SceJpegEncoderContext context,
s32 headerMode)
{
throw __FUNCTION__;
}
s32 sceJpegEncoderSetOutputAddr(
SceJpegEncoderContext context,
vm::psv::ptr<void> pJpeg,
u32 oJpegbufSize)
{
throw __FUNCTION__;
}
s32 sceJpegEncoderCsc(
SceJpegEncoderContext context,
vm::psv::ptr<void> pYCbCr,
vm::psv::ptr<const void> pRGBA,
s32 iFrameWidth,
s32 inputPixelFormat)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceJpegEnc, #name, name)
psv_log_base sceJpegEnc("SceJpegEnc", []()
{
sceJpegEnc.on_load = nullptr;
sceJpegEnc.on_unload = nullptr;
sceJpegEnc.on_stop = nullptr;
REG_FUNC(0x2B55844D, sceJpegEncoderGetContextSize);
REG_FUNC(0x88DA92B4, sceJpegEncoderInit);
REG_FUNC(0xC60DE94C, sceJpegEncoderEncode);
REG_FUNC(0xC87AA849, sceJpegEncoderEnd);
REG_FUNC(0x9511F3BC, sceJpegEncoderSetValidRegion);
REG_FUNC(0xB2B828EC, sceJpegEncoderSetCompressionRatio);
REG_FUNC(0x2F58B12C, sceJpegEncoderSetHeaderMode);
REG_FUNC(0x25D52D97, sceJpegEncoderSetOutputAddr);
REG_FUNC(0x824A7D4F, sceJpegEncoderCsc);
});

1213
rpcs3/Emu/ARMv7/Modules/sceLibKernel.cpp
View File

File diff suppressed because it is too large Load Diff

609
rpcs3/Emu/ARMv7/Modules/sceLibKernel.h Normal file
View File

@ -0,0 +1,609 @@
#pragma once
// Error Codes
enum
{
SCE_KERNEL_ERROR_ERROR = 0x80020001,
SCE_KERNEL_ERROR_NOT_IMPLEMENTED = 0x80020002,
SCE_KERNEL_ERROR_INVALID_ARGUMENT = 0x80020003,
SCE_KERNEL_ERROR_INVALID_ARGUMENT_SIZE = 0x80020004,
SCE_KERNEL_ERROR_INVALID_FLAGS = 0x80020005,
SCE_KERNEL_ERROR_ILLEGAL_SIZE = 0x80020006,
SCE_KERNEL_ERROR_ILLEGAL_ADDR = 0x80020007,
SCE_KERNEL_ERROR_UNSUP = 0x80020008,
SCE_KERNEL_ERROR_ILLEGAL_MODE = 0x80020009,
SCE_KERNEL_ERROR_ILLEGAL_ALIGNMENT = 0x8002000A,
SCE_KERNEL_ERROR_NOSYS = 0x8002000B,
SCE_KERNEL_ERROR_DEBUG_ERROR = 0x80021000,
SCE_KERNEL_ERROR_ILLEGAL_DIPSW_NUMBER = 0x80021001,
SCE_KERNEL_ERROR_CPU_ERROR = 0x80022000,
SCE_KERNEL_ERROR_MMU_ILLEGAL_L1_TYPE = 0x80022001,
SCE_KERNEL_ERROR_MMU_L2_INDEX_OVERFLOW = 0x80022002,
SCE_KERNEL_ERROR_MMU_L2_SIZE_OVERFLOW = 0x80022003,
SCE_KERNEL_ERROR_INVALID_CPU_AFFINITY = 0x80022004,
SCE_KERNEL_ERROR_INVALID_MEMORY_ACCESS = 0x80022005,
SCE_KERNEL_ERROR_INVALID_MEMORY_ACCESS_PERMISSION = 0x80022006,
SCE_KERNEL_ERROR_VA2PA_FAULT = 0x80022007,
SCE_KERNEL_ERROR_VA2PA_MAPPED = 0x80022008,
SCE_KERNEL_ERROR_VALIDATION_CHECK_FAILED = 0x80022009,
SCE_KERNEL_ERROR_SYSMEM_ERROR = 0x80024000,
SCE_KERNEL_ERROR_INVALID_PROCESS_CONTEXT = 0x80024001,
SCE_KERNEL_ERROR_UID_NAME_TOO_LONG = 0x80024002,
SCE_KERNEL_ERROR_VARANGE_IS_NOT_PHYSICAL_CONTINUOUS = 0x80024003,
SCE_KERNEL_ERROR_PHYADDR_ERROR = 0x80024100,
SCE_KERNEL_ERROR_NO_PHYADDR = 0x80024101,
SCE_KERNEL_ERROR_PHYADDR_USED = 0x80024102,
SCE_KERNEL_ERROR_PHYADDR_NOT_USED = 0x80024103,
SCE_KERNEL_ERROR_NO_IOADDR = 0x80024104,
SCE_KERNEL_ERROR_PHYMEM_ERROR = 0x80024300,
SCE_KERNEL_ERROR_ILLEGAL_PHYPAGE_STATUS = 0x80024301,
SCE_KERNEL_ERROR_NO_FREE_PHYSICAL_PAGE = 0x80024302,
SCE_KERNEL_ERROR_NO_FREE_PHYSICAL_PAGE_UNIT = 0x80024303,
SCE_KERNEL_ERROR_PHYMEMPART_NOT_EMPTY = 0x80024304,
SCE_KERNEL_ERROR_NO_PHYMEMPART_LPDDR2 = 0x80024305,
SCE_KERNEL_ERROR_NO_PHYMEMPART_CDRAM = 0x80024306,
SCE_KERNEL_ERROR_FIXEDHEAP_ERROR = 0x80024400,
SCE_KERNEL_ERROR_FIXEDHEAP_ILLEGAL_SIZE = 0x80024401,
SCE_KERNEL_ERROR_FIXEDHEAP_ILLEGAL_INDEX = 0x80024402,
SCE_KERNEL_ERROR_FIXEDHEAP_INDEX_OVERFLOW = 0x80024403,
SCE_KERNEL_ERROR_FIXEDHEAP_NO_CHUNK = 0x80024404,
SCE_KERNEL_ERROR_UID_ERROR = 0x80024500,
SCE_KERNEL_ERROR_INVALID_UID = 0x80024501,
SCE_KERNEL_ERROR_SYSMEM_UID_INVALID_ARGUMENT = 0x80024502,
SCE_KERNEL_ERROR_SYSMEM_INVALID_UID_RANGE = 0x80024503,
SCE_KERNEL_ERROR_SYSMEM_NO_VALID_UID = 0x80024504,
SCE_KERNEL_ERROR_SYSMEM_CANNOT_ALLOCATE_UIDENTRY = 0x80024505,
SCE_KERNEL_ERROR_NOT_PROCESS_UID = 0x80024506,
SCE_KERNEL_ERROR_NOT_KERNEL_UID = 0x80024507,
SCE_KERNEL_ERROR_INVALID_UID_CLASS = 0x80024508,
SCE_KERNEL_ERROR_INVALID_UID_SUBCLASS = 0x80024509,
SCE_KERNEL_ERROR_UID_CANNOT_FIND_BY_NAME = 0x8002450A,
SCE_KERNEL_ERROR_VIRPAGE_ERROR = 0x80024600,
SCE_KERNEL_ERROR_ILLEGAL_VIRPAGE_TYPE = 0x80024601,
SCE_KERNEL_ERROR_BLOCK_ERROR = 0x80024700,
SCE_KERNEL_ERROR_ILLEGAL_BLOCK_ID = 0x80024701,
SCE_KERNEL_ERROR_ILLEGAL_BLOCK_TYPE = 0x80024702,
SCE_KERNEL_ERROR_BLOCK_IN_USE = 0x80024703,
SCE_KERNEL_ERROR_PARTITION_ERROR = 0x80024800,
SCE_KERNEL_ERROR_ILLEGAL_PARTITION_ID = 0x80024801,
SCE_KERNEL_ERROR_ILLEGAL_PARTITION_INDEX = 0x80024802,
SCE_KERNEL_ERROR_NO_L2PAGETABLE = 0x80024803,
SCE_KERNEL_ERROR_HEAPLIB_ERROR = 0x80024900,
SCE_KERNEL_ERROR_ILLEGAL_HEAP_ID = 0x80024901,
SCE_KERNEL_ERROR_OUT_OF_RANG = 0x80024902,
SCE_KERNEL_ERROR_HEAPLIB_NOMEM = 0x80024903,
SCE_KERNEL_ERROR_SYSMEM_ADDRESS_SPACE_ERROR = 0x80024A00,
SCE_KERNEL_ERROR_INVALID_ADDRESS_SPACE_ID = 0x80024A01,
SCE_KERNEL_ERROR_INVALID_PARTITION_INDEX = 0x80024A02,
SCE_KERNEL_ERROR_ADDRESS_SPACE_CANNOT_FIND_PARTITION_BY_ADDR = 0x80024A03,
SCE_KERNEL_ERROR_SYSMEM_MEMBLOCK_ERROR = 0x80024B00,
SCE_KERNEL_ERROR_ILLEGAL_MEMBLOCK_TYPE = 0x80024B01,
SCE_KERNEL_ERROR_ILLEGAL_MEMBLOCK_REMAP_TYPE = 0x80024B02,
SCE_KERNEL_ERROR_NOT_PHY_CONT_MEMBLOCK = 0x80024B03,
SCE_KERNEL_ERROR_ILLEGAL_MEMBLOCK_CODE = 0x80024B04,
SCE_KERNEL_ERROR_ILLEGAL_MEMBLOCK_SIZE = 0x80024B05,
SCE_KERNEL_ERROR_ILLEGAL_USERMAP_SIZE = 0x80024B06,
SCE_KERNEL_ERROR_MEMBLOCK_TYPE_FOR_KERNEL_PROCESS = 0x80024B07,
SCE_KERNEL_ERROR_PROCESS_CANNOT_REMAP_MEMBLOCK = 0x80024B08,
SCE_KERNEL_ERROR_SYSMEM_PHYMEMLOW_ERROR = 0x80024C00,
SCE_KERNEL_ERROR_CANNOT_ALLOC_PHYMEMLOW = 0x80024C01,
SCE_KERNEL_ERROR_UNKNOWN_PHYMEMLOW_TYPE = 0x80024C02,
SCE_KERNEL_ERROR_SYSMEM_BITHEAP_ERROR = 0x80024D00,
SCE_KERNEL_ERROR_CANNOT_ALLOC_BITHEAP = 0x80024D01,
SCE_KERNEL_ERROR_LOADCORE_ERROR = 0x80025000,
SCE_KERNEL_ERROR_ILLEGAL_ELF_HEADER = 0x80025001,
SCE_KERNEL_ERROR_ILLEGAL_SELF_HEADER = 0x80025002,
SCE_KERNEL_ERROR_EXCPMGR_ERROR = 0x80027000,
SCE_KERNEL_ERROR_ILLEGAL_EXCPCODE = 0x80027001,
SCE_KERNEL_ERROR_ILLEGAL_EXCPHANDLER = 0x80027002,
SCE_KERNEL_ERROR_NOTFOUND_EXCPHANDLER = 0x80027003,
SCE_KERNEL_ERROR_CANNOT_RELEASE_EXCPHANDLER = 0x80027004,
SCE_KERNEL_ERROR_INTRMGR_ERROR = 0x80027100,
SCE_KERNEL_ERROR_ILLEGAL_CONTEXT = 0x80027101,
SCE_KERNEL_ERROR_ILLEGAL_INTRCODE = 0x80027102,
SCE_KERNEL_ERROR_ILLEGAL_INTRPARAM = 0x80027103,
SCE_KERNEL_ERROR_ILLEGAL_INTRPRIORITY = 0x80027104,
SCE_KERNEL_ERROR_ILLEGAL_TARGET_CPU = 0x80027105,
SCE_KERNEL_ERROR_ILLEGAL_INTRFILTER = 0x80027106,
SCE_KERNEL_ERROR_ILLEGAL_INTRTYPE = 0x80027107,
SCE_KERNEL_ERROR_ILLEGAL_HANDLER = 0x80027108,
SCE_KERNEL_ERROR_FOUND_HANDLER = 0x80027109,
SCE_KERNEL_ERROR_NOTFOUND_HANDLER = 0x8002710A,
SCE_KERNEL_ERROR_NO_MEMORY = 0x8002710B,
SCE_KERNEL_ERROR_DMACMGR_ERROR = 0x80027200,
SCE_KERNEL_ERROR_ALREADY_QUEUED = 0x80027201,
SCE_KERNEL_ERROR_NOT_QUEUED = 0x80027202,
SCE_KERNEL_ERROR_NOT_SETUP = 0x80027203,
SCE_KERNEL_ERROR_ON_TRANSFERRING = 0x80027204,
SCE_KERNEL_ERROR_NOT_INITIALIZED = 0x80027205,
SCE_KERNEL_ERROR_TRANSFERRED = 0x80027206,
SCE_KERNEL_ERROR_NOT_UNDER_CONTROL = 0x80027207,
SCE_KERNEL_ERROR_SYSTIMER_ERROR = 0x80027300,
SCE_KERNEL_ERROR_NO_FREE_TIMER = 0x80027301,
SCE_KERNEL_ERROR_TIMER_NOT_ALLOCATED = 0x80027302,
SCE_KERNEL_ERROR_TIMER_COUNTING = 0x80027303,
SCE_KERNEL_ERROR_TIMER_STOPPED = 0x80027304,
SCE_KERNEL_ERROR_THREADMGR_ERROR = 0x80028000,
SCE_KERNEL_ERROR_DORMANT = 0x80028001,
SCE_KERNEL_ERROR_NOT_DORMANT = 0x80028002,
SCE_KERNEL_ERROR_UNKNOWN_THID = 0x80028003,
SCE_KERNEL_ERROR_CAN_NOT_WAIT = 0x80028004,
SCE_KERNEL_ERROR_ILLEGAL_THID = 0x80028005,
SCE_KERNEL_ERROR_THREAD_TERMINATED = 0x80028006,
SCE_KERNEL_ERROR_DELETED = 0x80028007,
SCE_KERNEL_ERROR_WAIT_TIMEOUT = 0x80028008,
SCE_KERNEL_ERROR_NOTIFY_CALLBACK = 0x80028009,
SCE_KERNEL_ERROR_WAIT_DELETE = 0x8002800A,
SCE_KERNEL_ERROR_ILLEGAL_ATTR = 0x8002800B,
SCE_KERNEL_ERROR_EVF_MULTI = 0x8002800C,
SCE_KERNEL_ERROR_WAIT_CANCEL = 0x8002800D,
SCE_KERNEL_ERROR_EVF_COND = 0x8002800E,
SCE_KERNEL_ERROR_ILLEGAL_COUNT = 0x8002800F,
SCE_KERNEL_ERROR_ILLEGAL_PRIORITY = 0x80028010,
SCE_KERNEL_ERROR_MUTEX_RECURSIVE = 0x80028011,
SCE_KERNEL_ERROR_MUTEX_LOCK_OVF = 0x80028012,
SCE_KERNEL_ERROR_MUTEX_NOT_OWNED = 0x80028013,
SCE_KERNEL_ERROR_MUTEX_UNLOCK_UDF = 0x80028014,
SCE_KERNEL_ERROR_MUTEX_FAILED_TO_OWN = 0x80028015,
SCE_KERNEL_ERROR_FAST_MUTEX_RECURSIVE = 0x80028016,
SCE_KERNEL_ERROR_FAST_MUTEX_LOCK_OVF = 0x80028017,
SCE_KERNEL_ERROR_FAST_MUTEX_FAILED_TO_OWN = 0x80028018,
SCE_KERNEL_ERROR_FAST_MUTEX_NOT_OWNED = 0x80028019,
SCE_KERNEL_ERROR_FAST_MUTEX_OWNED = 0x8002801A,
SCE_KERNEL_ERROR_ALARM_CAN_NOT_CANCEL = 0x8002801B,
SCE_KERNEL_ERROR_INVALID_OBJECT_TYPE = 0x8002801C,
SCE_KERNEL_ERROR_KERNEL_TLS_FULL = 0x8002801D,
SCE_KERNEL_ERROR_ILLEGAL_KERNEL_TLS_INDEX = 0x8002801E,
SCE_KERNEL_ERROR_KERNEL_TLS_BUSY = 0x8002801F,
SCE_KERNEL_ERROR_DIFFERENT_UID_CLASS = 0x80028020,
SCE_KERNEL_ERROR_UNKNOWN_UID = 0x80028021,
SCE_KERNEL_ERROR_SEMA_ZERO = 0x80028022,
SCE_KERNEL_ERROR_SEMA_OVF = 0x80028023,
SCE_KERNEL_ERROR_PMON_NOT_THREAD_MODE = 0x80028024,
SCE_KERNEL_ERROR_PMON_NOT_CPU_MODE = 0x80028025,
SCE_KERNEL_ERROR_ALREADY_REGISTERED = 0x80028026,
SCE_KERNEL_ERROR_INVALID_THREAD_ID = 0x80028027,
SCE_KERNEL_ERROR_ALREADY_DEBUG_SUSPENDED = 0x80028028,
SCE_KERNEL_ERROR_NOT_DEBUG_SUSPENDED = 0x80028029,
SCE_KERNEL_ERROR_CAN_NOT_USE_VFP = 0x8002802A,
SCE_KERNEL_ERROR_RUNNING = 0x8002802B,
SCE_KERNEL_ERROR_EVENT_COND = 0x8002802C,
SCE_KERNEL_ERROR_MSG_PIPE_FULL = 0x8002802D,
SCE_KERNEL_ERROR_MSG_PIPE_EMPTY = 0x8002802E,
SCE_KERNEL_ERROR_ALREADY_SENT = 0x8002802F,
SCE_KERNEL_ERROR_CAN_NOT_SUSPEND = 0x80028030,
SCE_KERNEL_ERROR_FAST_MUTEX_ALREADY_INITIALIZED = 0x80028031,
SCE_KERNEL_ERROR_FAST_MUTEX_NOT_INITIALIZED = 0x80028032,
SCE_KERNEL_ERROR_THREAD_STOPPED = 0x80028033,
SCE_KERNEL_ERROR_THREAD_SUSPENDED = 0x80028034,
SCE_KERNEL_ERROR_NOT_SUSPENDED = 0x80028035,
SCE_KERNEL_ERROR_WAIT_DELETE_MUTEX = 0x80028036,
SCE_KERNEL_ERROR_WAIT_CANCEL_MUTEX = 0x80028037,
SCE_KERNEL_ERROR_WAIT_DELETE_COND = 0x80028038,
SCE_KERNEL_ERROR_WAIT_CANCEL_COND = 0x80028039,
SCE_KERNEL_ERROR_LW_MUTEX_NOT_OWNED = 0x8002803A,
SCE_KERNEL_ERROR_LW_MUTEX_LOCK_OVF = 0x8002803B,
SCE_KERNEL_ERROR_LW_MUTEX_UNLOCK_UDF = 0x8002803C,
SCE_KERNEL_ERROR_LW_MUTEX_RECURSIVE = 0x8002803D,
SCE_KERNEL_ERROR_LW_MUTEX_FAILED_TO_OWN = 0x8002803E,
SCE_KERNEL_ERROR_WAIT_DELETE_LW_MUTEX = 0x8002803F,
SCE_KERNEL_ERROR_ILLEGAL_STACK_SIZE = 0x80028040,
SCE_KERNEL_ERROR_RW_LOCK_RECURSIVE = 0x80028041,
SCE_KERNEL_ERROR_RW_LOCK_LOCK_OVF = 0x80028042,
SCE_KERNEL_ERROR_RW_LOCK_NOT_OWNED = 0x80028043,
SCE_KERNEL_ERROR_RW_LOCK_UNLOCK_UDF = 0x80028044,
SCE_KERNEL_ERROR_RW_LOCK_FAILED_TO_LOCK = 0x80028045,
SCE_KERNEL_ERROR_RW_LOCK_FAILED_TO_UNLOCK = 0x80028046,
SCE_KERNEL_ERROR_PROCESSMGR_ERROR = 0x80029000,
SCE_KERNEL_ERROR_INVALID_PID = 0x80029001,
SCE_KERNEL_ERROR_INVALID_PROCESS_TYPE = 0x80029002,
SCE_KERNEL_ERROR_PLS_FULL = 0x80029003,
SCE_KERNEL_ERROR_INVALID_PROCESS_STATUS = 0x80029004,
SCE_KERNEL_ERROR_INVALID_BUDGET_ID = 0x80029005,
SCE_KERNEL_ERROR_INVALID_BUDGET_SIZE = 0x80029006,
SCE_KERNEL_ERROR_CP14_DISABLED = 0x80029007,
SCE_KERNEL_ERROR_EXCEEDED_MAX_PROCESSES = 0x80029008,
SCE_KERNEL_ERROR_PROCESS_REMAINING = 0x80029009,
SCE_KERNEL_ERROR_IOFILEMGR_ERROR = 0x8002A000,
SCE_KERNEL_ERROR_IO_NAME_TOO_LONG = 0x8002A001,
SCE_KERNEL_ERROR_IO_REG_DEV = 0x8002A002,
SCE_KERNEL_ERROR_IO_ALIAS_USED = 0x8002A003,
SCE_KERNEL_ERROR_IO_DEL_DEV = 0x8002A004,
SCE_KERNEL_ERROR_IO_WOULD_BLOCK = 0x8002A005,
SCE_KERNEL_ERROR_MODULEMGR_START_FAILED = 0x8002D000,
SCE_KERNEL_ERROR_MODULEMGR_STOP_FAIL = 0x8002D001,
SCE_KERNEL_ERROR_MODULEMGR_IN_USE = 0x8002D002,
SCE_KERNEL_ERROR_MODULEMGR_NO_LIB = 0x8002D003,
SCE_KERNEL_ERROR_MODULEMGR_SYSCALL_REG = 0x8002D004,
SCE_KERNEL_ERROR_MODULEMGR_NOMEM_LIB = 0x8002D005,
SCE_KERNEL_ERROR_MODULEMGR_NOMEM_STUB = 0x8002D006,
SCE_KERNEL_ERROR_MODULEMGR_NOMEM_SELF = 0x8002D007,
SCE_KERNEL_ERROR_MODULEMGR_NOMEM = 0x8002D008,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_LIB = 0x8002D009,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_STUB = 0x8002D00A,
SCE_KERNEL_ERROR_MODULEMGR_NO_FUNC_NID = 0x8002D00B,
SCE_KERNEL_ERROR_MODULEMGR_NO_VAR_NID = 0x8002D00C,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_TYPE = 0x8002D00D,
SCE_KERNEL_ERROR_MODULEMGR_NO_MOD_ENTRY = 0x8002D00E,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_PROC_PARAM = 0x8002D00F,
SCE_KERNEL_ERROR_MODULEMGR_NO_MODOBJ = 0x8002D010,
SCE_KERNEL_ERROR_MODULEMGR_NO_MOD = 0x8002D011,
SCE_KERNEL_ERROR_MODULEMGR_NO_PROCESS = 0x8002D012,
SCE_KERNEL_ERROR_MODULEMGR_OLD_LIB = 0x8002D013,
SCE_KERNEL_ERROR_MODULEMGR_STARTED = 0x8002D014,
SCE_KERNEL_ERROR_MODULEMGR_NOT_STARTED = 0x8002D015,
SCE_KERNEL_ERROR_MODULEMGR_NOT_STOPPED = 0x8002D016,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_PROCESS_UID = 0x8002D017,
SCE_KERNEL_ERROR_MODULEMGR_CANNOT_EXPORT_LIB_TO_SHARED = 0x8002D018,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_REL_INFO = 0x8002D019,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_REF_INFO = 0x8002D01A,
SCE_KERNEL_ERROR_MODULEMGR_ELINK = 0x8002D01B,
SCE_KERNEL_ERROR_MODULEMGR_NOENT = 0x8002D01C,
SCE_KERNEL_ERROR_MODULEMGR_BUSY = 0x8002D01D,
SCE_KERNEL_ERROR_MODULEMGR_NOEXEC = 0x8002D01E,
SCE_KERNEL_ERROR_MODULEMGR_NAMETOOLONG = 0x8002D01F,
SCE_KERNEL_ERROR_LIBRARYDB_NOENT = 0x8002D080,
SCE_KERNEL_ERROR_LIBRARYDB_NO_LIB = 0x8002D081,
SCE_KERNEL_ERROR_LIBRARYDB_NO_MOD = 0x8002D082,
SCE_KERNEL_ERROR_AUTHFAIL = 0x8002F000,
SCE_KERNEL_ERROR_NO_AUTH = 0x8002F001,
};
enum psv_object_class_t : u32
{
SCE_KERNEL_UID_CLASS_PROCESS = 0,
SCE_KERNEL_THREADMGR_UID_CLASS_THREAD = 1,
SCE_KERNEL_THREADMGR_UID_CLASS_SEMA = 2,
SCE_KERNEL_THREADMGR_UID_CLASS_EVENT_FLAG = 3,
SCE_KERNEL_THREADMGR_UID_CLASS_MUTEX = 4,
SCE_KERNEL_THREADMGR_UID_CLASS_COND = 5,
SCE_KERNEL_THREADMGR_UID_CLASS_TIMER = 6,
SCE_KERNEL_THREADMGR_UID_CLASS_MSG_PIPE = 7,
SCE_KERNEL_THREADMGR_UID_CLASS_CALLBACK = 8,
SCE_KERNEL_THREADMGR_UID_CLASS_THREAD_EVENT = 9,
};
union SceKernelSysClock
{
struct
{
u32 low;
u32 hi;
};
u64 quad;
};
struct SceKernelCallFrame
{
u32 sp;
u32 pc;
};
// Memory Manager definitions
typedef s32 SceKernelMemoryType;
struct SceKernelMemBlockInfo
{
u32 size;
vm::psv::ptr<void> mappedBase;
u32 mappedSize;
SceKernelMemoryType memoryType;
u32 access;
};
struct SceKernelAllocMemBlockOpt
{
u32 size;
u32 attr;
u32 alignment;
s32 uidBaseBlock;
vm::psv::ptr<const char> strBaseBlockName;
};
// Thread Manager definitions (threads)
typedef s32(SceKernelThreadEntry)(u32 argSize, vm::psv::ptr<void> pArgBlock);
struct SceKernelThreadOptParam
{
u32 size;
u32 attr;
};
struct SceKernelThreadInfo
{
u32 size;
s32 processId;
char name[32];
u32 attr;
u32 status;
vm::psv::ptr<SceKernelThreadEntry> entry;
vm::psv::ptr<void> pStack;
u32 stackSize;
s32 initPriority;
s32 currentPriority;
s32 initCpuAffinityMask;
s32 currentCpuAffinityMask;
s32 currentCpuId;
s32 lastExecutedCpuId;
u32 waitType;
s32 waitId;
s32 exitStatus;
SceKernelSysClock runClocks;
u32 intrPreemptCount;
u32 threadPreemptCount;
u32 threadReleaseCount;
s32 changeCpuCount;
s32 fNotifyCallback;
s32 reserved;
};
struct SceKernelThreadRunStatus
{
u32 size;
struct
{
s32 processId;
s32 threadId;
s32 priority;
} cpuInfo[4];
};
struct SceKernelSystemInfo
{
u32 size;
u32 activeCpuMask;
struct
{
SceKernelSysClock idleClock;
u32 comesOutOfIdleCount;
u32 threadSwitchCount;
} cpuInfo[4];
};
// Thread Manager definitions (callbacks)
typedef s32(SceKernelCallbackFunction)(s32 notifyId, s32 notifyCount, s32 notifyArg, vm::psv::ptr<void> pCommon);
struct SceKernelCallbackInfo
{
u32 size;
s32 callbackId;
char name[32];
u32 attr;
s32 threadId;
vm::psv::ptr<SceKernelCallbackFunction> callbackFunc;
s32 notifyId;
s32 notifyCount;
s32 notifyArg;
vm::psv::ptr<void> pCommon;
};
// Thread Manager definitions (events)
typedef s32(SceKernelThreadEventHandler)(s32 type, s32 threadId, s32 arg, vm::psv::ptr<void> pCommon);
struct SceKernelEventInfo
{
u32 size;
s32 eventId;
char name[32];
u32 attr;
u32 eventPattern;
u64 userData;
u32 numWaitThreads;
s32 reserved[1];
};
struct SceKernelWaitEvent
{
s32 eventId;
u32 eventPattern;
};
struct SceKernelResultEvent
{
s32 eventId;
s32 result;
u32 resultPattern;
s32 reserved[1];
u64 userData;
};
// Thread Manager definitions (event flags)
struct SceKernelEventFlagOptParam
{
u32 size;
};
struct SceKernelEventFlagInfo
{
u32 size;
s32 evfId;
char name[32];
u32 attr;
u32 initPattern;
u32 currentPattern;
s32 numWaitThreads;
};
// Thread Manager definitions (semaphores)
struct SceKernelSemaOptParam
{
u32 size;
};
struct SceKernelSemaInfo
{
u32 size;
s32 semaId;
char name[32];
u32 attr;
s32 initCount;
s32 currentCount;
s32 maxCount;
s32 numWaitThreads;
};
// Thread Manager definitions (mutexes)
struct SceKernelMutexOptParam
{
u32 size;
s32 ceilingPriority;
};
struct SceKernelMutexInfo
{
u32 size;
s32 mutexId;
char name[32];
u32 attr;
s32 initCount;
s32 currentCount;
s32 currentOwnerId;
s32 numWaitThreads;
};
// Thread Manager definitions (lightweight mutexes)
struct SceKernelLwMutexWork
{
s32 data[4];
};
struct SceKernelLwMutexOptParam
{
u32 size;
};
struct SceKernelLwMutexInfo
{
u32 size;
s32 uid;
char name[32];
u32 attr;
vm::psv::ptr<SceKernelLwMutexWork> pWork;
s32 initCount;
s32 currentCount;
s32 currentOwnerId;
s32 numWaitThreads;
};
// Thread Manager definitions (condition variables)
struct SceKernelCondOptParam
{
u32 size;
};
struct SceKernelCondInfo
{
u32 size;
s32 condId;
char name[32];
u32 attr;
s32 mutexId;
u32 numWaitThreads;
};
// Thread Manager definitions (lightweight condition variables)
struct SceKernelLwCondWork
{
s32 data[4];
};
struct SceKernelLwCondOptParam
{
u32 size;
};
struct SceKernelLwCondInfo
{
u32 size;
s32 uid;
char name[32];
u32 attr;
vm::psv::ptr<SceKernelLwCondWork> pWork;
vm::psv::ptr<SceKernelLwMutexWork> pLwMutex;
u32 numWaitThreads;
};
// Thread Manager definitions (timers)
struct SceKernelTimerOptParam
{
u32 size;
};
struct SceKernelTimerInfo
{
u32 size;
s32 timerId;
char name[32];
u32 attr;
s32 fActive;
SceKernelSysClock baseTime;
SceKernelSysClock currentTime;
SceKernelSysClock schedule;
SceKernelSysClock interval;
s32 type;
s32 fRepeat;
s32 numWaitThreads;
s32 reserved[1];
};
// Thread Manager definitions (reader/writer locks)
struct SceKernelRWLockOptParam
{
u32 size;
};
struct SceKernelRWLockInfo
{
u32 size;
s32 rwLockId;
char name[32];
u32 attr;
s32 lockCount;
s32 writeOwnerId;
s32 numReadWaitThreads;
s32 numWriteWaitThreads;
};
// IO/File Manager definitions
struct SceIoStat
{
s32 mode;
u32 attr;
s64 size;
SceDateTime ctime;
SceDateTime atime;
SceDateTime mtime;
u64 _private[6];
};
struct SceIoDirent
{
SceIoStat d_stat;
char d_name[256];
vm::psv::ptr<void> d_private;
s32 dummy;
};
// Module
extern psv_log_base sceLibKernel;

164
rpcs3/Emu/ARMv7/Modules/sceLibc.cpp
View File

@ -1,63 +1,183 @@
#include "stdafx.h"
#include "stdafx.h"
#include "Utilities/Log.h"
#include "Emu/System.h"
#include "Emu/Memory/Memory.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "Emu/ARMv7/ARMv7Callback.h"
extern psv_log_base sceLibc;
vm::psv::ptr<void> g_dso;
typedef void(atexit_func_t)(vm::psv::ptr<void>);
std::vector<std::function<void(ARMv7Context&)>> g_atexit;
namespace sce_libc_func
{
void __cxa_atexit()
void __cxa_atexit(vm::psv::ptr<atexit_func_t> func, vm::psv::ptr<void> arg, vm::psv::ptr<void> dso)
{
sceLibc.Todo(__FUNCTION__);
Emu.Pause();
sceLibc.Warning("__cxa_atexit(func=0x%x, arg=0x%x, dso=0x%x)", func, arg, dso);
LV2_LOCK(0);
g_atexit.insert(g_atexit.begin(), [func, arg, dso](ARMv7Context& context)
{
func(context, arg);
});
}
void exit()
void __aeabi_atexit(vm::psv::ptr<void> arg, vm::psv::ptr<atexit_func_t> func, vm::psv::ptr<void> dso)
{
sceLibc.Error("exit()");
Emu.Pause();
sceLibc.Warning("__aeabi_atexit(arg=0x%x, func=0x%x, dso=0x%x)", arg, func, dso);
LV2_LOCK(0);
g_atexit.insert(g_atexit.begin(), [func, arg, dso](ARMv7Context& context)
{
func(context, arg);
});
}
void exit(ARMv7Context& context)
{
sceLibc.Warning("exit()");
LV2_LOCK(0);
for (auto func : g_atexit)
{
func(context);
}
g_atexit.clear();
sceLibc.Success("Process finished");
CallAfter([]()
{
Emu.Stop();
});
}
void printf(vm::psv::ptr<const char> fmt) // va_args...
std::string armv7_fmt(ARMv7Context& context, vm::psv::ptr<const char> fmt, u32 g_count, u32 f_count, u32 v_count)
{
sceLibc.Error("printf(fmt=0x%x)", fmt);
std::string result;
LOG_NOTICE(TTY, "%s", fmt.get_ptr());
for (char c = *fmt++; c; c = *fmt++)
{
switch (c)
{
case '%':
{
const auto start = fmt - 1;
const bool number_sign = *fmt == '#' ? fmt++, true : false;
switch (*fmt++)
{
case '%':
{
result += '%';
continue;
}
case 'd':
case 'i':
{
// signed decimal
const s64 value = context.get_next_gpr_arg(g_count, f_count, v_count);
result += fmt::to_sdec(value);
continue;
}
case 'x':
{
// hexadecimal
const u64 value = context.get_next_gpr_arg(g_count, f_count, v_count);
if (number_sign && value)
{
result += "0x";
}
result += fmt::to_hex(value);
continue;
}
default:
{
throw fmt::Format("armv7_fmt(): unknown formatting: '%s'", start.get_ptr());
}
}
}
}
result += c;
}
return result;
}
void __cxa_set_dso_handle_main()
void printf(ARMv7Context& context, vm::psv::ptr<const char> fmt) // va_args...
{
sceLibc.Error("__cxa_set_dso_handle_main()");
sceLibc.Warning("printf(fmt=0x%x)", fmt);
sceLibc.Notice("*** *fmt = '%s'", fmt.get_ptr());
LOG_NOTICE(TTY, armv7_fmt(context, fmt, 1, 0, 0));
}
void sprintf(ARMv7Context& context, vm::psv::ptr<char> str, vm::psv::ptr<const char> fmt) // va_args...
{
sceLibc.Warning("sprintf(str=0x%x, fmt=0x%x)", str, fmt);
sceLibc.Notice("*** *fmt = '%s'", fmt.get_ptr());
const std::string& result = armv7_fmt(context, fmt, 2, 0, 0);
sceLibc.Notice("*** res -> '%s'", result);
::memcpy(str.get_ptr(), result.c_str(), result.size() + 1);
}
void __cxa_set_dso_handle_main(vm::psv::ptr<void> dso)
{
sceLibc.Warning("__cxa_set_dso_handle_main(dso=0x%x)", dso);
g_dso = dso;
}
void memcpy(vm::psv::ptr<void> dst, vm::psv::ptr<const void> src, u32 size)
{
sceLibc.Error("memcpy(dst=0x%x, src=0x%x, size=0x%x)", dst, src, size);
sceLibc.Warning("memcpy(dst=0x%x, src=0x%x, size=0x%x)", dst, src, size);
::memcpy(dst.get_ptr(), src.get_ptr(), size);
}
void memset(vm::psv::ptr<void> dst, s32 value, u32 size)
{
sceLibc.Warning("memset(dst=0x%x, value=%d, size=0x%x)", dst, value, size);
::memset(dst.get_ptr(), value, size);
}
void _Assert(vm::psv::ptr<const char> text, vm::psv::ptr<const char> func)
{
sceLibc.Error("_Assert(text=0x%x, func=0x%x)", text, func);
sceLibc.Warning("_Assert(text=0x%x, func=0x%x)", text, func);
LOG_ERROR(TTY, "%s : %s", func.get_ptr(), text.get_ptr());
LOG_ERROR(TTY, "%s : %s\n", func.get_ptr(), text.get_ptr());
Emu.Pause();
}
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceLibc, #name, &sce_libc_func::name)
psv_log_base sceLibc = []() -> psv_log_base
psv_log_base sceLibc("SceLibc", []()
{
g_dso.set(0);
g_atexit.clear();
sceLibc.on_load = nullptr;
sceLibc.on_unload = nullptr;
sceLibc.on_stop = nullptr;
REG_FUNC(0xE4531F85, _Assert);
//REG_FUNC(0xE71C5CDE, _Stoul);
//REG_FUNC(0x7A5CA6A3, _Stoulx);
@ -147,7 +267,7 @@ psv_log_base sceLibc = []() -> psv_log_base
//REG_FUNC(0x395490DA, setbuf);
//REG_FUNC(0x2CA980A0, setvbuf);
//REG_FUNC(0xA1BFF606, snprintf);
//REG_FUNC(0x7449B359, sprintf);
REG_FUNC(0x7449B359, sprintf);
//REG_FUNC(0xEC585241, sscanf);
//REG_FUNC(0x2BCB3F01, ungetc);
//REG_FUNC(0xF7915685, vfprintf);
@ -200,7 +320,7 @@ psv_log_base sceLibc = []() -> psv_log_base
//REG_FUNC(0x7747F6D7, memcmp);
REG_FUNC(0x7205BFDB, memcpy);
//REG_FUNC(0xAF5C218D, memmove);
//REG_FUNC(0x6DC1F0D8, memset);
REG_FUNC(0x6DC1F0D8, memset);
//REG_FUNC(0x1434FA46, strcat);
//REG_FUNC(0xB9336E16, strchr);
//REG_FUNC(0x1B58FA3B, strcmp);
@ -317,7 +437,7 @@ psv_log_base sceLibc = []() -> psv_log_base
//REG_FUNC(0x9D885076, _Towctrans);
//REG_FUNC(0xE980110A, _Iswctype);
REG_FUNC(0x33b83b70, __cxa_atexit);
//REG_FUNC(0xEDC939E1, __aeabi_atexit);
REG_FUNC(0xEDC939E1, __aeabi_atexit);
//REG_FUNC(0xB538BF48, __cxa_finalize);
//REG_FUNC(0xD0310E31, __cxa_guard_acquire);
//REG_FUNC(0x4ED1056F, __cxa_guard_release);
@ -350,6 +470,4 @@ psv_log_base sceLibc = []() -> psv_log_base
//REG_FUNC(0x677CDE35, _Snan);
//REG_FUNC(0x7D35108B, _FSnan);
//REG_FUNC(0x48AEEF2A, _LSnan);
return psv_log_base("SceLibc");
}();
});

37
rpcs3/Emu/ARMv7/Modules/sceLibm.cpp
View File

@ -1,6 +1,5 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/Memory/Memory.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceLibm;
@ -12,8 +11,12 @@ namespace sce_libm_func
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceLibm, #name, &sce_libm_func::name)
psv_log_base sceLibm = []() -> psv_log_base
psv_log_base sceLibm("SceLibm", []()
{
sceLibm.on_load = nullptr;
sceLibm.on_unload = nullptr;
sceLibm.on_stop = nullptr;
//REG_FUNC(0xC73FE76D, _Exp);
//REG_FUNC(0xFF4EAE04, _FExp);
//REG_FUNC(0xB363D7D4, _LExp);
@ -44,10 +47,10 @@ psv_log_base sceLibm = []() -> psv_log_base
//REG_FUNC(0x63F05BD6, ceil);
//REG_FUNC(0x6BBFEC89, ceilf);
//REG_FUNC(0x48082D81, ceill);
//REG_FUNC(0xB918D13, copysign);
//REG_FUNC(0x0B918D13, copysign);
//REG_FUNC(0x16EB9E63, copysignf);
//REG_FUNC(0x19DFC0AA, copysignl);
//REG_FUNC(0x61D0244, cos);
//REG_FUNC(0x061D0244, cos);
//REG_FUNC(0x127F8302, cosf);
//REG_FUNC(0x89B9BE1F, cosl);
//REG_FUNC(0x110195E7, cosh);
@ -56,7 +59,7 @@ psv_log_base sceLibm = []() -> psv_log_base
//REG_FUNC(0x4B84C012, _Cosh);
//REG_FUNC(0x15993458, erf);
//REG_FUNC(0x524AEBFE, erfc);
//REG_FUNC(0x301F113, erfcf);
//REG_FUNC(0x0301F113, erfcf);
//REG_FUNC(0xD4C92471, erfcl);
//REG_FUNC(0x41DD1AB8, erff);
//REG_FUNC(0xFD431619, erfl);
@ -71,7 +74,7 @@ psv_log_base sceLibm = []() -> psv_log_base
//REG_FUNC(0x8BF1866C, expm1l);
//REG_FUNC(0x3E672BE3, fabs);
//REG_FUNC(0x75348906, fabsf);
//REG_FUNC(0x3ECA514, fabsl);
//REG_FUNC(0x03ECA514, fabsl);
//REG_FUNC(0xA278B20D, _FCosh);
//REG_FUNC(0xD6FD5A2E, fdim);
//REG_FUNC(0x8B6CC137, fdimf);
@ -93,19 +96,19 @@ psv_log_base sceLibm = []() -> psv_log_base
//REG_FUNC(0x1CD8F88E, fmodf);
//REG_FUNC(0x986011B4, fmodl);
//REG_FUNC(0x59197427, frexp);
//REG_FUNC(0xA6879AC, frexpf);
//REG_FUNC(0x0A6879AC, frexpf);
//REG_FUNC(0x6DC8D877, frexpl);
//REG_FUNC(0x4A496BC0, _FSin);
//REG_FUNC(0x7FBB4C55, _FSinh);
//REG_FUNC(0x2D2CD795, hypot);
//REG_FUNC(0xA397B929, hypotf);
//REG_FUNC(0x5BFBEE8, hypotl);
//REG_FUNC(0x05BFBEE8, hypotl);
//REG_FUNC(0x667EE864, ilogb);
//REG_FUNC(0x80050A43, ilogbf);
//REG_FUNC(0x91298DCA, ilogbl);
//REG_FUNC(0x197C9D5, _LCosh);
//REG_FUNC(0x56061B, ldexp);
//REG_FUNC(0xE61E016, ldexpf);
//REG_FUNC(0x0197C9D5, _LCosh);
//REG_FUNC(0x0056061B, ldexp);
//REG_FUNC(0x0E61E016, ldexpf);
//REG_FUNC(0x8280A7B1, ldexpl);
//REG_FUNC(0x2480AA54, lgamma);
//REG_FUNC(0x2D9556D5, lgammaf);
@ -115,7 +118,7 @@ psv_log_base sceLibm = []() -> psv_log_base
//REG_FUNC(0xC1F6135B, llrintf);
//REG_FUNC(0x80558247, llrintl);
//REG_FUNC(0xD1251A18, llround);
//REG_FUNC(0x4595A04, llroundf);
//REG_FUNC(0x04595A04, llroundf);
//REG_FUNC(0x9AB5C7AF, llroundl);
//REG_FUNC(0x6037C48F, log);
//REG_FUNC(0x811ED68B, logf);
@ -131,7 +134,7 @@ psv_log_base sceLibm = []() -> psv_log_base
//REG_FUNC(0x4095DBDB, log2f);
//REG_FUNC(0x720021A9, log2l);
//REG_FUNC(0x5EAE8AD4, logb);
//REG_FUNC(0x25F51CE, logbf);
//REG_FUNC(0x025F51CE, logbf);
//REG_FUNC(0x86C4B75F, logbl);
//REG_FUNC(0x207307D0, lrint);
//REG_FUNC(0xDA903135, lrintf);
@ -197,8 +200,8 @@ psv_log_base sceLibm = []() -> psv_log_base
//REG_FUNC(0x3A7FE686, tgamma);
//REG_FUNC(0xE6067AC0, tgammaf);
//REG_FUNC(0x2949109F, tgammal);
//REG_FUNC(0x212323E, trunc);
//REG_FUNC(0x90B899F, truncf);
//REG_FUNC(0x0212323E, trunc);
//REG_FUNC(0x090B899F, truncf);
//REG_FUNC(0xBC0F1B1A, truncl);
//REG_FUNC(0x98BBDAE0, _Dclass);
//REG_FUNC(0xBD8EF217, _FDclass);
@ -212,6 +215,4 @@ psv_log_base sceLibm = []() -> psv_log_base
//REG_FUNC(0x5BD0F71C, _Dsign);
//REG_FUNC(0xC4F7E42C, _FDsign);
//REG_FUNC(0x1DF73D2B, _LDsign);
return psv_log_base("SceLibm");
}();
});

253
rpcs3/Emu/ARMv7/Modules/sceLibstdcxx.cpp
View File

@ -1,6 +1,5 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/Memory/Memory.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceLibstdcxx;
@ -9,27 +8,29 @@ namespace sce_libstdcxx_func
{
void __aeabi_unwind_cpp_pr0()
{
sceLibstdcxx.Todo(__FUNCTION__);
Emu.Pause();
throw __FUNCTION__;
}
void __aeabi_unwind_cpp_pr1()
{
sceLibstdcxx.Todo(__FUNCTION__);
Emu.Pause();
throw __FUNCTION__;
}
void __aeabi_unwind_cpp_pr2()
{
sceLibstdcxx.Todo(__FUNCTION__);
Emu.Pause();
throw __FUNCTION__;
}
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceLibstdcxx, #name, &sce_libstdcxx_func::name)
// Attention: find and set correct original mangled name in third parameter, for example: REG_FUNC(0xAE71DC3, operator_new_nothrow, "_ZnwjRKSt9nothrow_t");
#define REG_FUNC(nid, name, orig_name) reg_psv_func(nid, &sceLibstdcxx, orig_name, &sce_libstdcxx_func::name)
psv_log_base sceLibstdcxx = []() -> psv_log_base
psv_log_base sceLibstdcxx("SceLibstdcxx", []()
{
sceLibstdcxx.on_load = nullptr;
sceLibstdcxx.on_unload = nullptr;
sceLibstdcxx.on_stop = nullptr;
//REG_FUNC(0x52B0C625, std::bad_typeid::what() const);
//REG_FUNC(0x64D7D074, std::bad_typeid::_Doraise() const);
//REG_FUNC(0x15FB88E2, std::logic_error::what() const);
@ -52,14 +53,14 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x16F56E8D, std::invalid_argument::_Doraise() const);
//REG_FUNC(0x6C568D20, std::_ctype<char>::do_tolower(char*, char const*) const);
//REG_FUNC(0xC334DE66, std::_ctype<char>::do_tolower(char) const);
//REG_FUNC(0x2DD808E, std::_ctype<char>::do_toupper(char*, char const*) const);
//REG_FUNC(0x02DD808E, std::_ctype<char>::do_toupper(char*, char const*) const);
//REG_FUNC(0xF6AF33EA, std::_ctype<char>::do_toupper(char) const);
//REG_FUNC(0x1B81D726, std::_ctype<char>::do_widen(char const*, char const*, char*) const);
//REG_FUNC(0x6471CC01, std::_ctype<char>::do_widen(char) const);
//REG_FUNC(0x9CFA56E5, std::_ctype<char>::do_narrow(char const*, char const*, char, char*) const);
//REG_FUNC(0x718669AB, std::_ctype<char>::do_narrow(char, char) const);
//REG_FUNC(0x759F105D, std::_ctype<wchar_t>::do_scan_is(short, wchar_t const*, wchar_t const*) const);
//REG_FUNC(0x56443F, std::_ctype<wchar_t>::do_tolower(wchar_t*, wchar_t const*) const);
//REG_FUNC(0x0056443F, std::_ctype<wchar_t>::do_tolower(wchar_t*, wchar_t const*) const);
//REG_FUNC(0x33E9ECDD, std::_ctype<wchar_t>::do_tolower(wchar_t) const);
//REG_FUNC(0x1256E6A5, std::_ctype<wchar_t>::do_toupper(wchar_t*, wchar_t const*) const);
//REG_FUNC(0x64072C2E, std::_ctype<wchar_t>::do_toupper(wchar_t) const);
@ -87,7 +88,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x664750EE, std::bad_alloc::what() const);
//REG_FUNC(0xBA89FBE7, std::bad_alloc::_Doraise() const);
//REG_FUNC(0xC133E331, std::exception::what() const);
//REG_FUNC(0x656BE32, std::exception::_Raise() const);
//REG_FUNC(0x0656BE32, std::exception::_Raise() const);
//REG_FUNC(0x47A5CDA2, std::exception::_Doraise() const);
//REG_FUNC(0xBAE38DF9, std::type_info::name() const);
//REG_FUNC(0x1F260F10, std::type_info::before(std::type_info const&) const);
@ -115,10 +116,10 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x9CF31703, std::istrstream::~istrstream());
//REG_FUNC(0x71D13A36, std::istrstream::~istrstream());
//REG_FUNC(0xAF5DF8C3, std::istrstream::~istrstream());
//REG_FUNC(0xC1E7C7A, std::ostrstream::ostrstream(char*, int, std::_Iosb<int>::_Openmode));
//REG_FUNC(0xC09B290, std::ostrstream::ostrstream(char*, int, std::_Iosb<int>::_Openmode));
//REG_FUNC(0x0C1E7C7A, std::ostrstream::ostrstream(char*, int, std::_Iosb<int>::_Openmode));
//REG_FUNC(0x0C09B290, std::ostrstream::ostrstream(char*, int, std::_Iosb<int>::_Openmode));
//REG_FUNC(0x4B8BA644, std::ostrstream::~ostrstream());
//REG_FUNC(0xE463FB3, std::ostrstream::~ostrstream());
//REG_FUNC(0x0E463FB3, std::ostrstream::~ostrstream());
//REG_FUNC(0xA0A34FEF, std::ostrstream::~ostrstream());
//REG_FUNC(0xC9F632FF, std::logic_error::logic_error(std::logic_error const&));
//REG_FUNC(0xE6356C5C, std::logic_error::logic_error(std::string const&));
@ -132,12 +133,12 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x7D5412EF, std::domain_error::domain_error(std::domain_error const&));
//REG_FUNC(0x803A7D3E, std::domain_error::~domain_error());
//REG_FUNC(0xA6BCA2AD, std::domain_error::~domain_error());
//REG_FUNC(0x36F9D2A, std::domain_error::~domain_error());
//REG_FUNC(0x036F9D2A, std::domain_error::~domain_error());
//REG_FUNC(0x5F3428AD, std::length_error::length_error(std::length_error const&));
//REG_FUNC(0xF6FB801D, std::length_error::length_error(std::string const&));
//REG_FUNC(0xF83AA7DA, std::length_error::~length_error());
//REG_FUNC(0xA873D7F9, std::length_error::~length_error());
//REG_FUNC(0xBB12C75, std::length_error::~length_error());
//REG_FUNC(0x0BB12C75, std::length_error::~length_error());
//REG_FUNC(0x299AA587, std::out_of_range::out_of_range(std::out_of_range const&));
//REG_FUNC(0xC8BA5522, std::out_of_range::out_of_range(std::string const&));
//REG_FUNC(0xA8C470A4, std::out_of_range::~out_of_range());
@ -153,7 +154,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0xA9F4FABF, std::strstreambuf::underflow());
//REG_FUNC(0x1C887DDE, std::strstreambuf::~strstreambuf());
//REG_FUNC(0x29E1E930, std::strstreambuf::~strstreambuf());
//REG_FUNC(0xA140889, std::strstreambuf::~strstreambuf());
//REG_FUNC(0x0A140889, std::strstreambuf::~strstreambuf());
//REG_FUNC(0xA8FE6FC4, std::_codecvt_base::~_codecvt_base());
//REG_FUNC(0xB0E47AE4, std::_codecvt_base::~_codecvt_base());
//REG_FUNC(0xB7EE9CC2, std::bad_exception::bad_exception(std::bad_exception const&));
@ -170,7 +171,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x413E813E, std::basic_filebuf<char, std::char_traits<char> >::setbuf(char*, int));
//REG_FUNC(0x9D193B65, std::basic_filebuf<char, std::char_traits<char> >::_Unlock());
//REG_FUNC(0x52E47FB5, std::basic_filebuf<char, std::char_traits<char> >::seekoff(long, std::_Iosb<int>::_Seekdir, std::_Iosb<int>::_Openmode));
//REG_FUNC(0xE119B37, std::basic_filebuf<char, std::char_traits<char> >::seekpos(std::fpos<std::_Mbstatet>, std::_Iosb<int>::_Openmode));
//REG_FUNC(0x0E119B37, std::basic_filebuf<char, std::char_traits<char> >::seekpos(std::fpos<std::_Mbstatet>, std::_Iosb<int>::_Openmode));
//REG_FUNC(0x616754BC, std::basic_filebuf<char, std::char_traits<char> >::overflow(int));
//REG_FUNC(0xCD5BD2E1, std::basic_filebuf<char, std::char_traits<char> >::_Endwrite());
//REG_FUNC(0xFC1C7F3A, std::basic_filebuf<char, std::char_traits<char> >::pbackfail(int));
@ -193,7 +194,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0xFFFA683E, std::basic_istream<wchar_t, std::char_traits<wchar_t> >::~basic_istream());
//REG_FUNC(0xB58839C5, std::basic_istream<wchar_t, std::char_traits<wchar_t> >::~basic_istream());
//REG_FUNC(0x9BF8855B, std::basic_ostream<wchar_t, std::char_traits<wchar_t> >::basic_ostream(std::basic_streambuf<wchar_t, std::char_traits<wchar_t> >*, bool));
//REG_FUNC(0xD74F56E, std::basic_ostream<wchar_t, std::char_traits<wchar_t> >::~basic_ostream());
//REG_FUNC(0x0D74F56E, std::basic_ostream<wchar_t, std::char_traits<wchar_t> >::~basic_ostream());
//REG_FUNC(0x9B831B60, std::basic_ostream<wchar_t, std::char_traits<wchar_t> >::~basic_ostream());
//REG_FUNC(0x396337CE, std::runtime_error::runtime_error(std::runtime_error const&));
//REG_FUNC(0xDAD26367, std::runtime_error::~runtime_error());
@ -205,20 +206,20 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x4E45F680, std::overflow_error::~overflow_error());
//REG_FUNC(0x626515E3, std::basic_streambuf<char, std::char_traits<char> >::sync());
//REG_FUNC(0x2E55F15A, std::basic_streambuf<char, std::char_traits<char> >::_Lock());
//REG_FUNC(0xF8535AB, std::basic_streambuf<char, std::char_traits<char> >::uflow());
//REG_FUNC(0x0F8535AB, std::basic_streambuf<char, std::char_traits<char> >::uflow());
//REG_FUNC(0xD7933D06, std::basic_streambuf<char, std::char_traits<char> >::setbuf(char*, int));
//REG_FUNC(0xB8BCCC8D, std::basic_streambuf<char, std::char_traits<char> >::xsgetn(char*, int));
//REG_FUNC(0x43E5D0F1, std::basic_streambuf<char, std::char_traits<char> >::xsputn(char const*, int));
//REG_FUNC(0x149B193A, std::basic_streambuf<char, std::char_traits<char> >::_Unlock());
//REG_FUNC(0x600998EC, std::basic_streambuf<char, std::char_traits<char> >::seekoff(long, std::_Iosb<int>::_Seekdir, std::_Iosb<int>::_Openmode));
//REG_FUNC(0x1DEFFD6, std::basic_streambuf<char, std::char_traits<char> >::seekpos(std::fpos<std::_Mbstatet>, std::_Iosb<int>::_Openmode));
//REG_FUNC(0x01DEFFD6, std::basic_streambuf<char, std::char_traits<char> >::seekpos(std::fpos<std::_Mbstatet>, std::_Iosb<int>::_Openmode));
//REG_FUNC(0xF5F44352, std::basic_streambuf<char, std::char_traits<char> >::overflow(int));
//REG_FUNC(0xCA79344F, std::basic_streambuf<char, std::char_traits<char> >::pbackfail(int));
//REG_FUNC(0x441788B1, std::basic_streambuf<char, std::char_traits<char> >::showmanyc());
//REG_FUNC(0x797DAE94, std::basic_streambuf<char, std::char_traits<char> >::underflow());
//REG_FUNC(0x74AD52E, std::basic_streambuf<char, std::char_traits<char> >::~basic_streambuf());
//REG_FUNC(0x074AD52E, std::basic_streambuf<char, std::char_traits<char> >::~basic_streambuf());
//REG_FUNC(0xE449E2BF, std::basic_streambuf<char, std::char_traits<char> >::~basic_streambuf());
//REG_FUNC(0x9FAA0AA, std::basic_streambuf<wchar_t, std::char_traits<wchar_t> >::sync());
//REG_FUNC(0x09FAA0AA, std::basic_streambuf<wchar_t, std::char_traits<wchar_t> >::sync());
//REG_FUNC(0xA596C88C, std::basic_streambuf<wchar_t, std::char_traits<wchar_t> >::_Lock());
//REG_FUNC(0x373C2CD8, std::basic_streambuf<wchar_t, std::char_traits<wchar_t> >::uflow());
//REG_FUNC(0x3F363796, std::basic_streambuf<wchar_t, std::char_traits<wchar_t> >::setbuf(wchar_t*, int));
@ -242,7 +243,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x9982A4FC, std::invalid_argument::~invalid_argument());
//REG_FUNC(0x1AB2B1AC, std::invalid_argument::~invalid_argument());
//REG_FUNC(0xF9FAB558, std::_Mutex::_Lock());
//REG_FUNC(0x402C9F8, std::_Mutex::_Unlock());
//REG_FUNC(0x0402C9F8, std::_Mutex::_Unlock());
//REG_FUNC(0x9DA92617, std::_Mutex::_Mutex(std::_Uninitialized));
//REG_FUNC(0xA4F99AE7, std::_Mutex::_Mutex());
//REG_FUNC(0x7B5A6B7F, std::_Mutex::_Mutex(std::_Uninitialized));
@ -275,12 +276,12 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x65D88619, std::ios_base::Init::~Init());
//REG_FUNC(0x3483E01D, std::ios_base::Init::~Init());
//REG_FUNC(0x78CB190E, std::ios_base::_Init());
//REG_FUNC(0x23B8BEE, std::ios_base::_Tidy());
//REG_FUNC(0x023B8BEE, std::ios_base::_Tidy());
//REG_FUNC(0xC9DE8208, std::ios_base::clear(std::_Iosb<int>::_Iostate, bool));
//REG_FUNC(0xAA9171FB, std::ios_base::_Addstd());
//REG_FUNC(0xFC58778, std::ios_base::copyfmt(std::ios_base const&));
//REG_FUNC(0x0FC58778, std::ios_base::copyfmt(std::ios_base const&));
//REG_FUNC(0x2DF76755, std::ios_base::failure::failure(std::ios_base::failure const&));
//REG_FUNC(0x94048F7, std::ios_base::failure::failure(std::string const&));
//REG_FUNC(0x094048F7, std::ios_base::failure::failure(std::string const&));
//REG_FUNC(0x20AAAB95, std::ios_base::failure::~failure());
//REG_FUNC(0x31D0197A, std::ios_base::failure::~failure());
//REG_FUNC(0x7736E940, std::ios_base::_Callfns(std::ios_base::event));
@ -293,18 +294,18 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x6AF75467, std::bad_alloc::bad_alloc(std::bad_alloc const&));
//REG_FUNC(0x57096162, std::bad_alloc::bad_alloc());
//REG_FUNC(0xB2DAA408, std::bad_alloc::~bad_alloc());
//REG_FUNC(0x7AEE736, std::bad_alloc::~bad_alloc());
//REG_FUNC(0x07AEE736, std::bad_alloc::~bad_alloc());
//REG_FUNC(0xA9E9B7B7, std::bad_alloc::~bad_alloc());
//REG_FUNC(0x7853E8E5, std::bad_alloc::operator=(std::bad_alloc const&));
//REG_FUNC(0xF78468EB, std::basic_ios<char, std::char_traits<char> >::~basic_ios());
//REG_FUNC(0x3150182, std::basic_ios<char, std::char_traits<char> >::~basic_ios());
//REG_FUNC(0x03150182, std::basic_ios<char, std::char_traits<char> >::~basic_ios());
//REG_FUNC(0x9654168A, std::basic_ios<wchar_t, std::char_traits<wchar_t> >::~basic_ios());
//REG_FUNC(0x8FFB8524, std::basic_ios<wchar_t, std::char_traits<wchar_t> >::~basic_ios());
//REG_FUNC(0x7AF1BB16, std::exception::_Set_raise_handler(void (*)(std::exception const&)));
//REG_FUNC(0x8C5A4417, std::exception::exception(std::exception const&));
//REG_FUNC(0xFC169D71, std::exception::exception());
//REG_FUNC(0x59758E74, std::exception::exception(std::exception const&));
//REG_FUNC(0xE08376, std::exception::exception());
//REG_FUNC(0x00E08376, std::exception::exception());
//REG_FUNC(0x82EEA67E, std::exception::~exception());
//REG_FUNC(0x30405D88, std::exception::~exception());
//REG_FUNC(0xAF7A7081, std::exception::~exception());
@ -316,7 +317,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x7D8DFE43, std::strstream::~strstream());
//REG_FUNC(0x8D4B1A13, std::type_info::~type_info());
//REG_FUNC(0xBD786240, std::type_info::~type_info());
//REG_FUNC(0xC04303, std::type_info::~type_info());
//REG_FUNC(0x00C04303, std::type_info::~type_info());
//REG_FUNC(0x9983D8B9, std::unexpected());
//REG_FUNC(0x385D19B2, std::setiosflags(std::_Iosb<int>::_Fmtflags));
//REG_FUNC(0xD8A78A61, std::setprecision(int));
@ -325,7 +326,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x644CBAA2, std::_Debug_message(char const*, char const*));
//REG_FUNC(0x9B2F0CA6, std::set_unexpected(void (*)()));
//REG_FUNC(0xC107B555, std::set_new_handler(void (*)()));
//REG_FUNC(0x11CEB00, std::uncaught_exception());
//REG_FUNC(0x011CEB00, std::uncaught_exception());
//REG_FUNC(0x36282336, std::__gen_dummy_typeinfos());
//REG_FUNC(0x3622003F, std::setw(int));
//REG_FUNC(0x6CAFA8EF, std::_Throw(std::exception const&));
@ -362,7 +363,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0xE7FB2BF4, operator new[](unsigned int));
//REG_FUNC(0x31C62481, operator new[](unsigned int, std::nothrow_t const&));
//REG_FUNC(0xF99ED5AC, operator new(unsigned int));
//REG_FUNC(0xAE71DC3, operator new(unsigned int, std::nothrow_t const&));
//REG_FUNC(0x0AE71DC3, operator new(unsigned int, std::nothrow_t const&));
//REG_FUNC(0x1818C323, _SNC_get_global_vars);
//REG_FUNC(0x2CFA1F15, _SNC_get_tlocal_vars);
//REG_FUNC(0x7742D916, _Unwind_Backtrace);
@ -373,9 +374,9 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0xE7889A5B, _Unwind_VRS_Get);
//REG_FUNC(0xF106D050, _Unwind_VRS_Pop);
//REG_FUNC(0x91CDA2F9, _Unwind_VRS_Set);
REG_FUNC(0x173E7421, __aeabi_unwind_cpp_pr0);
REG_FUNC(0x3C78DDE3, __aeabi_unwind_cpp_pr1);
REG_FUNC(0xF95BDD36, __aeabi_unwind_cpp_pr2);
REG_FUNC(0x173E7421, __aeabi_unwind_cpp_pr0, "__aeabi_unwind_cpp_pr0");
REG_FUNC(0x3C78DDE3, __aeabi_unwind_cpp_pr1, "__aeabi_unwind_cpp_pr1");
REG_FUNC(0xF95BDD36, __aeabi_unwind_cpp_pr2, "__aeabi_unwind_cpp_pr2");
//REG_FUNC(0x8C93EFDA, __cxa_allocate_exception);
//REG_FUNC(0x6165EE89, __cxa_begin_catch);
//REG_FUNC(0x5D74285C, __cxa_begin_cleanup);
@ -424,12 +425,12 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0xBF90A45A, _PJP_CPP_Copyright);
//REG_FUNC(0x3B6D9752, std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >::npos);
//REG_FUNC(0xA3498140, std::string::npos);
//REG_FUNC(0x5273EA3, std::_Num_int_base::is_bounded);
//REG_FUNC(0x05273EA3, std::_Num_int_base::is_bounded);
//REG_FUNC(0x8A0994F8, std::_Num_int_base::is_integer);
//REG_FUNC(0x401F1224, std::_Num_int_base::is_specialized);
//REG_FUNC(0xA65FE916, std::_Num_int_base::radix);
//REG_FUNC(0xF2AA872E, std::_Num_int_base::is_exact);
//REG_FUNC(0x8FE5A4F, std::_Num_int_base::is_modulo);
//REG_FUNC(0x08FE5A4F, std::_Num_int_base::is_modulo);
//REG_FUNC(0x7D4C55EC, std::numeric_limits<signed char>::digits);
//REG_FUNC(0xA4E5BF5E, std::numeric_limits<signed char>::digits10);
//REG_FUNC(0xD9938B84, std::numeric_limits<signed char>::is_signed);
@ -438,7 +439,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x81B82E0E, std::numeric_limits<bool>::is_modulo);
//REG_FUNC(0x9E6D2025, std::numeric_limits<bool>::is_signed);
//REG_FUNC(0x810ED593, std::numeric_limits<char>::digits);
//REG_FUNC(0xAC1A819, std::numeric_limits<char>::digits10);
//REG_FUNC(0x0AC1A819, std::numeric_limits<char>::digits10);
//REG_FUNC(0x660E14E1, std::numeric_limits<char>::is_signed);
//REG_FUNC(0x3EEB3B23, std::numeric_limits<double>::max_exponent);
//REG_FUNC(0x13B634BE, std::numeric_limits<double>::min_exponent);
@ -466,10 +467,10 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x3AB38CDA, std::numeric_limits<int>::is_signed);
//REG_FUNC(0xEEB7B642, std::numeric_limits<unsigned int>::digits);
//REG_FUNC(0xBCDE68B3, std::numeric_limits<unsigned int>::digits10);
//REG_FUNC(0xDA8EFB0, std::numeric_limits<unsigned int>::is_signed);
//REG_FUNC(0x0DA8EFB0, std::numeric_limits<unsigned int>::is_signed);
//REG_FUNC(0x65DAD8D6, std::numeric_limits<long>::digits);
//REG_FUNC(0xFB52BC0A, std::numeric_limits<long>::digits10);
//REG_FUNC(0x63544FC, std::numeric_limits<long>::is_signed);
//REG_FUNC(0x063544FC, std::numeric_limits<long>::is_signed);
//REG_FUNC(0x441D097A, std::numeric_limits<unsigned long>::digits);
//REG_FUNC(0xB56F1B07, std::numeric_limits<unsigned long>::digits10);
//REG_FUNC(0xA9799886, std::numeric_limits<unsigned long>::is_signed);
@ -510,13 +511,13 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x759FD02E, std::_Iosb<int>::app);
//REG_FUNC(0x6F410A00, std::_Iosb<int>::ate);
//REG_FUNC(0xD2A42D0C, std::_Iosb<int>::beg);
//REG_FUNC(0x9B45C3B, std::_Iosb<int>::cur);
//REG_FUNC(0x09B45C3B, std::_Iosb<int>::cur);
//REG_FUNC(0x121A8952, std::_Iosb<int>::dec);
//REG_FUNC(0x7CC027CD, std::_Iosb<int>::end);
//REG_FUNC(0x6E2FF90B, std::_Iosb<int>::hex);
//REG_FUNC(0xB4A55C29, std::_Iosb<int>::oct);
//REG_FUNC(0x2CB2DC70, std::_Iosb<int>::out);
//REG_FUNC(0x78E34A9, std::_Iosb<int>::trunc);
//REG_FUNC(0x078E34A9, std::_Iosb<int>::trunc);
//REG_FUNC(0xB5EFA1B3, std::_Iosb<int>::badbit);
//REG_FUNC(0x5312A538, std::_Iosb<int>::binary);
//REG_FUNC(0xD9D32526, std::_Iosb<int>::skipws);
@ -536,10 +537,10 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0xB11D20E2, std::_Num_base::has_infinity);
//REG_FUNC(0x3E169F74, std::_Num_base::max_exponent);
//REG_FUNC(0xD7C041E0, std::_Num_base::min_exponent);
//REG_FUNC(0x2DA0D59, std::_Num_base::has_quiet_NaN);
//REG_FUNC(0x02DA0D59, std::_Num_base::has_quiet_NaN);
//REG_FUNC(0xBE06BD79, std::_Num_base::is_specialized);
//REG_FUNC(0xEBBC4DDD, std::_Num_base::max_exponent10);
//REG_FUNC(0xFFCF7FC, std::_Num_base::min_exponent10);
//REG_FUNC(0x0FFCF7FC, std::_Num_base::min_exponent10);
//REG_FUNC(0xB317DDDF, std::_Num_base::has_denorm_loss);
//REG_FUNC(0x245D399E, std::_Num_base::tinyness_before);
//REG_FUNC(0xBD5F0B8A, std::_Num_base::has_signaling_NaN);
@ -586,7 +587,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0xA4018B84, typeinfo for __simd128_float32_t);
//REG_FUNC(0xA1FE4058, typeinfo for half);
//REG_FUNC(0x5351829B, typeinfo for std::ios_base::failure);
//REG_FUNC(0xAC6C8F, typeinfo for __simd64_int8_t*);
//REG_FUNC(0x00AC6C8F, typeinfo for __simd64_int8_t*);
//REG_FUNC(0xD5B056B8, typeinfo for __simd128_int8_t*);
//REG_FUNC(0x13975DAE, typeinfo for __simd64_int16_t*);
//REG_FUNC(0x963C04E3, typeinfo for __simd64_int32_t*);
@ -601,7 +602,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0xEE862280, typeinfo for __simd64_uint32_t*);
//REG_FUNC(0xB5CEC4FF, typeinfo for __simd128_poly16_t*);
//REG_FUNC(0x46124E82, typeinfo for __simd128_uint16_t*);
//REG_FUNC(0x7E6CC17, typeinfo for __simd128_uint32_t*);
//REG_FUNC(0x07E6CC17, typeinfo for __simd128_uint32_t*);
//REG_FUNC(0x588EBCAD, typeinfo for __simd64_float16_t*);
//REG_FUNC(0xDFCB2417, typeinfo for __simd64_float32_t*);
//REG_FUNC(0x9502D3C0, typeinfo for __simd128_float16_t*);
@ -612,8 +613,8 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x52A04C47, typeinfo for __simd64_int16_t const*);
//REG_FUNC(0xBB64CCF1, typeinfo for __simd64_int32_t const*);
//REG_FUNC(0x7C9D0C33, typeinfo for __simd64_poly8_t const*);
//REG_FUNC(0x21A57A1, typeinfo for __simd64_uint8_t const*);
//REG_FUNC(0x21E3DD1, typeinfo for __simd128_int16_t const*);
//REG_FUNC(0x021A57A1, typeinfo for __simd64_uint8_t const*);
//REG_FUNC(0x021E3DD1, typeinfo for __simd128_int16_t const*);
//REG_FUNC(0xFF8DDBE7, typeinfo for __simd128_int32_t const*);
//REG_FUNC(0xB30AB3B5, typeinfo for __simd128_poly8_t const*);
//REG_FUNC(0xC8721E86, typeinfo for __simd128_uint8_t const*);
@ -650,12 +651,12 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0xA6C2A25C, typeinfo for long long __vector*);
//REG_FUNC(0x81B51915, typeinfo for unsigned long long __vector*);
//REG_FUNC(0xA7CB4EAA, typeinfo for signed char*);
//REG_FUNC(0x87B0FB6, typeinfo for bool*);
//REG_FUNC(0x087B0FB6, typeinfo for bool*);
//REG_FUNC(0xE4D24E14, typeinfo for char*);
//REG_FUNC(0x6825FFE6, typeinfo for double*);
//REG_FUNC(0x926B9A3A, typeinfo for long double*);
//REG_FUNC(0x24072F3E, typeinfo for float*);
//REG_FUNC(0x8B5247B, typeinfo for unsigned char*);
//REG_FUNC(0x08B5247B, typeinfo for unsigned char*);
//REG_FUNC(0x15C21CC8, typeinfo for int*);
//REG_FUNC(0xD234CF18, typeinfo for unsigned int*);
//REG_FUNC(0x50E25810, typeinfo for long*);
@ -700,7 +701,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0xB93721C7, typeinfo for std::ios_base);
//REG_FUNC(0x35E135A0, typeinfo for std::bad_alloc);
//REG_FUNC(0x7BA61382, typeinfo for std::basic_ios<char, std::char_traits<char> >);
//REG_FUNC(0x905B8B0, typeinfo for std::basic_ios<wchar_t, std::char_traits<wchar_t> >);
//REG_FUNC(0x0905B8B0, typeinfo for std::basic_ios<wchar_t, std::char_traits<wchar_t> >);
//REG_FUNC(0x1E8C6100, typeinfo for std::exception);
//REG_FUNC(0x1CC15F54, typeinfo for std::strstream);
//REG_FUNC(0x8A026EAD, typeinfo for std::type_info);
@ -732,16 +733,16 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0xC3FA8530, typeinfo name for __simd128_int16_t);
//REG_FUNC(0x67A63A08, typeinfo name for __simd128_int32_t);
//REG_FUNC(0x6B26EFF8, typeinfo name for __simd128_poly8_t);
//REG_FUNC(0x8C4C69F, typeinfo name for __simd128_uint8_t);
//REG_FUNC(0x08C4C69F, typeinfo name for __simd128_uint8_t);
//REG_FUNC(0x40BC2E0E, typeinfo name for __simd64_poly16_t);
//REG_FUNC(0x8D1AE4A7, typeinfo name for __simd64_uint16_t);
//REG_FUNC(0xC4096952, typeinfo name for __simd64_uint32_t);
//REG_FUNC(0x16D366F1, typeinfo name for __simd128_poly16_t);
//REG_FUNC(0x45552A1, typeinfo name for __simd128_uint16_t);
//REG_FUNC(0x045552A1, typeinfo name for __simd128_uint16_t);
//REG_FUNC(0x7DBF4FFF, typeinfo name for __simd128_uint32_t);
//REG_FUNC(0xED26DE1, typeinfo name for __simd64_float16_t);
//REG_FUNC(0x0ED26DE1, typeinfo name for __simd64_float16_t);
//REG_FUNC(0xAB0D789A, typeinfo name for __simd64_float32_t);
//REG_FUNC(0x3200DDB, typeinfo name for __simd128_float16_t);
//REG_FUNC(0x03200DDB, typeinfo name for __simd128_float16_t);
//REG_FUNC(0xD54CBD7C, typeinfo name for __simd128_float32_t);
//REG_FUNC(0xA8E6842E, typeinfo name for half);
//REG_FUNC(0x5246E71E, typeinfo name for std::ios_base::failure);
@ -773,7 +774,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0xC356ACF6, typeinfo name for __simd64_poly8_t const*);
//REG_FUNC(0x878C75F4, typeinfo name for __simd64_uint8_t const*);
//REG_FUNC(0x68B777E3, typeinfo name for __simd128_int16_t const*);
//REG_FUNC(0x61188BD, typeinfo name for __simd128_int32_t const*);
//REG_FUNC(0x061188BD, typeinfo name for __simd128_int32_t const*);
//REG_FUNC(0xC7733F13, typeinfo name for __simd128_poly8_t const*);
//REG_FUNC(0x3D8A69EC, typeinfo name for __simd128_uint8_t const*);
//REG_FUNC(0xCC081D58, typeinfo name for __simd64_poly16_t const*);
@ -823,12 +824,12 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0xE2A0B0A8, typeinfo name for unsigned short*);
//REG_FUNC(0xF7B6B02A, typeinfo name for void*);
//REG_FUNC(0xF1C9A755, typeinfo name for wchar_t*);
//REG_FUNC(0x968B212, typeinfo name for long long*);
//REG_FUNC(0x9787CAD, typeinfo name for unsigned long long*);
//REG_FUNC(0x0968B212, typeinfo name for long long*);
//REG_FUNC(0x09787CAD, typeinfo name for unsigned long long*);
//REG_FUNC(0xF86F5756, typeinfo name for std::iostream);
//REG_FUNC(0x999300E0, typeinfo name for std::istream);
//REG_FUNC(0x591C25A3, typeinfo name for std::ostream);
//REG_FUNC(0xFC9D21B, typeinfo name for std::bad_typeid);
//REG_FUNC(0x0FC9D21B, typeinfo name for std::bad_typeid);
//REG_FUNC(0x867D109E, typeinfo name for std::istrstream);
//REG_FUNC(0x88BFC745, typeinfo name for std::ostrstream);
//REG_FUNC(0xB315CE7A, typeinfo name for std::_ctype_base);
@ -838,7 +839,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x9E317CE1, typeinfo name for std::length_error);
//REG_FUNC(0xD8DAD98D, typeinfo name for std::out_of_range);
//REG_FUNC(0x1C929309, typeinfo name for std::strstreambuf);
//REG_FUNC(0xE17E4D6, typeinfo name for std::_codecvt_base);
//REG_FUNC(0x0E17E4D6, typeinfo name for std::_codecvt_base);
//REG_FUNC(0x918FE198, typeinfo name for std::bad_exception);
//REG_FUNC(0x227B4568, typeinfo name for std::basic_filebuf<char, std::char_traits<char> >);
//REG_FUNC(0xD34BAF59, typeinfo name for std::basic_filebuf<wchar_t, std::char_traits<wchar_t> >);
@ -867,7 +868,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x2856DCD6, typeinfo name for std::type_info);
//REG_FUNC(0x75A1CED4, typeinfo name for long long __vector);
//REG_FUNC(0x508FF61E, typeinfo name for unsigned long long __vector);
//REG_FUNC(0x8E6A51A, typeinfo name for signed char);
//REG_FUNC(0x08E6A51A, typeinfo name for signed char);
//REG_FUNC(0x491DB7D3, typeinfo name for bool);
//REG_FUNC(0xD657B5A0, typeinfo name for char);
//REG_FUNC(0x322C7CB5, typeinfo name for double);
@ -887,7 +888,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x51B29810, VTT for std::iostream);
//REG_FUNC(0x52128B13, VTT for std::istream);
//REG_FUNC(0x3C508708, VTT for std::ostream);
//REG_FUNC(0x87753F6, VTT for std::istrstream);
//REG_FUNC(0x087753F6, VTT for std::istrstream);
//REG_FUNC(0xE3D7CB30, VTT for std::ostrstream);
//REG_FUNC(0xBC326B50, VTT for std::basic_istream<wchar_t, std::char_traits<wchar_t> >);
//REG_FUNC(0x16E32018, VTT for std::basic_ostream<wchar_t, std::char_traits<wchar_t> >);
@ -910,7 +911,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x82A84E5E, vtable for std::logic_error);
//REG_FUNC(0x1D583475, vtable for std::range_error);
//REG_FUNC(0x80C77E16, vtable for std::domain_error);
//REG_FUNC(0x64ADA35, vtable for std::length_error);
//REG_FUNC(0x064ADA35, vtable for std::length_error);
//REG_FUNC(0xDDAE7CBE, vtable for std::out_of_range);
//REG_FUNC(0x11B2781A, vtable for std::strstreambuf);
//REG_FUNC(0x75D16BD0, vtable for std::_codecvt_base);
@ -921,7 +922,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x48F3405B, vtable for std::basic_ostream<wchar_t, std::char_traits<wchar_t> >);
//REG_FUNC(0x53F02A18, vtable for std::runtime_error);
//REG_FUNC(0x177FCCDC, vtable for std::overflow_error);
//REG_FUNC(0x5548FF7, vtable for std::basic_streambuf<char, std::char_traits<char> >);
//REG_FUNC(0x05548FF7, vtable for std::basic_streambuf<char, std::char_traits<char> >);
//REG_FUNC(0xE8A9F32E, vtable for std::basic_streambuf<wchar_t, std::char_traits<wchar_t> >);
//REG_FUNC(0x515AE097, vtable for std::underflow_error);
//REG_FUNC(0x23EEDAF0, vtable for std::invalid_argument);
@ -933,7 +934,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0xD58C5F52, vtable for std::ios_base);
//REG_FUNC(0xA27EFBA3, vtable for std::bad_alloc);
//REG_FUNC(0x147996ED, vtable for std::basic_ios<char, std::char_traits<char> >);
//REG_FUNC(0xDE4AFE9, _ZTVSt9basic_iosIcSt11char_traitsIcEE__Sd__St9strstream);
//REG_FUNC(0x0DE4AFE9, _ZTVSt9basic_iosIcSt11char_traitsIcEE__Sd__St9strstream);
//REG_FUNC(0x87D18300, _ZTVSt9basic_iosIcSt11char_traitsIcEE__SiSd__St9strstream);
//REG_FUNC(0x3D6A38D3, _ZTVSt9basic_iosIcSt11char_traitsIcEE__Si__Sd);
//REG_FUNC(0xA8E795AF, _ZTVSt9basic_iosIcSt11char_traitsIcEE__Si__St10istrstream);
@ -946,7 +947,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x8E9879A7, vtable for std::type_info);
//REG_FUNC(0xE63750C1, std::basic_filebuf<char, std::char_traits<char> >::_Init(std::_Dnk_filet*, std::basic_filebuf<char, std::char_traits<char> >::_Initfl)::_Stinit);
//REG_FUNC(0x1D4E29BC, std::basic_filebuf<wchar_t, std::char_traits<wchar_t> >::_Init(std::_Dnk_filet*, std::basic_filebuf<wchar_t, std::char_traits<wchar_t> >::_Initfl)::_Stinit);
//REG_FUNC(0x8A37475, typeinfo for __cxxabiv1::__enum_type_info);
//REG_FUNC(0x08A37475, typeinfo for __cxxabiv1::__enum_type_info);
//REG_FUNC(0x66CC7DBB, typeinfo for __cxxabiv1::__array_type_info);
//REG_FUNC(0x81C44513, typeinfo for __cxxabiv1::__class_type_info);
//REG_FUNC(0xC35024DA, typeinfo for __cxxabiv1::__pbase_type_info);
@ -976,9 +977,7 @@ psv_log_base sceLibstdcxx = []() -> psv_log_base
//REG_FUNC(0x7321E731, vtable for __cxxabiv1::__vmi_class_type_info);
//REG_FUNC(0x33836375, vtable for __cxxabiv1::__fundamental_type_info);
//REG_FUNC(0x94664DEB, vtable for __cxxabiv1::__pointer_to_member_type_info);
return psv_log_base("SceLibstdcxx");
}();
});
/*
// original names
@ -1006,14 +1005,14 @@ REG_FUNC(0xB1AE6F9E, _ZNKSt15underflow_error8_DoraiseEv);
REG_FUNC(0x16F56E8D, _ZNKSt16invalid_argument8_DoraiseEv);
REG_FUNC(0x6C568D20, _ZNKSt6_ctypeIcE10do_tolowerEPcPKc);
REG_FUNC(0xC334DE66, _ZNKSt6_ctypeIcE10do_tolowerEc);
REG_FUNC(0x2DD808E, _ZNKSt6_ctypeIcE10do_toupperEPcPKc);
REG_FUNC(0x02DD808E, _ZNKSt6_ctypeIcE10do_toupperEPcPKc);
REG_FUNC(0xF6AF33EA, _ZNKSt6_ctypeIcE10do_toupperEc);
REG_FUNC(0x1B81D726, _ZNKSt6_ctypeIcE8do_widenEPKcS2_Pc);
REG_FUNC(0x6471CC01, _ZNKSt6_ctypeIcE8do_widenEc);
REG_FUNC(0x9CFA56E5, _ZNKSt6_ctypeIcE9do_narrowEPKcS2_cPc);
REG_FUNC(0x718669AB, _ZNKSt6_ctypeIcE9do_narrowEcc);
REG_FUNC(0x759F105D, _ZNKSt6_ctypeIwE10do_scan_isEsPKwS2_);
REG_FUNC(0x56443F, _ZNKSt6_ctypeIwE10do_tolowerEPwPKw);
REG_FUNC(0x0056443F, _ZNKSt6_ctypeIwE10do_tolowerEPwPKw);
REG_FUNC(0x33E9ECDD, _ZNKSt6_ctypeIwE10do_tolowerEw);
REG_FUNC(0x1256E6A5, _ZNKSt6_ctypeIwE10do_toupperEPwPKw);
REG_FUNC(0x64072C2E, _ZNKSt6_ctypeIwE10do_toupperEw);
@ -1041,7 +1040,7 @@ REG_FUNC(0xF877F51E, _ZNKSt8ios_base7failure8_DoraiseEv);
REG_FUNC(0x664750EE, _ZNKSt9bad_alloc4whatEv);
REG_FUNC(0xBA89FBE7, _ZNKSt9bad_alloc8_DoraiseEv);
REG_FUNC(0xC133E331, _ZNKSt9exception4whatEv);
REG_FUNC(0x656BE32, _ZNKSt9exception6_RaiseEv);
REG_FUNC(0x0656BE32, _ZNKSt9exception6_RaiseEv);
REG_FUNC(0x47A5CDA2, _ZNKSt9exception8_DoraiseEv);
REG_FUNC(0xBAE38DF9, _ZNKSt9type_info4nameEv);
REG_FUNC(0x1F260F10, _ZNKSt9type_info6beforeERKS_);
@ -1069,10 +1068,10 @@ REG_FUNC(0x55AAD6A6, _ZNSt10bad_typeidaSERKS_);
REG_FUNC(0x9CF31703, _ZNSt10istrstreamD0Ev);
REG_FUNC(0x71D13A36, _ZNSt10istrstreamD1Ev);
REG_FUNC(0xAF5DF8C3, _ZNSt10istrstreamD2Ev);
REG_FUNC(0xC1E7C7A, _ZNSt10ostrstreamC1EPciNSt5_IosbIiE9_OpenmodeE);
REG_FUNC(0xC09B290, _ZNSt10ostrstreamC2EPciNSt5_IosbIiE9_OpenmodeE);
REG_FUNC(0x0C1E7C7A, _ZNSt10ostrstreamC1EPciNSt5_IosbIiE9_OpenmodeE);
REG_FUNC(0x0C09B290, _ZNSt10ostrstreamC2EPciNSt5_IosbIiE9_OpenmodeE);
REG_FUNC(0x4B8BA644, _ZNSt10ostrstreamD0Ev);
REG_FUNC(0xE463FB3, _ZNSt10ostrstreamD1Ev);
REG_FUNC(0x0E463FB3, _ZNSt10ostrstreamD1Ev);
REG_FUNC(0xA0A34FEF, _ZNSt10ostrstreamD2Ev);
REG_FUNC(0xC9F632FF, _ZNSt11logic_errorC1ERKS_);
REG_FUNC(0xE6356C5C, _ZNSt11logic_errorC2ERKSs);
@ -1086,12 +1085,12 @@ REG_FUNC(0xEF754EBD, _ZNSt11range_errorD2Ev);
REG_FUNC(0x7D5412EF, _ZNSt12domain_errorC1ERKS_);
REG_FUNC(0x803A7D3E, _ZNSt12domain_errorD0Ev);
REG_FUNC(0xA6BCA2AD, _ZNSt12domain_errorD1Ev);
REG_FUNC(0x36F9D2A, _ZNSt12domain_errorD2Ev);
REG_FUNC(0x036F9D2A, _ZNSt12domain_errorD2Ev);
REG_FUNC(0x5F3428AD, _ZNSt12length_errorC1ERKS_);
REG_FUNC(0xF6FB801D, _ZNSt12length_errorC1ERKSs);
REG_FUNC(0xF83AA7DA, _ZNSt12length_errorD0Ev);
REG_FUNC(0xA873D7F9, _ZNSt12length_errorD1Ev);
REG_FUNC(0xBB12C75, _ZNSt12length_errorD2Ev);
REG_FUNC(0x0BB12C75, _ZNSt12length_errorD2Ev);
REG_FUNC(0x299AA587, _ZNSt12out_of_rangeC1ERKS_);
REG_FUNC(0xC8BA5522, _ZNSt12out_of_rangeC1ERKSs);
REG_FUNC(0xA8C470A4, _ZNSt12out_of_rangeD0Ev);
@ -1107,7 +1106,7 @@ REG_FUNC(0xC725F896, _ZNSt12strstreambuf9pbackfailEi);
REG_FUNC(0xA9F4FABF, _ZNSt12strstreambuf9underflowEv);
REG_FUNC(0x1C887DDE, _ZNSt12strstreambufD0Ev);
REG_FUNC(0x29E1E930, _ZNSt12strstreambufD1Ev);
REG_FUNC(0xA140889, _ZNSt12strstreambufD2Ev);
REG_FUNC(0x0A140889, _ZNSt12strstreambufD2Ev);
REG_FUNC(0xA8FE6FC4, _ZNSt13_codecvt_baseD0Ev);
REG_FUNC(0xB0E47AE4, _ZNSt13_codecvt_baseD1Ev);
REG_FUNC(0xB7EE9CC2, _ZNSt13bad_exceptionC1ERKS_);
@ -1124,7 +1123,7 @@ REG_FUNC(0xD5F03A74, _ZNSt13basic_filebufIcSt11char_traitsIcEE5uflowEv);
REG_FUNC(0x413E813E, _ZNSt13basic_filebufIcSt11char_traitsIcEE6setbufEPci);
REG_FUNC(0x9D193B65, _ZNSt13basic_filebufIcSt11char_traitsIcEE7_UnlockEv);
REG_FUNC(0x52E47FB5, _ZNSt13basic_filebufIcSt11char_traitsIcEE7seekoffElNSt5_IosbIiE8_SeekdirENS4_9_OpenmodeE);
REG_FUNC(0xE119B37, _ZNSt13basic_filebufIcSt11char_traitsIcEE7seekposESt4fposISt9_MbstatetENSt5_IosbIiE9_OpenmodeE);
REG_FUNC(0x0E119B37, _ZNSt13basic_filebufIcSt11char_traitsIcEE7seekposESt4fposISt9_MbstatetENSt5_IosbIiE9_OpenmodeE);
REG_FUNC(0x616754BC, _ZNSt13basic_filebufIcSt11char_traitsIcEE8overflowEi);
REG_FUNC(0xCD5BD2E1, _ZNSt13basic_filebufIcSt11char_traitsIcEE9_EndwriteEv);
REG_FUNC(0xFC1C7F3A, _ZNSt13basic_filebufIcSt11char_traitsIcEE9pbackfailEi);
@ -1147,7 +1146,7 @@ REG_FUNC(0xD434F085, _ZNSt13basic_filebufIwSt11char_traitsIwEED1Ev);
REG_FUNC(0xFFFA683E, _ZNSt13basic_istreamIwSt11char_traitsIwEED0Ev);
REG_FUNC(0xB58839C5, _ZNSt13basic_istreamIwSt11char_traitsIwEED1Ev);
REG_FUNC(0x9BF8855B, _ZNSt13basic_ostreamIwSt11char_traitsIwEEC1EPSt15basic_streambufIwS1_Eb);
REG_FUNC(0xD74F56E, _ZNSt13basic_ostreamIwSt11char_traitsIwEED0Ev);
REG_FUNC(0x0D74F56E, _ZNSt13basic_ostreamIwSt11char_traitsIwEED0Ev);
REG_FUNC(0x9B831B60, _ZNSt13basic_ostreamIwSt11char_traitsIwEED1Ev);
REG_FUNC(0x396337CE, _ZNSt13runtime_errorC1ERKS_);
REG_FUNC(0xDAD26367, _ZNSt13runtime_errorD0Ev);
@ -1159,20 +1158,20 @@ REG_FUNC(0x5C666F7E, _ZNSt14overflow_errorD1Ev);
REG_FUNC(0x4E45F680, _ZNSt14overflow_errorD2Ev);
REG_FUNC(0x626515E3, _ZNSt15basic_streambufIcSt11char_traitsIcEE4syncEv);
REG_FUNC(0x2E55F15A, _ZNSt15basic_streambufIcSt11char_traitsIcEE5_LockEv);
REG_FUNC(0xF8535AB, _ZNSt15basic_streambufIcSt11char_traitsIcEE5uflowEv);
REG_FUNC(0x0F8535AB, _ZNSt15basic_streambufIcSt11char_traitsIcEE5uflowEv);
REG_FUNC(0xD7933D06, _ZNSt15basic_streambufIcSt11char_traitsIcEE6setbufEPci);
REG_FUNC(0xB8BCCC8D, _ZNSt15basic_streambufIcSt11char_traitsIcEE6xsgetnEPci);
REG_FUNC(0x43E5D0F1, _ZNSt15basic_streambufIcSt11char_traitsIcEE6xsputnEPKci);
REG_FUNC(0x149B193A, _ZNSt15basic_streambufIcSt11char_traitsIcEE7_UnlockEv);
REG_FUNC(0x600998EC, _ZNSt15basic_streambufIcSt11char_traitsIcEE7seekoffElNSt5_IosbIiE8_SeekdirENS4_9_OpenmodeE);
REG_FUNC(0x1DEFFD6, _ZNSt15basic_streambufIcSt11char_traitsIcEE7seekposESt4fposISt9_MbstatetENSt5_IosbIiE9_OpenmodeE);
REG_FUNC(0x01DEFFD6, _ZNSt15basic_streambufIcSt11char_traitsIcEE7seekposESt4fposISt9_MbstatetENSt5_IosbIiE9_OpenmodeE);
REG_FUNC(0xF5F44352, _ZNSt15basic_streambufIcSt11char_traitsIcEE8overflowEi);
REG_FUNC(0xCA79344F, _ZNSt15basic_streambufIcSt11char_traitsIcEE9pbackfailEi);
REG_FUNC(0x441788B1, _ZNSt15basic_streambufIcSt11char_traitsIcEE9showmanycEv);
REG_FUNC(0x797DAE94, _ZNSt15basic_streambufIcSt11char_traitsIcEE9underflowEv);
REG_FUNC(0x74AD52E, _ZNSt15basic_streambufIcSt11char_traitsIcEED0Ev);
REG_FUNC(0x074AD52E, _ZNSt15basic_streambufIcSt11char_traitsIcEED0Ev);
REG_FUNC(0xE449E2BF, _ZNSt15basic_streambufIcSt11char_traitsIcEED1Ev);
REG_FUNC(0x9FAA0AA, _ZNSt15basic_streambufIwSt11char_traitsIwEE4syncEv);
REG_FUNC(0x09FAA0AA, _ZNSt15basic_streambufIwSt11char_traitsIwEE4syncEv);
REG_FUNC(0xA596C88C, _ZNSt15basic_streambufIwSt11char_traitsIwEE5_LockEv);
REG_FUNC(0x373C2CD8, _ZNSt15basic_streambufIwSt11char_traitsIwEE5uflowEv);
REG_FUNC(0x3F363796, _ZNSt15basic_streambufIwSt11char_traitsIwEE6setbufEPwi);
@ -1196,7 +1195,7 @@ REG_FUNC(0x188D86CF, _ZNSt16invalid_argumentD0Ev);
REG_FUNC(0x9982A4FC, _ZNSt16invalid_argumentD1Ev);
REG_FUNC(0x1AB2B1AC, _ZNSt16invalid_argumentD2Ev);
REG_FUNC(0xF9FAB558, _ZNSt6_Mutex5_LockEv);
REG_FUNC(0x402C9F8, _ZNSt6_Mutex7_UnlockEv);
REG_FUNC(0x0402C9F8, _ZNSt6_Mutex7_UnlockEv);
REG_FUNC(0x9DA92617, _ZNSt6_MutexC1ESt14_Uninitialized);
REG_FUNC(0xA4F99AE7, _ZNSt6_MutexC1Ev);
REG_FUNC(0x7B5A6B7F, _ZNSt6_MutexC2ESt14_Uninitialized);
@ -1229,12 +1228,12 @@ REG_FUNC(0x5ED60DEE, _ZNSt8ios_base4InitC2Ev);
REG_FUNC(0x65D88619, _ZNSt8ios_base4InitD1Ev);
REG_FUNC(0x3483E01D, _ZNSt8ios_base4InitD2Ev);
REG_FUNC(0x78CB190E, _ZNSt8ios_base5_InitEv);
REG_FUNC(0x23B8BEE, _ZNSt8ios_base5_TidyEv);
REG_FUNC(0x023B8BEE, _ZNSt8ios_base5_TidyEv);
REG_FUNC(0xC9DE8208, _ZNSt8ios_base5clearENSt5_IosbIiE8_IostateEb);
REG_FUNC(0xAA9171FB, _ZNSt8ios_base7_AddstdEv);
REG_FUNC(0xFC58778, _ZNSt8ios_base7copyfmtERKS_);
REG_FUNC(0x0FC58778, _ZNSt8ios_base7copyfmtERKS_);
REG_FUNC(0x2DF76755, _ZNSt8ios_base7failureC1ERKS0_);
REG_FUNC(0x94048F7, _ZNSt8ios_base7failureC1ERKSs);
REG_FUNC(0x094048F7, _ZNSt8ios_base7failureC1ERKSs);
REG_FUNC(0x20AAAB95, _ZNSt8ios_base7failureD0Ev);
REG_FUNC(0x31D0197A, _ZNSt8ios_base7failureD1Ev);
REG_FUNC(0x7736E940, _ZNSt8ios_base8_CallfnsENS_5eventE);
@ -1247,18 +1246,18 @@ REG_FUNC(0xEC3804D2, _ZNSt9bad_allocC1Ev);
REG_FUNC(0x6AF75467, _ZNSt9bad_allocC2ERKS_);
REG_FUNC(0x57096162, _ZNSt9bad_allocC2Ev);
REG_FUNC(0xB2DAA408, _ZNSt9bad_allocD0Ev);
REG_FUNC(0x7AEE736, _ZNSt9bad_allocD1Ev);
REG_FUNC(0x07AEE736, _ZNSt9bad_allocD1Ev);
REG_FUNC(0xA9E9B7B7, _ZNSt9bad_allocD2Ev);
REG_FUNC(0x7853E8E5, _ZNSt9bad_allocaSERKS_);
REG_FUNC(0xF78468EB, _ZNSt9basic_iosIcSt11char_traitsIcEED0Ev);
REG_FUNC(0x3150182, _ZNSt9basic_iosIcSt11char_traitsIcEED1Ev);
REG_FUNC(0x03150182, _ZNSt9basic_iosIcSt11char_traitsIcEED1Ev);
REG_FUNC(0x9654168A, _ZNSt9basic_iosIwSt11char_traitsIwEED0Ev);
REG_FUNC(0x8FFB8524, _ZNSt9basic_iosIwSt11char_traitsIwEED1Ev);
REG_FUNC(0x7AF1BB16, _ZNSt9exception18_Set_raise_handlerEPFvRKS_E);
REG_FUNC(0x8C5A4417, _ZNSt9exceptionC1ERKS_);
REG_FUNC(0xFC169D71, _ZNSt9exceptionC1Ev);
REG_FUNC(0x59758E74, _ZNSt9exceptionC2ERKS_);
REG_FUNC(0xE08376, _ZNSt9exceptionC2Ev);
REG_FUNC(0x00E08376, _ZNSt9exceptionC2Ev);
REG_FUNC(0x82EEA67E, _ZNSt9exceptionD0Ev);
REG_FUNC(0x30405D88, _ZNSt9exceptionD1Ev);
REG_FUNC(0xAF7A7081, _ZNSt9exceptionD2Ev);
@ -1270,7 +1269,7 @@ REG_FUNC(0x98BD8AE1, _ZNSt9strstreamD1Ev);
REG_FUNC(0x7D8DFE43, _ZNSt9strstreamD2Ev);
REG_FUNC(0x8D4B1A13, _ZNSt9type_infoD0Ev);
REG_FUNC(0xBD786240, _ZNSt9type_infoD1Ev);
REG_FUNC(0xC04303, _ZNSt9type_infoD2Ev);
REG_FUNC(0x00C04303, _ZNSt9type_infoD2Ev);
REG_FUNC(0x9983D8B9, _ZSt10unexpectedv);
REG_FUNC(0x385D19B2, _ZSt11setiosflagsNSt5_IosbIiE9_FmtflagsE);
REG_FUNC(0xD8A78A61, _ZSt12setprecisioni);
@ -1279,7 +1278,7 @@ REG_FUNC(0x13BAEE11, _ZSt13set_terminatePFvvE);
REG_FUNC(0x644CBAA2, _ZSt14_Debug_messagePKcS0_);
REG_FUNC(0x9B2F0CA6, _ZSt14set_unexpectedPFvvE);
REG_FUNC(0xC107B555, _ZSt15set_new_handlerPFvvE);
REG_FUNC(0x11CEB00, _ZSt18uncaught_exceptionv);
REG_FUNC(0x011CEB00, _ZSt18uncaught_exceptionv);
REG_FUNC(0x36282336, _ZSt21__gen_dummy_typeinfosv);
REG_FUNC(0x3622003F, _ZSt4setwi);
REG_FUNC(0x6CAFA8EF, _ZSt6_ThrowRKSt9exception);
@ -1316,7 +1315,7 @@ REG_FUNC(0x1EB89099, _ZdlPvS_);
REG_FUNC(0xE7FB2BF4, _Znaj);
REG_FUNC(0x31C62481, _ZnajRKSt9nothrow_t);
REG_FUNC(0xF99ED5AC, _Znwj);
REG_FUNC(0xAE71DC3, _ZnwjRKSt9nothrow_t);
REG_FUNC(0x0AE71DC3, _ZnwjRKSt9nothrow_t);
REG_FUNC(0x1818C323, _SNC_get_global_vars);
REG_FUNC(0x2CFA1F15, _SNC_get_tlocal_vars);
REG_FUNC(0x7742D916, _Unwind_Backtrace);
@ -1378,12 +1377,12 @@ REG_FUNC(0xD4C11B17, _ZN10__cxxabiv129__pointer_to_member_type_infoD2Ev);
REG_FUNC(0xBF90A45A, _PJP_CPP_Copyright);
REG_FUNC(0x3B6D9752, _ZNSbIwSt11char_traitsIwESaIwEE4nposE);
REG_FUNC(0xA3498140, _ZNSs4nposE);
REG_FUNC(0x5273EA3, _ZNSt13_Num_int_base10is_boundedE);
REG_FUNC(0x05273EA3, _ZNSt13_Num_int_base10is_boundedE);
REG_FUNC(0x8A0994F8, _ZNSt13_Num_int_base10is_integerE);
REG_FUNC(0x401F1224, _ZNSt13_Num_int_base14is_specializedE);
REG_FUNC(0xA65FE916, _ZNSt13_Num_int_base5radixE);
REG_FUNC(0xF2AA872E, _ZNSt13_Num_int_base8is_exactE);
REG_FUNC(0x8FE5A4F, _ZNSt13_Num_int_base9is_moduloE);
REG_FUNC(0x08FE5A4F, _ZNSt13_Num_int_base9is_moduloE);
REG_FUNC(0x7D4C55EC, _ZNSt14numeric_limitsIaE6digitsE);
REG_FUNC(0xA4E5BF5E, _ZNSt14numeric_limitsIaE8digits10E);
REG_FUNC(0xD9938B84, _ZNSt14numeric_limitsIaE9is_signedE);
@ -1392,7 +1391,7 @@ REG_FUNC(0xF52E5F76, _ZNSt14numeric_limitsIbE8digits10E);
REG_FUNC(0x81B82E0E, _ZNSt14numeric_limitsIbE9is_moduloE);
REG_FUNC(0x9E6D2025, _ZNSt14numeric_limitsIbE9is_signedE);
REG_FUNC(0x810ED593, _ZNSt14numeric_limitsIcE6digitsE);
REG_FUNC(0xAC1A819, _ZNSt14numeric_limitsIcE8digits10E);
REG_FUNC(0x0AC1A819, _ZNSt14numeric_limitsIcE8digits10E);
REG_FUNC(0x660E14E1, _ZNSt14numeric_limitsIcE9is_signedE);
REG_FUNC(0x3EEB3B23, _ZNSt14numeric_limitsIdE12max_exponentE);
REG_FUNC(0x13B634BE, _ZNSt14numeric_limitsIdE12min_exponentE);
@ -1420,10 +1419,10 @@ REG_FUNC(0xE8EB3133, _ZNSt14numeric_limitsIiE8digits10E);
REG_FUNC(0x3AB38CDA, _ZNSt14numeric_limitsIiE9is_signedE);
REG_FUNC(0xEEB7B642, _ZNSt14numeric_limitsIjE6digitsE);
REG_FUNC(0xBCDE68B3, _ZNSt14numeric_limitsIjE8digits10E);
REG_FUNC(0xDA8EFB0, _ZNSt14numeric_limitsIjE9is_signedE);
REG_FUNC(0x0DA8EFB0, _ZNSt14numeric_limitsIjE9is_signedE);
REG_FUNC(0x65DAD8D6, _ZNSt14numeric_limitsIlE6digitsE);
REG_FUNC(0xFB52BC0A, _ZNSt14numeric_limitsIlE8digits10E);
REG_FUNC(0x63544FC, _ZNSt14numeric_limitsIlE9is_signedE);
REG_FUNC(0x063544FC, _ZNSt14numeric_limitsIlE9is_signedE);
REG_FUNC(0x441D097A, _ZNSt14numeric_limitsImE6digitsE);
REG_FUNC(0xB56F1B07, _ZNSt14numeric_limitsImE8digits10E);
REG_FUNC(0xA9799886, _ZNSt14numeric_limitsImE9is_signedE);
@ -1464,13 +1463,13 @@ REG_FUNC(0xE615A657, _ZNSt5_IosbIiE2inE);
REG_FUNC(0x759FD02E, _ZNSt5_IosbIiE3appE);
REG_FUNC(0x6F410A00, _ZNSt5_IosbIiE3ateE);
REG_FUNC(0xD2A42D0C, _ZNSt5_IosbIiE3begE);
REG_FUNC(0x9B45C3B, _ZNSt5_IosbIiE3curE);
REG_FUNC(0x09B45C3B, _ZNSt5_IosbIiE3curE);
REG_FUNC(0x121A8952, _ZNSt5_IosbIiE3decE);
REG_FUNC(0x7CC027CD, _ZNSt5_IosbIiE3endE);
REG_FUNC(0x6E2FF90B, _ZNSt5_IosbIiE3hexE);
REG_FUNC(0xB4A55C29, _ZNSt5_IosbIiE3octE);
REG_FUNC(0x2CB2DC70, _ZNSt5_IosbIiE3outE);
REG_FUNC(0x78E34A9, _ZNSt5_IosbIiE5truncE);
REG_FUNC(0x078E34A9, _ZNSt5_IosbIiE5truncE);
REG_FUNC(0xB5EFA1B3, _ZNSt5_IosbIiE6badbitE);
REG_FUNC(0x5312A538, _ZNSt5_IosbIiE6binaryE);
REG_FUNC(0xD9D32526, _ZNSt5_IosbIiE6skipwsE);
@ -1490,10 +1489,10 @@ REG_FUNC(0x13B38354, _ZNSt9_Num_base11round_styleE);
REG_FUNC(0xB11D20E2, _ZNSt9_Num_base12has_infinityE);
REG_FUNC(0x3E169F74, _ZNSt9_Num_base12max_exponentE);
REG_FUNC(0xD7C041E0, _ZNSt9_Num_base12min_exponentE);
REG_FUNC(0x2DA0D59, _ZNSt9_Num_base13has_quiet_NaNE);
REG_FUNC(0x02DA0D59, _ZNSt9_Num_base13has_quiet_NaNE);
REG_FUNC(0xBE06BD79, _ZNSt9_Num_base14is_specializedE);
REG_FUNC(0xEBBC4DDD, _ZNSt9_Num_base14max_exponent10E);
REG_FUNC(0xFFCF7FC, _ZNSt9_Num_base14min_exponent10E);
REG_FUNC(0x0FFCF7FC, _ZNSt9_Num_base14min_exponent10E);
REG_FUNC(0xB317DDDF, _ZNSt9_Num_base15has_denorm_lossE);
REG_FUNC(0x245D399E, _ZNSt9_Num_base15tinyness_beforeE);
REG_FUNC(0xBD5F0B8A, _ZNSt9_Num_base17has_signaling_NaNE);
@ -1540,7 +1539,7 @@ REG_FUNC(0x525557F3, _ZTI19__simd128_float16_t);
REG_FUNC(0xA4018B84, _ZTI19__simd128_float32_t);
REG_FUNC(0xA1FE4058, _ZTIDh);
REG_FUNC(0x5351829B, _ZTINSt8ios_base7failureE);
REG_FUNC(0xAC6C8F, _ZTIP15__simd64_int8_t);
REG_FUNC(0x00AC6C8F, _ZTIP15__simd64_int8_t);
REG_FUNC(0xD5B056B8, _ZTIP16__simd128_int8_t);
REG_FUNC(0x13975DAE, _ZTIP16__simd64_int16_t);
REG_FUNC(0x963C04E3, _ZTIP16__simd64_int32_t);
@ -1555,7 +1554,7 @@ REG_FUNC(0xA96D02B1, _ZTIP17__simd64_uint16_t);
REG_FUNC(0xEE862280, _ZTIP17__simd64_uint32_t);
REG_FUNC(0xB5CEC4FF, _ZTIP18__simd128_poly16_t);
REG_FUNC(0x46124E82, _ZTIP18__simd128_uint16_t);
REG_FUNC(0x7E6CC17, _ZTIP18__simd128_uint32_t);
REG_FUNC(0x07E6CC17, _ZTIP18__simd128_uint32_t);
REG_FUNC(0x588EBCAD, _ZTIP18__simd64_float16_t);
REG_FUNC(0xDFCB2417, _ZTIP18__simd64_float32_t);
REG_FUNC(0x9502D3C0, _ZTIP19__simd128_float16_t);
@ -1566,8 +1565,8 @@ REG_FUNC(0x60D7D920, _ZTIPK16__simd128_int8_t);
REG_FUNC(0x52A04C47, _ZTIPK16__simd64_int16_t);
REG_FUNC(0xBB64CCF1, _ZTIPK16__simd64_int32_t);
REG_FUNC(0x7C9D0C33, _ZTIPK16__simd64_poly8_t);
REG_FUNC(0x21A57A1, _ZTIPK16__simd64_uint8_t);
REG_FUNC(0x21E3DD1, _ZTIPK17__simd128_int16_t);
REG_FUNC(0x021A57A1, _ZTIPK16__simd64_uint8_t);
REG_FUNC(0x021E3DD1, _ZTIPK17__simd128_int16_t);
REG_FUNC(0xFF8DDBE7, _ZTIPK17__simd128_int32_t);
REG_FUNC(0xB30AB3B5, _ZTIPK17__simd128_poly8_t);
REG_FUNC(0xC8721E86, _ZTIPK17__simd128_uint8_t);
@ -1604,12 +1603,12 @@ REG_FUNC(0xA0F5E8F5, _ZTIPKy);
REG_FUNC(0xA6C2A25C, _ZTIPU8__vectorx);
REG_FUNC(0x81B51915, _ZTIPU8__vectory);
REG_FUNC(0xA7CB4EAA, _ZTIPa);
REG_FUNC(0x87B0FB6, _ZTIPb);
REG_FUNC(0x087B0FB6, _ZTIPb);
REG_FUNC(0xE4D24E14, _ZTIPc);
REG_FUNC(0x6825FFE6, _ZTIPd);
REG_FUNC(0x926B9A3A, _ZTIPe);
REG_FUNC(0x24072F3E, _ZTIPf);
REG_FUNC(0x8B5247B, _ZTIPh);
REG_FUNC(0x08B5247B, _ZTIPh);
REG_FUNC(0x15C21CC8, _ZTIPi);
REG_FUNC(0xD234CF18, _ZTIPj);
REG_FUNC(0x50E25810, _ZTIPl);
@ -1654,7 +1653,7 @@ REG_FUNC(0xA7CA7C93, _ZTISt8bad_cast);
REG_FUNC(0xB93721C7, _ZTISt8ios_base);
REG_FUNC(0x35E135A0, _ZTISt9bad_alloc);
REG_FUNC(0x7BA61382, _ZTISt9basic_iosIcSt11char_traitsIcEE);
REG_FUNC(0x905B8B0, _ZTISt9basic_iosIwSt11char_traitsIwEE);
REG_FUNC(0x0905B8B0, _ZTISt9basic_iosIwSt11char_traitsIwEE);
REG_FUNC(0x1E8C6100, _ZTISt9exception);
REG_FUNC(0x1CC15F54, _ZTISt9strstream);
REG_FUNC(0x8A026EAD, _ZTISt9type_info);
@ -1686,16 +1685,16 @@ REG_FUNC(0xCD2802B5, _ZTS16__simd64_uint8_t);
REG_FUNC(0xC3FA8530, _ZTS17__simd128_int16_t);
REG_FUNC(0x67A63A08, _ZTS17__simd128_int32_t);
REG_FUNC(0x6B26EFF8, _ZTS17__simd128_poly8_t);
REG_FUNC(0x8C4C69F, _ZTS17__simd128_uint8_t);
REG_FUNC(0x08C4C69F, _ZTS17__simd128_uint8_t);
REG_FUNC(0x40BC2E0E, _ZTS17__simd64_poly16_t);
REG_FUNC(0x8D1AE4A7, _ZTS17__simd64_uint16_t);
REG_FUNC(0xC4096952, _ZTS17__simd64_uint32_t);
REG_FUNC(0x16D366F1, _ZTS18__simd128_poly16_t);
REG_FUNC(0x45552A1, _ZTS18__simd128_uint16_t);
REG_FUNC(0x045552A1, _ZTS18__simd128_uint16_t);
REG_FUNC(0x7DBF4FFF, _ZTS18__simd128_uint32_t);
REG_FUNC(0xED26DE1, _ZTS18__simd64_float16_t);
REG_FUNC(0x0ED26DE1, _ZTS18__simd64_float16_t);
REG_FUNC(0xAB0D789A, _ZTS18__simd64_float32_t);
REG_FUNC(0x3200DDB, _ZTS19__simd128_float16_t);
REG_FUNC(0x03200DDB, _ZTS19__simd128_float16_t);
REG_FUNC(0xD54CBD7C, _ZTS19__simd128_float32_t);
REG_FUNC(0xA8E6842E, _ZTSDh);
REG_FUNC(0x5246E71E, _ZTSNSt8ios_base7failureE);
@ -1727,7 +1726,7 @@ REG_FUNC(0x6A472A63, _ZTSPK16__simd64_int32_t);
REG_FUNC(0xC356ACF6, _ZTSPK16__simd64_poly8_t);
REG_FUNC(0x878C75F4, _ZTSPK16__simd64_uint8_t);
REG_FUNC(0x68B777E3, _ZTSPK17__simd128_int16_t);
REG_FUNC(0x61188BD, _ZTSPK17__simd128_int32_t);
REG_FUNC(0x061188BD, _ZTSPK17__simd128_int32_t);
REG_FUNC(0xC7733F13, _ZTSPK17__simd128_poly8_t);
REG_FUNC(0x3D8A69EC, _ZTSPK17__simd128_uint8_t);
REG_FUNC(0xCC081D58, _ZTSPK17__simd64_poly16_t);
@ -1777,12 +1776,12 @@ REG_FUNC(0x982D9703, _ZTSPs);
REG_FUNC(0xE2A0B0A8, _ZTSPt);
REG_FUNC(0xF7B6B02A, _ZTSPv);
REG_FUNC(0xF1C9A755, _ZTSPw);
REG_FUNC(0x968B212, _ZTSPx);
REG_FUNC(0x9787CAD, _ZTSPy);
REG_FUNC(0x0968B212, _ZTSPx);
REG_FUNC(0x09787CAD, _ZTSPy);
REG_FUNC(0xF86F5756, _ZTSSd);
REG_FUNC(0x999300E0, _ZTSSi);
REG_FUNC(0x591C25A3, _ZTSSo);
REG_FUNC(0xFC9D21B, _ZTSSt10bad_typeid);
REG_FUNC(0x0FC9D21B, _ZTSSt10bad_typeid);
REG_FUNC(0x867D109E, _ZTSSt10istrstream);
REG_FUNC(0x88BFC745, _ZTSSt10ostrstream);
REG_FUNC(0xB315CE7A, _ZTSSt11_ctype_base);
@ -1792,7 +1791,7 @@ REG_FUNC(0xBE23707A, _ZTSSt12domain_error);
REG_FUNC(0x9E317CE1, _ZTSSt12length_error);
REG_FUNC(0xD8DAD98D, _ZTSSt12out_of_range);
REG_FUNC(0x1C929309, _ZTSSt12strstreambuf);
REG_FUNC(0xE17E4D6, _ZTSSt13_codecvt_base);
REG_FUNC(0x0E17E4D6, _ZTSSt13_codecvt_base);
REG_FUNC(0x918FE198, _ZTSSt13bad_exception);
REG_FUNC(0x227B4568, _ZTSSt13basic_filebufIcSt11char_traitsIcEE);
REG_FUNC(0xD34BAF59, _ZTSSt13basic_filebufIwSt11char_traitsIwEE);
@ -1821,7 +1820,7 @@ REG_FUNC(0xE5C789D4, _ZTSSt9strstream);
REG_FUNC(0x2856DCD6, _ZTSSt9type_info);
REG_FUNC(0x75A1CED4, _ZTSU8__vectorx);
REG_FUNC(0x508FF61E, _ZTSU8__vectory);
REG_FUNC(0x8E6A51A, _ZTSa);
REG_FUNC(0x08E6A51A, _ZTSa);
REG_FUNC(0x491DB7D3, _ZTSb);
REG_FUNC(0xD657B5A0, _ZTSc);
REG_FUNC(0x322C7CB5, _ZTSd);
@ -1841,7 +1840,7 @@ REG_FUNC(0x402717E4, _ZTSy);
REG_FUNC(0x51B29810, _ZTTSd);
REG_FUNC(0x52128B13, _ZTTSi);
REG_FUNC(0x3C508708, _ZTTSo);
REG_FUNC(0x87753F6, _ZTTSt10istrstream);
REG_FUNC(0x087753F6, _ZTTSt10istrstream);
REG_FUNC(0xE3D7CB30, _ZTTSt10ostrstream);
REG_FUNC(0xBC326B50, _ZTTSt13basic_istreamIwSt11char_traitsIwEE);
REG_FUNC(0x16E32018, _ZTTSt13basic_ostreamIwSt11char_traitsIwEE);
@ -1864,7 +1863,7 @@ REG_FUNC(0xA81AD21D, _ZTVSt10ostrstream);
REG_FUNC(0x82A84E5E, _ZTVSt11logic_error);
REG_FUNC(0x1D583475, _ZTVSt11range_error);
REG_FUNC(0x80C77E16, _ZTVSt12domain_error);
REG_FUNC(0x64ADA35, _ZTVSt12length_error);
REG_FUNC(0x064ADA35, _ZTVSt12length_error);
REG_FUNC(0xDDAE7CBE, _ZTVSt12out_of_range);
REG_FUNC(0x11B2781A, _ZTVSt12strstreambuf);
REG_FUNC(0x75D16BD0, _ZTVSt13_codecvt_base);
@ -1875,7 +1874,7 @@ REG_FUNC(0xB952752B, _ZTVSt13basic_istreamIwSt11char_traitsIwEE);
REG_FUNC(0x48F3405B, _ZTVSt13basic_ostreamIwSt11char_traitsIwEE);
REG_FUNC(0x53F02A18, _ZTVSt13runtime_error);
REG_FUNC(0x177FCCDC, _ZTVSt14overflow_error);
REG_FUNC(0x5548FF7, _ZTVSt15basic_streambufIcSt11char_traitsIcEE);
REG_FUNC(0x05548FF7, _ZTVSt15basic_streambufIcSt11char_traitsIcEE);
REG_FUNC(0xE8A9F32E, _ZTVSt15basic_streambufIwSt11char_traitsIwEE);
REG_FUNC(0x515AE097, _ZTVSt15underflow_error);
REG_FUNC(0x23EEDAF0, _ZTVSt16invalid_argument);
@ -1887,7 +1886,7 @@ REG_FUNC(0xAA09FD32, _ZTVSt8bad_cast);
REG_FUNC(0xD58C5F52, _ZTVSt8ios_base);
REG_FUNC(0xA27EFBA3, _ZTVSt9bad_alloc);
REG_FUNC(0x147996ED, _ZTVSt9basic_iosIcSt11char_traitsIcEE);
REG_FUNC(0xDE4AFE9, _ZTVSt9basic_iosIcSt11char_traitsIcEE__Sd__St9strstream);
REG_FUNC(0x0DE4AFE9, _ZTVSt9basic_iosIcSt11char_traitsIcEE__Sd__St9strstream);
REG_FUNC(0x87D18300, _ZTVSt9basic_iosIcSt11char_traitsIcEE__SiSd__St9strstream);
REG_FUNC(0x3D6A38D3, _ZTVSt9basic_iosIcSt11char_traitsIcEE__Si__Sd);
REG_FUNC(0xA8E795AF, _ZTVSt9basic_iosIcSt11char_traitsIcEE__Si__St10istrstream);
@ -1900,7 +1899,7 @@ REG_FUNC(0xFD21E1F1, _ZTVSt9strstream);
REG_FUNC(0x8E9879A7, _ZTVSt9type_info);
REG_FUNC(0xE63750C1, _ZZNSt13basic_filebufIcSt11char_traitsIcEE5_InitEPSt10_Dnk_filetNS2_7_InitflEE7_Stinit);
REG_FUNC(0x1D4E29BC, _ZZNSt13basic_filebufIwSt11char_traitsIwEE5_InitEPSt10_Dnk_filetNS2_7_InitflEE7_Stinit);
REG_FUNC(0x8A37475, _ZTIN10__cxxabiv116__enum_type_infoE);
REG_FUNC(0x08A37475, _ZTIN10__cxxabiv116__enum_type_infoE);
REG_FUNC(0x66CC7DBB, _ZTIN10__cxxabiv117__array_type_infoE);
REG_FUNC(0x81C44513, _ZTIN10__cxxabiv117__class_type_infoE);
REG_FUNC(0xC35024DA, _ZTIN10__cxxabiv117__pbase_type_infoE);

27
rpcs3/Emu/ARMv7/Modules/sceLiveArea.cpp Normal file
View File

@ -0,0 +1,27 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceLiveArea;
s32 sceLiveAreaResourceReplaceAll(vm::psv::ptr<const char> dirpath)
{
throw __FUNCTION__;
}
s32 sceLiveAreaResourceGetStatus()
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceLiveArea, #name, name)
psv_log_base sceLiveArea("SceLiveArea", []()
{
sceLiveArea.on_load = nullptr;
sceLiveArea.on_unload = nullptr;
sceLiveArea.on_stop = nullptr;
REG_FUNC(0xA4B506F9, sceLiveAreaResourceReplaceAll);
REG_FUNC(0x54A395FB, sceLiveAreaResourceGetStatus);
});

202
rpcs3/Emu/ARMv7/Modules/sceLocation.cpp Normal file
View File

@ -0,0 +1,202 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceLocation;
typedef u8 SceLocationHandle;
enum SceLocationLocationMethod : s32
{
SCE_LOCATION_LMETHOD_NONE = 0,
SCE_LOCATION_LMETHOD_AGPS_AND_3G_AND_WIFI = 1,
SCE_LOCATION_LMETHOD_GPS_AND_WIFI = 2,
SCE_LOCATION_LMETHOD_WIFI = 3,
SCE_LOCATION_LMETHOD_3G = 4,
SCE_LOCATION_LMETHOD_GPS = 5
};
enum SceLocationHeadingMethod : s32
{
SCE_LOCATION_HMETHOD_NONE = 0,
SCE_LOCATION_HMETHOD_AUTO = 1,
SCE_LOCATION_HMETHOD_VERTICAL = 2,
SCE_LOCATION_HMETHOD_HORIZONTAL = 3,
SCE_LOCATION_HMETHOD_CAMERA = 4
};
enum SceLocationDialogStatus : s32
{
SCE_LOCATION_DIALOG_STATUS_IDLE = 0,
SCE_LOCATION_DIALOG_STATUS_RUNNING = 1,
SCE_LOCATION_DIALOG_STATUS_FINISHED = 2
};
enum SceLocationDialogResult : s32
{
SCE_LOCATION_DIALOG_RESULT_NONE = 0,
SCE_LOCATION_DIALOG_RESULT_DISABLE = 1,
SCE_LOCATION_DIALOG_RESULT_ENABLE = 2
};
enum SceLocationPermissionApplicationStatus : s32
{
SCE_LOCATION_PERMISSION_APPLICATION_NONE = 0,
SCE_LOCATION_PERMISSION_APPLICATION_INIT = 1,
SCE_LOCATION_PERMISSION_APPLICATION_DENY = 2,
SCE_LOCATION_PERMISSION_APPLICATION_ALLOW = 3
};
enum SceLocationPermissionStatus : s32
{
SCE_LOCATION_PERMISSION_DENY = 0,
SCE_LOCATION_PERMISSION_ALLOW = 1
};
struct SceLocationLocationInfo
{
double latitude;
double longitude;
double altitude;
float accuracy;
float reserve;
float direction;
float speed;
u64 timestamp;
};
struct SceLocationHeadingInfo
{
float trueHeading;
float headingVectorX;
float headingVectorY;
float headingVectorZ;
float reserve;
float reserve2;
u64 timestamp;
};
typedef vm::psv::ptr<void(s32 result, SceLocationHandle handle, vm::psv::ptr<const SceLocationLocationInfo> location, vm::psv::ptr<void> userdata)> SceLocationLocationInfoCallback;
typedef vm::psv::ptr<void(s32 result, SceLocationHandle handle, vm::psv::ptr<const SceLocationHeadingInfo> heading, vm::psv::ptr<void> userdata)> SceLocationHeadingInfoCallback;
struct SceLocationPermissionInfo
{
SceLocationPermissionStatus parentalstatus;
SceLocationPermissionStatus mainstatus;
SceLocationPermissionApplicationStatus applicationstatus;
};
s32 sceLocationOpen(vm::psv::ptr<SceLocationHandle> handle, SceLocationLocationMethod lmethod, SceLocationHeadingMethod hmethod)
{
throw __FUNCTION__;
}
s32 sceLocationClose(SceLocationHandle handle)
{
throw __FUNCTION__;
}
s32 sceLocationReopen(SceLocationHandle handle, SceLocationLocationMethod lmethod, SceLocationHeadingMethod hmethod)
{
throw __FUNCTION__;
}
s32 sceLocationGetMethod(SceLocationHandle handle, vm::psv::ptr<SceLocationLocationMethod> lmethod, vm::psv::ptr<SceLocationHeadingMethod> hmethod)
{
throw __FUNCTION__;
}
s32 sceLocationGetLocation(SceLocationHandle handle, vm::psv::ptr<SceLocationLocationInfo> linfo)
{
throw __FUNCTION__;
}
s32 sceLocationCancelGetLocation(SceLocationHandle handle)
{
throw __FUNCTION__;
}
s32 sceLocationStartLocationCallback(SceLocationHandle handle, u32 distance, SceLocationLocationInfoCallback callback, vm::psv::ptr<void> userdata)
{
throw __FUNCTION__;
}
s32 sceLocationStopLocationCallback(SceLocationHandle handle)
{
throw __FUNCTION__;
}
s32 sceLocationGetHeading(SceLocationHandle handle, vm::psv::ptr<SceLocationHeadingInfo> hinfo)
{
throw __FUNCTION__;
}
s32 sceLocationStartHeadingCallback(SceLocationHandle handle, u32 difference, SceLocationHeadingInfoCallback callback, vm::psv::ptr<void> userdata)
{
throw __FUNCTION__;
}
s32 sceLocationStopHeadingCallback(SceLocationHandle handle)
{
throw __FUNCTION__;
}
s32 sceLocationConfirm(SceLocationHandle handle)
{
throw __FUNCTION__;
}
s32 sceLocationConfirmGetStatus(SceLocationHandle handle, vm::psv::ptr<SceLocationDialogStatus> status)
{
throw __FUNCTION__;
}
s32 sceLocationConfirmGetResult(SceLocationHandle handle, vm::psv::ptr<SceLocationDialogResult> result)
{
throw __FUNCTION__;
}
s32 sceLocationConfirmAbort(SceLocationHandle handle)
{
throw __FUNCTION__;
}
s32 sceLocationGetPermission(SceLocationHandle handle, vm::psv::ptr<SceLocationPermissionInfo> info)
{
throw __FUNCTION__;
}
s32 sceLocationSetGpsEmulationFile(vm::psv::ptr<char> filename)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceLocation, #name, name)
psv_log_base sceLocation("SceLibLocation", []()
{
sceLocation.on_load = nullptr;
sceLocation.on_unload = nullptr;
sceLocation.on_stop = nullptr;
REG_FUNC(0xDD271661, sceLocationOpen);
REG_FUNC(0x14FE76E8, sceLocationClose);
REG_FUNC(0xB1F55065, sceLocationReopen);
REG_FUNC(0x188CE004, sceLocationGetMethod);
REG_FUNC(0x15BC27C8, sceLocationGetLocation);
REG_FUNC(0x71503251, sceLocationCancelGetLocation);
REG_FUNC(0x12D1F0EA, sceLocationStartLocationCallback);
REG_FUNC(0xED378700, sceLocationStopLocationCallback);
REG_FUNC(0x4E9E5ED9, sceLocationGetHeading);
REG_FUNC(0x07D4DFE0, sceLocationStartHeadingCallback);
REG_FUNC(0x92E53F94, sceLocationStopHeadingCallback);
//REG_FUNC(0xE055BCF5, sceLocationSetHeapAllocator);
REG_FUNC(0xC895E567, sceLocationConfirm);
REG_FUNC(0x730FF842, sceLocationConfirmGetStatus);
REG_FUNC(0xFF016C13, sceLocationConfirmGetResult);
REG_FUNC(0xE3CBF875, sceLocationConfirmAbort);
REG_FUNC(0x482622C6, sceLocationGetPermission);
REG_FUNC(0xDE0A9EA4, sceLocationSetGpsEmulationFile);
//REG_FUNC(0x760D08FF, sceLocationConfirmSetMessage);
});

50
rpcs3/Emu/ARMv7/Modules/sceMd5.cpp Normal file
View File

@ -0,0 +1,50 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceMd5;
struct SceMd5Context
{
u32 h[4];
u32 pad;
u16 usRemains;
u16 usComputed;
u64 ullTotalLen;
u8 buf[64];
u8 result[64];
};
s32 sceMd5Digest(vm::psv::ptr<const void> plain, u32 len, vm::psv::ptr<u8> digest)
{
throw __FUNCTION__;
}
s32 sceMd5BlockInit(vm::psv::ptr<SceMd5Context> pContext)
{
throw __FUNCTION__;
}
s32 sceMd5BlockUpdate(vm::psv::ptr<SceMd5Context> pContext, vm::psv::ptr<const void> plain, u32 len)
{
throw __FUNCTION__;
}
s32 sceMd5BlockResult(vm::psv::ptr<SceMd5Context> pContext, vm::psv::ptr<u8> digest)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceMd5, #name, name)
psv_log_base sceMd5("SceMd5", []()
{
sceMd5.on_load = nullptr;
sceMd5.on_unload = nullptr;
sceMd5.on_stop = nullptr;
REG_FUNC(0xB845BCCB, sceMd5Digest);
REG_FUNC(0x4D6436F9, sceMd5BlockInit);
REG_FUNC(0x094A4902, sceMd5BlockUpdate);
REG_FUNC(0xB94ABF83, sceMd5BlockResult);
});

138
rpcs3/Emu/ARMv7/Modules/sceMotion.cpp Normal file
View File

@ -0,0 +1,138 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceMotion;
struct SceMotionState
{
u32 timestamp;
SceFVector3 acceleration;
SceFVector3 angularVelocity;
u8 reserve1[12];
SceFQuaternion deviceQuat;
SceUMatrix4 rotationMatrix;
SceUMatrix4 nedMatrix;
u8 reserve2[4];
SceFVector3 basicOrientation;
u64 hostTimestamp;
u8 reserve3[40];
};
struct SceMotionSensorState
{
SceFVector3 accelerometer;
SceFVector3 gyro;
u8 reserve1[12];
u32 timestamp;
u32 counter;
u8 reserve2[4];
u64 hostTimestamp;
u8 reserve3[8];
};
s32 sceMotionGetState(vm::psv::ptr<SceMotionState> motionState)
{
throw __FUNCTION__;
}
s32 sceMotionGetSensorState(vm::psv::ptr<SceMotionSensorState> sensorState, s32 numRecords)
{
throw __FUNCTION__;
}
s32 sceMotionGetBasicOrientation(vm::psv::ptr<SceFVector3> basicOrientation)
{
throw __FUNCTION__;
}
//s32 sceMotionRotateYaw(const float radians)
//{
// throw __FUNCTION__;
//}
s32 sceMotionGetTiltCorrection()
{
throw __FUNCTION__;
}
s32 sceMotionSetTiltCorrection(s32 setValue)
{
throw __FUNCTION__;
}
s32 sceMotionGetDeadband()
{
throw __FUNCTION__;
}
s32 sceMotionSetDeadband(s32 setValue)
{
throw __FUNCTION__;
}
//s32 sceMotionSetAngleThreshold(const float angle)
//{
// throw __FUNCTION__;
//}
//float sceMotionGetAngleThreshold()
//{
// throw __FUNCTION__;
//}
s32 sceMotionReset()
{
throw __FUNCTION__;
}
s32 sceMotionMagnetometerOn()
{
throw __FUNCTION__;
}
s32 sceMotionMagnetometerOff()
{
throw __FUNCTION__;
}
s32 sceMotionGetMagnetometerState()
{
throw __FUNCTION__;
}
s32 sceMotionStartSampling()
{
throw __FUNCTION__;
}
s32 sceMotionStopSampling()
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceMotion, #name, name)
psv_log_base sceMotion("SceMotion", []()
{
sceMotion.on_load = nullptr;
sceMotion.on_unload = nullptr;
sceMotion.on_stop = nullptr;
REG_FUNC(0xBDB32767, sceMotionGetState);
REG_FUNC(0x47D679EA, sceMotionGetSensorState);
REG_FUNC(0xC1652201, sceMotionGetTiltCorrection);
REG_FUNC(0xAF09FCDB, sceMotionSetTiltCorrection);
REG_FUNC(0x112E0EAE, sceMotionGetDeadband);
REG_FUNC(0x917EA390, sceMotionSetDeadband);
//REG_FUNC(0x20F00078, sceMotionRotateYaw);
REG_FUNC(0x0FD2CDA2, sceMotionReset);
REG_FUNC(0x28034AC9, sceMotionStartSampling);
REG_FUNC(0xAF32CB1D, sceMotionStopSampling);
//REG_FUNC(0xDACB2A41, sceMotionSetAngleThreshold);
//REG_FUNC(0x499B6C87, sceMotionGetAngleThreshold);
REG_FUNC(0x4F28BFE0, sceMotionGetBasicOrientation);
REG_FUNC(0x122A79F8, sceMotionMagnetometerOn);
REG_FUNC(0xC1A7395A, sceMotionMagnetometerOff);
REG_FUNC(0x3D4813AE, sceMotionGetMagnetometerState);
});

34
rpcs3/Emu/ARMv7/Modules/sceMt19937.cpp Normal file
View File

@ -0,0 +1,34 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceMt19937;
struct SceMt19937Context
{
u32 count;
u32 state[624];
};
s32 sceMt19937Init(vm::psv::ptr<SceMt19937Context> pCtx, u32 seed)
{
throw __FUNCTION__;
}
u32 sceMt19937UInt(vm::psv::ptr<SceMt19937Context> pCtx)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceMt19937, #name, name)
psv_log_base sceMt19937("SceMt19937", []()
{
sceMt19937.on_load = nullptr;
sceMt19937.on_unload = nullptr;
sceMt19937.on_stop = nullptr;
REG_FUNC(0xEE5BA27C, sceMt19937Init);
REG_FUNC(0x29E43BB5, sceMt19937UInt);
});

364
rpcs3/Emu/ARMv7/Modules/sceNet.cpp Normal file
View File

@ -0,0 +1,364 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceNet.h"
s32 sceNetSetDnsInfo(vm::psv::ptr<SceNetDnsInfo> info, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetClearDnsCache(s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetDumpCreate(vm::psv::ptr<const char> name, s32 len, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetDumpRead(s32 id, vm::psv::ptr<void> buf, s32 len, vm::psv::ptr<s32> pflags)
{
throw __FUNCTION__;
}
s32 sceNetDumpDestroy(s32 id)
{
throw __FUNCTION__;
}
s32 sceNetDumpAbort(s32 id, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetEpollCreate(vm::psv::ptr<const char> name, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetEpollControl(s32 eid, s32 op, s32 id, vm::psv::ptr<SceNetEpollEvent> event)
{
throw __FUNCTION__;
}
s32 sceNetEpollWait(s32 eid, vm::psv::ptr<SceNetEpollEvent> events, s32 maxevents, s32 timeout)
{
throw __FUNCTION__;
}
s32 sceNetEpollWaitCB(s32 eid, vm::psv::ptr<SceNetEpollEvent> events, s32 maxevents, s32 timeout)
{
throw __FUNCTION__;
}
s32 sceNetEpollDestroy(s32 eid)
{
throw __FUNCTION__;
}
s32 sceNetEpollAbort(s32 eid, s32 flags)
{
throw __FUNCTION__;
}
vm::psv::ptr<s32> sceNetErrnoLoc()
{
throw __FUNCTION__;
}
s32 sceNetEtherStrton(vm::psv::ptr<const char> str, vm::psv::ptr<SceNetEtherAddr> n)
{
throw __FUNCTION__;
}
s32 sceNetEtherNtostr(vm::psv::ptr<const SceNetEtherAddr> n, vm::psv::ptr<char> str, u32 len)
{
throw __FUNCTION__;
}
s32 sceNetGetMacAddress(vm::psv::ptr<SceNetEtherAddr> addr, s32 flags)
{
throw __FUNCTION__;
}
vm::psv::ptr<const char> sceNetInetNtop(s32 af, vm::psv::ptr<const void> src, vm::psv::ptr<char> dst, SceNetSocklen_t size)
{
throw __FUNCTION__;
}
s32 sceNetInetPton(s32 af, vm::psv::ptr<const char> src, vm::psv::ptr<void> dst)
{
throw __FUNCTION__;
}
u64 sceNetHtonll(u64 host64)
{
throw __FUNCTION__;
}
u32 sceNetHtonl(u32 host32)
{
throw __FUNCTION__;
}
u16 sceNetHtons(u16 host16)
{
throw __FUNCTION__;
}
u64 sceNetNtohll(u64 net64)
{
throw __FUNCTION__;
}
u32 sceNetNtohl(u32 net32)
{
throw __FUNCTION__;
}
u16 sceNetNtohs(u16 net16)
{
throw __FUNCTION__;
}
s32 sceNetInit(vm::psv::ptr<SceNetInitParam> param)
{
throw __FUNCTION__;
}
s32 sceNetTerm()
{
throw __FUNCTION__;
}
s32 sceNetShowIfconfig()
{
throw __FUNCTION__;
}
s32 sceNetShowRoute()
{
throw __FUNCTION__;
}
s32 sceNetShowNetstat()
{
throw __FUNCTION__;
}
s32 sceNetEmulationSet(vm::psv::ptr<SceNetEmulationParam> param, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetEmulationGet(vm::psv::ptr<SceNetEmulationParam> param, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetResolverCreate(vm::psv::ptr<const char> name, vm::psv::ptr<SceNetResolverParam> param, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetResolverStartNtoa(s32 rid, vm::psv::ptr<const char> hostname, vm::psv::ptr<SceNetInAddr> addr, s32 timeout, s32 retry, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetResolverStartAton(s32 rid, vm::psv::ptr<const SceNetInAddr> addr, vm::psv::ptr<char> hostname, s32 len, s32 timeout, s32 retry, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetResolverGetError(s32 rid, vm::psv::ptr<s32> result)
{
throw __FUNCTION__;
}
s32 sceNetResolverDestroy(s32 rid)
{
throw __FUNCTION__;
}
s32 sceNetResolverAbort(s32 rid, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetSocket(vm::psv::ptr<const char> name, s32 domain, s32 type, s32 protocol)
{
throw __FUNCTION__;
}
s32 sceNetAccept(s32 s, vm::psv::ptr<SceNetSockaddr> addr, vm::psv::ptr<SceNetSocklen_t> addrlen)
{
throw __FUNCTION__;
}
s32 sceNetBind(s32 s, vm::psv::ptr<const SceNetSockaddr> addr, SceNetSocklen_t addrlen)
{
throw __FUNCTION__;
}
s32 sceNetConnect(s32 s, vm::psv::ptr<const SceNetSockaddr> name, SceNetSocklen_t namelen)
{
throw __FUNCTION__;
}
s32 sceNetGetpeername(s32 s, vm::psv::ptr<SceNetSockaddr> name, vm::psv::ptr<SceNetSocklen_t> namelen)
{
throw __FUNCTION__;
}
s32 sceNetGetsockname(s32 s, vm::psv::ptr<SceNetSockaddr> name, vm::psv::ptr<SceNetSocklen_t> namelen)
{
throw __FUNCTION__;
}
s32 sceNetGetsockopt(s32 s, s32 level, s32 optname, vm::psv::ptr<void> optval, vm::psv::ptr<SceNetSocklen_t> optlen)
{
throw __FUNCTION__;
}
s32 sceNetListen(s32 s, s32 backlog)
{
throw __FUNCTION__;
}
s32 sceNetRecv(s32 s, vm::psv::ptr<void> buf, u32 len, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetRecvfrom(s32 s, vm::psv::ptr<void> buf, u32 len, s32 flags, vm::psv::ptr<SceNetSockaddr> from, vm::psv::ptr<SceNetSocklen_t> fromlen)
{
throw __FUNCTION__;
}
s32 sceNetRecvmsg(s32 s, vm::psv::ptr<SceNetMsghdr> msg, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetSend(s32 s, vm::psv::ptr<const void> msg, u32 len, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetSendto(s32 s, vm::psv::ptr<const void> msg, u32 len, s32 flags, vm::psv::ptr<const SceNetSockaddr> to, SceNetSocklen_t tolen)
{
throw __FUNCTION__;
}
s32 sceNetSendmsg(s32 s, vm::psv::ptr<const SceNetMsghdr> msg, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetSetsockopt(s32 s, s32 level, s32 optname, vm::psv::ptr<const void> optval, SceNetSocklen_t optlen)
{
throw __FUNCTION__;
}
s32 sceNetShutdown(s32 s, s32 how)
{
throw __FUNCTION__;
}
s32 sceNetSocketClose(s32 s)
{
throw __FUNCTION__;
}
s32 sceNetSocketAbort(s32 s, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetGetSockInfo(s32 s, vm::psv::ptr<SceNetSockInfo> info, s32 n, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetGetSockIdInfo(vm::psv::ptr<SceNetFdSet> fds, s32 sockinfoflags, s32 flags)
{
throw __FUNCTION__;
}
s32 sceNetGetStatisticsInfo(vm::psv::ptr<SceNetStatisticsInfo> info, s32 flags)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNet, #name, name)
psv_log_base sceNet("SceNet", []()
{
sceNet.on_load = nullptr;
sceNet.on_unload = nullptr;
sceNet.on_stop = nullptr;
REG_FUNC(0xD62EF218, sceNetSetDnsInfo);
REG_FUNC(0xFEC1166D, sceNetClearDnsCache);
REG_FUNC(0xAFF9FA4D, sceNetDumpCreate);
REG_FUNC(0x04042925, sceNetDumpRead);
REG_FUNC(0x82DDCF63, sceNetDumpDestroy);
REG_FUNC(0x3B24E75F, sceNetDumpAbort);
REG_FUNC(0xF9D102AE, sceNetEpollCreate);
REG_FUNC(0x4C8764AC, sceNetEpollControl);
REG_FUNC(0x45CE337D, sceNetEpollWait);
REG_FUNC(0x92D3E767, sceNetEpollWaitCB);
REG_FUNC(0x7915CAF3, sceNetEpollDestroy);
REG_FUNC(0x93FCC4E8, sceNetEpollAbort);
REG_FUNC(0xE37F34AA, sceNetErrnoLoc);
REG_FUNC(0xEEC6D75F, sceNetEtherStrton);
REG_FUNC(0x84334EB2, sceNetEtherNtostr);
REG_FUNC(0x06C05518, sceNetGetMacAddress);
REG_FUNC(0x98839B74, sceNetInetNtop);
REG_FUNC(0xD5EEB048, sceNetInetPton);
REG_FUNC(0x12C19209, sceNetHtonll);
REG_FUNC(0x4C30B03C, sceNetHtonl);
REG_FUNC(0x9FA3207B, sceNetHtons);
REG_FUNC(0xFB3336A6, sceNetNtohll);
REG_FUNC(0xD2EAA645, sceNetNtohl);
REG_FUNC(0x07845128, sceNetNtohs);
REG_FUNC(0xEB03E265, sceNetInit);
REG_FUNC(0xEA3CC286, sceNetTerm);
REG_FUNC(0x658B903B, sceNetShowIfconfig);
REG_FUNC(0x6AB3B74B, sceNetShowRoute);
REG_FUNC(0x338EDC2E, sceNetShowNetstat);
REG_FUNC(0x561DFD03, sceNetEmulationSet);
REG_FUNC(0xAE3F4AC6, sceNetEmulationGet);
REG_FUNC(0x6DA29319, sceNetResolverCreate);
REG_FUNC(0x1EB11857, sceNetResolverStartNtoa);
REG_FUNC(0x0424AE26, sceNetResolverStartAton);
REG_FUNC(0x874EF500, sceNetResolverGetError);
REG_FUNC(0x3559F098, sceNetResolverDestroy);
REG_FUNC(0x38EBBD57, sceNetResolverAbort);
REG_FUNC(0xF084FCE3, sceNetSocket);
REG_FUNC(0x1ADF9BB1, sceNetAccept);
REG_FUNC(0x1296A94B, sceNetBind);
REG_FUNC(0x11E5B6F6, sceNetConnect);
REG_FUNC(0x2348D353, sceNetGetpeername);
REG_FUNC(0x1C66A6DB, sceNetGetsockname);
REG_FUNC(0xBA652062, sceNetGetsockopt);
REG_FUNC(0x7A8DA094, sceNetListen);
REG_FUNC(0x023643B7, sceNetRecv);
REG_FUNC(0xB226138B, sceNetRecvfrom);
REG_FUNC(0xDE94C6FE, sceNetRecvmsg);
REG_FUNC(0xE3DD8CD9, sceNetSend);
REG_FUNC(0x52DB31D5, sceNetSendto);
REG_FUNC(0x99C579AE, sceNetSendmsg);
REG_FUNC(0x065505CA, sceNetSetsockopt);
REG_FUNC(0x69E50BB5, sceNetShutdown);
REG_FUNC(0x29822B4D, sceNetSocketClose);
REG_FUNC(0x891C1B9B, sceNetSocketAbort);
REG_FUNC(0xB1AF6840, sceNetGetSockInfo);
REG_FUNC(0x138CF1D6, sceNetGetSockIdInfo);
REG_FUNC(0xA86F8FE5, sceNetGetStatisticsInfo);
});

187
rpcs3/Emu/ARMv7/Modules/sceNet.h Normal file
View File

@ -0,0 +1,187 @@
#pragma once
typedef u32 SceNetInAddr_t;
typedef u16 SceNetInPort_t;
typedef u8 SceNetSaFamily_t;
typedef u32 SceNetSocklen_t;
struct SceNetInAddr
{
SceNetInAddr_t s_addr;
};
struct SceNetSockaddrIn
{
u8 sin_len;
SceNetSaFamily_t sin_family;
SceNetInPort_t sin_port;
SceNetInAddr sin_addr;
SceNetInPort_t sin_vport;
char sin_zero[6];
};
struct SceNetDnsInfo
{
SceNetInAddr dns_addr[2];
};
struct SceNetSockaddr
{
u8 sa_len;
SceNetSaFamily_t sa_family;
char sa_data[14];
};
struct SceNetEpollDataExt
{
s32 id;
u32 data;
};
union SceNetEpollData
{
vm::psv::ptr<void> ptr;
s32 fd;
u32 _u32;
u64 _u64;
SceNetEpollDataExt ext;
};
struct SceNetEpollSystemData
{
u32 system[4];
};
struct SceNetEpollEvent
{
u32 events;
u32 reserved;
SceNetEpollSystemData system;
SceNetEpollData data;
};
struct SceNetEtherAddr
{
u8 data[6];
};
typedef u32 SceNetIdMask;
struct SceNetFdSet
{
SceNetIdMask bits[32];
};
struct SceNetIpMreq
{
SceNetInAddr imr_multiaddr;
SceNetInAddr imr_interface;
};
struct SceNetInitParam
{
vm::psv::ptr<void> memory;
s32 size;
s32 flags;
};
struct SceNetEmulationData
{
u16 drop_rate;
u16 drop_duration;
u16 pass_duration;
u16 delay_time;
u16 delay_jitter;
u16 order_rate;
u16 order_delay_time;
u16 duplication_rate;
u32 bps_limit;
u16 lower_size_limit;
u16 upper_size_limit;
u32 system_policy_pattern;
u32 game_policy_pattern;
u16 policy_flags[64];
u8 reserved[64];
};
struct SceNetEmulationParam
{
u16 version;
u16 option_number;
u16 current_version;
u16 result;
u32 flags;
u32 reserved1;
SceNetEmulationData send;
SceNetEmulationData recv;
u32 seed;
u8 reserved[44];
};
typedef vm::psv::ptr<vm::psv::ptr<void>(u32 size, s32 rid, vm::psv::ptr<const char> name, vm::psv::ptr<void> user)> SceNetResolverFunctionAllocate;
typedef vm::psv::ptr<void(vm::psv::ptr<void> ptr, s32 rid, vm::psv::ptr<const char> name, vm::psv::ptr<void> user)> SceNetResolverFunctionFree;
struct SceNetResolverParam
{
SceNetResolverFunctionAllocate allocate;
SceNetResolverFunctionFree free;
vm::psv::ptr<void> user;
};
struct SceNetLinger
{
s32 l_onoff;
s32 l_linger;
};
struct SceNetIovec
{
vm::psv::ptr<void> iov_base;
u32 iov_len;
};
struct SceNetMsghdr
{
vm::psv::ptr<void> msg_name;
SceNetSocklen_t msg_namelen;
vm::psv::ptr<SceNetIovec> msg_iov;
s32 msg_iovlen;
vm::psv::ptr<void> msg_control;
SceNetSocklen_t msg_controllen;
s32 msg_flags;
};
struct SceNetSockInfo
{
char name[32];
s32 pid;
s32 s;
s8 socket_type;
s8 policy;
s16 reserved16;
s32 recv_queue_length;
s32 send_queue_length;
SceNetInAddr local_adr;
SceNetInAddr remote_adr;
SceNetInPort_t local_port;
SceNetInPort_t remote_port;
SceNetInPort_t local_vport;
SceNetInPort_t remote_vport;
s32 state;
s32 flags;
s32 reserved[8];
};
struct SceNetStatisticsInfo
{
s32 kernel_mem_free_size;
s32 kernel_mem_free_min;
s32 packet_count;
s32 packet_qos_count;
s32 libnet_mem_free_size;
s32 libnet_mem_free_min;
};
extern psv_log_base sceNet;

155
rpcs3/Emu/ARMv7/Modules/sceNetCtl.cpp Normal file
View File

@ -0,0 +1,155 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceNet.h"
extern psv_log_base sceNetCtl;
union SceNetCtlInfo
{
char cnf_name[65];
u32 device;
SceNetEtherAddr ether_addr;
u32 mtu;
u32 link;
SceNetEtherAddr bssid;
char ssid[33];
u32 wifi_security;
u32 rssi_dbm;
u32 rssi_percentage;
u32 channel;
u32 ip_config;
char dhcp_hostname[256];
char pppoe_auth_name[128];
char ip_address[16];
char netmask[16];
char default_route[16];
char primary_dns[16];
char secondary_dns[16];
u32 http_proxy_config;
char http_proxy_server[256];
u32 http_proxy_port;
};
struct SceNetCtlNatInfo
{
u32 size;
s32 stun_status;
s32 nat_type;
SceNetInAddr mapped_addr;
};
struct SceNetCtlAdhocPeerInfo
{
vm::psv::ptr<SceNetCtlAdhocPeerInfo> next;
SceNetInAddr inet_addr;
};
typedef vm::psv::ptr<void(s32 event_type, vm::psv::ptr<void> arg)> SceNetCtlCallback;
s32 sceNetCtlInit()
{
throw __FUNCTION__;
}
void sceNetCtlTerm()
{
throw __FUNCTION__;
}
s32 sceNetCtlCheckCallback()
{
throw __FUNCTION__;
}
s32 sceNetCtlInetGetResult(s32 eventType, vm::psv::ptr<s32> errorCode)
{
throw __FUNCTION__;
}
s32 sceNetCtlAdhocGetResult(s32 eventType, vm::psv::ptr<s32> errorCode)
{
throw __FUNCTION__;
}
s32 sceNetCtlInetGetInfo(s32 code, vm::psv::ptr<SceNetCtlInfo> info)
{
throw __FUNCTION__;
}
s32 sceNetCtlInetGetState(vm::psv::ptr<s32> state)
{
throw __FUNCTION__;
}
s32 sceNetCtlGetNatInfo(vm::psv::ptr<SceNetCtlNatInfo> natinfo)
{
throw __FUNCTION__;
}
s32 sceNetCtlInetRegisterCallback(SceNetCtlCallback func, vm::psv::ptr<void> arg, vm::psv::ptr<s32> cid)
{
throw __FUNCTION__;
}
s32 sceNetCtlInetUnregisterCallback(s32 cid)
{
throw __FUNCTION__;
}
s32 sceNetCtlAdhocRegisterCallback(SceNetCtlCallback func, vm::psv::ptr<void> arg, vm::psv::ptr<s32> cid)
{
throw __FUNCTION__;
}
s32 sceNetCtlAdhocUnregisterCallback(s32 cid)
{
throw __FUNCTION__;
}
s32 sceNetCtlAdhocGetState(vm::psv::ptr<s32> state)
{
throw __FUNCTION__;
}
s32 sceNetCtlAdhocDisconnect()
{
throw __FUNCTION__;
}
s32 sceNetCtlAdhocGetPeerList(vm::psv::ptr<u32> buflen, vm::psv::ptr<void> buf)
{
throw __FUNCTION__;
}
s32 sceNetCtlAdhocGetInAddr(vm::psv::ptr<SceNetInAddr> inaddr)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNetCtl, #name, name)
psv_log_base sceNetCtl("SceNetCtl", []()
{
sceNetCtl.on_load = nullptr;
sceNetCtl.on_unload = nullptr;
sceNetCtl.on_stop = nullptr;
REG_FUNC(0x495CA1DB, sceNetCtlInit);
REG_FUNC(0xCD188648, sceNetCtlTerm);
REG_FUNC(0xDFFC3ED4, sceNetCtlCheckCallback);
REG_FUNC(0x6B20EC02, sceNetCtlInetGetResult);
REG_FUNC(0x7AE0ED19, sceNetCtlAdhocGetResult);
REG_FUNC(0xB26D07F3, sceNetCtlInetGetInfo);
REG_FUNC(0x6D26AC68, sceNetCtlInetGetState);
REG_FUNC(0xEAEE6185, sceNetCtlInetRegisterCallback);
REG_FUNC(0xD0C3BF3F, sceNetCtlInetUnregisterCallback);
REG_FUNC(0x4DDD6149, sceNetCtlGetNatInfo);
REG_FUNC(0x0961A561, sceNetCtlAdhocGetState);
REG_FUNC(0xFFA9D594, sceNetCtlAdhocRegisterCallback);
REG_FUNC(0xA4471E10, sceNetCtlAdhocUnregisterCallback);
REG_FUNC(0xED43B79A, sceNetCtlAdhocDisconnect);
REG_FUNC(0x77586C59, sceNetCtlAdhocGetPeerList);
REG_FUNC(0x7118C99D, sceNetCtlAdhocGetInAddr);
});

503
rpcs3/Emu/ARMv7/Modules/sceNgs.cpp Normal file
View File

@ -0,0 +1,503 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceNgs;
struct SceNgsVoiceDefinition;
typedef u32 SceNgsModuleID;
typedef u32 SceNgsParamsID;
typedef vm::psv::ptr<void> SceNgsHVoice;
typedef vm::psv::ptr<void> SceNgsHPatch;
typedef vm::psv::ptr<void> SceNgsHSynSystem;
typedef vm::psv::ptr<void> SceNgsHRack;
struct SceNgsModuleParamHeader
{
s32 moduleId;
s32 chan;
};
struct SceNgsParamsDescriptor
{
SceNgsParamsID id;
u32 size;
};
struct SceNgsBufferInfo
{
vm::psv::ptr<void> data;
u32 size;
};
struct SceNgsVoicePreset
{
s32 nNameOffset;
u32 uNameLength;
s32 nPresetDataOffset;
u32 uSizePresetData;
s32 nBypassFlagsOffset;
u32 uNumBypassFlags;
};
struct SceNgsSystemInitParams
{
s32 nMaxRacks;
s32 nMaxVoices;
s32 nGranularity;
s32 nSampleRate;
s32 nMaxModules;
};
struct SceNgsRackDescription
{
vm::psv::ptr<const SceNgsVoiceDefinition> pVoiceDefn;
s32 nVoices;
s32 nChannelsPerVoice;
s32 nMaxPatchesPerInput;
s32 nPatchesPerOutput;
vm::psv::ptr<void> pUserReleaseData;
};
struct SceNgsPatchSetupInfo
{
SceNgsHVoice hVoiceSource;
s32 nSourceOutputIndex;
s32 nSourceOutputSubIndex;
SceNgsHVoice hVoiceDestination;
s32 nTargetInputIndex;
};
struct SceNgsVolumeMatrix
{
float m[2][2];
};
struct SceNgsPatchRouteInfo
{
s32 nOutputChannels;
s32 nInputChannels;
SceNgsVolumeMatrix vols;
};
struct SceNgsVoiceInfo
{
u32 uVoiceState;
u32 uNumModules;
u32 uNumInputs;
u32 uNumOutputs;
u32 uNumPatchesPerOutput;
};
struct SceNgsCallbackInfo
{
SceNgsHVoice hVoiceHandle;
SceNgsHRack hRackHandle;
SceNgsModuleID uModuleID;
s32 nCallbackData;
s32 nCallbackData2;
vm::psv::ptr<void> pCallbackPtr;
vm::psv::ptr<void> pUserData;
};
typedef vm::psv::ptr<void(vm::psv::ptr<const SceNgsCallbackInfo> pCallbackInfo)> SceNgsCallbackFunc;
typedef SceNgsCallbackFunc SceNgsRackReleaseCallbackFunc;
typedef SceNgsCallbackFunc SceNgsModuleCallbackFunc;
typedef SceNgsCallbackFunc SceNgsParamsErrorCallbackFunc;
struct SceSulphaNgsConfig
{
u32 maxNamedObjects;
u32 maxTraceBufferBytes;
};
s32 sceNgsSystemGetRequiredMemorySize(vm::psv::ptr<const SceNgsSystemInitParams> pSynthParams, vm::psv::ptr<u32> pnSize)
{
throw __FUNCTION__;
}
s32 sceNgsSystemInit(vm::psv::ptr<void> pSynthSysMemory, const u32 uMemSize, vm::psv::ptr<const SceNgsSystemInitParams> pSynthParams, vm::psv::ptr<SceNgsHSynSystem> pSystemHandle)
{
throw __FUNCTION__;
}
s32 sceNgsSystemUpdate(SceNgsHSynSystem hSystemHandle)
{
throw __FUNCTION__;
}
s32 sceNgsSystemRelease(SceNgsHSynSystem hSystemHandle)
{
throw __FUNCTION__;
}
s32 sceNgsSystemLock(SceNgsHSynSystem hSystemHandle)
{
throw __FUNCTION__;
}
s32 sceNgsSystemUnlock(SceNgsHSynSystem hSystemHandle)
{
throw __FUNCTION__;
}
s32 sceNgsSystemSetParamErrorCallback(SceNgsHSynSystem hSystemHandle, const SceNgsParamsErrorCallbackFunc callbackFuncPtr)
{
throw __FUNCTION__;
}
s32 sceNgsSystemSetFlags(SceNgsHSynSystem hSystemHandle, const u32 uSystemFlags)
{
throw __FUNCTION__;
}
s32 sceNgsRackGetRequiredMemorySize(SceNgsHSynSystem hSystemHandle, vm::psv::ptr<const SceNgsRackDescription> pRackDesc, vm::psv::ptr<u32> pnSize)
{
throw __FUNCTION__;
}
s32 sceNgsRackInit(SceNgsHSynSystem hSystemHandle, vm::psv::ptr<SceNgsBufferInfo> pRackBuffer, vm::psv::ptr<const SceNgsRackDescription> pRackDesc, vm::psv::ptr<SceNgsHRack> pRackHandle)
{
throw __FUNCTION__;
}
s32 sceNgsRackGetVoiceHandle(SceNgsHRack hRackHandle, const u32 uIndex, vm::psv::ptr<SceNgsHVoice> pVoiceHandle)
{
throw __FUNCTION__;
}
s32 sceNgsRackRelease(SceNgsHRack hRackHandle, const SceNgsRackReleaseCallbackFunc callbackFuncPtr)
{
throw __FUNCTION__;
}
s32 sceNgsRackSetParamErrorCallback(SceNgsHRack hRackHandle, const SceNgsParamsErrorCallbackFunc callbackFuncPtr)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceInit(SceNgsHVoice hVoiceHandle, vm::psv::ptr<const SceNgsVoicePreset> pPreset, const u32 uInitFlags)
{
throw __FUNCTION__;
}
s32 sceNgsVoicePlay(SceNgsHVoice hVoiceHandle)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceKeyOff(SceNgsHVoice hVoiceHandle)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceKill(SceNgsHVoice hVoiceHandle)
{
throw __FUNCTION__;
}
s32 sceNgsVoicePause(SceNgsHVoice hVoiceHandle)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceResume(SceNgsHVoice hVoiceHandle)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceSetPreset(SceNgsHVoice hVoiceHandle, vm::psv::ptr<const SceNgsVoicePreset> pVoicePreset)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceLockParams(SceNgsHVoice hVoiceHandle, const u32 uModule, const SceNgsParamsID uParamsInterfaceId, vm::psv::ptr<SceNgsBufferInfo> pParamsBuffer)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceUnlockParams(SceNgsHVoice hVoiceHandle, const u32 uModule)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceSetParamsBlock(SceNgsHVoice hVoiceHandle, vm::psv::ptr<const SceNgsModuleParamHeader> pParamData, const u32 uSize, vm::psv::ptr<s32> pnErrorCount)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceBypassModule(SceNgsHVoice hVoiceHandle, const u32 uModule, const u32 uBypassFlag)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceSetModuleCallback(SceNgsHVoice hVoiceHandle, const u32 uModule, const SceNgsModuleCallbackFunc callbackFuncPtr, vm::psv::ptr<void> pUserData)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceSetFinishedCallback(SceNgsHVoice hVoiceHandle, const SceNgsCallbackFunc callbackFuncPtr, vm::psv::ptr<void> pUserData)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceGetStateData(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::psv::ptr<void> pMem, const u32 uMemSize)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceGetInfo(SceNgsHVoice hVoiceHandle, vm::psv::ptr<SceNgsVoiceInfo> pInfo)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceGetModuleType(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::psv::ptr<SceNgsModuleID> pModuleType)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceGetModuleBypass(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::psv::ptr<u32> puBypassFlag)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceGetParamsOutOfRange(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::psv::ptr<char> pszMessageBuffer)
{
throw __FUNCTION__;
}
s32 sceNgsPatchCreateRouting(vm::psv::ptr<const SceNgsPatchSetupInfo> pPatchInfo, vm::psv::ptr<SceNgsHPatch> pPatchHandle)
{
throw __FUNCTION__;
}
s32 sceNgsPatchGetInfo(SceNgsHPatch hPatchHandle, vm::psv::ptr<SceNgsPatchRouteInfo> pRouteInfo, vm::psv::ptr<SceNgsPatchSetupInfo> pSetup)
{
throw __FUNCTION__;
}
s32 sceNgsVoiceGetOutputPatch(SceNgsHVoice hVoiceHandle, const s32 nOutputIndex, const s32 nSubIndex, vm::psv::ptr<SceNgsHPatch> pPatchHandle)
{
throw __FUNCTION__;
}
s32 sceNgsPatchRemoveRouting(SceNgsHPatch hPatchHandle)
{
throw __FUNCTION__;
}
//s32 sceNgsVoicePatchSetVolume(SceNgsHPatch hPatchHandle, const s32 nOutputChannel, const s32 nInputChannel, const float fVol)
//{
// throw __FUNCTION__;
//}
s32 sceNgsVoicePatchSetVolumes(SceNgsHPatch hPatchHandle, const s32 nOutputChannel, vm::psv::ptr<const float> pVolumes, const s32 nVols)
{
throw __FUNCTION__;
}
s32 sceNgsVoicePatchSetVolumesMatrix(SceNgsHPatch hPatchHandle, vm::psv::ptr<const SceNgsVolumeMatrix> pMatrix)
{
throw __FUNCTION__;
}
s32 sceNgsModuleGetNumPresets(SceNgsHSynSystem hSystemHandle, const SceNgsModuleID uModuleID, vm::psv::ptr<u32> puNumPresets)
{
throw __FUNCTION__;
}
s32 sceNgsModuleGetPreset(SceNgsHSynSystem hSystemHandle, const SceNgsModuleID uModuleID, const u32 uPresetIndex, vm::psv::ptr<SceNgsBufferInfo> pParamsBuffer)
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetCompressorBuss()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetCompressorSideChainBuss()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetDelayBuss()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetDistortionBuss()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetEnvelopeBuss()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetEqBuss()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetMasterBuss()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetMixerBuss()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetPauserBuss()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetReverbBuss()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetSasEmuVoice()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetSimpleVoice()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetTemplate1()
{
throw __FUNCTION__;
}
vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetAtrac9Voice()
{
throw __FUNCTION__;
}
s32 sceSulphaNgsGetDefaultConfig(vm::psv::ptr<SceSulphaNgsConfig> config)
{
throw __FUNCTION__;
}
s32 sceSulphaNgsGetNeededMemory(vm::psv::ptr<const SceSulphaNgsConfig> config, vm::psv::ptr<u32> sizeInBytes)
{
throw __FUNCTION__;
}
s32 sceSulphaNgsInit(vm::psv::ptr<const SceSulphaNgsConfig> config, vm::psv::ptr<void> buffer, u32 sizeInBytes)
{
throw __FUNCTION__;
}
s32 sceSulphaNgsShutdown()
{
throw __FUNCTION__;
}
s32 sceSulphaNgsSetSynthName(SceNgsHSynSystem synthHandle, vm::psv::ptr<const char> name)
{
throw __FUNCTION__;
}
s32 sceSulphaNgsSetRackName(SceNgsHRack rackHandle, vm::psv::ptr<const char> name)
{
throw __FUNCTION__;
}
s32 sceSulphaNgsSetVoiceName(SceNgsHVoice voiceHandle, vm::psv::ptr<const char> name)
{
throw __FUNCTION__;
}
s32 sceSulphaNgsSetSampleName(vm::psv::ptr<const void> location, u32 length, vm::psv::ptr<const char> name)
{
throw __FUNCTION__;
}
s32 sceSulphaNgsTrace(vm::psv::ptr<const char> message)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNgs, #name, name)
psv_log_base sceNgs("SceNgs", []()
{
sceNgs.on_load = nullptr;
sceNgs.on_unload = nullptr;
sceNgs.on_stop = nullptr;
REG_FUNC(0x6CE8B36F, sceNgsSystemGetRequiredMemorySize);
REG_FUNC(0xED14CF4A, sceNgsSystemInit);
REG_FUNC(0x684F080C, sceNgsSystemUpdate);
REG_FUNC(0x4A25BEBC, sceNgsSystemRelease);
REG_FUNC(0xB9D971F2, sceNgsSystemLock);
REG_FUNC(0x0A93EA96, sceNgsSystemUnlock);
REG_FUNC(0x5ADD22DC, sceNgsSystemSetParamErrorCallback);
REG_FUNC(0x64D80013, sceNgsSystemSetFlags);
REG_FUNC(0x477318C0, sceNgsRackGetRequiredMemorySize);
REG_FUNC(0x0A92E4EC, sceNgsRackInit);
REG_FUNC(0xFE1A98E9, sceNgsRackGetVoiceHandle);
REG_FUNC(0xDD5CA10B, sceNgsRackRelease);
REG_FUNC(0x534B6E3F, sceNgsRackSetParamErrorCallback);
REG_FUNC(0x1DDBEBEB, sceNgsVoiceInit);
REG_FUNC(0xFA0A0F34, sceNgsVoicePlay);
REG_FUNC(0xBB13373D, sceNgsVoiceKeyOff);
REG_FUNC(0x0E291AAD, sceNgsVoiceKill);
REG_FUNC(0xD7786E99, sceNgsVoicePause);
REG_FUNC(0x54CFB981, sceNgsVoiceResume);
REG_FUNC(0x8A88E665, sceNgsVoiceSetPreset);
REG_FUNC(0xAB6BEF8F, sceNgsVoiceLockParams);
REG_FUNC(0x3D46D8A7, sceNgsVoiceUnlockParams);
REG_FUNC(0xFB8174B1, sceNgsVoiceSetParamsBlock);
REG_FUNC(0x9AB87E71, sceNgsVoiceBypassModule);
REG_FUNC(0x24E909A8, sceNgsVoiceSetModuleCallback);
REG_FUNC(0x17A6F564, sceNgsVoiceSetFinishedCallback);
REG_FUNC(0xC9B8C0B4, sceNgsVoiceGetStateData);
REG_FUNC(0x5551410D, sceNgsVoiceGetInfo);
REG_FUNC(0xB307185E, sceNgsVoiceGetModuleType);
REG_FUNC(0x431BF3AB, sceNgsVoiceGetModuleBypass);
REG_FUNC(0xD668B49C, sceNgsPatchCreateRouting);
REG_FUNC(0x98703DBC, sceNgsPatchGetInfo);
REG_FUNC(0x01A52E3A, sceNgsVoiceGetOutputPatch);
REG_FUNC(0xD0C9AE5A, sceNgsPatchRemoveRouting);
//REG_FUNC(0xA3C807BC, sceNgsVoicePatchSetVolume);
REG_FUNC(0xBD6F57F0, sceNgsVoicePatchSetVolumes);
REG_FUNC(0xA0F5402D, sceNgsVoicePatchSetVolumesMatrix);
REG_FUNC(0xF6B68C31, sceNgsVoiceDefGetEnvelopeBuss);
REG_FUNC(0x9DCF50F5, sceNgsVoiceDefGetReverbBuss);
REG_FUNC(0x214485D6, sceNgsVoiceDefGetPauserBuss);
REG_FUNC(0xE0AC8776, sceNgsVoiceDefGetMixerBuss);
REG_FUNC(0x79A121D1, sceNgsVoiceDefGetMasterBuss);
REG_FUNC(0x0E0ACB68, sceNgsVoiceDefGetCompressorBuss);
REG_FUNC(0x1AF83512, sceNgsVoiceDefGetCompressorSideChainBuss);
REG_FUNC(0xAAD90DEB, sceNgsVoiceDefGetDistortionBuss);
REG_FUNC(0xF964120E, sceNgsVoiceDefGetEqBuss);
REG_FUNC(0xE9B572B7, sceNgsVoiceDefGetTemplate1);
REG_FUNC(0x0D5399CF, sceNgsVoiceDefGetSimpleVoice);
REG_FUNC(0x1F51C2BA, sceNgsVoiceDefGetSasEmuVoice);
REG_FUNC(0x4CBE08F3, sceNgsVoiceGetParamsOutOfRange);
REG_FUNC(0x14EF65A0, sceNgsVoiceDefGetAtrac9Voice);
REG_FUNC(0x4D705E3E, sceNgsVoiceDefGetDelayBuss);
REG_FUNC(0x5FD8AEDB, sceSulphaNgsGetDefaultConfig);
REG_FUNC(0x793E3E8C, sceSulphaNgsGetNeededMemory);
REG_FUNC(0xAFCD824F, sceSulphaNgsInit);
REG_FUNC(0xD124BFB1, sceSulphaNgsShutdown);
REG_FUNC(0x2F3F7515, sceSulphaNgsSetSynthName);
REG_FUNC(0x251AF6A9, sceSulphaNgsSetRackName);
REG_FUNC(0x508975BD, sceSulphaNgsSetVoiceName);
REG_FUNC(0x54EC5B8D, sceSulphaNgsSetSampleName);
REG_FUNC(0xDC7C0F05, sceSulphaNgsTrace);
REG_FUNC(0x5C71FE09, sceNgsModuleGetNumPresets);
REG_FUNC(0xC58298A7, sceNgsModuleGetPreset);
});

237
rpcs3/Emu/ARMv7/Modules/sceNpBasic.cpp Normal file
View File

@ -0,0 +1,237 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceNpCommon.h"
extern psv_log_base sceNpBasic;
enum SceNpBasicFriendListEventType : s32
{
SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_SYNC = 1,
SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_SYNC_DONE = 2,
SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_ADDED = 3,
SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_DELETED = 4
};
typedef vm::psv::ptr<void(SceNpBasicFriendListEventType eventType, vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<void> userdata)> SceNpBasicFriendListEventHandler;
enum SceNpBasicFriendOnlineStatusEventType : s32
{
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_SYNC = 1,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_SYNC_DONE = 2,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_UPDATED = 3
};
enum SceNpBasicFriendOnlineStatus : s32
{
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_UNKNOWN = 0,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_OFFLINE = 1,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_STANDBY = 2,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_ONLINE_OUT_OF_CONTEXT = 3,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_ONLINE_IN_CONTEXT = 4
};
typedef vm::psv::ptr<void(SceNpBasicFriendOnlineStatusEventType eventType, vm::psv::ptr<const SceNpId> friendId, SceNpBasicFriendOnlineStatus status, vm::psv::ptr<void> userdata)> SceNpBasicFriendOnlineStatusEventHandler;
enum SceNpBasicBlockListEventType : s32
{
SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_SYNC = 1,
SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_SYNC_DONE = 2,
SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_ADDED = 3,
SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_DELETED = 4
};
typedef vm::psv::ptr<void(SceNpBasicBlockListEventType eventType, vm::psv::ptr<const SceNpId> playerId, vm::psv::ptr<void> userdata)> SceNpBasicBlockListEventHandler;
enum SceNpBasicFriendGamePresenceEventType : s32
{
SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_SYNC = 1,
SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_SYNC_DONE = 2,
SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_UPDATED = 3
};
enum SceNpBasicInGamePresenceType
{
SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_UNKNOWN = -1,
SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_NONE = 0,
SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_DEFAULT = 1,
SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_JOINABLE = 2,
SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_MAX = 3
};
struct SceNpBasicInGamePresence
{
u32 sdkVersion;
SceNpBasicInGamePresenceType type;
char status[192];
u8 data[128];
u32 dataSize;
};
struct SceNpBasicGamePresence
{
u32 size;
char title[128];
SceNpBasicInGamePresence inGamePresence;
};
typedef vm::psv::ptr<void(SceNpBasicFriendGamePresenceEventType eventtype, vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<const SceNpBasicGamePresence> presence, vm::psv::ptr<void> userdata)> SceNpBasicFriendGamePresenceEventHandler;
struct SceNpBasicInGameDataMessage
{
u8 data[128];
u32 dataSize;
};
typedef vm::psv::ptr<void(vm::psv::ptr<const SceNpId> from, vm::psv::ptr<const SceNpBasicInGameDataMessage> message, vm::psv::ptr<void> userdata)> SceNpBasicInGameDataMessageEventHandler;
struct SceNpBasicEventHandlers
{
u32 sdkVersion;
SceNpBasicFriendListEventHandler friendListEventHandler;
SceNpBasicFriendOnlineStatusEventHandler friendOnlineStatusEventHandler;
SceNpBasicBlockListEventHandler blockListEventHandler;
SceNpBasicFriendGamePresenceEventHandler friendGamePresenceEventHandler;
SceNpBasicInGameDataMessageEventHandler inGameDataMessageEventHandler;
};
struct SceNpBasicPlaySessionLogDescription
{
char text[512];
};
struct SceNpBasicPlaySessionLog
{
u64 date;
SceNpId withWhom;
SceNpCommunicationId commId;
char title[128];
SceNpBasicPlaySessionLogDescription description;
};
enum SceNpBasicPlaySessionLogType : s32
{
SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_INVALID = -1,
SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_ALL = 0,
SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_BY_NP_COMM_ID = 1,
SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_MAX = 2
};
s32 sceNpBasicInit(vm::psv::ptr<void> opt)
{
throw __FUNCTION__;
}
s32 sceNpBasicTerm(ARMv7Context&)
{
throw __FUNCTION__;
}
s32 sceNpBasicRegisterHandler(vm::psv::ptr<const SceNpBasicEventHandlers> handlers, vm::psv::ptr<const SceNpCommunicationId> context, vm::psv::ptr<void> userdata)
{
throw __FUNCTION__;
}
s32 sceNpBasicUnregisterHandler(ARMv7Context&)
{
throw __FUNCTION__;
}
s32 sceNpBasicCheckCallback()
{
throw __FUNCTION__;
}
s32 sceNpBasicGetFriendOnlineStatus(vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<SceNpBasicFriendOnlineStatus> status)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetGamePresenceOfFriend(vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<SceNpBasicGamePresence> presence)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetFriendListEntryCount(vm::psv::ptr<u32> count)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetFriendListEntries(u32 startIndex, vm::psv::ptr<SceNpId> entries, u32 numEntries, vm::psv::ptr<u32> retrieved)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetBlockListEntryCount(vm::psv::ptr<u32> count)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetBlockListEntries(u32 startIndex, vm::psv::ptr<SceNpId> entries, u32 numEntries, vm::psv::ptr<u32> retrieved)
{
throw __FUNCTION__;
}
s32 sceNpBasicCheckIfPlayerIsBlocked(vm::psv::ptr<const SceNpId> player, vm::psv::ptr<u8> playerIsBlocked)
{
throw __FUNCTION__;
}
s32 sceNpBasicSetInGamePresence(vm::psv::ptr<const SceNpBasicInGamePresence> presence)
{
throw __FUNCTION__;
}
s32 sceNpBasicUnsetInGamePresence()
{
throw __FUNCTION__;
}
s32 sceNpBasicSendInGameDataMessage(vm::psv::ptr<const SceNpId> to, vm::psv::ptr<const SceNpBasicInGameDataMessage> message)
{
throw __FUNCTION__;
}
s32 sceNpBasicRecordPlaySessionLog(vm::psv::ptr<const SceNpId> withWhom, vm::psv::ptr<const SceNpBasicPlaySessionLogDescription> description)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetPlaySessionLogSize(SceNpBasicPlaySessionLogType type, vm::psv::ptr<u32> size)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetPlaySessionLog(SceNpBasicPlaySessionLogType type, u32 index, vm::psv::ptr<SceNpBasicPlaySessionLog> log)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpBasic, #name, name)
psv_log_base sceNpBasic("SceNpBasic", []()
{
sceNpBasic.on_load = nullptr;
sceNpBasic.on_unload = nullptr;
sceNpBasic.on_stop = nullptr;
REG_FUNC(0xEFB91A99, sceNpBasicInit);
REG_FUNC(0x389BCB3B, sceNpBasicTerm);
REG_FUNC(0x26E6E048, sceNpBasicRegisterHandler);
REG_FUNC(0x050AE072, sceNpBasicUnregisterHandler);
REG_FUNC(0x20146AEC, sceNpBasicCheckCallback);
REG_FUNC(0x5183A4B5, sceNpBasicGetFriendOnlineStatus);
REG_FUNC(0xEF8A91BC, sceNpBasicGetGamePresenceOfFriend);
REG_FUNC(0xDF41F308, sceNpBasicGetFriendListEntryCount);
REG_FUNC(0xFF07E787, sceNpBasicGetFriendListEntries);
REG_FUNC(0x407E1E6F, sceNpBasicGetBlockListEntryCount);
REG_FUNC(0x1211AE8E, sceNpBasicGetBlockListEntries);
REG_FUNC(0xF51545D8, sceNpBasicCheckIfPlayerIsBlocked);
REG_FUNC(0x51D75562, sceNpBasicSetInGamePresence);
REG_FUNC(0xD20C2370, sceNpBasicUnsetInGamePresence);
REG_FUNC(0x7A5020A5, sceNpBasicSendInGameDataMessage);
REG_FUNC(0x3B0A7F47, sceNpBasicRecordPlaySessionLog);
REG_FUNC(0xFB0F7FDF, sceNpBasicGetPlaySessionLogSize);
REG_FUNC(0x364531A8, sceNpBasicGetPlaySessionLog);
});

81
rpcs3/Emu/ARMv7/Modules/sceNpCommon.cpp Normal file
View File

@ -0,0 +1,81 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceNpCommon.h"
s32 sceNpAuthInit()
{
throw __FUNCTION__;
}
s32 sceNpAuthTerm()
{
throw __FUNCTION__;
}
s32 sceNpAuthCreateStartRequest(vm::psv::ptr<const SceNpAuthRequestParameter> param)
{
throw __FUNCTION__;
}
s32 sceNpAuthDestroyRequest(SceNpAuthRequestId id)
{
throw __FUNCTION__;
}
s32 sceNpAuthAbortRequest(SceNpAuthRequestId id)
{
throw __FUNCTION__;
}
s32 sceNpAuthGetTicket(SceNpAuthRequestId id, vm::psv::ptr<void> buf, u32 len)
{
throw __FUNCTION__;
}
s32 sceNpAuthGetTicketParam(vm::psv::ptr<const u8> ticket, u32 ticketSize, s32 paramId, vm::psv::ptr<SceNpTicketParam> param)
{
throw __FUNCTION__;
}
s32 sceNpAuthGetEntitlementIdList(vm::psv::ptr<const u8> ticket, u32 ticketSize, vm::psv::ptr<SceNpEntitlementId> entIdList, u32 entIdListNum)
{
throw __FUNCTION__;
}
s32 sceNpAuthGetEntitlementById(vm::psv::ptr<const u8> ticket, u32 ticketSize, vm::psv::ptr<const char> entId, vm::psv::ptr<SceNpEntitlement> ent)
{
throw __FUNCTION__;
}
s32 sceNpCmpNpId(vm::psv::ptr<const SceNpId> npid1, vm::psv::ptr<const SceNpId> npid2)
{
throw __FUNCTION__;
}
s32 sceNpCmpNpIdInOrder(vm::psv::ptr<const SceNpId> npid1, vm::psv::ptr<const SceNpId> npid2, vm::psv::ptr<s32> order)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpCommon, #name, name)
psv_log_base sceNpCommon("SceNpCommon", []()
{
sceNpCommon.on_load = nullptr;
sceNpCommon.on_unload = nullptr;
sceNpCommon.on_stop = nullptr;
REG_FUNC(0x441D8B4E, sceNpAuthInit);
REG_FUNC(0x6093B689, sceNpAuthTerm);
REG_FUNC(0xED42079F, sceNpAuthCreateStartRequest);
REG_FUNC(0x14FC18AF, sceNpAuthDestroyRequest);
REG_FUNC(0xE2582575, sceNpAuthAbortRequest);
REG_FUNC(0x59608D1C, sceNpAuthGetTicket);
REG_FUNC(0xC1E23E01, sceNpAuthGetTicketParam);
REG_FUNC(0x3377CD37, sceNpAuthGetEntitlementIdList);
REG_FUNC(0xF93842F0, sceNpAuthGetEntitlementById);
REG_FUNC(0xFB8D82E5, sceNpCmpNpId);
REG_FUNC(0x6BC8150A, sceNpCmpNpIdInOrder);
});

154
rpcs3/Emu/ARMv7/Modules/sceNpCommon.h Normal file
View File

@ -0,0 +1,154 @@
#pragma once
enum SceNpServiceState : s32
{
SCE_NP_SERVICE_STATE_UNKNOWN = 0,
SCE_NP_SERVICE_STATE_SIGNED_OUT,
SCE_NP_SERVICE_STATE_SIGNED_IN,
SCE_NP_SERVICE_STATE_ONLINE
};
struct SceNpCommunicationId
{
char data[9];
char term;
u8 num;
char dummy;
};
struct SceNpCommunicationPassphrase
{
u8 data[128];
};
struct SceNpCommunicationSignature
{
u8 data[160];
};
struct SceNpCommunicationConfig
{
vm::psv::ptr<const SceNpCommunicationId> commId;
vm::psv::ptr<const SceNpCommunicationPassphrase> commPassphrase;
vm::psv::ptr<const SceNpCommunicationSignature> commSignature;
};
struct SceNpCountryCode
{
char data[2];
char term;
char padding[1];
};
struct SceNpOnlineId
{
char data[16];
char term;
char dummy[3];
};
struct SceNpId
{
SceNpOnlineId handle;
u8 opt[8];
u8 reserved[8];
};
struct SceNpAvatarUrl
{
char data[127];
char term;
};
struct SceNpUserInformation
{
SceNpId userId;
SceNpAvatarUrl icon;
u8 reserved[52];
};
struct SceNpMyLanguages
{
s32 language1;
s32 language2;
s32 language3;
u8 padding[4];
};
struct SceNpAvatarImage
{
u8 data[200 * 1024];
u32 size;
u8 reserved[12];
};
enum SceNpAvatarSizeType : s32
{
SCE_NP_AVATAR_SIZE_LARGE,
SCE_NP_AVATAR_SIZE_MIDDLE,
SCE_NP_AVATAR_SIZE_SMALL
};
struct SceNpAboutMe
{
char data[64];
};
typedef s32 SceNpAuthRequestId;
typedef u64 SceNpTime;
struct SceNpDate
{
u16 year;
u8 month;
u8 day;
};
union SceNpTicketParam
{
s32 _s32;
s64 _s64;
u32 _u32;
u64 _u64;
SceNpDate date;
u8 data[256];
};
struct SceNpTicketVersion
{
u16 major;
u16 minor;
};
typedef vm::psv::ptr<s32(SceNpAuthRequestId id, s32 result, vm::psv::ptr<void> arg)> SceNpAuthCallback;
struct SceNpAuthRequestParameter
{
u32 size;
SceNpTicketVersion version;
vm::psv::ptr<const char> serviceId;
vm::psv::ptr<const void> cookie;
u32 cookieSize;
vm::psv::ptr<const char> entitlementId;
u32 consumedCount;
SceNpAuthCallback ticketCb;
vm::psv::ptr<void> cbArg;
};
struct SceNpEntitlementId
{
u8 data[32];
};
struct SceNpEntitlement
{
SceNpEntitlementId id;
SceNpTime createdDate;
SceNpTime expireDate;
u32 type;
s32 remainingCount;
u32 consumedCount;
char padding[4];
};
extern psv_log_base sceNpCommon;

84
rpcs3/Emu/ARMv7/Modules/sceNpManager.cpp Normal file
View File

@ -0,0 +1,84 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceNpCommon.h"
extern psv_log_base sceNpManager;
struct SceNpOptParam
{
u32 optParamSize;
};
typedef vm::psv::ptr<void(SceNpServiceState state, vm::psv::ptr<void> userdata)> SceNpServiceStateCallback;
s32 sceNpInit(vm::psv::ptr<const SceNpCommunicationConfig> commConf, vm::psv::ptr<SceNpOptParam> opt)
{
throw __FUNCTION__;
}
s32 sceNpTerm(ARMv7Context&)
{
throw __FUNCTION__;
}
s32 sceNpCheckCallback()
{
throw __FUNCTION__;
}
s32 sceNpGetServiceState(vm::psv::ptr<SceNpServiceState> state)
{
throw __FUNCTION__;
}
s32 sceNpRegisterServiceStateCallback(SceNpServiceStateCallback callback, vm::psv::ptr<void> userdata)
{
throw __FUNCTION__;
}
s32 sceNpUnregisterServiceStateCallback()
{
throw __FUNCTION__;
}
s32 sceNpManagerGetNpId(vm::psv::ptr<SceNpId> npId)
{
throw __FUNCTION__;
}
s32 sceNpManagerGetAccountRegion(vm::psv::ptr<SceNpCountryCode> countryCode, vm::psv::ptr<s32> languageCode)
{
throw __FUNCTION__;
}
s32 sceNpManagerGetContentRatingFlag(vm::psv::ptr<s32> isRestricted, vm::psv::ptr<s32> age)
{
throw __FUNCTION__;
}
s32 sceNpManagerGetChatRestrictionFlag(vm::psv::ptr<s32> isRestricted)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpManager, #name, name)
psv_log_base sceNpManager("SceNpManager", []()
{
sceNpManager.on_load = nullptr;
sceNpManager.on_unload = nullptr;
sceNpManager.on_stop = nullptr;
REG_FUNC(0x04D9F484, sceNpInit);
REG_FUNC(0x19E40AE1, sceNpTerm);
REG_FUNC(0x3C94B4B4, sceNpManagerGetNpId);
REG_FUNC(0x54060DF6, sceNpGetServiceState);
REG_FUNC(0x44239C35, sceNpRegisterServiceStateCallback);
REG_FUNC(0xD9E6E56C, sceNpUnregisterServiceStateCallback);
REG_FUNC(0x3B0AE9A9, sceNpCheckCallback);
REG_FUNC(0xFE835967, sceNpManagerGetAccountRegion);
REG_FUNC(0xAF0073B2, sceNpManagerGetContentRatingFlag);
REG_FUNC(0x60C575B1, sceNpManagerGetChatRestrictionFlag);
});

1344
rpcs3/Emu/ARMv7/Modules/sceNpMatching.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

373
rpcs3/Emu/ARMv7/Modules/sceNpScore.cpp Normal file
View File

@ -0,0 +1,373 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceNpCommon.h"
extern psv_log_base sceNpScore;
typedef u32 SceNpScoreBoardId;
typedef s64 SceNpScoreValue;
typedef u32 SceNpScoreRankNumber;
typedef s32 SceNpScorePcId;
struct SceNpScoreGameInfo
{
u32 infoSize;
u8 pad[4];
u8 data[192];
};
struct SceNpScoreComment
{
char utf8Comment[64];
};
struct SceNpScoreRankData
{
SceNpId npId;
u8 reserved[49];
u8 pad0[3];
SceNpScorePcId pcId;
SceNpScoreRankNumber serialRank;
SceNpScoreRankNumber rank;
SceNpScoreRankNumber highestRank;
s32 hasGameData;
u8 pad1[4];
SceNpScoreValue scoreValue;
u64 recordDate;
};
struct SceNpScorePlayerRankData
{
s32 hasData;
u8 pad0[4];
SceNpScoreRankData rankData;
};
struct SceNpScoreBoardInfo
{
u32 rankLimit;
u32 updateMode;
u32 sortMode;
u32 uploadNumLimit;
u32 uploadSizeLimit;
};
struct SceNpScoreNpIdPcId
{
SceNpId npId;
SceNpScorePcId pcId;
u8 pad[4];
};
s32 sceNpScoreInit(s32 threadPriority, s32 cpuAffinityMask, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreTerm(ARMv7Context&)
{
throw __FUNCTION__;
}
s32 sceNpScoreCreateTitleCtx(vm::psv::ptr<const SceNpCommunicationId> titleId, vm::psv::ptr<const SceNpCommunicationPassphrase> passphrase, vm::psv::ptr<const SceNpId> selfNpId)
{
throw __FUNCTION__;
}
s32 sceNpScoreDeleteTitleCtx(s32 titleCtxId)
{
throw __FUNCTION__;
}
s32 sceNpScoreCreateRequest(s32 titleCtxId)
{
throw __FUNCTION__;
}
s32 sceNpScoreDeleteRequest(s32 reqId)
{
throw __FUNCTION__;
}
s32 sceNpScoreAbortRequest(s32 reqId)
{
throw __FUNCTION__;
}
s32 sceNpScoreSetTimeout(s32 id, s32 resolveRetry, s32 resolveTimeout, s32 connTimeout, s32 sendTimeout, s32 recvTimeout)
{
throw __FUNCTION__;
}
s32 sceNpScoreSetPlayerCharacterId(s32 id, SceNpScorePcId pcId)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetBoardInfo(s32 reqId, SceNpScoreBoardId boardId, vm::psv::ptr<SceNpScoreBoardInfo> boardInfo, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreRecordScore(
s32 reqId,
SceNpScoreBoardId boardId,
SceNpScoreValue score,
vm::psv::ptr<const SceNpScoreComment> scoreComment,
vm::psv::ptr<const SceNpScoreGameInfo> gameInfo,
vm::psv::ptr<SceNpScoreRankNumber> tmpRank,
vm::psv::ptr<const u64> compareDate,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreRecordGameData(
s32 reqId,
SceNpScoreBoardId boardId,
SceNpScoreValue score,
u32 totalSize,
u32 sendSize,
vm::psv::ptr<const void> data,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetGameData(
s32 reqId,
SceNpScoreBoardId boardId,
vm::psv::ptr<const SceNpId> npId,
vm::psv::ptr<u32> totalSize,
u32 recvSize,
vm::psv::ptr<void> data,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetRankingByNpId(
s32 reqId,
SceNpScoreBoardId boardId,
vm::psv::ptr<const SceNpId> npIdArray,
u32 npIdArraySize,
vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
u32 rankArraySize,
vm::psv::ptr<SceNpScoreComment> commentArray,
u32 commentArraySize,
vm::psv::ptr<SceNpScoreGameInfo> infoArray,
u32 infoArraySize,
u32 arrayNum,
vm::psv::ptr<u64> lastSortDate,
vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetRankingByRange(
s32 reqId,
SceNpScoreBoardId boardId,
SceNpScoreRankNumber startSerialRank,
vm::psv::ptr<SceNpScoreRankData> rankArray,
u32 rankArraySize,
vm::psv::ptr<SceNpScoreComment> commentArray,
u32 commentArraySize,
vm::psv::ptr<SceNpScoreGameInfo> infoArray,
u32 infoArraySize,
u32 arrayNum,
vm::psv::ptr<u64> lastSortDate,
vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetRankingByNpIdPcId(
s32 reqId,
SceNpScoreBoardId boardId,
vm::psv::ptr<const SceNpScoreNpIdPcId> idArray,
u32 idArraySize,
vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
u32 rankArraySize,
vm::psv::ptr<SceNpScoreComment> commentArray,
u32 commentArraySize,
vm::psv::ptr<SceNpScoreGameInfo> infoArray,
u32 infoArraySize,
u32 arrayNum,
vm::psv::ptr<u64> lastSortDate,
vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreCensorComment(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreSanitizeComment(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::ptr<char> sanitizedComment, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreWaitAsync(s32 id, vm::psv::ptr<s32> result)
{
throw __FUNCTION__;
}
s32 sceNpScorePollAsync(s32 reqId, vm::psv::ptr<s32> result)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetBoardInfoAsync(s32 reqId, SceNpScoreBoardId boardId, vm::psv::ptr<SceNpScoreBoardInfo> boardInfo, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreRecordScoreAsync(
s32 reqId,
SceNpScoreBoardId boardId,
SceNpScoreValue score,
vm::psv::ptr<const SceNpScoreComment> scoreComment,
vm::psv::ptr<const SceNpScoreGameInfo> gameInfo,
vm::psv::ptr<SceNpScoreRankNumber> tmpRank,
vm::psv::ptr<const u64> compareDate,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreRecordGameDataAsync(
s32 reqId,
SceNpScoreBoardId boardId,
SceNpScoreValue score,
u32 totalSize,
u32 sendSize,
vm::psv::ptr<const void> data,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetGameDataAsync(
s32 reqId,
SceNpScoreBoardId boardId,
vm::psv::ptr<const SceNpId> npId,
vm::psv::ptr<u32> totalSize,
u32 recvSize,
vm::psv::ptr<void> data,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetRankingByNpIdAsync(
s32 reqId,
SceNpScoreBoardId boardId,
vm::psv::ptr<const SceNpId> npIdArray,
u32 npIdArraySize,
vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
u32 rankArraySize,
vm::psv::ptr<SceNpScoreComment> commentArray,
u32 commentArraySize,
vm::psv::ptr<SceNpScoreGameInfo> infoArray,
u32 infoArraySize,
u32 arrayNum,
vm::psv::ptr<u64> lastSortDate,
vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetRankingByRangeAsync(
s32 reqId,
SceNpScoreBoardId boardId,
SceNpScoreRankNumber startSerialRank,
vm::psv::ptr<SceNpScoreRankData> rankArray,
u32 rankArraySize,
vm::psv::ptr<SceNpScoreComment> commentArray,
u32 commentArraySize,
vm::psv::ptr<SceNpScoreGameInfo> infoArray,
u32 infoArraySize,
u32 arrayNum,
vm::psv::ptr<u64> lastSortDate,
vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetRankingByNpIdPcIdAsync(
s32 reqId,
SceNpScoreBoardId boardId,
vm::psv::ptr<const SceNpScoreNpIdPcId> idArray,
u32 idArraySize,
vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
u32 rankArraySize,
vm::psv::ptr<SceNpScoreComment> commentArray,
u32 commentArraySize,
vm::psv::ptr<SceNpScoreGameInfo> infoArray,
u32 infoArraySize,
u32 arrayNum,
vm::psv::ptr<u64> lastSortDate,
vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreCensorCommentAsync(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreSanitizeCommentAsync(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::ptr<char> sanitizedComment, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpScore, #name, name)
psv_log_base sceNpScore("SceNpScore", []()
{
sceNpScore.on_load = nullptr;
sceNpScore.on_unload = nullptr;
sceNpScore.on_stop = nullptr;
REG_FUNC(0x0433069F, sceNpScoreInit);
REG_FUNC(0x2050F98F, sceNpScoreTerm);
REG_FUNC(0x5685F225, sceNpScoreCreateTitleCtx);
REG_FUNC(0xD30D1993, sceNpScoreCreateRequest);
REG_FUNC(0xF52EA88A, sceNpScoreDeleteTitleCtx);
REG_FUNC(0xFFF24BB1, sceNpScoreDeleteRequest);
REG_FUNC(0x320C0277, sceNpScoreRecordScore);
REG_FUNC(0x24B09634, sceNpScoreRecordScoreAsync);
REG_FUNC(0xC2862B67, sceNpScoreRecordGameData);
REG_FUNC(0x40573917, sceNpScoreRecordGameDataAsync);
REG_FUNC(0xDFAD64D3, sceNpScoreGetGameData);
REG_FUNC(0xCE416993, sceNpScoreGetGameDataAsync);
REG_FUNC(0x427D3412, sceNpScoreGetRankingByRange);
REG_FUNC(0xC45E3FCD, sceNpScoreGetRankingByRangeAsync);
REG_FUNC(0xBAE55B34, sceNpScoreGetRankingByNpId);
REG_FUNC(0x45CD1D00, sceNpScoreGetRankingByNpIdAsync);
REG_FUNC(0x871F28AA, sceNpScoreGetRankingByNpIdPcId);
REG_FUNC(0xCE3A9544, sceNpScoreGetRankingByNpIdPcIdAsync);
REG_FUNC(0xA7E93CE1, sceNpScoreAbortRequest);
REG_FUNC(0x31733BF3, sceNpScoreWaitAsync);
REG_FUNC(0x9F2A7AC9, sceNpScorePollAsync);
REG_FUNC(0x00F90E7B, sceNpScoreGetBoardInfo);
REG_FUNC(0x3CD9974E, sceNpScoreGetBoardInfoAsync);
REG_FUNC(0xA0C94D46, sceNpScoreCensorComment);
REG_FUNC(0xAA0BBF8E, sceNpScoreCensorCommentAsync);
REG_FUNC(0x6FD2041A, sceNpScoreSanitizeComment);
REG_FUNC(0x15981858, sceNpScoreSanitizeCommentAsync);
REG_FUNC(0x5EF44841, sceNpScoreSetTimeout);
REG_FUNC(0x53D77883, sceNpScoreSetPlayerCharacterId);
});

167
rpcs3/Emu/ARMv7/Modules/sceNpUtility.cpp Normal file
View File

@ -0,0 +1,167 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceNpCommon.h"
extern psv_log_base sceNpUtility;
struct SceNpBandwidthTestResult
{
double uploadBps;
double downloadBps;
s32 result;
char padding[4];
};
s32 sceNpLookupInit(s32 usesAsync, s32 threadPriority, s32 cpuAffinityMask, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpLookupTerm(ARMv7Context&)
{
throw __FUNCTION__;
}
s32 sceNpLookupCreateTitleCtx(vm::psv::ptr<const SceNpCommunicationId> titleId, vm::psv::ptr<const SceNpId> selfNpId)
{
throw __FUNCTION__;
}
s32 sceNpLookupDeleteTitleCtx(s32 titleCtxId)
{
throw __FUNCTION__;
}
s32 sceNpLookupCreateRequest(s32 titleCtxId)
{
throw __FUNCTION__;
}
s32 sceNpLookupDeleteRequest(s32 reqId)
{
throw __FUNCTION__;
}
s32 sceNpLookupAbortRequest(s32 reqId)
{
throw __FUNCTION__;
}
s32 sceNpLookupSetTimeout(s32 id, s32 resolveRetry, u32 resolveTimeout, u32 connTimeout, u32 sendTimeout, u32 recvTimeout)
{
throw __FUNCTION__;
}
s32 sceNpLookupWaitAsync(s32 reqId, vm::psv::ptr<s32> result)
{
throw __FUNCTION__;
}
s32 sceNpLookupPollAsync(s32 reqId, vm::psv::ptr<s32> result)
{
throw __FUNCTION__;
}
s32 sceNpLookupNpId(s32 reqId, vm::psv::ptr<const SceNpOnlineId> onlineId, vm::psv::ptr<SceNpId> npId, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpLookupNpIdAsync(s32 reqId, vm::psv::ptr<const SceNpOnlineId> onlineId, vm::psv::ptr<SceNpId> npId, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpLookupUserProfile(
s32 reqId,
s32 avatarSizeType,
vm::psv::ptr<const SceNpId> npId,
vm::psv::ptr<SceNpUserInformation> userInfo,
vm::psv::ptr<SceNpAboutMe> aboutMe,
vm::psv::ptr<SceNpMyLanguages> languages,
vm::psv::ptr<SceNpCountryCode> countryCode,
vm::psv::ptr<void> avatarImageData,
u32 avatarImageDataMaxSize,
vm::psv::ptr<u32> avatarImageDataSize,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpLookupUserProfileAsync(
s32 reqId,
s32 avatarSizeType,
vm::psv::ptr<const SceNpId> npId,
vm::psv::ptr<SceNpUserInformation> userInfo,
vm::psv::ptr<SceNpAboutMe> aboutMe,
vm::psv::ptr<SceNpMyLanguages> languages,
vm::psv::ptr<SceNpCountryCode> countryCode,
vm::psv::ptr<void> avatarImageData,
u32 avatarImageDataMaxSize,
vm::psv::ptr<u32> avatarImageDataSize,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpLookupAvatarImage(s32 reqId, vm::psv::ptr<const SceNpAvatarUrl> avatarUrl, vm::psv::ptr<SceNpAvatarImage> avatarImage, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpLookupAvatarImageAsync(s32 reqId, vm::psv::ptr<const SceNpAvatarUrl> avatarUrl, vm::psv::ptr<SceNpAvatarImage> avatarImage, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpBandwidthTestInitStart(s32 initPriority, s32 cpuAffinityMask)
{
throw __FUNCTION__;
}
s32 sceNpBandwidthTestGetStatus()
{
throw __FUNCTION__;
}
s32 sceNpBandwidthTestShutdown(vm::psv::ptr<SceNpBandwidthTestResult> result)
{
throw __FUNCTION__;
}
s32 sceNpBandwidthTestAbort()
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpUtility, #name, name)
psv_log_base sceNpUtility("SceNpUtility", []()
{
sceNpUtility.on_load = nullptr;
sceNpUtility.on_unload = nullptr;
sceNpUtility.on_stop = nullptr;
REG_FUNC(0x9246A673, sceNpLookupInit);
REG_FUNC(0x0158B61B, sceNpLookupTerm);
REG_FUNC(0x5110E17E, sceNpLookupCreateTitleCtx);
REG_FUNC(0x33B64699, sceNpLookupDeleteTitleCtx);
REG_FUNC(0x9E42E922, sceNpLookupCreateRequest);
REG_FUNC(0x8B608BF6, sceNpLookupDeleteRequest);
REG_FUNC(0x027587C4, sceNpLookupAbortRequest);
REG_FUNC(0xB0C9DC45, sceNpLookupSetTimeout);
REG_FUNC(0xCF956F23, sceNpLookupWaitAsync);
REG_FUNC(0xFCDBA234, sceNpLookupPollAsync);
REG_FUNC(0xB1A14879, sceNpLookupNpId);
REG_FUNC(0x5387BABB, sceNpLookupNpIdAsync);
REG_FUNC(0x6A1BF429, sceNpLookupUserProfile);
REG_FUNC(0xE5285E0F, sceNpLookupUserProfileAsync);
REG_FUNC(0xFDB0AE47, sceNpLookupAvatarImage);
REG_FUNC(0x282BD43C, sceNpLookupAvatarImageAsync);
REG_FUNC(0x081FA13C, sceNpBandwidthTestInitStart);
REG_FUNC(0xE0EBFBF6, sceNpBandwidthTestGetStatus);
REG_FUNC(0x58D92EFD, sceNpBandwidthTestShutdown);
REG_FUNC(0x32B068C4, sceNpBandwidthTestAbort);
});

284
rpcs3/Emu/ARMv7/Modules/scePerf.cpp Normal file
View File

@ -0,0 +1,284 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "Emu/SysCalls/lv2/sys_time.h"
#define RETURN_ERROR(code) { Emu.Pause(); scePerf.Error("%s() failed: %s", __FUNCTION__, #code); return code; }
extern psv_log_base scePerf;
enum
{
// Error Codes
SCE_PERF_ERROR_INVALID_ARGUMENT = 0x80580000,
};
enum : s32
{
// Thread IDs
SCE_PERF_ARM_PMON_THREAD_ID_ALL = -1,
SCE_PERF_ARM_PMON_THREAD_ID_SELF = 0,
};
enum : u32
{
// Counter Numbers
SCE_PERF_ARM_PMON_CYCLE_COUNTER = 31,
SCE_PERF_ARM_PMON_COUNTER_5 = 5,
SCE_PERF_ARM_PMON_COUNTER_4 = 4,
SCE_PERF_ARM_PMON_COUNTER_3 = 3,
SCE_PERF_ARM_PMON_COUNTER_2 = 2,
SCE_PERF_ARM_PMON_COUNTER_1 = 1,
SCE_PERF_ARM_PMON_COUNTER_0 = 0,
// Counter Masks
SCE_PERF_ARM_PMON_COUNTER_MASK_5 = 0x20,
SCE_PERF_ARM_PMON_COUNTER_MASK_4 = 0x10,
SCE_PERF_ARM_PMON_COUNTER_MASK_3 = 0x08,
SCE_PERF_ARM_PMON_COUNTER_MASK_2 = 0x04,
SCE_PERF_ARM_PMON_COUNTER_MASK_1 = 0x02,
SCE_PERF_ARM_PMON_COUNTER_MASK_0 = 0x01,
SCE_PERF_ARM_PMON_COUNTER_MASK_ALL = 0x3f,
};
enum : u8
{
// Performance Counter Events
SCE_PERF_ARM_PMON_SOFT_INCREMENT = 0x00,
SCE_PERF_ARM_PMON_ICACHE_MISS = 0x01,
SCE_PERF_ARM_PMON_ITLB_MISS = 0x02,
SCE_PERF_ARM_PMON_DCACHE_MISS = 0x03,
SCE_PERF_ARM_PMON_DCACHE_ACCESS = 0x04,
SCE_PERF_ARM_PMON_DTLB_MISS = 0x05,
SCE_PERF_ARM_PMON_DATA_READ = 0x06,
SCE_PERF_ARM_PMON_DATA_WRITE = 0x07,
SCE_PERF_ARM_PMON_EXCEPTION_TAKEN = 0x09,
SCE_PERF_ARM_PMON_EXCEPTION_RETURN = 0x0A,
SCE_PERF_ARM_PMON_WRITE_CONTEXTID = 0x0B,
SCE_PERF_ARM_PMON_SOFT_CHANGEPC = 0x0C,
SCE_PERF_ARM_PMON_IMMEDIATE_BRANCH = 0x0D,
SCE_PERF_ARM_PMON_UNALIGNED = 0x0F,
SCE_PERF_ARM_PMON_BRANCH_MISPREDICT = 0x10,
SCE_PERF_ARM_PMON_PREDICT_BRANCH = 0x12,
SCE_PERF_ARM_PMON_COHERENT_LF_MISS = 0x50,
SCE_PERF_ARM_PMON_COHERENT_LF_HIT = 0x51,
SCE_PERF_ARM_PMON_ICACHE_STALL = 0x60,
SCE_PERF_ARM_PMON_DCACHE_STALL = 0x61,
SCE_PERF_ARM_PMON_MAINTLB_STALL = 0x62,
SCE_PERF_ARM_PMON_STREX_PASSED = 0x63,
SCE_PERF_ARM_PMON_STREX_FAILED = 0x64,
SCE_PERF_ARM_PMON_DATA_EVICTION = 0x65,
SCE_PERF_ARM_PMON_ISSUE_NO_DISPATCH = 0x66,
SCE_PERF_ARM_PMON_ISSUE_EMPTY = 0x67,
SCE_PERF_ARM_PMON_INST_RENAME = 0x68,
SCE_PERF_ARM_PMON_PREDICT_FUNC_RET = 0x6E,
SCE_PERF_ARM_PMON_MAIN_PIPE = 0x70,
SCE_PERF_ARM_PMON_SECOND_PIPE = 0x71,
SCE_PERF_ARM_PMON_LS_PIPE = 0x72,
SCE_PERF_ARM_PMON_FPU_RENAME = 0x73,
SCE_PERF_ARM_PMON_PLD_STALL = 0x80,
SCE_PERF_ARM_PMON_WRITE_STALL = 0x81,
SCE_PERF_ARM_PMON_INST_MAINTLB_STALL = 0x82,
SCE_PERF_ARM_PMON_DATA_MAINTLB_STALL = 0x83,
SCE_PERF_ARM_PMON_INST_UTLB_STALL = 0x84,
SCE_PERF_ARM_PMON_DATA_UTLB_STALL = 0x85,
SCE_PERF_ARM_PMON_DMB_STALL = 0x86,
SCE_PERF_ARM_PMON_INTEGER_CLOCK = 0x8A,
SCE_PERF_ARM_PMON_DATAENGINE_CLOCK = 0x8B,
SCE_PERF_ARM_PMON_ISB = 0x90,
SCE_PERF_ARM_PMON_DSB = 0x91,
SCE_PERF_ARM_PMON_DMB = 0x92,
SCE_PERF_ARM_PMON_EXT_INTERRUPT = 0x93,
SCE_PERF_ARM_PMON_PLE_LINE_REQ_COMPLETED = 0xA0,
SCE_PERF_ARM_PMON_PLE_CHANNEL_SKIPPED = 0xA1,
SCE_PERF_ARM_PMON_PLE_FIFO_FLUSH = 0xA2,
SCE_PERF_ARM_PMON_PLE_REQ_COMPLETED = 0xA3,
SCE_PERF_ARM_PMON_PLE_FIFO_OVERFLOW = 0xA4,
SCE_PERF_ARM_PMON_PLE_REQ_PROGRAMMED = 0xA5,
};
s32 scePerfArmPmonReset(ARMv7Context& context, s32 threadId)
{
scePerf.Warning("scePerfArmPmonReset(threadId=0x%x)", threadId);
if (threadId != SCE_PERF_ARM_PMON_THREAD_ID_SELF)
{
throw __FUNCTION__;
}
context.counters = {};
return SCE_OK;
}
s32 scePerfArmPmonSelectEvent(ARMv7Context& context, s32 threadId, u32 counter, u8 eventCode)
{
scePerf.Warning("scePerfArmPmonSelectEvent(threadId=0x%x, counter=0x%x, eventCode=0x%x)", threadId, counter, eventCode);
if (threadId != SCE_PERF_ARM_PMON_THREAD_ID_SELF)
{
throw __FUNCTION__;
}
if (counter >= 6)
{
RETURN_ERROR(SCE_PERF_ERROR_INVALID_ARGUMENT);
}
u32 value = 0; // initial value
switch (eventCode)
{
case SCE_PERF_ARM_PMON_SOFT_INCREMENT: break;
case SCE_PERF_ARM_PMON_BRANCH_MISPREDICT:
case SCE_PERF_ARM_PMON_DCACHE_MISS:
case SCE_PERF_ARM_PMON_UNALIGNED:
{
value = 1; // these events will probably never be implemented
break;
}
case SCE_PERF_ARM_PMON_PREDICT_BRANCH:
case SCE_PERF_ARM_PMON_DCACHE_ACCESS:
{
value = 1000; // these events will probably never be implemented
break;
}
default: throw "scePerfArmPmonSelectEvent(): unknown event requested";
}
context.counters[counter].event = eventCode;
context.counters[counter].value = value;
return SCE_OK;
}
s32 scePerfArmPmonStart(ARMv7Context& context, s32 threadId)
{
scePerf.Warning("scePerfArmPmonStart(threadId=0x%x)", threadId);
if (threadId != SCE_PERF_ARM_PMON_THREAD_ID_SELF)
{
throw __FUNCTION__;
}
return SCE_OK;
}
s32 scePerfArmPmonStop(ARMv7Context& context, s32 threadId)
{
scePerf.Warning("scePerfArmPmonStop(threadId=0x%x)");
if (threadId != SCE_PERF_ARM_PMON_THREAD_ID_SELF)
{
throw __FUNCTION__;
}
return SCE_OK;
}
s32 scePerfArmPmonGetCounterValue(ARMv7Context& context, s32 threadId, u32 counter, vm::psv::ptr<u32> pValue)
{
scePerf.Warning("scePerfArmPmonGetCounterValue(threadId=0x%x, counter=%d, pValue=0x%x)", threadId, counter, pValue);
if (threadId != SCE_PERF_ARM_PMON_THREAD_ID_SELF)
{
throw __FUNCTION__;
}
if (counter >= 6 && counter != SCE_PERF_ARM_PMON_CYCLE_COUNTER)
{
RETURN_ERROR(SCE_PERF_ERROR_INVALID_ARGUMENT);
}
if (counter < 6)
{
*pValue = context.counters[counter].value;
}
else
{
throw "scePerfArmPmonGetCounterValue(): cycle counter requested";
}
return SCE_OK;
}
s32 scePerfArmPmonSoftwareIncrement(ARMv7Context& context, u32 mask)
{
scePerf.Warning("scePerfArmPmonSoftwareIncrement(mask=0x%x)", mask);
if (mask > SCE_PERF_ARM_PMON_COUNTER_MASK_ALL)
{
RETURN_ERROR(SCE_PERF_ERROR_INVALID_ARGUMENT);
}
for (u32 i = 0; i < 6; i++, mask >>= 1)
{
if (mask & 1)
{
context.counters[i].value++;
}
}
return SCE_OK;
}
u64 scePerfGetTimebaseValue()
{
scePerf.Warning("scePerfGetTimebaseValue()");
return get_system_time();
}
u32 scePerfGetTimebaseFrequency()
{
scePerf.Warning("scePerfGetTimebaseFrequency()");
return 1;
}
s32 _sceRazorCpuInit(vm::psv::ptr<const void> pBufferBase, u32 bufferSize, u32 numPerfCounters, vm::psv::ptr<vm::psv::ptr<u32>> psceRazorVars)
{
throw __FUNCTION__;
}
s32 sceRazorCpuPushMarker(vm::psv::ptr<const char> szLabel)
{
throw __FUNCTION__;
}
s32 sceRazorCpuPopMarker()
{
throw __FUNCTION__;
}
s32 sceRazorCpuSync()
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &scePerf, #name, name)
psv_log_base scePerf("ScePerf", []()
{
scePerf.on_load = nullptr;
scePerf.on_unload = nullptr;
scePerf.on_stop = nullptr;
REG_FUNC(0x35151735, scePerfArmPmonReset);
REG_FUNC(0x63CBEA8B, scePerfArmPmonSelectEvent);
REG_FUNC(0xC9D969D5, scePerfArmPmonStart);
REG_FUNC(0xD1A40F54, scePerfArmPmonStop);
REG_FUNC(0x6132A497, scePerfArmPmonGetCounterValue);
//REG_FUNC(0x12F6C708, scePerfArmPmonSetCounterValue);
REG_FUNC(0x4264B4E7, scePerfArmPmonSoftwareIncrement);
REG_FUNC(0xBD9615E5, scePerfGetTimebaseValue);
REG_FUNC(0x78EA4FFB, scePerfGetTimebaseFrequency);
REG_FUNC(0x7AD6AC30, _sceRazorCpuInit);
REG_FUNC(0xC3DE4C0A, sceRazorCpuPushMarker);
REG_FUNC(0xDC3224C3, sceRazorCpuPopMarker);
REG_FUNC(0x4F1385E3, sceRazorCpuSync);
});

38
rpcs3/Emu/ARMv7/Modules/scePgf.cpp Normal file
View File

@ -0,0 +1,38 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base scePgf;
#define REG_FUNC(nid, name) reg_psv_func(nid, &scePgf, #name, name)
psv_log_base scePgf("ScePgf", []()
{
scePgf.on_load = nullptr;
scePgf.on_unload = nullptr;
scePgf.on_stop = nullptr;
//REG_FUNC(0x1055ABA3, sceFontNewLib);
//REG_FUNC(0x07EE1733, sceFontDoneLib);
//REG_FUNC(0xDE47674C, sceFontSetResolution);
//REG_FUNC(0x9F842307, sceFontGetNumFontList);
//REG_FUNC(0xD56DCCEA, sceFontGetFontList);
//REG_FUNC(0x8DFBAE1B, sceFontFindOptimumFont);
//REG_FUNC(0x51061D87, sceFontFindFont);
//REG_FUNC(0xAB034738, sceFontGetFontInfoByIndexNumber);
//REG_FUNC(0xBD2DFCFF, sceFontOpen);
//REG_FUNC(0xE260E740, sceFontOpenUserFile);
//REG_FUNC(0xB23ED47C, sceFontOpenUserMemory);
//REG_FUNC(0x4A7293E9, sceFontClose);
//REG_FUNC(0xF9414FA2, sceFontGetFontInfo);
//REG_FUNC(0x6FD1BA65, sceFontGetCharInfo);
//REG_FUNC(0x70C86B3E, sceFontGetCharImageRect);
//REG_FUNC(0xAB45AAD3, sceFontGetCharGlyphImage);
//REG_FUNC(0xEB589530, sceFontGetCharGlyphImage_Clip);
//REG_FUNC(0x9E38F4D6, sceFontPixelToPointH);
//REG_FUNC(0x7B45E2D1, sceFontPixelToPointV);
//REG_FUNC(0x39B9AEFF, sceFontPointToPixelH);
//REG_FUNC(0x03F10EC8, sceFontPointToPixelV);
//REG_FUNC(0x8D5B44DF, sceFontSetAltCharacterCode);
//REG_FUNC(0x7D8CB13B, sceFontFlush);
});

53
rpcs3/Emu/ARMv7/Modules/scePhotoExport.cpp Normal file
View File

@ -0,0 +1,53 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base scePhotoExport;
struct ScePhotoExportParam
{
u32 version;
vm::psv::ptr<const char> photoTitle;
vm::psv::ptr<const char> gameTitle;
vm::psv::ptr<const char> gameComment;
char reserved[32];
};
typedef vm::psv::ptr<s32(vm::psv::ptr<void>)> ScePhotoExportCancelFunc;
s32 scePhotoExportFromData(
vm::psv::ptr<const void> photodata,
s32 photodataSize,
vm::psv::ptr<const ScePhotoExportParam> param,
vm::psv::ptr<void> workMemory,
ScePhotoExportCancelFunc cancelFunc,
vm::psv::ptr<void> userdata,
vm::psv::ptr<char> exportedPath,
s32 exportedPathLength)
{
throw __FUNCTION__;
}
s32 scePhotoExportFromFile(
vm::psv::ptr<const char> photodataPath,
vm::psv::ptr<const ScePhotoExportParam> param,
vm::psv::ptr<void> workMemory,
ScePhotoExportCancelFunc cancelFunc,
vm::psv::ptr<void> userdata,
vm::psv::ptr<char> exportedPath,
s32 exportedPathLength)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &scePhotoExport, #name, name)
psv_log_base scePhotoExport("ScePhotoExport", []()
{
scePhotoExport.on_load = nullptr;
scePhotoExport.on_unload = nullptr;
scePhotoExport.on_stop = nullptr;
REG_FUNC(0x70512321, scePhotoExportFromData);
REG_FUNC(0x84FD9FC5, scePhotoExportFromFile);
});

33
rpcs3/Emu/ARMv7/Modules/sceRazorCapture.cpp Normal file
View File

@ -0,0 +1,33 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceRazorCapture;
void sceRazorCaptureSetTrigger(u32 frameIndex, vm::psv::ptr<const char> captureFilename)
{
throw __FUNCTION__;
}
void sceRazorCaptureSetTriggerNextFrame(vm::psv::ptr<const char> captureFilename)
{
throw __FUNCTION__;
}
bool sceRazorCaptureIsInProgress()
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceRazorCapture, #name, name)
psv_log_base sceRazorCapture("SceRazorCapture", []()
{
sceRazorCapture.on_load = nullptr;
sceRazorCapture.on_unload = nullptr;
sceRazorCapture.on_stop = nullptr;
REG_FUNC(0x911E0AA0, sceRazorCaptureIsInProgress);
REG_FUNC(0xE916B538, sceRazorCaptureSetTrigger);
REG_FUNC(0x3D4B7E68, sceRazorCaptureSetTriggerNextFrame);
});

238
rpcs3/Emu/ARMv7/Modules/sceRtc.cpp Normal file
View File

@ -0,0 +1,238 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceRtc;
u32 sceRtcGetTickResolution()
{
throw __FUNCTION__;
}
s32 sceRtcGetCurrentTick(vm::psv::ptr<u64> pTick)
{
throw __FUNCTION__;
}
s32 sceRtcGetCurrentClock(vm::psv::ptr<SceDateTime> pTime, s32 iTimeZone)
{
throw __FUNCTION__;
}
s32 sceRtcGetCurrentClockLocalTime(vm::psv::ptr<SceDateTime> pTime)
{
throw __FUNCTION__;
}
s32 sceRtcGetCurrentNetworkTick(vm::psv::ptr<u64> pTick)
{
throw __FUNCTION__;
}
s32 sceRtcConvertUtcToLocalTime(vm::psv::ptr<const u64> pUtc, vm::psv::ptr<u64> pLocalTime)
{
throw __FUNCTION__;
}
s32 sceRtcConvertLocalTimeToUtc(vm::psv::ptr<const u64> pLocalTime, vm::psv::ptr<u64> pUtc)
{
throw __FUNCTION__;
}
s32 sceRtcIsLeapYear(s32 year)
{
throw __FUNCTION__;
}
s32 sceRtcGetDaysInMonth(s32 year, s32 month)
{
throw __FUNCTION__;
}
s32 sceRtcGetDayOfWeek(s32 year, s32 month, s32 day)
{
throw __FUNCTION__;
}
s32 sceRtcCheckValid(vm::psv::ptr<const SceDateTime> pTime)
{
throw __FUNCTION__;
}
s32 sceRtcSetTime_t(vm::psv::ptr<SceDateTime> pTime, u32 iTime)
{
throw __FUNCTION__;
}
s32 sceRtcSetTime64_t(vm::psv::ptr<SceDateTime> pTime, u64 ullTime)
{
throw __FUNCTION__;
}
s32 sceRtcGetTime_t(vm::psv::ptr<const SceDateTime> pTime, vm::psv::ptr<u32> piTime)
{
throw __FUNCTION__;
}
s32 sceRtcGetTime64_t(vm::psv::ptr<const SceDateTime> pTime, vm::psv::ptr<u64> pullTime)
{
throw __FUNCTION__;
}
s32 sceRtcSetDosTime(vm::psv::ptr<SceDateTime> pTime, u32 uiDosTime)
{
throw __FUNCTION__;
}
s32 sceRtcGetDosTime(vm::psv::ptr<const SceDateTime> pTime, vm::psv::ptr<u32> puiDosTime)
{
throw __FUNCTION__;
}
s32 sceRtcSetWin32FileTime(vm::psv::ptr<SceDateTime> pTime, u64 ulWin32Time)
{
throw __FUNCTION__;
}
s32 sceRtcGetWin32FileTime(vm::psv::ptr<const SceDateTime> pTime, vm::psv::ptr<u64> ulWin32Time)
{
throw __FUNCTION__;
}
s32 sceRtcSetTick(vm::psv::ptr<SceDateTime> pTime, vm::psv::ptr<const u64> pTick)
{
throw __FUNCTION__;
}
s32 sceRtcGetTick(vm::psv::ptr<const SceDateTime> pTime, vm::psv::ptr<u64> pTick)
{
throw __FUNCTION__;
}
s32 sceRtcCompareTick(vm::psv::ptr<const u64> pTick1, vm::psv::ptr<const u64> pTick2)
{
throw __FUNCTION__;
}
s32 sceRtcTickAddTicks(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, u64 lAdd)
{
throw __FUNCTION__;
}
s32 sceRtcTickAddMicroseconds(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, u64 lAdd)
{
throw __FUNCTION__;
}
s32 sceRtcTickAddSeconds(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, u64 lAdd)
{
throw __FUNCTION__;
}
s32 sceRtcTickAddMinutes(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, u64 lAdd)
{
throw __FUNCTION__;
}
s32 sceRtcTickAddHours(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, s32 lAdd)
{
throw __FUNCTION__;
}
s32 sceRtcTickAddDays(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, s32 lAdd)
{
throw __FUNCTION__;
}
s32 sceRtcTickAddWeeks(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, s32 lAdd)
{
throw __FUNCTION__;
}
s32 sceRtcTickAddMonths(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, s32 lAdd)
{
throw __FUNCTION__;
}
s32 sceRtcTickAddYears(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, s32 lAdd)
{
throw __FUNCTION__;
}
s32 sceRtcFormatRFC2822(vm::psv::ptr<char> pszDateTime, vm::psv::ptr<const u64> pUtc, s32 iTimeZoneMinutes)
{
throw __FUNCTION__;
}
s32 sceRtcFormatRFC2822LocalTime(vm::psv::ptr<char> pszDateTime, vm::psv::ptr<const u64> pUtc)
{
throw __FUNCTION__;
}
s32 sceRtcFormatRFC3339(vm::psv::ptr<char> pszDateTime, vm::psv::ptr<const u64> pUtc, s32 iTimeZoneMinutes)
{
throw __FUNCTION__;
}
s32 sceRtcFormatRFC3339LocalTime(vm::psv::ptr<char> pszDateTime, vm::psv::ptr<const u64> pUtc)
{
throw __FUNCTION__;
}
s32 sceRtcParseDateTime(vm::psv::ptr<u64> pUtc, vm::psv::ptr<const char> pszDateTime)
{
throw __FUNCTION__;
}
s32 sceRtcParseRFC3339(vm::psv::ptr<u64> pUtc, vm::psv::ptr<const char> pszDateTime)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceRtc, #name, name)
psv_log_base sceRtc("SceRtc", []()
{
sceRtc.on_load = nullptr;
sceRtc.on_unload = nullptr;
sceRtc.on_stop = nullptr;
REG_FUNC(0x23F79274, sceRtcGetCurrentTick);
REG_FUNC(0xCDDD25FE, sceRtcGetCurrentNetworkTick);
REG_FUNC(0x70FDE8F1, sceRtcGetCurrentClock);
REG_FUNC(0x0572EDDC, sceRtcGetCurrentClockLocalTime);
REG_FUNC(0x1282C436, sceRtcConvertUtcToLocalTime);
REG_FUNC(0x0A05E201, sceRtcConvertLocalTimeToUtc);
REG_FUNC(0x42CA8EB5, sceRtcFormatRFC2822LocalTime);
REG_FUNC(0x147F2138, sceRtcFormatRFC2822);
REG_FUNC(0x742250A9, sceRtcFormatRFC3339LocalTime);
REG_FUNC(0xCCEA2B54, sceRtcFormatRFC3339);
REG_FUNC(0xF17FD8B5, sceRtcIsLeapYear);
REG_FUNC(0x49EB4556, sceRtcGetDaysInMonth);
REG_FUNC(0x2F3531EB, sceRtcGetDayOfWeek);
REG_FUNC(0xD7622935, sceRtcCheckValid);
REG_FUNC(0x3A332F81, sceRtcSetTime_t);
REG_FUNC(0xA6C36B6A, sceRtcSetTime64_t);
REG_FUNC(0x8DE6FEB7, sceRtcGetTime_t);
REG_FUNC(0xC995DE02, sceRtcGetTime64_t);
REG_FUNC(0xF8B22B07, sceRtcSetDosTime);
REG_FUNC(0x92ABEBAF, sceRtcGetDosTime);
REG_FUNC(0xA79A8846, sceRtcSetWin32FileTime);
REG_FUNC(0x8A95E119, sceRtcGetWin32FileTime);
REG_FUNC(0x811313B3, sceRtcGetTickResolution);
REG_FUNC(0xCD89F464, sceRtcSetTick);
REG_FUNC(0xF2B238E2, sceRtcGetTick);
REG_FUNC(0xC7385158, sceRtcCompareTick);
REG_FUNC(0x4559E2DB, sceRtcTickAddTicks);
REG_FUNC(0xAE26D920, sceRtcTickAddMicroseconds);
REG_FUNC(0x979AFD79, sceRtcTickAddSeconds);
REG_FUNC(0x4C358871, sceRtcTickAddMinutes);
REG_FUNC(0x6F193F55, sceRtcTickAddHours);
REG_FUNC(0x58DE3C70, sceRtcTickAddDays);
REG_FUNC(0xE713C640, sceRtcTickAddWeeks);
REG_FUNC(0x6321B4AA, sceRtcTickAddMonths);
REG_FUNC(0xDF6C3E1B, sceRtcTickAddYears);
REG_FUNC(0x2347CE12, sceRtcParseDateTime);
REG_FUNC(0x2D18AEEC, sceRtcParseRFC3339);
});

210
rpcs3/Emu/ARMv7/Modules/sceSas.cpp Normal file
View File

@ -0,0 +1,210 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceSas;
s32 sceSasGetNeededMemorySize(vm::psv::ptr<const char> config, vm::psv::ptr<u32> outSize)
{
throw __FUNCTION__;
}
s32 sceSasInit(vm::psv::ptr<const char> config, vm::psv::ptr<void> buffer, u32 bufferSize)
{
throw __FUNCTION__;
}
s32 sceSasInitWithGrain(vm::psv::ptr<const char> config, u32 grain, vm::psv::ptr<void> buffer, u32 bufferSize)
{
throw __FUNCTION__;
}
s32 sceSasExit(vm::psv::ptr<vm::psv::ptr<void>> outBuffer, vm::psv::ptr<u32> outBufferSize)
{
throw __FUNCTION__;
}
s32 sceSasSetGrain(u32 grain)
{
throw __FUNCTION__;
}
s32 sceSasGetGrain()
{
throw __FUNCTION__;
}
s32 sceSasSetOutputmode(u32 outputmode)
{
throw __FUNCTION__;
}
s32 sceSasGetOutputmode()
{
throw __FUNCTION__;
}
s32 sceSasCore(vm::psv::ptr<s16> out)
{
throw __FUNCTION__;
}
s32 sceSasCoreWithMix(vm::psv::ptr<s16> inOut, s32 lvol, s32 rvol)
{
throw __FUNCTION__;
}
s32 sceSasSetVoice(s32 iVoiceNum, vm::psv::ptr<const void> vagBuf, u32 size, u32 loopflag)
{
throw __FUNCTION__;
}
s32 sceSasSetVoicePCM(s32 iVoiceNum, vm::psv::ptr<const void> pcmBuf, u32 size, s32 loopsize)
{
throw __FUNCTION__;
}
s32 sceSasSetNoise(s32 iVoiceNum, u32 uClk)
{
throw __FUNCTION__;
}
s32 sceSasSetVolume(s32 iVoiceNum, s32 l, s32 r, s32 wl, s32 wr)
{
throw __FUNCTION__;
}
s32 sceSasSetPitch(s32 iVoiceNum, s32 pitch)
{
throw __FUNCTION__;
}
s32 sceSasSetADSR(s32 iVoiceNum, u32 flag, u32 ar, u32 dr, u32 sr, u32 rr)
{
throw __FUNCTION__;
}
s32 sceSasSetADSRmode(s32 iVoiceNum, u32 flag, u32 am, u32 dm, u32 sm, u32 rm)
{
throw __FUNCTION__;
}
s32 sceSasSetSL(s32 iVoiceNum, u32 sl)
{
throw __FUNCTION__;
}
s32 sceSasSetSimpleADSR(s32 iVoiceNum, u16 adsr1, u16 adsr2)
{
throw __FUNCTION__;
}
s32 sceSasSetKeyOn(s32 iVoiceNum)
{
throw __FUNCTION__;
}
s32 sceSasSetKeyOff(s32 iVoiceNum)
{
throw __FUNCTION__;
}
s32 sceSasSetPause(s32 iVoiceNum, u32 pauseFlag)
{
throw __FUNCTION__;
}
s32 sceSasGetPauseState(s32 iVoiceNum)
{
throw __FUNCTION__;
}
s32 sceSasGetEndState(s32 iVoiceNum)
{
throw __FUNCTION__;
}
s32 sceSasGetEnvelope(s32 iVoiceNum)
{
throw __FUNCTION__;
}
s32 sceSasSetEffect(s32 drySwitch, s32 wetSwitch)
{
throw __FUNCTION__;
}
s32 sceSasSetEffectType(s32 type)
{
throw __FUNCTION__;
}
s32 sceSasSetEffectVolume(s32 valL, s32 valR)
{
throw __FUNCTION__;
}
s32 sceSasSetEffectParam(u32 delayTime, u32 feedback)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceSas, #name, name)
psv_log_base sceSas("SceSas", []()
{
sceSas.on_load = nullptr;
sceSas.on_unload = nullptr;
sceSas.on_stop = nullptr;
//REG_FUNC(0xA2209C58, sceAsSetRegisterReportHandler);
//REG_FUNC(0xBB635544, sceAsSetUnregisterReportHandler);
//REG_FUNC(0xF578F0EF, sceAsGetSystemNeededMemory);
//REG_FUNC(0xAA8D4541, sceAsCreateSystem);
//REG_FUNC(0x139D29C0, sceAsDestroySystem);
//REG_FUNC(0xBE843EEC, sceAsLockParam);
//REG_FUNC(0xFF2380C4, sceAsUnlockParam);
//REG_FUNC(0x2549F436, sceAsSetEvent);
//REG_FUNC(0xDC26B9F2, sceAsGetState);
//REG_FUNC(0xB6220E73, sceAsSetBuss);
//REG_FUNC(0x1E608068, sceAsSetRacks);
//REG_FUNC(0x5835B473, sceAsSetGranularity);
//REG_FUNC(0xDFE6502F, sceAsGetGranularity);
//REG_FUNC(0xC72F1EEF, sceAsRender);
//REG_FUNC(0xCE23F057, sceAsLockUpdate);
//REG_FUNC(0x8BEF3C92, sceAsUnlockUpdate);
REG_FUNC(0x180C6824, sceSasGetNeededMemorySize);
REG_FUNC(0x449B5974, sceSasInit);
REG_FUNC(0x820D5F82, sceSasInitWithGrain);
REG_FUNC(0xBB7D6790, sceSasExit);
REG_FUNC(0x2B4A207C, sceSasSetGrain);
REG_FUNC(0x2BEA45BC, sceSasGetGrain);
REG_FUNC(0x44DDB3C4, sceSasSetOutputmode);
REG_FUNC(0x2C36E150, sceSasGetOutputmode);
REG_FUNC(0x7A4672B2, sceSasCore);
REG_FUNC(0xBD496983, sceSasCoreWithMix);
REG_FUNC(0x2B75F9BC, sceSasSetVoice);
REG_FUNC(0xB1756EFC, sceSasSetVoicePCM);
REG_FUNC(0xF1C63CB9, sceSasSetNoise);
REG_FUNC(0x0BE8204D, sceSasSetVolume);
//REG_FUNC(0x011788BE, sceSasSetDistortion);
REG_FUNC(0x2C48A08C, sceSasSetPitch);
REG_FUNC(0x18A5EFA2, sceSasSetADSR);
REG_FUNC(0x5207F9D2, sceSasSetADSRmode);
REG_FUNC(0xDE6227B8, sceSasSetSL);
REG_FUNC(0xECCE0DB8, sceSasSetSimpleADSR);
REG_FUNC(0xC838DB6F, sceSasSetKeyOn);
REG_FUNC(0x5E42ADAB, sceSasSetKeyOff);
REG_FUNC(0x59C7A9DF, sceSasSetPause);
REG_FUNC(0x007E63E6, sceSasGetEndState);
REG_FUNC(0xFD1A0CBF, sceSasGetPauseState);
REG_FUNC(0x296A9910, sceSasGetEnvelope);
REG_FUNC(0xB0444E69, sceSasSetEffect);
REG_FUNC(0xCDF2DDD5, sceSasSetEffectType);
REG_FUNC(0x55EDDBFA, sceSasSetEffectVolume);
REG_FUNC(0xBAD546A0, sceSasSetEffectParam);
//REG_FUNC(0xB6642276, sceSasGetDryPeak);
//REG_FUNC(0x4314F0E9, sceSasGetWetPeak);
//REG_FUNC(0x1568017A, sceSasGetPreMasterPeak);
});

48
rpcs3/Emu/ARMv7/Modules/sceScreenShot.cpp Normal file
View File

@ -0,0 +1,48 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceScreenShot;
struct SceScreenShotParam
{
vm::psv::ptr<const char> photoTitle;
vm::psv::ptr<const char> gameTitle;
vm::psv::ptr<const char> gameComment;
vm::psv::ptr<void> reserved;
};
s32 sceScreenShotSetParam(vm::psv::ptr<const SceScreenShotParam> param)
{
throw __FUNCTION__;
}
s32 sceScreenShotSetOverlayImage(vm::psv::ptr<const char> filePath, s32 offsetX, s32 offsetY)
{
throw __FUNCTION__;
}
s32 sceScreenShotDisable()
{
throw __FUNCTION__;
}
s32 sceScreenShotEnable()
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceScreenShot, #name, name)
psv_log_base sceScreenShot("SceScreenShot", []()
{
sceScreenShot.on_load = nullptr;
sceScreenShot.on_unload = nullptr;
sceScreenShot.on_stop = nullptr;
REG_FUNC(0x05DB59C7, sceScreenShotSetParam);
REG_FUNC(0x7061665B, sceScreenShotSetOverlayImage);
REG_FUNC(0x50AE9FF9, sceScreenShotDisable);
REG_FUNC(0x76E674D1, sceScreenShotEnable);
});

84
rpcs3/Emu/ARMv7/Modules/sceSfmt.cpp Normal file
View File

@ -0,0 +1,84 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceSfmt;
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceSfmt, #name, name)
psv_log_base sceSfmt("SceSfmt", []()
{
sceSfmt.on_load = nullptr;
sceSfmt.on_unload = nullptr;
sceSfmt.on_stop = nullptr;
//REG_FUNC(0x8FF464C9, sceSfmt11213InitGenRand);
//REG_FUNC(0xBAF5F058, sceSfmt11213InitByArray);
//REG_FUNC(0xFB281CD7, sceSfmt11213GenRand32);
//REG_FUNC(0xAFEDD6E1, sceSfmt11213GenRand64);
//REG_FUNC(0xFD696585, sceSfmt11213FillArray32);
//REG_FUNC(0x7A412A29, sceSfmt11213FillArray64);
//REG_FUNC(0x02E8D906, sceSfmt1279InitGenRand);
//REG_FUNC(0xC25D9ACE, sceSfmt1279InitByArray);
//REG_FUNC(0x9B4A48DF, sceSfmt1279GenRand32);
//REG_FUNC(0xA2C5EE14, sceSfmt1279GenRand64);
//REG_FUNC(0xE7F63838, sceSfmt1279FillArray32);
//REG_FUNC(0xDB3832EB, sceSfmt1279FillArray64);
//REG_FUNC(0xDC6B23B0, sceSfmt132049InitGenRand);
//REG_FUNC(0xDC69294A, sceSfmt132049InitByArray);
//REG_FUNC(0x795F9644, sceSfmt132049GenRand32);
//REG_FUNC(0xBBD80AC4, sceSfmt132049GenRand64);
//REG_FUNC(0xD891A99F, sceSfmt132049FillArray32);
//REG_FUNC(0x68AD7866, sceSfmt132049FillArray64);
//REG_FUNC(0x2AFACB0B, sceSfmt19937InitGenRand);
//REG_FUNC(0xAC496C8C, sceSfmt19937InitByArray);
//REG_FUNC(0xF0557157, sceSfmt19937GenRand32);
//REG_FUNC(0xE66F2502, sceSfmt19937GenRand64);
//REG_FUNC(0xA1C654D8, sceSfmt19937FillArray32);
//REG_FUNC(0xE74BA81C, sceSfmt19937FillArray64);
//REG_FUNC(0x86DDE4A7, sceSfmt216091InitGenRand);
//REG_FUNC(0xA9CF6616, sceSfmt216091InitByArray);
//REG_FUNC(0x4A972DCD, sceSfmt216091GenRand32);
//REG_FUNC(0x23369ABF, sceSfmt216091GenRand64);
//REG_FUNC(0xDD4256F0, sceSfmt216091FillArray32);
//REG_FUNC(0xA1CE5628, sceSfmt216091FillArray64);
//REG_FUNC(0xB8E5A0BB, sceSfmt2281InitGenRand);
//REG_FUNC(0xAB3AD459, sceSfmt2281InitByArray);
//REG_FUNC(0x84BB4ADB, sceSfmt2281GenRand32);
//REG_FUNC(0x3CC47146, sceSfmt2281GenRand64);
//REG_FUNC(0xBB89D8F0, sceSfmt2281FillArray32);
//REG_FUNC(0x17C10E2D, sceSfmt2281FillArray64);
//REG_FUNC(0xE9F8CB9A, sceSfmt4253InitGenRand);
//REG_FUNC(0xC4D7AA2D, sceSfmt4253InitByArray);
//REG_FUNC(0x8791E2EF, sceSfmt4253GenRand32);
//REG_FUNC(0x6C0E5E3C, sceSfmt4253GenRand64);
//REG_FUNC(0x59A1B9FC, sceSfmt4253FillArray32);
//REG_FUNC(0x01683CDD, sceSfmt4253FillArray64);
//REG_FUNC(0xCF1C8C38, sceSfmt44497InitGenRand);
//REG_FUNC(0x16D8AA5E, sceSfmt44497InitByArray);
//REG_FUNC(0xF869DFDC, sceSfmt44497GenRand32);
//REG_FUNC(0xD411A9A6, sceSfmt44497GenRand64);
//REG_FUNC(0x1C38322A, sceSfmt44497FillArray32);
//REG_FUNC(0x908F1122, sceSfmt44497FillArray64);
//REG_FUNC(0x76A5D8CA, sceSfmt607InitGenRand);
//REG_FUNC(0xCC6DABA0, sceSfmt607InitByArray);
//REG_FUNC(0x8A0BF859, sceSfmt607GenRand32);
//REG_FUNC(0x5E880862, sceSfmt607GenRand64);
//REG_FUNC(0xA288ADB9, sceSfmt607FillArray32);
//REG_FUNC(0x1520D408, sceSfmt607FillArray64);
//REG_FUNC(0x2FF42588, sceSfmt86243InitGenRand);
//REG_FUNC(0x81B67AB5, sceSfmt86243InitByArray);
//REG_FUNC(0x569BF903, sceSfmt86243GenRand32);
//REG_FUNC(0x8E25CBA8, sceSfmt86243GenRand64);
//REG_FUNC(0xC297E6B1, sceSfmt86243FillArray32);
//REG_FUNC(0xF7FFE87C, sceSfmt86243FillArray64);
});

44
rpcs3/Emu/ARMv7/Modules/sceSha.cpp Normal file
View File

@ -0,0 +1,44 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceSha;
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceSha, #name, name)
psv_log_base sceSha("SceSha", []()
{
sceSha.on_load = nullptr;
sceSha.on_unload = nullptr;
sceSha.on_stop = nullptr;
//REG_FUNC(0xD19A9AA8, sceSha0Digest);
//REG_FUNC(0xBCF6DB3A, sceSha0BlockInit);
//REG_FUNC(0x37EF2AFC, sceSha0BlockUpdate);
//REG_FUNC(0xBF0158C4, sceSha0BlockResult);
//REG_FUNC(0xE1215C9D, sceSha1Digest);
//REG_FUNC(0xB13D65AA, sceSha1BlockInit);
//REG_FUNC(0x9007205E, sceSha1BlockUpdate);
//REG_FUNC(0x0195DADF, sceSha1BlockResult);
//REG_FUNC(0x1346D270, sceSha224Digest);
//REG_FUNC(0x538F04CE, sceSha224BlockInit);
//REG_FUNC(0xB5FD0160, sceSha224BlockUpdate);
//REG_FUNC(0xA36ECF65, sceSha224BlockResult);
//REG_FUNC(0xA337079C, sceSha256Digest);
//REG_FUNC(0xE281374F, sceSha256BlockInit);
//REG_FUNC(0xDAECA1F8, sceSha256BlockUpdate);
//REG_FUNC(0x9B5BB4BA, sceSha256BlockResult);
//REG_FUNC(0xA602C694, sceSha384Digest);
//REG_FUNC(0x037AABE7, sceSha384BlockInit);
//REG_FUNC(0x4B99DBB8, sceSha384BlockUpdate);
//REG_FUNC(0x30D5C919, sceSha384BlockResult);
//REG_FUNC(0x5DC0B916, sceSha512Digest);
//REG_FUNC(0xE017A9CD, sceSha512BlockInit);
//REG_FUNC(0x669281E8, sceSha512BlockUpdate);
//REG_FUNC(0x26146A16, sceSha512BlockResult);
});

187
rpcs3/Emu/ARMv7/Modules/sceSqlite.cpp Normal file
View File

@ -0,0 +1,187 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceSqlite;
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceSqlite, #name, name)
psv_log_base sceSqlite("SceSqlite", []()
{
sceSqlite.on_load = nullptr;
sceSqlite.on_unload = nullptr;
sceSqlite.on_stop = nullptr;
//REG_FUNC(0x26E46324, sqlite3_libversion);
//REG_FUNC(0x4CCB58A2, sqlite3_sourceid);
//REG_FUNC(0x5982F404, sqlite3_libversion_number);
//REG_FUNC(0xA3B818DA, sqlite3_threadsafe);
//REG_FUNC(0x7DF94B79, sqlite3_close);
//REG_FUNC(0x2371E86A, sqlite3_exec);
//REG_FUNC(0xC22AF627, sqlite3_initialize);
//REG_FUNC(0x99B5A4A3, sqlite3_shutdown);
//REG_FUNC(0xBD304836, sqlite3_os_init);
//REG_FUNC(0x9CE7C4C3, sqlite3_os_end);
//REG_FUNC(0x96C5D388, sqlite3_config);
//REG_FUNC(0xADFB25C0, sqlite3_db_config);
//REG_FUNC(0x3892C4B8, sqlite3_extended_result_codes);
//REG_FUNC(0x301851A1, sqlite3_last_insert_rowid);
//REG_FUNC(0xF206FBA1, sqlite3_changes);
//REG_FUNC(0x02ADA92D, sqlite3_total_changes);
//REG_FUNC(0x3CB771AC, sqlite3_interrupt);
//REG_FUNC(0x2E28B2A7, sqlite3_complete);
//REG_FUNC(0x4EAB317B, sqlite3_complete16);
//REG_FUNC(0xB5B5D287, sqlite3_busy_handler);
//REG_FUNC(0xAE8E3630, sqlite3_busy_timeout);
//REG_FUNC(0xF2AB9C89, sqlite3_get_table);
//REG_FUNC(0x1FEC6959, sqlite3_free_table);
//REG_FUNC(0xE630216C, sqlite3_mprintf);
//REG_FUNC(0xC6372184, sqlite3_vmprintf);
//REG_FUNC(0xCC189941, sqlite3_snprintf);
//REG_FUNC(0xF01DEB95, sqlite3_malloc);
//REG_FUNC(0xD1CF5631, sqlite3_realloc);
//REG_FUNC(0xCBF0CA8A, sqlite3_free);
//REG_FUNC(0x8E4F6ED5, sqlite3_memory_used);
//REG_FUNC(0x2F33DAD6, sqlite3_memory_highwater);
//REG_FUNC(0x5A2590BF, sqlite3_randomness);
//REG_FUNC(0x77FB3458, sqlite3_set_authorizer);
//REG_FUNC(0xFC127A83, sqlite3_trace);
//REG_FUNC(0x48B789A1, sqlite3_profile);
//REG_FUNC(0x19165D04, sqlite3_progress_handler);
//REG_FUNC(0x8E506859, sqlite3_open);
//REG_FUNC(0x881EEDD8, sqlite3_open16);
//REG_FUNC(0xA1E98A41, sqlite3_open_v2);
//REG_FUNC(0xA7AAE2E7, sqlite3_errcode);
//REG_FUNC(0x91187282, sqlite3_extended_errcode);
//REG_FUNC(0xABFB8B6E, sqlite3_errmsg);
//REG_FUNC(0xF0DE1A97, sqlite3_errmsg16);
//REG_FUNC(0xDED2D517, sqlite3_limit);
//REG_FUNC(0x0C1B5509, sqlite3_prepare);
//REG_FUNC(0xBC4BDCF4, sqlite3_prepare_v2);
//REG_FUNC(0xC657CFB8, sqlite3_prepare16);
//REG_FUNC(0x426D81D2, sqlite3_prepare16_v2);
//REG_FUNC(0x082C36D4, sqlite3_sql);
//REG_FUNC(0x3F225D62, sqlite3_bind_blob);
//REG_FUNC(0xDE007F1B, sqlite3_bind_double);
//REG_FUNC(0x14ABCBCC, sqlite3_bind_int);
//REG_FUNC(0x43D967EF, sqlite3_bind_int64);
//REG_FUNC(0xFF8A9974, sqlite3_bind_null);
//REG_FUNC(0x613AB709, sqlite3_bind_text);
//REG_FUNC(0x9D0FEAEF, sqlite3_bind_text16);
//REG_FUNC(0x8A667D2A, sqlite3_bind_value);
//REG_FUNC(0x78FBA2D0, sqlite3_bind_zeroblob);
//REG_FUNC(0x17D4F00B, sqlite3_bind_parameter_count);
//REG_FUNC(0x96D3B5F9, sqlite3_bind_parameter_name);
//REG_FUNC(0xD4D2A5D8, sqlite3_bind_parameter_index);
//REG_FUNC(0x690947E2, sqlite3_clear_bindings);
//REG_FUNC(0x8567A8DE, sqlite3_column_count);
//REG_FUNC(0xBC422DF6, sqlite3_column_name);
//REG_FUNC(0x6EF9A642, sqlite3_column_name16);
//REG_FUNC(0x5AE92D67, sqlite3_column_decltype);
//REG_FUNC(0xE058DE60, sqlite3_column_decltype16);
//REG_FUNC(0xCA8755B7, sqlite3_step);
//REG_FUNC(0x61911935, sqlite3_data_count);
//REG_FUNC(0xFE237ED7, sqlite3_column_blob);
//REG_FUNC(0x36013FE4, sqlite3_column_bytes);
//REG_FUNC(0x439F160B, sqlite3_column_bytes16);
//REG_FUNC(0xC4866097, sqlite3_column_double);
//REG_FUNC(0xE5B6BA01, sqlite3_column_int);
//REG_FUNC(0x90BA0B88, sqlite3_column_int64);
//REG_FUNC(0x8E68D270, sqlite3_column_text);
//REG_FUNC(0xD7BD6B76, sqlite3_column_text16);
//REG_FUNC(0xDBB25C43, sqlite3_column_type);
//REG_FUNC(0x2227F21D, sqlite3_column_value);
//REG_FUNC(0xB656B7E2, sqlite3_finalize);
//REG_FUNC(0xA6ECC214, sqlite3_reset);
//REG_FUNC(0xB0543897, sqlite3_create_function);
//REG_FUNC(0x7655FA45, sqlite3_create_function16);
//REG_FUNC(0x6AB02532, sqlite3_aggregate_count);
//REG_FUNC(0xF8AA518B, sqlite3_expired);
//REG_FUNC(0x6EC012E5, sqlite3_transfer_bindings);
//REG_FUNC(0xF48E021B, sqlite3_global_recover);
//REG_FUNC(0x173C9C0B, sqlite3_thread_cleanup);
//REG_FUNC(0x56EDF517, sqlite3_memory_alarm);
//REG_FUNC(0xC9962B31, sqlite3_value_blob);
//REG_FUNC(0x5368EF1F, sqlite3_value_bytes);
//REG_FUNC(0x4D10900D, sqlite3_value_bytes16);
//REG_FUNC(0xF1F2C9BE, sqlite3_value_double);
//REG_FUNC(0x4809A520, sqlite3_value_int);
//REG_FUNC(0xA6581C04, sqlite3_value_int64);
//REG_FUNC(0x7EB97356, sqlite3_value_text);
//REG_FUNC(0x5BBE38C2, sqlite3_value_text16);
//REG_FUNC(0x014863A6, sqlite3_value_text16le);
//REG_FUNC(0x3B89AA8D, sqlite3_value_text16be);
//REG_FUNC(0xC5EEBB5D, sqlite3_value_type);
//REG_FUNC(0x81B7D43D, sqlite3_value_numeric_type);
//REG_FUNC(0xAA8BE477, sqlite3_aggregate_context);
//REG_FUNC(0x78FF81FB, sqlite3_user_data);
//REG_FUNC(0x74259C09, sqlite3_context_db_handle);
//REG_FUNC(0x394FC1CB, sqlite3_get_auxdata);
//REG_FUNC(0x129E01C9, sqlite3_set_auxdata);
//REG_FUNC(0x90CDF8C1, sqlite3_result_blob);
//REG_FUNC(0xC2A5C2F8, sqlite3_result_double);
//REG_FUNC(0x063BFACA, sqlite3_result_error);
//REG_FUNC(0xAB2AEB4A, sqlite3_result_error16);
//REG_FUNC(0xAB9EFF96, sqlite3_result_error_toobig);
//REG_FUNC(0x944E747A, sqlite3_result_error_nomem);
//REG_FUNC(0x1165223C, sqlite3_result_error_code);
//REG_FUNC(0x5C9CD9D4, sqlite3_result_int);
//REG_FUNC(0x0EF1AA07, sqlite3_result_int64);
//REG_FUNC(0x6DE09482, sqlite3_result_null);
//REG_FUNC(0x696B5E6A, sqlite3_result_text);
//REG_FUNC(0x3AF5D206, sqlite3_result_text16);
//REG_FUNC(0x845B4FC2, sqlite3_result_text16le);
//REG_FUNC(0xEE3E906A, sqlite3_result_text16be);
//REG_FUNC(0x09664492, sqlite3_result_value);
//REG_FUNC(0x3D463CF7, sqlite3_result_zeroblob);
//REG_FUNC(0xC61B63FB, sqlite3_create_collation);
//REG_FUNC(0x4B110AF2, sqlite3_create_collation_v2);
//REG_FUNC(0xF7FE99C8, sqlite3_create_collation16);
//REG_FUNC(0x836C99A3, sqlite3_collation_needed);
//REG_FUNC(0x537066CE, sqlite3_collation_needed16);
//REG_FUNC(0x6B88D1D4, sqlite3_sleep);
//REG_FUNC(0x0910C3CB, sqlite3_get_autocommit);
//REG_FUNC(0x2C62429E, sqlite3_db_handle);
//REG_FUNC(0xD257592A, sqlite3_next_stmt);
//REG_FUNC(0x4BAE6E3B, sqlite3_commit_hook);
//REG_FUNC(0x67F53D6B, sqlite3_rollback_hook);
//REG_FUNC(0xEB05FE87, sqlite3_update_hook);
//REG_FUNC(0xF0094BED, sqlite3_enable_shared_cache);
//REG_FUNC(0x8F99FBE5, sqlite3_release_memory);
//REG_FUNC(0xD1458BA7, sqlite3_soft_heap_limit);
//REG_FUNC(0xC9EA8E1F, sqlite3_load_extension);
//REG_FUNC(0x9BFC6F07, sqlite3_enable_load_extension);
//REG_FUNC(0x24738263, sqlite3_auto_extension);
//REG_FUNC(0xC4296FFD, sqlite3_reset_auto_extension);
//REG_FUNC(0x8970C45F, sqlite3_create_module);
//REG_FUNC(0x1AA3BC1A, sqlite3_create_module_v2);
//REG_FUNC(0x7E2A5E8F, sqlite3_declare_vtab);
//REG_FUNC(0xAF680D40, sqlite3_overload_function);
//REG_FUNC(0xD35B3E55, sqlite3_blob_open);
//REG_FUNC(0xC085A15D, sqlite3_blob_close);
//REG_FUNC(0xA07AEEE3, sqlite3_blob_bytes);
//REG_FUNC(0x71393AA4, sqlite3_blob_read);
//REG_FUNC(0xBDB46BCF, sqlite3_blob_write);
//REG_FUNC(0x0C6DD8C3, sqlite3_vfs_find);
//REG_FUNC(0x65F53B9C, sqlite3_vfs_register);
//REG_FUNC(0x69CF4171, sqlite3_vfs_unregister);
//REG_FUNC(0xEEB7839F, sqlite3_mutex_alloc);
//REG_FUNC(0x38E933E2, sqlite3_mutex_free);
//REG_FUNC(0x60DB89C0, sqlite3_mutex_enter);
//REG_FUNC(0x218D700E, sqlite3_mutex_try);
//REG_FUNC(0x545ABDDB, sqlite3_mutex_leave);
//REG_FUNC(0xA8E53D26, sqlite3_db_mutex);
//REG_FUNC(0xBB096FBD, sqlite3_file_control);
//REG_FUNC(0x324D4EFD, sqlite3_test_control);
//REG_FUNC(0xD8C435AA, sqlite3_status);
//REG_FUNC(0xB5DFAF6A, sqlite3_db_status);
//REG_FUNC(0xF7ABF5FA, sqlite3_stmt_status);
//REG_FUNC(0x91DDB12A, sqlite3_backup_init);
//REG_FUNC(0x2A15E081, sqlite3_backup_step);
//REG_FUNC(0x93A6B7EF, sqlite3_backup_finish);
//REG_FUNC(0x9962540B, sqlite3_backup_remaining);
//REG_FUNC(0x20D054CF, sqlite3_backup_pagecount);
//REG_FUNC(0x12E2FC18, sqlite3_strnicmp);
//REG_FUNC(0xB80D43C7, sqlite3_version);
//REG_FUNC(0x1AEC1F74, sqlite3_temp_directory);
});

82
rpcs3/Emu/ARMv7/Modules/sceSsl.cpp Normal file
View File

@ -0,0 +1,82 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceSsl.h"
s32 sceSslInit(u32 poolSize)
{
throw __FUNCTION__;
}
s32 sceSslTerm()
{
throw __FUNCTION__;
}
s32 sceSslGetMemoryPoolStats(vm::psv::ptr<SceSslMemoryPoolStats> currentStat)
{
throw __FUNCTION__;
}
s32 sceSslGetSerialNumber(vm::psv::ptr<SceSslCert> sslCert, vm::psv::ptr<vm::psv::ptr<const u8>> sboData, vm::psv::ptr<u32> sboLen)
{
throw __FUNCTION__;
}
vm::psv::ptr<SceSslCertName> sceSslGetSubjectName(vm::psv::ptr<SceSslCert> sslCert)
{
throw __FUNCTION__;
}
vm::psv::ptr<SceSslCertName> sceSslGetIssuerName(vm::psv::ptr<SceSslCert> sslCert)
{
throw __FUNCTION__;
}
s32 sceSslGetNotBefore(vm::psv::ptr<SceSslCert> sslCert, vm::psv::ptr<u64> begin)
{
throw __FUNCTION__;
}
s32 sceSslGetNotAfter(vm::psv::ptr<SceSslCert> sslCert, vm::psv::ptr<u64> limit)
{
throw __FUNCTION__;
}
s32 sceSslGetNameEntryCount(vm::psv::ptr<SceSslCertName> certName)
{
throw __FUNCTION__;
}
s32 sceSslGetNameEntryInfo(vm::psv::ptr<SceSslCertName> certName, s32 entryNum, vm::psv::ptr<char> oidname, u32 maxOidnameLen, vm::psv::ptr<u8> value, u32 maxValueLen, vm::psv::ptr<u32> valueLen)
{
throw __FUNCTION__;
}
s32 sceSslFreeSslCertName(vm::psv::ptr<SceSslCertName> certName)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceSsl, #name, name)
psv_log_base sceSsl("SceSsl", []()
{
sceSsl.on_load = nullptr;
sceSsl.on_unload = nullptr;
sceSsl.on_stop = nullptr;
REG_FUNC(0x3C733316, sceSslInit);
REG_FUNC(0x03CE6E3A, sceSslTerm);
REG_FUNC(0xBD203262, sceSslGetMemoryPoolStats);
REG_FUNC(0x901C5C15, sceSslGetSerialNumber);
REG_FUNC(0x9B2F1BC1, sceSslGetSubjectName);
REG_FUNC(0x412711E5, sceSslGetIssuerName);
REG_FUNC(0x70DEA174, sceSslGetNotBefore);
REG_FUNC(0xF5ED7B68, sceSslGetNotAfter);
REG_FUNC(0x95E14CA6, sceSslGetNameEntryCount);
REG_FUNC(0x2A857867, sceSslGetNameEntryInfo);
REG_FUNC(0xC73687E4, sceSslFreeSslCertName);
});

14
rpcs3/Emu/ARMv7/Modules/sceSsl.h Normal file
View File

@ -0,0 +1,14 @@
#pragma once
typedef void SceSslCert;
typedef void SceSslCertName;
struct SceSslMemoryPoolStats
{
u32 poolSize;
u32 maxInuseSize;
u32 currentInuseSize;
s32 reserved;
};
extern psv_log_base sceSsl;

116
rpcs3/Emu/ARMv7/Modules/sceSulpha.cpp Normal file
View File

@ -0,0 +1,116 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceSulpha;
typedef vm::psv::ptr<void(vm::psv::ptr<void> arg)> SceSulphaCallback;
struct SceSulphaConfig
{
SceSulphaCallback notifyCallback;
u32 port;
u32 bookmarkCount;
};
struct SceSulphaAgentsRegister;
typedef void SceSulphaHandle;
s32 sceSulphaNetworkInit()
{
throw __FUNCTION__;
}
s32 sceSulphaNetworkShutdown()
{
throw __FUNCTION__;
}
s32 sceSulphaGetDefaultConfig(vm::psv::ptr<SceSulphaConfig> config)
{
throw __FUNCTION__;
}
s32 sceSulphaGetNeededMemory(vm::psv::ptr<const SceSulphaConfig> config, vm::psv::ptr<u32> sizeInBytes)
{
throw __FUNCTION__;
}
s32 sceSulphaInit(vm::psv::ptr<const SceSulphaConfig> config, vm::psv::ptr<void> buffer, u32 sizeInBytes)
{
throw __FUNCTION__;
}
s32 sceSulphaShutdown()
{
throw __FUNCTION__;
}
s32 sceSulphaUpdate()
{
throw __FUNCTION__;
}
s32 sceSulphaFileConnect(vm::psv::ptr<const char> filename)
{
throw __FUNCTION__;
}
s32 sceSulphaFileDisconnect()
{
throw __FUNCTION__;
}
s32 sceSulphaSetBookmark(vm::psv::ptr<const char> name, s32 id)
{
throw __FUNCTION__;
}
s32 sceSulphaAgentsGetNeededMemory(vm::psv::ptr<const SceSulphaAgentsRegister> config, vm::psv::ptr<u32> sizeInBytes)
{
throw __FUNCTION__;
}
s32 sceSulphaAgentsRegister(vm::psv::ptr<const SceSulphaAgentsRegister> config, vm::psv::ptr<void> buffer, u32 sizeInBytes, vm::psv::ptr<SceSulphaHandle> handles)
{
throw __FUNCTION__;
}
s32 sceSulphaAgentsUnregister(vm::psv::ptr<const SceSulphaHandle> handles, u32 agentCount)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceSulpha, #name, name)
psv_log_base sceSulpha("SceSulpha", []()
{
sceSulpha.on_load = nullptr;
sceSulpha.on_unload = nullptr;
sceSulpha.on_stop = nullptr;
REG_FUNC(0xB4668AEA, sceSulphaNetworkInit);
REG_FUNC(0x0FC71B72, sceSulphaNetworkShutdown);
REG_FUNC(0xA6A05C50, sceSulphaGetDefaultConfig);
REG_FUNC(0xD52E5A5A, sceSulphaGetNeededMemory);
REG_FUNC(0x324F158F, sceSulphaInit);
REG_FUNC(0x10770BA7, sceSulphaShutdown);
REG_FUNC(0x920EC7BF, sceSulphaUpdate);
REG_FUNC(0x7968A138, sceSulphaFileConnect);
REG_FUNC(0xB16E7B88, sceSulphaFileDisconnect);
REG_FUNC(0x5E15E164, sceSulphaSetBookmark);
REG_FUNC(0xC5752B6B, sceSulphaAgentsGetNeededMemory);
REG_FUNC(0x7ADB454D, sceSulphaAgentsRegister);
REG_FUNC(0x2A8B74D7, sceSulphaAgentsUnregister);
//REG_FUNC(0xDE7E2911, sceSulphaGetAgent);
//REG_FUNC(0xA41B7402, sceSulphaNodeNew);
//REG_FUNC(0xD44C9F86, sceSulphaNodeDelete);
//REG_FUNC(0xBF61F3B8, sceSulphaEventNew);
//REG_FUNC(0xD5D995A9, sceSulphaEventDelete);
//REG_FUNC(0xB0C2B9CE, sceSulphaEventAdd);
//REG_FUNC(0xBC6A2833, sceSulphaEventReport);
//REG_FUNC(0x29F0DA12, sceSulphaGetTimestamp);
//REG_FUNC(0x951D159D, sceSulphaLogSetLevel);
//REG_FUNC(0x5C6815C6, sceSulphaLogHandler);
});

39
rpcs3/Emu/ARMv7/Modules/sceSysmodule.cpp Normal file
View File

@ -0,0 +1,39 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceSysmodule;
s32 sceSysmoduleLoadModule(u16 id)
{
sceSysmodule.Error("sceSysmoduleLoadModule(id=0x%04x) -> SCE_OK", id);
return SCE_OK; // loading succeeded
}
s32 sceSysmoduleUnloadModule(u16 id)
{
sceSysmodule.Error("sceSysmoduleUnloadModule(id=0x%04x) -> SCE_OK", id);
return SCE_OK; // unloading succeeded
}
s32 sceSysmoduleIsLoaded(u16 id)
{
sceSysmodule.Error("sceSysmoduleIsLoaded(id=0x%04x) -> SCE_OK", id);
return SCE_OK; // module is loaded
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceSysmodule, #name, name)
psv_log_base sceSysmodule("SceSysmodule", []()
{
sceSysmodule.on_load = nullptr;
sceSysmodule.on_unload = nullptr;
sceSysmodule.on_stop = nullptr;
REG_FUNC(0x79A0160A, sceSysmoduleLoadModule);
REG_FUNC(0x31D87805, sceSysmoduleUnloadModule);
REG_FUNC(0x53099B7A, sceSysmoduleIsLoaded);
});

274
rpcs3/Emu/ARMv7/Modules/sceSystemGesture.cpp Normal file
View File

@ -0,0 +1,274 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceTouch.h"
extern psv_log_base sceSystemGesture;
enum SceSystemGestureTouchState : s32
{
SCE_SYSTEM_GESTURE_TOUCH_STATE_INACTIVE = 0,
SCE_SYSTEM_GESTURE_TOUCH_STATE_BEGIN = 1,
SCE_SYSTEM_GESTURE_TOUCH_STATE_ACTIVE = 2,
SCE_SYSTEM_GESTURE_TOUCH_STATE_END = 3
};
enum SceSystemGestureType : s32
{
SCE_SYSTEM_GESTURE_TYPE_TAP = 1,
SCE_SYSTEM_GESTURE_TYPE_DRAG = 2,
SCE_SYSTEM_GESTURE_TYPE_TAP_AND_HOLD = 4,
SCE_SYSTEM_GESTURE_TYPE_PINCH_OUT_IN = 8
};
struct SceSystemGestureVector2
{
s16 x;
s16 y;
};
struct SceSystemGestureRectangle
{
s16 x;
s16 y;
s16 width;
s16 height;
};
struct SceSystemGesturePrimitiveTouchEvent
{
SceSystemGestureTouchState eventState;
u16 primitiveID;
SceSystemGestureVector2 pressedPosition;
s16 pressedForce;
SceSystemGestureVector2 currentPosition;
s16 currentForce;
SceSystemGestureVector2 deltaVector;
s16 deltaForce;
u64 deltaTime;
u64 elapsedTime;
u8 reserved[56];
};
struct SceSystemGesturePrimitiveTouchRecognizerParameter
{
u8 reserved[64];
};
struct SceSystemGestureTouchRecognizer
{
u64 reserved[307];
};
struct SceSystemGestureTouchRecognizerInformation
{
SceSystemGestureType gestureType;
u32 touchPanelPortID;
SceSystemGestureRectangle rectangle;
u64 updatedTime;
u8 reserved[256];
};
struct SceSystemGestureTapRecognizerParameter
{
u8 maxTapCount;
u8 reserved[63];
};
struct SceSystemGestureDragRecognizerParameter
{
u8 reserved[64];
};
struct SceSystemGestureTapAndHoldRecognizerParameter
{
u64 timeToInvokeEvent;
u8 reserved[56];
};
struct SceSystemGesturePinchOutInRecognizerParameter
{
u8 reserved[64];
};
union SceSystemGestureTouchRecognizerParameter
{
u8 parameterBuf[64];
SceSystemGestureTapRecognizerParameter tap;
SceSystemGestureDragRecognizerParameter drag;
SceSystemGestureTapAndHoldRecognizerParameter tapAndHold;
SceSystemGesturePinchOutInRecognizerParameter pinchOutIn;
};
struct SceSystemGestureTapEventProperty
{
u16 primitiveID;
SceSystemGestureVector2 position;
u8 tappedCount;
u8 reserved[57];
};
struct SceSystemGestureDragEventProperty
{
u16 primitiveID;
SceSystemGestureVector2 deltaVector;
SceSystemGestureVector2 currentPosition;
SceSystemGestureVector2 pressedPosition;
u8 reserved[50];
};
struct SceSystemGestureTapAndHoldEventProperty
{
u16 primitiveID;
SceSystemGestureVector2 pressedPosition;
u8 reserved[58];
};
struct SceSystemGesturePinchOutInEventProperty
{
float scale;
struct
{
u16 primitiveID;
SceSystemGestureVector2 currentPosition;
SceSystemGestureVector2 deltaVector;
SceSystemGestureVector2 pairedPosition;
} primitive[2];
u8 reserved[32];
};
struct SceSystemGestureTouchEvent
{
u32 eventID;
SceSystemGestureTouchState eventState;
SceSystemGestureType gestureType;
u8 padding[4];
u64 updatedTime;
union
{
u8 propertyBuf[64];
SceSystemGestureTapEventProperty tap;
SceSystemGestureDragEventProperty drag;
SceSystemGestureTapAndHoldEventProperty tapAndHold;
SceSystemGesturePinchOutInEventProperty pinchOutIn;
} property;
u8 reserved[56];
};
s32 sceSystemGestureInitializePrimitiveTouchRecognizer(vm::psv::ptr<SceSystemGesturePrimitiveTouchRecognizerParameter> parameter)
{
throw __FUNCTION__;
}
s32 sceSystemGestureFinalizePrimitiveTouchRecognizer()
{
throw __FUNCTION__;
}
s32 sceSystemGestureResetPrimitiveTouchRecognizer()
{
throw __FUNCTION__;
}
s32 sceSystemGestureUpdatePrimitiveTouchRecognizer(vm::psv::ptr<const SceTouchData> pFrontData, vm::psv::ptr<const SceTouchData> pBackData)
{
throw __FUNCTION__;
}
s32 sceSystemGestureGetPrimitiveTouchEvents(vm::psv::ptr<SceSystemGesturePrimitiveTouchEvent> primitiveEventBuffer, const u32 capacityOfBuffer, vm::psv::ptr<u32> numberOfEvent)
{
throw __FUNCTION__;
}
s32 sceSystemGestureGetPrimitiveTouchEventsCount()
{
throw __FUNCTION__;
}
s32 sceSystemGestureGetPrimitiveTouchEventByIndex(const u32 index, vm::psv::ptr<SceSystemGesturePrimitiveTouchEvent> primitiveTouchEvent)
{
throw __FUNCTION__;
}
s32 sceSystemGestureGetPrimitiveTouchEventByPrimitiveID(const u16 primitiveID, vm::psv::ptr<SceSystemGesturePrimitiveTouchEvent> primitiveTouchEvent)
{
throw __FUNCTION__;
}
s32 sceSystemGestureCreateTouchRecognizer(vm::psv::ptr<SceSystemGestureTouchRecognizer> touchRecognizer, const SceSystemGestureType gestureType, const u8 touchPanelPortID, vm::psv::ptr<const SceSystemGestureRectangle> rectangle, vm::psv::ptr<const SceSystemGestureTouchRecognizerParameter> touchRecognizerParameter)
{
throw __FUNCTION__;
}
s32 sceSystemGestureGetTouchRecognizerInformation(vm::psv::ptr<const SceSystemGestureTouchRecognizer> touchRecognizer, vm::psv::ptr<SceSystemGestureTouchRecognizerInformation> information)
{
throw __FUNCTION__;
}
s32 sceSystemGestureResetTouchRecognizer(vm::psv::ptr<SceSystemGestureTouchRecognizer> touchRecognizer)
{
throw __FUNCTION__;
}
s32 sceSystemGestureUpdateTouchRecognizer(vm::psv::ptr<SceSystemGestureTouchRecognizer> touchRecognizer)
{
throw __FUNCTION__;
}
s32 sceSystemGestureUpdateTouchRecognizerRectangle(vm::psv::ptr<SceSystemGestureTouchRecognizer> touchRecognizer, vm::psv::ptr<const SceSystemGestureRectangle> rectangle)
{
throw __FUNCTION__;
}
s32 sceSystemGestureGetTouchEvents(vm::psv::ptr<const SceSystemGestureTouchRecognizer> touchRecognizer, vm::psv::ptr<SceSystemGestureTouchEvent> eventBuffer, const u32 capacityOfBuffer, vm::psv::ptr<u32> numberOfEvent)
{
throw __FUNCTION__;
}
s32 sceSystemGestureGetTouchEventsCount(vm::psv::ptr<const SceSystemGestureTouchRecognizer> touchRecognizer)
{
throw __FUNCTION__;
}
s32 sceSystemGestureGetTouchEventByIndex(vm::psv::ptr<const SceSystemGestureTouchRecognizer> touchRecognizer, const u32 index, vm::psv::ptr<SceSystemGestureTouchEvent> touchEvent)
{
throw __FUNCTION__;
}
s32 sceSystemGestureGetTouchEventByEventID(vm::psv::ptr<const SceSystemGestureTouchRecognizer> touchRecognizer, const u32 eventID, vm::psv::ptr<SceSystemGestureTouchEvent> touchEvent)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceSystemGesture, #name, name)
psv_log_base sceSystemGesture("SceSystemGesture", []()
{
sceSystemGesture.on_load = nullptr;
sceSystemGesture.on_unload = nullptr;
sceSystemGesture.on_stop = nullptr;
REG_FUNC(0x6078A08B, sceSystemGestureInitializePrimitiveTouchRecognizer);
REG_FUNC(0xFD5A6504, sceSystemGestureResetPrimitiveTouchRecognizer);
REG_FUNC(0xB3875104, sceSystemGestureFinalizePrimitiveTouchRecognizer);
REG_FUNC(0xDF4C665A, sceSystemGestureUpdatePrimitiveTouchRecognizer);
REG_FUNC(0xC750D3DA, sceSystemGestureGetPrimitiveTouchEvents);
REG_FUNC(0xBAB8ECCB, sceSystemGestureGetPrimitiveTouchEventsCount);
REG_FUNC(0xE0577765, sceSystemGestureGetPrimitiveTouchEventByIndex);
REG_FUNC(0x480564C9, sceSystemGestureGetPrimitiveTouchEventByPrimitiveID);
REG_FUNC(0xC3367370, sceSystemGestureCreateTouchRecognizer);
REG_FUNC(0xF0DB1AE5, sceSystemGestureGetTouchRecognizerInformation);
REG_FUNC(0x0D941B90, sceSystemGestureResetTouchRecognizer);
REG_FUNC(0x851FB144, sceSystemGestureUpdateTouchRecognizer);
REG_FUNC(0xA9DB29F6, sceSystemGestureUpdateTouchRecognizerRectangle);
REG_FUNC(0x789D867C, sceSystemGestureGetTouchEvents);
REG_FUNC(0x13AD2218, sceSystemGestureGetTouchEventsCount);
REG_FUNC(0x74724147, sceSystemGestureGetTouchEventByIndex);
REG_FUNC(0x5570B83E, sceSystemGestureGetTouchEventByEventID);
});

46
rpcs3/Emu/ARMv7/Modules/sceTouch.cpp Normal file
View File

@ -0,0 +1,46 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceTouch.h"
s32 sceTouchGetPanelInfo(u32 port, vm::psv::ptr<SceTouchPanelInfo> pPanelInfo)
{
throw __FUNCTION__;
}
s32 sceTouchRead(u32 port, vm::psv::ptr<SceTouchData> pData, u32 nBufs)
{
throw __FUNCTION__;
}
s32 sceTouchPeek(u32 port, vm::psv::ptr<SceTouchData> pData, u32 nBufs)
{
throw __FUNCTION__;
}
s32 sceTouchSetSamplingState(u32 port, u32 state)
{
throw __FUNCTION__;
}
s32 sceTouchGetSamplingState(u32 port, vm::psv::ptr<u32> pState)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceTouch, #name, name)
psv_log_base sceTouch("SceTouch", []()
{
sceTouch.on_load = nullptr;
sceTouch.on_unload = nullptr;
sceTouch.on_stop = nullptr;
REG_FUNC(0x169A1D58, sceTouchRead);
REG_FUNC(0xFF082DF0, sceTouchPeek);
REG_FUNC(0x1B9C5D14, sceTouchSetSamplingState);
REG_FUNC(0x26531526, sceTouchGetSamplingState);
REG_FUNC(0x10A2CA25, sceTouchGetPanelInfo);
});

36
rpcs3/Emu/ARMv7/Modules/sceTouch.h Normal file
View File

@ -0,0 +1,36 @@
#pragma once
struct SceTouchPanelInfo
{
s16 minAaX;
s16 minAaY;
s16 maxAaX;
s16 maxAaY;
s16 minDispX;
s16 minDispY;
s16 maxDispX;
s16 maxDispY;
u8 minForce;
u8 maxForce;
u8 rsv[30];
};
struct SceTouchReport
{
u8 id;
u8 force;
s16 x;
s16 y;
s8 rsv[8];
u16 info;
};
struct SceTouchData
{
u64 timeStamp;
u32 status;
u32 reportNum;
SceTouchReport report[8];
};
extern psv_log_base sceTouch;

605
rpcs3/Emu/ARMv7/Modules/sceUlt.cpp Normal file
View File

@ -0,0 +1,605 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "sceLibKernel.h"
extern psv_log_base sceUlt;
#define CHECK_SIZE(type, size) static_assert(sizeof(type) == size, "Invalid " #type " size")
struct _SceUltOptParamHeader
{
s64 reserved[2];
};
struct SceUltWaitingQueueResourcePoolOptParam
{
_SceUltOptParamHeader header;
u64 reserved[14];
};
CHECK_SIZE(SceUltWaitingQueueResourcePoolOptParam, 128);
struct SceUltWaitingQueueResourcePool
{
u64 reserved[32];
};
CHECK_SIZE(SceUltWaitingQueueResourcePool, 256);
struct SceUltQueueDataResourcePoolOptParam
{
_SceUltOptParamHeader header;
u64 reserved[14];
};
CHECK_SIZE(SceUltQueueDataResourcePoolOptParam, 128);
struct SceUltQueueDataResourcePool
{
u64 reserved[32];
};
CHECK_SIZE(SceUltQueueDataResourcePool, 256);
struct SceUltMutexOptParam
{
_SceUltOptParamHeader header;
u32 attribute;
u32 reserved_0;
u64 reserved[13];
};
CHECK_SIZE(SceUltMutexOptParam, 128);
struct SceUltMutex
{
u64 reserved[32];
};
CHECK_SIZE(SceUltMutex, 256);
struct SceUltConditionVariableOptParam
{
_SceUltOptParamHeader header;
u64 reserved[14];
};
CHECK_SIZE(SceUltConditionVariableOptParam, 128);
struct SceUltConditionVariable
{
u64 reserved[32];
};
CHECK_SIZE(SceUltConditionVariable, 256);
struct SceUltQueueOptParam
{
_SceUltOptParamHeader header;
u64 reserved[14];
};
CHECK_SIZE(SceUltQueueOptParam, 128);
struct SceUltQueue
{
u64 reserved[32];
};
CHECK_SIZE(SceUltQueue, 256);
struct SceUltReaderWriterLockOptParam
{
_SceUltOptParamHeader header;
u64 reserved[14];
};
CHECK_SIZE(SceUltReaderWriterLockOptParam, 128);
struct SceUltReaderWriterLock
{
u64 reserved[32];
};
CHECK_SIZE(SceUltReaderWriterLock, 256);
struct SceUltSemaphoreOptParam
{
_SceUltOptParamHeader header;
u64 reserved[14];
};
CHECK_SIZE(SceUltSemaphoreOptParam, 128);
struct SceUltSemaphore
{
u64 reserved[32];
};
CHECK_SIZE(SceUltSemaphore, 256);
struct SceUltUlthreadRuntimeOptParam
{
_SceUltOptParamHeader header;
u32 oneShotThreadStackSize;
s32 workerThreadPriority;
u32 workerThreadCpuAffinityMask;
u32 workerThreadAttr;
vm::psv::ptr<const SceKernelThreadOptParam> workerThreadOptParam;
u64 reserved[11];
};
CHECK_SIZE(SceUltUlthreadRuntimeOptParam, 128);
struct SceUltUlthreadRuntime
{
u64 reserved[128];
};
CHECK_SIZE(SceUltUlthreadRuntime, 1024);
struct SceUltUlthreadOptParam
{
_SceUltOptParamHeader header;
u32 attribute;
u32 reserved_0;
u64 reserved[13];
};
CHECK_SIZE(SceUltUlthreadOptParam, 128);
struct SceUltUlthread
{
u64 reserved[32];
};
CHECK_SIZE(SceUltUlthread, 256);
typedef vm::psv::ptr<s32(u32 arg)> SceUltUlthreadEntry;
// Functions
s32 _sceUltWaitingQueueResourcePoolOptParamInitialize(vm::psv::ptr<SceUltWaitingQueueResourcePoolOptParam> optParam, u32 buildVersion)
{
throw __FUNCTION__;
}
u32 sceUltWaitingQueueResourcePoolGetWorkAreaSize(u32 numThreads, u32 numSyncObjects)
{
throw __FUNCTION__;
}
s32 _sceUltWaitingQueueResourcePoolCreate(
vm::psv::ptr<SceUltWaitingQueueResourcePool> pool,
vm::psv::ptr<const char> name,
u32 numThreads,
u32 numSyncObjects,
vm::psv::ptr<void> workArea,
vm::psv::ptr<const SceUltWaitingQueueResourcePoolOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 sceUltWaitingQueueResourcePoolDestroy(vm::psv::ptr<SceUltWaitingQueueResourcePool> pool)
{
throw __FUNCTION__;
}
s32 _sceUltQueueDataResourcePoolOptParamInitialize(vm::psv::ptr<SceUltQueueDataResourcePoolOptParam> optParam, u32 buildVersion)
{
throw __FUNCTION__;
}
u32 sceUltQueueDataResourcePoolGetWorkAreaSize(u32 numData, u32 dataSize, u32 numQueueObject)
{
throw __FUNCTION__;
}
s32 _sceUltQueueDataResourcePoolCreate(
vm::psv::ptr<SceUltQueueDataResourcePool> pool,
vm::psv::ptr<const char> name,
u32 numData,
u32 dataSize,
u32 numQueueObject,
vm::psv::ptr<SceUltWaitingQueueResourcePool> waitingQueueResourcePool,
vm::psv::ptr<void> workArea,
vm::psv::ptr<const SceUltQueueDataResourcePoolOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 sceUltQueueDataResourcePoolDestroy(vm::psv::ptr<SceUltQueueDataResourcePool> pool)
{
throw __FUNCTION__;
}
u32 sceUltMutexGetStandaloneWorkAreaSize(u32 waitingQueueDepth, u32 numConditionVariable)
{
throw __FUNCTION__;
}
s32 _sceUltMutexOptParamInitialize(vm::psv::ptr<SceUltMutexOptParam> optParam, u32 buildVersion)
{
throw __FUNCTION__;
}
s32 _sceUltMutexCreate(
vm::psv::ptr<SceUltMutex> mutex,
vm::psv::ptr<const char> name,
vm::psv::ptr<SceUltWaitingQueueResourcePool> waitingQueueResourcePool,
vm::psv::ptr<const SceUltMutexOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 _sceUltMutexCreateStandalone(
vm::psv::ptr<SceUltMutex> mutex,
vm::psv::ptr<const char> name,
u32 numConditionVariable,
u32 maxNumThreads,
vm::psv::ptr<void> workArea,
vm::psv::ptr<const SceUltMutexOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 sceUltMutexLock(vm::psv::ptr<SceUltMutex> mutex)
{
throw __FUNCTION__;
}
s32 sceUltMutexTryLock(vm::psv::ptr<SceUltMutex> mutex)
{
throw __FUNCTION__;
}
s32 sceUltMutexUnlock(vm::psv::ptr<SceUltMutex> mutex)
{
throw __FUNCTION__;
}
s32 sceUltMutexDestroy(vm::psv::ptr<SceUltMutex> mutex)
{
throw __FUNCTION__;
}
s32 _sceUltConditionVariableOptParamInitialize(vm::psv::ptr<SceUltConditionVariableOptParam> optParam, u32 buildVersion)
{
throw __FUNCTION__;
}
s32 _sceUltConditionVariableCreate(
vm::psv::ptr<SceUltConditionVariable> conditionVariable,
vm::psv::ptr<const char> name,
vm::psv::ptr<SceUltMutex> mutex,
vm::psv::ptr<const SceUltConditionVariableOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 sceUltConditionVariableSignal(vm::psv::ptr<SceUltConditionVariable> conditionVariable)
{
throw __FUNCTION__;
}
s32 sceUltConditionVariableSignalAll(vm::psv::ptr<SceUltConditionVariable> conditionVariable)
{
throw __FUNCTION__;
}
s32 sceUltConditionVariableWait(vm::psv::ptr<SceUltConditionVariable> conditionVariable)
{
throw __FUNCTION__;
}
s32 sceUltConditionVariableDestroy(vm::psv::ptr<SceUltConditionVariable> conditionVariable)
{
throw __FUNCTION__;
}
s32 _sceUltQueueOptParamInitialize(vm::psv::ptr<SceUltQueueOptParam> optParam, u32 buildVersion)
{
throw __FUNCTION__;
}
u32 sceUltQueueGetStandaloneWorkAreaSize(u32 queueDepth,
u32 dataSize,
u32 waitingQueueLength)
{
throw __FUNCTION__;
}
s32 _sceUltQueueCreate(
vm::psv::ptr<SceUltQueue> queue,
vm::psv::ptr<const char> _name,
u32 dataSize,
vm::psv::ptr<SceUltWaitingQueueResourcePool> resourcePool,
vm::psv::ptr<SceUltQueueDataResourcePool> queueResourcePool,
vm::psv::ptr<const SceUltQueueOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 _sceUltQueueCreateStandalone(
vm::psv::ptr<SceUltQueue> queue,
vm::psv::ptr<const char> name,
u32 queueDepth,
u32 dataSize,
u32 waitingQueueLength,
vm::psv::ptr<void> workArea,
vm::psv::ptr<const SceUltQueueOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 sceUltQueuePush(vm::psv::ptr<SceUltQueue> queue, vm::psv::ptr<const void> data)
{
throw __FUNCTION__;
}
s32 sceUltQueueTryPush(vm::psv::ptr<SceUltQueue> queue, vm::psv::ptr<const void> data)
{
throw __FUNCTION__;
}
s32 sceUltQueuePop(vm::psv::ptr<SceUltQueue> queue, vm::psv::ptr<void> data)
{
throw __FUNCTION__;
}
s32 sceUltQueueTryPop(vm::psv::ptr<SceUltQueue> queue, vm::psv::ptr<void> data)
{
throw __FUNCTION__;
}
s32 sceUltQueueDestroy(vm::psv::ptr<SceUltQueue> queue)
{
throw __FUNCTION__;
}
s32 _sceUltReaderWriterLockOptParamInitialize(vm::psv::ptr<SceUltReaderWriterLockOptParam> optParam, u32 buildVersion)
{
throw __FUNCTION__;
}
s32 _sceUltReaderWriterLockCreate(
vm::psv::ptr<SceUltReaderWriterLock> rwlock,
vm::psv::ptr<const char> name,
vm::psv::ptr<SceUltWaitingQueueResourcePool> waitingQueueResourcePool,
vm::psv::ptr<const SceUltReaderWriterLockOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 _sceUltReaderWriterLockCreateStandalone(
vm::psv::ptr<SceUltReaderWriterLock> rwlock,
vm::psv::ptr<const char> name,
u32 waitingQueueDepth,
vm::psv::ptr<void> workArea,
vm::psv::ptr<const SceUltReaderWriterLockOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
u32 sceUltReaderWriterLockGetStandaloneWorkAreaSize(u32 waitingQueueDepth)
{
throw __FUNCTION__;
}
s32 sceUltReaderWriterLockLockRead(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
{
throw __FUNCTION__;
}
s32 sceUltReaderWriterLockTryLockRead(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
{
throw __FUNCTION__;
}
s32 sceUltReaderWriterLockUnlockRead(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
{
throw __FUNCTION__;
}
s32 sceUltReaderWriterLockLockWrite(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
{
throw __FUNCTION__;
}
s32 sceUltReaderWriterLockTryLockWrite(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
{
throw __FUNCTION__;
}
s32 sceUltReaderWriterLockUnlockWrite(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
{
throw __FUNCTION__;
}
s32 sceUltReaderWriterLockDestroy(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
{
throw __FUNCTION__;
}
s32 _sceUltSemaphoreOptParamInitialize(vm::psv::ptr<SceUltSemaphoreOptParam> optParam, u32 buildVersion)
{
throw __FUNCTION__;
}
s32 _sceUltSemaphoreCreate(
vm::psv::ptr<SceUltSemaphore> semaphore,
vm::psv::ptr<const char> name,
s32 numInitialResource,
vm::psv::ptr<SceUltWaitingQueueResourcePool> waitingQueueResourcePool,
vm::psv::ptr<const SceUltSemaphoreOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 sceUltSemaphoreAcquire(vm::psv::ptr<SceUltSemaphore> semaphore, s32 numResource)
{
throw __FUNCTION__;
}
s32 sceUltSemaphoreTryAcquire(vm::psv::ptr<SceUltSemaphore> semaphore, s32 numResource)
{
throw __FUNCTION__;
}
s32 sceUltSemaphoreRelease(vm::psv::ptr<SceUltSemaphore> semaphore, s32 numResource)
{
throw __FUNCTION__;
}
s32 sceUltSemaphoreDestroy(vm::psv::ptr<SceUltSemaphore> semaphore)
{
throw __FUNCTION__;
}
s32 _sceUltUlthreadRuntimeOptParamInitialize(vm::psv::ptr<SceUltUlthreadRuntimeOptParam> optParam, u32 buildVersion)
{
throw __FUNCTION__;
}
u32 sceUltUlthreadRuntimeGetWorkAreaSize(u32 numMaxUlthread, u32 numWorkerThread)
{
throw __FUNCTION__;
}
s32 _sceUltUlthreadRuntimeCreate(
vm::psv::ptr<SceUltUlthreadRuntime> runtime,
vm::psv::ptr<const char> name,
u32 numMaxUlthread,
u32 numWorkerThread,
vm::psv::ptr<void> workArea,
vm::psv::ptr<const SceUltUlthreadRuntimeOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 sceUltUlthreadRuntimeDestroy(vm::psv::ptr<SceUltUlthreadRuntime> runtime)
{
throw __FUNCTION__;
}
s32 _sceUltUlthreadOptParamInitialize(vm::psv::ptr<SceUltUlthreadOptParam> optParam, u32 buildVersion)
{
throw __FUNCTION__;
}
s32 _sceUltUlthreadCreate(
vm::psv::ptr<SceUltUlthread> ulthread,
vm::psv::ptr<const char> name,
SceUltUlthreadEntry entry,
u32 arg,
vm::psv::ptr<void> context,
u32 sizeContext,
vm::psv::ptr<SceUltUlthreadRuntime> runtime,
vm::psv::ptr<const SceUltUlthreadOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 sceUltUlthreadYield()
{
throw __FUNCTION__;
}
s32 sceUltUlthreadExit(s32 status)
{
throw __FUNCTION__;
}
s32 sceUltUlthreadJoin(vm::psv::ptr<SceUltUlthread> ulthread, vm::psv::ptr<s32> status)
{
throw __FUNCTION__;
}
s32 sceUltUlthreadTryJoin(vm::psv::ptr<SceUltUlthread> ulthread, vm::psv::ptr<s32> status)
{
throw __FUNCTION__;
}
s32 sceUltUlthreadGetSelf(vm::psv::ptr<vm::psv::ptr<SceUltUlthread>> ulthread)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceUlt, #name, name)
psv_log_base sceUlt("SceUlt", []()
{
sceUlt.on_load = nullptr;
sceUlt.on_unload = nullptr;
sceUlt.on_stop = nullptr;
REG_FUNC(0xEF094E35, _sceUltWaitingQueueResourcePoolOptParamInitialize);
REG_FUNC(0x644DA029, sceUltWaitingQueueResourcePoolGetWorkAreaSize);
REG_FUNC(0x62F9493E, _sceUltWaitingQueueResourcePoolCreate);
REG_FUNC(0xC9E96714, sceUltWaitingQueueResourcePoolDestroy);
REG_FUNC(0x8A4F88A2, _sceUltQueueDataResourcePoolOptParamInitialize);
REG_FUNC(0xECDA7FEE, sceUltQueueDataResourcePoolGetWorkAreaSize);
REG_FUNC(0x40856827, _sceUltQueueDataResourcePoolCreate);
REG_FUNC(0x2B8D33F1, sceUltQueueDataResourcePoolDestroy);
REG_FUNC(0x24D87E05, _sceUltMutexOptParamInitialize);
REG_FUNC(0x5AFEC7A1, _sceUltMutexCreate);
REG_FUNC(0x001EAC8A, sceUltMutexLock);
REG_FUNC(0xE5936A69, sceUltMutexTryLock);
REG_FUNC(0x897C9097, sceUltMutexUnlock);
REG_FUNC(0xEEBD9052, sceUltMutexDestroy);
REG_FUNC(0x0603FCC1, _sceUltConditionVariableOptParamInitialize);
REG_FUNC(0xD76A156C, _sceUltConditionVariableCreate);
REG_FUNC(0x9FE7CB9F, sceUltConditionVariableSignal);
REG_FUNC(0xEBB6FC1E, sceUltConditionVariableSignalAll);
REG_FUNC(0x2CD0F57C, sceUltConditionVariableWait);
REG_FUNC(0x53420ED2, sceUltConditionVariableDestroy);
REG_FUNC(0xF7A83023, _sceUltQueueOptParamInitialize);
REG_FUNC(0x14DA1BB4, _sceUltQueueCreate);
REG_FUNC(0xA7E78FF9, sceUltQueuePush);
REG_FUNC(0x6D356B29, sceUltQueueTryPush);
REG_FUNC(0x1AD58A53, sceUltQueuePop);
REG_FUNC(0x2A1A8EA6, sceUltQueueTryPop);
REG_FUNC(0xF37862DE, sceUltQueueDestroy);
REG_FUNC(0xD8334A1F, _sceUltReaderWriterLockOptParamInitialize);
REG_FUNC(0x2FB0EB32, _sceUltReaderWriterLockCreate);
REG_FUNC(0x9AD07630, sceUltReaderWriterLockLockRead);
REG_FUNC(0x2629C055, sceUltReaderWriterLockTryLockRead);
REG_FUNC(0x218D4743, sceUltReaderWriterLockUnlockRead);
REG_FUNC(0xF5F63E2C, sceUltReaderWriterLockLockWrite);
REG_FUNC(0x944FB222, sceUltReaderWriterLockTryLockWrite);
REG_FUNC(0x2A5741F5, sceUltReaderWriterLockUnlockWrite);
REG_FUNC(0xB1FEB79B, sceUltReaderWriterLockDestroy);
REG_FUNC(0x8E31B9FE, _sceUltSemaphoreOptParamInitialize);
REG_FUNC(0xDD59562C, _sceUltSemaphoreCreate);
REG_FUNC(0xF220D3AE, sceUltSemaphoreAcquire);
REG_FUNC(0xAF15606D, sceUltSemaphoreTryAcquire);
REG_FUNC(0x65376E2D, sceUltSemaphoreRelease);
REG_FUNC(0x8EC57420, sceUltSemaphoreDestroy);
REG_FUNC(0x8486DDE6, _sceUltUlthreadRuntimeOptParamInitialize);
REG_FUNC(0x5435C586, sceUltUlthreadRuntimeGetWorkAreaSize);
REG_FUNC(0x86DDA3AE, _sceUltUlthreadRuntimeCreate);
REG_FUNC(0x4E9A745C, sceUltUlthreadRuntimeDestroy);
REG_FUNC(0x7F373376, _sceUltUlthreadOptParamInitialize);
REG_FUNC(0xB1290375, _sceUltUlthreadCreate);
REG_FUNC(0xCAD57BAD, sceUltUlthreadYield);
REG_FUNC(0x1E401DF8, sceUltUlthreadExit);
REG_FUNC(0x63483381, sceUltUlthreadJoin);
REG_FUNC(0xB4CF88AC, sceUltUlthreadTryJoin);
REG_FUNC(0xA798C5D7, sceUltUlthreadGetSelf);
});

206
rpcs3/Emu/ARMv7/Modules/sceVideodec.cpp Normal file
View File

@ -0,0 +1,206 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceVideodec;
struct SceVideodecQueryInitInfoHwAvcdec
{
u32 size;
u32 horizontal;
u32 vertical;
u32 numOfRefFrames;
u32 numOfStreams;
};
union SceVideodecQueryInitInfo
{
u8 reserved[32];
SceVideodecQueryInitInfoHwAvcdec hwAvc;
};
struct SceVideodecTimeStamp
{
u32 upper;
u32 lower;
};
struct SceAvcdecQueryDecoderInfo
{
u32 horizontal;
u32 vertical;
u32 numOfRefFrames;
};
struct SceAvcdecDecoderInfo
{
u32 frameMemSize;
};
struct SceAvcdecBuf
{
vm::psv::ptr<void> pBuf;
u32 size;
};
struct SceAvcdecCtrl
{
u32 handle;
SceAvcdecBuf frameBuf;
};
struct SceAvcdecAu
{
SceVideodecTimeStamp pts;
SceVideodecTimeStamp dts;
SceAvcdecBuf es;
};
struct SceAvcdecInfo
{
u32 numUnitsInTick;
u32 timeScale;
u8 fixedFrameRateFlag;
u8 aspectRatioIdc;
u16 sarWidth;
u16 sarHeight;
u8 colourPrimaries;
u8 transferCharacteristics;
u8 matrixCoefficients;
u8 videoFullRangeFlag;
u8 picStruct[2];
u8 ctType;
u8 padding[3];
};
struct SceAvcdecFrameOptionRGBA
{
u8 alpha;
u8 cscCoefficient;
u8 reserved[14];
};
union SceAvcdecFrameOption
{
u8 reserved[16];
SceAvcdecFrameOptionRGBA rgba;
};
struct SceAvcdecFrame
{
u32 pixelType;
u32 framePitch;
u32 frameWidth;
u32 frameHeight;
u32 horizontalSize;
u32 verticalSize;
u32 frameCropLeftOffset;
u32 frameCropRightOffset;
u32 frameCropTopOffset;
u32 frameCropBottomOffset;
SceAvcdecFrameOption opt;
vm::psv::ptr<void> pPicture[2];
};
struct SceAvcdecPicture
{
u32 size;
SceAvcdecFrame frame;
SceAvcdecInfo info;
};
struct SceAvcdecArrayPicture
{
u32 numOfOutput;
u32 numOfElm;
vm::psv::ptr<vm::psv::ptr<SceAvcdecPicture>> pPicture;
};
s32 sceVideodecInitLibrary(u32 codecType, vm::psv::ptr<const SceVideodecQueryInitInfo> pInitInfo)
{
throw __FUNCTION__;
}
s32 sceVideodecTermLibrary(u32 codecType)
{
throw __FUNCTION__;
}
s32 sceAvcdecQueryDecoderMemSize(u32 codecType, vm::psv::ptr<const SceAvcdecQueryDecoderInfo> pDecoderInfo, vm::psv::ptr<SceAvcdecDecoderInfo> pMemInfo)
{
throw __FUNCTION__;
}
s32 sceAvcdecCreateDecoder(u32 codecType, vm::psv::ptr<SceAvcdecCtrl> pCtrl, vm::psv::ptr<const SceAvcdecQueryDecoderInfo> pDecoderInfo)
{
throw __FUNCTION__;
}
s32 sceAvcdecDeleteDecoder(vm::psv::ptr<SceAvcdecCtrl> pCtrl)
{
throw __FUNCTION__;
}
s32 sceAvcdecDecodeAvailableSize(vm::psv::ptr<SceAvcdecCtrl> pCtrl)
{
throw __FUNCTION__;
}
s32 sceAvcdecDecode(vm::psv::ptr<SceAvcdecCtrl> pCtrl, vm::psv::ptr<const SceAvcdecAu> pAu, vm::psv::ptr<SceAvcdecArrayPicture> pArrayPicture)
{
throw __FUNCTION__;
}
s32 sceAvcdecDecodeStop(vm::psv::ptr<SceAvcdecCtrl> pCtrl, vm::psv::ptr<SceAvcdecArrayPicture> pArrayPicture)
{
throw __FUNCTION__;
}
s32 sceAvcdecDecodeFlush(vm::psv::ptr<SceAvcdecCtrl> pCtrl)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceVideodec, #name, name)
psv_log_base sceVideodec("SceVideodec", []()
{
sceVideodec.on_load = nullptr;
sceVideodec.on_unload = nullptr;
sceVideodec.on_stop = nullptr;
REG_FUNC(0xF1AF65A3, sceVideodecInitLibrary);
REG_FUNC(0x3A5F4924, sceVideodecTermLibrary);
REG_FUNC(0x97E95EDB, sceAvcdecQueryDecoderMemSize);
REG_FUNC(0xE82BB69B, sceAvcdecCreateDecoder);
REG_FUNC(0x8A0E359E, sceAvcdecDeleteDecoder);
REG_FUNC(0x441673E3, sceAvcdecDecodeAvailableSize);
REG_FUNC(0xD6190A06, sceAvcdecDecode);
REG_FUNC(0x9648D853, sceAvcdecDecodeStop);
REG_FUNC(0x25F31020, sceAvcdecDecodeFlush);
//REG_FUNC(0xB2A428DB, sceAvcdecCsc);
//REG_FUNC(0x6C68A38F, sceAvcdecDecodeNalAu);
//REG_FUNC(0xC67C1A80, sceM4vdecQueryDecoderMemSize);
//REG_FUNC(0x17C6AC9E, sceM4vdecCreateDecoder);
//REG_FUNC(0x0EB2E4E7, sceM4vdecDeleteDecoder);
//REG_FUNC(0xA8CF1942, sceM4vdecDecodeAvailableSize);
//REG_FUNC(0x624664DB, sceM4vdecDecode);
//REG_FUNC(0x87CFD23B, sceM4vdecDecodeStop);
//REG_FUNC(0x7C460D75, sceM4vdecDecodeFlush);
//REG_FUNC(0xB4BC325B, sceM4vdecCsc);
});

286
rpcs3/Emu/ARMv7/Modules/sceVoice.cpp Normal file
View File

@ -0,0 +1,286 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceVoice;
enum SceVoicePortType : s32
{
SCEVOICE_PORTTYPE_NULL = -1,
SCEVOICE_PORTTYPE_IN_DEVICE = 0,
SCEVOICE_PORTTYPE_IN_PCMAUDIO = 1,
SCEVOICE_PORTTYPE_IN_VOICE = 2,
SCEVOICE_PORTTYPE_OUT_PCMAUDIO = 3,
SCEVOICE_PORTTYPE_OUT_VOICE = 4,
SCEVOICE_PORTTYPE_OUT_DEVICE = 5
};
enum SceVoicePortState : s32
{
SCEVOICE_PORTSTATE_NULL = -1,
SCEVOICE_PORTSTATE_IDLE = 0,
SCEVOICE_PORTSTATE_READY = 1,
SCEVOICE_PORTSTATE_BUFFERING = 2,
SCEVOICE_PORTSTATE_RUNNING = 3
};
enum SceVoiceBitRate : s32
{
SCEVOICE_BITRATE_NULL = -1,
SCEVOICE_BITRATE_3850 = 3850,
SCEVOICE_BITRATE_4650 = 4650,
SCEVOICE_BITRATE_5700 = 5700,
SCEVOICE_BITRATE_7300 = 7300
};
enum SceVoiceSamplingRate : s32
{
SCEVOICE_SAMPLINGRATE_NULL = -1,
SCEVOICE_SAMPLINGRATE_16000 = 16000
};
enum SceVoicePcmDataType : s32
{
SCEVOICE_PCM_NULL = -1,
SCEVOICE_PCM_SHORT_LITTLE_ENDIAN = 0
};
enum SceVoiceVersion : s32
{
SCEVOICE_VERSION_100 = 100
};
enum SceVoiceAppType : s32
{
SCEVOICE_APPTYPE_GAME = 1 << 29
};
struct SceVoicePCMFormat
{
SceVoicePcmDataType dataType;
SceVoiceSamplingRate sampleRate;
};
struct SceVoiceResourceInfo
{
u16 maxInVoicePort;
u16 maxOutVoicePort;
u16 maxInDevicePort;
u16 maxOutDevicePort;
u16 maxTotalPort;
};
struct SceVoiceBasePortInfo
{
SceVoicePortType portType;
SceVoicePortState state;
vm::psv::ptr<u32> pEdge;
u32 numByte;
u32 frameSize;
u16 numEdge;
u16 reserved;
};
struct SceVoicePortParam
{
SceVoicePortType portType;
u16 threshold;
u16 bMute;
float volume;
union
{
struct
{
SceVoiceBitRate bitrate;
} voice;
struct
{
u32 bufSize;
SceVoicePCMFormat format;
} pcmaudio;
struct
{
u32 playerId;
} device;
};
};
typedef vm::psv::ptr<void(vm::psv::ptr<void> event)> SceVoiceEventCallback;
struct SceVoiceInitParam
{
s32 appType;
SceVoiceEventCallback onEvent;
u8 reserved[24];
};
struct SceVoiceStartParam
{
s32 container;
u8 reserved[28];
};
s32 sceVoiceInit(vm::psv::ptr<SceVoiceInitParam> pArg, SceVoiceVersion version)
{
throw __FUNCTION__;
}
s32 sceVoiceEnd()
{
throw __FUNCTION__;
}
s32 sceVoiceStart(vm::psv::ptr<SceVoiceStartParam> pArg)
{
throw __FUNCTION__;
}
s32 sceVoiceStop()
{
throw __FUNCTION__;
}
s32 sceVoiceResetPort(u32 portId)
{
throw __FUNCTION__;
}
s32 sceVoiceCreatePort(vm::psv::ptr<u32> portId, vm::psv::ptr<const SceVoicePortParam> pArg)
{
throw __FUNCTION__;
}
s32 sceVoiceUpdatePort(u32 portId, vm::psv::ptr<const SceVoicePortParam> pArg)
{
throw __FUNCTION__;
}
s32 sceVoiceConnectIPortToOPort(u32 ips, u32 ops)
{
throw __FUNCTION__;
}
s32 sceVoiceDisconnectIPortFromOPort(u32 ips, u32 ops)
{
throw __FUNCTION__;
}
s32 sceVoiceDeletePort(u32 portId)
{
throw __FUNCTION__;
}
s32 sceVoiceWriteToIPort(u32 ips, vm::psv::ptr<const void> data, vm::psv::ptr<u32> size, s16 frameGaps)
{
throw __FUNCTION__;
}
s32 sceVoiceReadFromOPort(u32 ops, vm::psv::ptr<void> data, vm::psv::ptr<u32> size)
{
throw __FUNCTION__;
}
s32 sceVoiceSetMuteFlagAll(u16 bMuted)
{
throw __FUNCTION__;
}
s32 sceVoiceSetMuteFlag(u32 portId, u16 bMuted)
{
throw __FUNCTION__;
}
s32 sceVoiceGetMuteFlag(u32 portId, vm::psv::ptr<u16> bMuted)
{
throw __FUNCTION__;
}
//s32 sceVoiceSetVolume(u32 portId, float volume)
//{
// throw __FUNCTION__;
//}
s32 sceVoiceGetVolume(u32 portId, vm::psv::ptr<float> volume)
{
throw __FUNCTION__;
}
s32 sceVoiceSetBitRate(u32 portId, SceVoiceBitRate bitrate)
{
throw __FUNCTION__;
}
s32 sceVoiceGetBitRate(u32 portId, vm::psv::ptr<u32> bitrate)
{
throw __FUNCTION__;
}
s32 sceVoiceGetPortInfo(u32 portId, vm::psv::ptr<SceVoiceBasePortInfo> pInfo)
{
throw __FUNCTION__;
}
s32 sceVoicePausePort(u32 portId)
{
throw __FUNCTION__;
}
s32 sceVoiceResumePort(u32 portId)
{
throw __FUNCTION__;
}
s32 sceVoicePausePortAll()
{
throw __FUNCTION__;
}
s32 sceVoiceResumePortAll()
{
throw __FUNCTION__;
}
s32 sceVoiceGetResourceInfo(vm::psv::ptr<SceVoiceResourceInfo> pInfo)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceVoice, #name, name)
psv_log_base sceVoice("SceVoice", []()
{
sceVoice.on_load = nullptr;
sceVoice.on_unload = nullptr;
sceVoice.on_stop = nullptr;
REG_FUNC(0xD02C00B4, sceVoiceGetBitRate);
REG_FUNC(0xC913F7E9, sceVoiceGetMuteFlag);
REG_FUNC(0x875CC80D, sceVoiceGetVolume);
REG_FUNC(0x02F58D6F, sceVoiceSetBitRate);
REG_FUNC(0x0B9E4AE2, sceVoiceSetMuteFlag);
REG_FUNC(0xDB90EAC4, sceVoiceSetMuteFlagAll);
//REG_FUNC(0xD93769E6, sceVoiceSetVolume);
REG_FUNC(0x6E46950E, sceVoiceGetResourceInfo);
REG_FUNC(0xAC98853E, sceVoiceEnd);
REG_FUNC(0x805CC20F, sceVoiceInit);
REG_FUNC(0xB2ED725B, sceVoiceStart);
REG_FUNC(0xC3868DF6, sceVoiceStop);
REG_FUNC(0x698BDAAE, sceVoiceConnectIPortToOPort);
REG_FUNC(0xFA4E57B1, sceVoiceCreatePort);
REG_FUNC(0xAE46564D, sceVoiceDeletePort);
REG_FUNC(0x5F0260F4, sceVoiceDisconnectIPortFromOPort);
REG_FUNC(0x5933CCFB, sceVoiceGetPortInfo);
REG_FUNC(0x23C6B16B, sceVoicePausePort);
REG_FUNC(0x39AA3884, sceVoicePausePortAll);
REG_FUNC(0x09E4D18C, sceVoiceReadFromOPort);
REG_FUNC(0x5E1CE910, sceVoiceResetPort);
REG_FUNC(0x2DE35411, sceVoiceResumePort);
REG_FUNC(0x1F93FC0C, sceVoiceResumePortAll);
REG_FUNC(0xCE855C50, sceVoiceUpdatePort);
REG_FUNC(0x0A22EC0E, sceVoiceWriteToIPort);
});

140
rpcs3/Emu/ARMv7/Modules/sceVoiceQoS.cpp Normal file
View File

@ -0,0 +1,140 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceVoiceQoS;
typedef s32 SceVoiceQoSLocalId;
typedef s32 SceVoiceQoSRemoteId;
typedef s32 SceVoiceQoSConnectionId;
enum SceVoiceQoSAttributeId : s32
{
SCE_VOICE_QOS_ATTR_MIC_VOLUME,
SCE_VOICE_QOS_ATTR_MIC_MUTE,
SCE_VOICE_QOS_ATTR_SPEAKER_VOLUME,
SCE_VOICE_QOS_ATTR_SPEAKER_MUTE,
SCE_VOICE_QOS_ATTR_DESIRED_OUT_BIT_RATE
};
enum SceVoiceQoSStatusId : s32
{
SCE_VOICE_QOS_IN_BITRATE,
SCE_VOICE_QOS_OUT_BITRATE,
SCE_VOICE_QOS_OUT_READ_BITRATE,
SCE_VOICE_QOS_IN_FRAME_RECEIVED_RATIO,
SCE_VOICE_QOS_HEARTBEAT_FLAG
};
s32 sceVoiceQoSInit()
{
throw __FUNCTION__;
}
s32 sceVoiceQoSEnd()
{
throw __FUNCTION__;
}
s32 sceVoiceQoSCreateLocalEndpoint(vm::psv::ptr<SceVoiceQoSLocalId> pLocalId)
{
throw __FUNCTION__;
}
s32 sceVoiceQoSDeleteLocalEndpoint(SceVoiceQoSLocalId localId)
{
throw __FUNCTION__;
}
s32 sceVoiceQoSCreateRemoteEndpoint(vm::psv::ptr<SceVoiceQoSRemoteId> pRemoteId)
{
throw __FUNCTION__;
}
s32 sceVoiceQoSDeleteRemoteEndpoint(SceVoiceQoSRemoteId remoteId)
{
throw __FUNCTION__;
}
s32 sceVoiceQoSConnect(vm::psv::ptr<SceVoiceQoSConnectionId> pConnectionId, SceVoiceQoSLocalId localId, SceVoiceQoSRemoteId remoteId)
{
throw __FUNCTION__;
}
s32 sceVoiceQoSDisconnect(SceVoiceQoSConnectionId connectionId)
{
throw __FUNCTION__;
}
s32 sceVoiceQoSGetLocalEndpoint(SceVoiceQoSConnectionId connectionId, vm::psv::ptr<SceVoiceQoSLocalId> pLocalId)
{
throw __FUNCTION__;
}
s32 sceVoiceQoSGetRemoteEndpoint(SceVoiceQoSConnectionId connectionId, vm::psv::ptr<SceVoiceQoSRemoteId> pRemoteId)
{
throw __FUNCTION__;
}
s32 sceVoiceQoSSetLocalEndpointAttribute(SceVoiceQoSLocalId localId, SceVoiceQoSAttributeId attributeId, vm::psv::ptr<const void> pAttributeValue, s32 attributeSize)
{
throw __FUNCTION__;
}
s32 sceVoiceQoSGetLocalEndpointAttribute(SceVoiceQoSLocalId localId, SceVoiceQoSAttributeId attributeId, vm::psv::ptr<void> pAttributeValue, s32 attributeSize)
{
throw __FUNCTION__;
}
s32 sceVoiceQoSSetConnectionAttribute(SceVoiceQoSConnectionId connectionId, SceVoiceQoSAttributeId attributeId, vm::psv::ptr<const void> pAttributeValue, s32 attributeSize)
{
throw __FUNCTION__;
}
s32 sceVoiceQoSGetConnectionAttribute(SceVoiceQoSConnectionId connectionId, SceVoiceQoSAttributeId attributeId, vm::psv::ptr<void> pAttributeValue, s32 attributeSize)
{
throw __FUNCTION__;
}
s32 sceVoiceQoSGetStatus(SceVoiceQoSConnectionId connectionId, SceVoiceQoSStatusId statusId, vm::psv::ptr<void> pStatusValue, s32 statusSize)
{
throw __FUNCTION__;
}
s32 sceVoiceQoSWritePacket(SceVoiceQoSConnectionId connectionId, vm::psv::ptr<const void> pData, vm::psv::ptr<u32> pSize)
{
throw __FUNCTION__;
}
s32 sceVoiceQoSReadPacket(SceVoiceQoSConnectionId connectionId, vm::psv::ptr<void> pData, vm::psv::ptr<u32> pSize)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceVoiceQoS, #name, name)
psv_log_base sceVoiceQoS("SceVoiceQos", []()
{
sceVoiceQoS.on_load = nullptr;
sceVoiceQoS.on_unload = nullptr;
sceVoiceQoS.on_stop = nullptr;
REG_FUNC(0x4B5FFF1C, sceVoiceQoSInit);
REG_FUNC(0xFB0B747B, sceVoiceQoSEnd);
REG_FUNC(0xAAB54BE4, sceVoiceQoSCreateLocalEndpoint);
REG_FUNC(0x68FABF6F, sceVoiceQoSDeleteLocalEndpoint);
REG_FUNC(0xBAB98727, sceVoiceQoSCreateRemoteEndpoint);
REG_FUNC(0xC2F2C771, sceVoiceQoSDeleteRemoteEndpoint);
REG_FUNC(0xE0C5CEEE, sceVoiceQoSConnect);
REG_FUNC(0x3C7A08B0, sceVoiceQoSDisconnect);
REG_FUNC(0xE5B4527D, sceVoiceQoSGetLocalEndpoint);
REG_FUNC(0x876A9B9C, sceVoiceQoSGetRemoteEndpoint);
REG_FUNC(0x540CEBA5, sceVoiceQoSSetLocalEndpointAttribute);
REG_FUNC(0xC981AB3B, sceVoiceQoSGetLocalEndpointAttribute);
REG_FUNC(0xE757806F, sceVoiceQoSSetConnectionAttribute);
REG_FUNC(0xE81B8D44, sceVoiceQoSGetConnectionAttribute);
REG_FUNC(0xC9DC1425, sceVoiceQoSGetStatus);
REG_FUNC(0x2FE1F28F, sceVoiceQoSWritePacket);
REG_FUNC(0x2D613549, sceVoiceQoSReadPacket);
});

201
rpcs3/Emu/ARMv7/Modules/sceXml.cpp Normal file
View File

@ -0,0 +1,201 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceXml;
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceXml, #name, name)
psv_log_base sceXml("SceXml", []()
{
sceXml.on_load = nullptr;
sceXml.on_unload = nullptr;
sceXml.on_stop = nullptr;
//REG_FUNC(0x57400A1A, _ZN3sce3Xml10SimpleDataC1EPKcj);
//REG_FUNC(0x7E582075, _ZN3sce3Xml10SimpleDataC1Ev);
//REG_FUNC(0x4CF0656B, _ZN3sce3Xml10SimpleDataC2EPKcj);
//REG_FUNC(0x95077028, _ZN3sce3Xml10SimpleDataC2Ev);
//REG_FUNC(0xECFA6A2A, _ZN3sce3Xml11Initializer10initializeEPKNS0_13InitParameterE);
//REG_FUNC(0x29824CD5, _ZN3sce3Xml11Initializer9terminateEv);
//REG_FUNC(0xBF13FDE6, _ZN3sce3Xml11InitializerC1Ev);
//REG_FUNC(0x94AAA71D, _ZN3sce3Xml11InitializerC2Ev);
//REG_FUNC(0xB4547C88, _ZN3sce3Xml11InitializerD1Ev);
//REG_FUNC(0xAAA08FA8, _ZN3sce3Xml11InitializerD2Ev);
//REG_FUNC(0x8D387E01, _ZN3sce3Xml12MemAllocatorC1Ev);
//REG_FUNC(0xE982E681, _ZN3sce3Xml12MemAllocatorC2Ev);
//REG_FUNC(0x90B82579, _ZN3sce3Xml12MemAllocatorD0Ev);
//REG_FUNC(0x56002B9D, _ZN3sce3Xml12MemAllocatorD1Ev);
//REG_FUNC(0x1BE022EA, _ZN3sce3Xml12MemAllocatorD2Ev);
//REG_FUNC(0x89AA847E, _ZN3sce3Xml13AttributeList10initializeEPKNS0_11InitializerE);
//REG_FUNC(0xD08EE434, _ZN3sce3Xml13AttributeList12addAttributeEPKNS0_6StringES4_);
//REG_FUNC(0xCCEE4E7C, _ZN3sce3Xml13AttributeList5clearEv);
//REG_FUNC(0x11FE5A65, _ZN3sce3Xml13AttributeList9terminateEv);
//REG_FUNC(0x9CBD82D4, _ZN3sce3Xml13AttributeListC1ERKS1_);
//REG_FUNC(0x542076D8, _ZN3sce3Xml13AttributeListC1Ev);
//REG_FUNC(0x87C89447, _ZN3sce3Xml13AttributeListC2ERKS1_);
//REG_FUNC(0x5D49542A, _ZN3sce3Xml13AttributeListC2Ev);
//REG_FUNC(0x38861841, _ZN3sce3Xml13AttributeListD1Ev);
//REG_FUNC(0x1B0B3976, _ZN3sce3Xml13AttributeListD2Ev);
//REG_FUNC(0x30520B78, _ZN3sce3Xml14VarAllocBuffer4copyEPKhjb);
//REG_FUNC(0x7D5A0041, _ZN3sce3Xml14VarAllocBuffer5clearEv);
//REG_FUNC(0xD95D3824, _ZN3sce3Xml14VarAllocBuffer7copyStrEPKcj);
//REG_FUNC(0xFE99676E, _ZN3sce3Xml14VarAllocBuffer7copyStrERKNS0_6StringE);
//REG_FUNC(0x82747F92, _ZN3sce3Xml14VarAllocBuffer7reserveEj);
//REG_FUNC(0xE93EACFC, _ZN3sce3Xml14VarAllocBuffer9terminateEv);
//REG_FUNC(0x8045D9C2, _ZN3sce3Xml14VarAllocBufferC1EPKNS0_11InitializerE);
//REG_FUNC(0xEF4FA027, _ZN3sce3Xml14VarAllocBufferC2EPKNS0_11InitializerE);
//REG_FUNC(0xD61CAAFC, _ZN3sce3Xml14VarAllocBufferD0Ev);
//REG_FUNC(0xD9217FC8, _ZN3sce3Xml14VarAllocBufferD1Ev);
//REG_FUNC(0x8A4B9379, _ZN3sce3Xml14VarAllocBufferD2Ev);
//REG_FUNC(0xB7770E5E, _ZN3sce3Xml18SerializeParameterC1Ev);
//REG_FUNC(0xF65270FC, _ZN3sce3Xml18SerializeParameterC2Ev);
//REG_FUNC(0x2CB61A7C, _ZN3sce3Xml20bXResultToResultTypeEi);
//REG_FUNC(0x59C5E9B2, _ZN3sce3Xml23getMemManagerDebugLevelEv);
//REG_FUNC(0xBA8B7374, _ZN3sce3Xml23setMemManagerDebugLevelEi);
//REG_FUNC(0xBBACFE87, _ZN3sce3Xml3Dom15DocumentBuilder10initializeEPKNS0_11InitializerE);
//REG_FUNC(0x1A29526B, _ZN3sce3Xml3Dom15DocumentBuilder11getDocumentEv);
//REG_FUNC(0xA2431C2B, _ZN3sce3Xml3Dom15DocumentBuilder16setResolveEntityEb);
//REG_FUNC(0xB8C4D13C, _ZN3sce3Xml3Dom15DocumentBuilder20setSkipIgnorableTextEb);
//REG_FUNC(0xF351D753, _ZN3sce3Xml3Dom15DocumentBuilder26setSkipIgnorableWhiteSpaceEb);
//REG_FUNC(0x7744DD14, _ZN3sce3Xml3Dom15DocumentBuilder5parseEPKNS0_6StringEb);
//REG_FUNC(0x42D59053, _ZN3sce3Xml3Dom15DocumentBuilder9terminateEv);
//REG_FUNC(0x702492EA, _ZN3sce3Xml3Dom15DocumentBuilderC1Ev);
//REG_FUNC(0x36F6BDF2, _ZN3sce3Xml3Dom15DocumentBuilderC2Ev);
//REG_FUNC(0x79C9322E, _ZN3sce3Xml3Dom15DocumentBuilderD0Ev);
//REG_FUNC(0x19D0E024, _ZN3sce3Xml3Dom15DocumentBuilderD1Ev);
//REG_FUNC(0x99C58389, _ZN3sce3Xml3Dom15DocumentBuilderD2Ev);
//REG_FUNC(0x3CA958D3, _ZN3sce3Xml3Dom4Node11removeChildEy);
//REG_FUNC(0x1B98BDBE, _ZN3sce3Xml3Dom4Node12insertBeforeEyy);
//REG_FUNC(0x26BA1E6E, _ZNK3sce3Xml3Dom4Node13hasAttributesEv);
//REG_FUNC(0xC6F4F6A8, _ZN3sce3Xml3Dom4Node13hasChildNodesEv);
//REG_FUNC(0x088C100E, _ZN3sce3Xml3Dom4NodeC1Ey);
//REG_FUNC(0x44CAF9E1, _ZN3sce3Xml3Dom4NodeC2Ey);
//REG_FUNC(0x8F2EB967, _ZN3sce3Xml3Dom4NodeD1Ev);
//REG_FUNC(0x241EFC0E, _ZN3sce3Xml3Dom4NodeD2Ev);
//REG_FUNC(0x6A16C2FF, _ZN3sce3Xml3Dom8Document10importNodeEyyPKS2_y);
//REG_FUNC(0xB4A33B78, _ZN3sce3Xml3Dom8Document10initializeEPKNS0_11InitializerE);
//REG_FUNC(0x18686B94, _ZN3sce3Xml3Dom8Document10insertNodeEyyy);
//REG_FUNC(0x49263CE5, _ZN3sce3Xml3Dom8Document11removeChildEyy);
//REG_FUNC(0xD945184A, _ZN3sce3Xml3Dom8Document11resetStatusEv);
//REG_FUNC(0x7B0A8F6C, _ZN3sce3Xml3Dom8Document11setWritableEv);
//REG_FUNC(0x0CBC1C3F, _ZN3sce3Xml3Dom8Document12importParentEPKS2_y);
//REG_FUNC(0x016A9ADB, _ZN3sce3Xml3Dom8Document12setAttrValueEyPKNS0_6StringES5_);
//REG_FUNC(0xEA19C7CF, _ZN3sce3Xml3Dom8Document12setAttributeEyPKNS0_6StringES5_);
//REG_FUNC(0x35C50B8B, _ZN3sce3Xml3Dom8Document13createElementEPKNS0_6StringEPKNS0_13AttributeListES5_);
//REG_FUNC(0xBCA5E62A, _ZN3sce3Xml3Dom8Document13recurseDeleteEy);
//REG_FUNC(0x8D19723F, _ZN3sce3Xml3Dom8Document14createTextNodeEPKNS0_6StringE);
//REG_FUNC(0x6220E98B, _ZN3sce3Xml3Dom8Document15addElementChildEyPKNS0_6StringEPKNS0_13AttributeListES5_);
//REG_FUNC(0xF1DB18B1, _ZN3sce3Xml3Dom8Document15removeAttributeEyPKNS0_6StringE);
//REG_FUNC(0x779036AB, _ZN3sce3Xml3Dom8Document16removeAttributesEy);
//REG_FUNC(0x0667B08D, _ZN3sce3Xml3Dom8Document16setAttributeListEyPKNS0_13AttributeListE);
//REG_FUNC(0xD2BFBC47, _ZNK3sce3Xml3Dom8Document20getElementsByTagNameEyPKNS0_6StringEPNS1_8NodeListE);
//REG_FUNC(0xDEFEAFD2, _ZN3sce3Xml3Dom8Document7setTextEyPKNS0_6StringE);
//REG_FUNC(0x87F8B4DA, _ZN3sce3Xml3Dom8Document9serializeEPKNS0_18SerializeParameterEPNS0_6StringE);
//REG_FUNC(0x4B7321FB, _ZN3sce3Xml3Dom8Document9terminateEv);
//REG_FUNC(0x1DD41C7A, _ZN3sce3Xml3Dom8DocumentC1ERKS2_);
//REG_FUNC(0x7B7107AD, _ZN3sce3Xml3Dom8DocumentC1Ev);
//REG_FUNC(0xF399F763, _ZN3sce3Xml3Dom8DocumentC2ERKS2_);
//REG_FUNC(0xE6BA9C73, _ZN3sce3Xml3Dom8DocumentC2Ev);
//REG_FUNC(0xFB207925, _ZN3sce3Xml3Dom8DocumentD1Ev);
//REG_FUNC(0x11A5F0A3, _ZN3sce3Xml3Dom8DocumentD2Ev);
//REG_FUNC(0xD622A7FE, _ZN3sce3Xml3Dom8DocumentaSERKS2_);
//REG_FUNC(0x860CC706, _ZN3sce3Xml3Dom8NodeList10initializeEPKNS0_11InitializerE);
//REG_FUNC(0x7A889374, _ZN3sce3Xml3Dom8NodeList10insertLastEy);
//REG_FUNC(0xE9995F58, _ZN3sce3Xml3Dom8NodeList10removeItemEy);
//REG_FUNC(0xFA921C6E, _ZN3sce3Xml3Dom8NodeList11insertFirstEy);
//REG_FUNC(0xCDD1D418, _ZNK3sce3Xml3Dom8NodeList4itemEj);
//REG_FUNC(0x508E9150, _ZN3sce3Xml3Dom8NodeList5clearEv);
//REG_FUNC(0xA41ED241, _ZNK3sce3Xml3Dom8NodeList8findItemEPKNS0_6StringE);
//REG_FUNC(0xE1AB441D, _ZNK3sce3Xml3Dom8NodeList8findItemEy);
//REG_FUNC(0xFB9EDBF9, _ZNK3sce3Xml3Dom8NodeList9getLengthEv);
//REG_FUNC(0x32B396AD, _ZN3sce3Xml3Dom8NodeList9terminateEv);
//REG_FUNC(0xB1CA0E34, _ZN3sce3Xml3Dom8NodeListC1ERKS2_);
//REG_FUNC(0x0580C02E, _ZN3sce3Xml3Dom8NodeListC1Ev);
//REG_FUNC(0xB97BF737, _ZN3sce3Xml3Dom8NodeListC2ERKS2_);
//REG_FUNC(0x684E57B9, _ZN3sce3Xml3Dom8NodeListC2Ev);
//REG_FUNC(0x92EBC9F8, _ZN3sce3Xml3Dom8NodeListD1Ev);
//REG_FUNC(0x2DF80037, _ZN3sce3Xml3Dom8NodeListD2Ev);
//REG_FUNC(0xBAD4AAFA, _ZNK3sce3Xml3Dom8NodeListixEj);
//REG_FUNC(0x874C8331, _ZN3sce3Xml3Sax6Parser10initializeEPKNS0_11InitializerE);
//REG_FUNC(0x4DB998E6, _ZN3sce3Xml3Sax6Parser11setUserDataEPv);
//REG_FUNC(0xB77BF8A0, _ZN3sce3Xml3Sax6Parser16setResolveEntityEb);
//REG_FUNC(0x1B2442A0, _ZN3sce3Xml3Sax6Parser18setDocumentHandlerEPNS1_15DocumentHandlerE);
//REG_FUNC(0xCE1DAE23, _ZN3sce3Xml3Sax6Parser26setSkipIgnorableWhiteSpaceEb);
//REG_FUNC(0x70D9FC8E, _ZN3sce3Xml3Sax6Parser5parseEPKNS0_6StringEb);
//REG_FUNC(0xA2B40FA7, _ZN3sce3Xml3Sax6Parser5resetEv);
//REG_FUNC(0xF2C8950D, _ZN3sce3Xml3Sax6Parser9terminateEv);
//REG_FUNC(0x60BF9988, _ZN3sce3Xml3Sax6ParserC1Ev);
//REG_FUNC(0x56390CA0, _ZN3sce3Xml3Sax6ParserC2Ev);
//REG_FUNC(0xA11C2AED, _ZN3sce3Xml3Sax6ParserD1Ev);
//REG_FUNC(0x02E8F7FA, _ZN3sce3Xml3Sax6ParserD2Ev);
//REG_FUNC(0xE5314387, _ZN3sce3Xml4Attr10initializeEPKNS0_11InitializerE);
//REG_FUNC(0x66D1B605, _ZN3sce3Xml4Attr7setNameEPKNS0_6StringE);
//REG_FUNC(0x7DD3059D, _ZN3sce3Xml4Attr8setValueEPKNS0_6StringE);
//REG_FUNC(0x67E0DF2B, _ZN3sce3Xml4Attr9terminateEv);
//REG_FUNC(0xC09ABF87, _ZN3sce3Xml4AttrC1ERKS1_);
//REG_FUNC(0xD016F1BC, _ZN3sce3Xml4AttrC1Ev);
//REG_FUNC(0xB4851BEC, _ZN3sce3Xml4AttrC2ERKS1_);
//REG_FUNC(0x0B3AE81B, _ZN3sce3Xml4AttrC2Ev);
//REG_FUNC(0x58E349A5, _ZN3sce3Xml4AttrD1Ev);
//REG_FUNC(0xB9E6F81A, _ZN3sce3Xml4AttrD2Ev);
//REG_FUNC(0xA5B902D4, _ZN3sce3Xml4AttraSERKS1_);
//REG_FUNC(0xA7E983E2, _ZN3sce3Xml4Util9strResultEi);
//REG_FUNC(0x035F013B, _ZN3sce3Xml6StringC1EPKc);
//REG_FUNC(0x0B5461E0, _ZN3sce3Xml6StringC1EPKcj);
//REG_FUNC(0x67191CC6, _ZN3sce3Xml6StringC1ERKS1_);
//REG_FUNC(0xA17502C1, _ZN3sce3Xml6StringC1Ev);
//REG_FUNC(0xECC1F1A4, _ZN3sce3Xml6StringC2EPKc);
//REG_FUNC(0x457CCE55, _ZN3sce3Xml6StringC2EPKcj);
//REG_FUNC(0xD785BA85, _ZN3sce3Xml6StringC2ERKS1_);
//REG_FUNC(0x8816F7EF, _ZN3sce3Xml6StringC2Ev);
//REG_FUNC(0x18758863, _ZN3sce3Xml6StringaSERKS1_);
//REG_FUNC(0x4F30F0CC, _ZNK3sce3Xml13AttributeList12getAttributeEPKNS0_6StringE);
//REG_FUNC(0x5ED0B2F9, _ZNK3sce3Xml13AttributeList12getAttributeEj);
//REG_FUNC(0x38AEB52E, _ZNK3sce3Xml13AttributeList9getLengthEv);
//REG_FUNC(0xEC96BFC6, _ZNK3sce3Xml3Dom13DocumentDebug13getStructSizeEv);
//REG_FUNC(0xE1100FC0, _ZNK3sce3Xml3Dom13DocumentDebug16getAttrTableSizeEv);
//REG_FUNC(0x6E1F1FFB, _ZNK3sce3Xml3Dom13DocumentDebug16getCharTableSizeEv);
//REG_FUNC(0x8F9CEE10, _ZNK3sce3Xml3Dom13DocumentDebug19getElementTableSizeEv);
//REG_FUNC(0xE1269956, _ZNK3sce3Xml3Dom4Node11getNodeNameEv);
//REG_FUNC(0xCED5E0FF, _ZNK3sce3Xml3Dom4Node11getNodeTypeEv);
//REG_FUNC(0x4F2D5541, _ZNK3sce3Xml3Dom4Node12getNodeValueEv);
//REG_FUNC(0xB405A149, _ZNK3sce3Xml3Dom4Node13getAttributesEv);
//REG_FUNC(0x117BEA8A, _ZNK3sce3Xml3Dom4Node13getChildNodesEv);
//REG_FUNC(0x639D219C, _ZNK3sce3Xml3Dom4Node13getFirstChildEv);
//REG_FUNC(0x3FD63FB8, _ZNK3sce3Xml3Dom4Node12getLastChildEv);
//REG_FUNC(0x1A46C0E1, _ZNK3sce3Xml3Dom4Node14getNextSiblingEv);
//REG_FUNC(0xD9757BC8, _ZNK3sce3Xml3Dom4Node14getParenetNodeEv);
//REG_FUNC(0x3E8122AB, _ZNK3sce3Xml3Dom4Node16getOwnerDocumentEv);
//REG_FUNC(0x22DBB221, _ZNK3sce3Xml3Dom8Document10getDocRootEv);
//REG_FUNC(0xE3D0A78A, _ZNK3sce3Xml3Dom8Document10getSiblingEy);
//REG_FUNC(0x2D370226, _ZNK3sce3Xml3Dom8Document10getXmlMetaEv);
//REG_FUNC(0xA4D99D40, _ZNK3sce3Xml3Dom8Document10isReadOnlyEv);
//REG_FUNC(0xCD65B91F, _ZNK3sce3Xml3Dom8Document11getAttrNameEy);
//REG_FUNC(0x883E1BFC, _ZNK3sce3Xml3Dom8Document11getNextAttrEy);
//REG_FUNC(0x471A22E8, _ZNK3sce3Xml3Dom8Document11getNodeNameEy);
//REG_FUNC(0x62D3CB44, _ZNK3sce3Xml3Dom8Document11getNodeTypeEy);
//REG_FUNC(0x28FD79E3, _ZNK3sce3Xml3Dom8Document11isAvailableEv);
//REG_FUNC(0x7C6A03FD, _ZNK3sce3Xml3Dom8Document12getAttrValueEy);
//REG_FUNC(0x9531C3CD, _ZNK3sce3Xml3Dom8Document12getAttributeEyPKNS0_6StringE);
//REG_FUNC(0xEC856072, _ZNK3sce3Xml3Dom8Document12getFirstAttrEy);
//REG_FUNC(0xFBCF0D3E, _ZNK3sce3Xml3Dom8Document12getLastChildEy);
//REG_FUNC(0xCDEC3F43, _ZNK3sce3Xml3Dom8Document13getAttributesEyPNS1_8NodeListE);
//REG_FUNC(0xFC61FDF1, _ZNK3sce3Xml3Dom8Document13getChildNodesEyPNS1_8NodeListE);
//REG_FUNC(0xDAC75E49, _ZNK3sce3Xml3Dom8Document13getEntityTypeEy);
//REG_FUNC(0xEA805296, _ZNK3sce3Xml3Dom8Document13hasAttributesEy);
//REG_FUNC(0xC5E7431A, _ZNK3sce3Xml3Dom8Document13hasChildNodesEy);
//REG_FUNC(0x0C1DDEC5, _ZNK3sce3Xml3Dom8Document14getSkippedTextEy);
//REG_FUNC(0xB34D9672, _ZNK3sce3Xml3Dom8Document7getRootEv);
//REG_FUNC(0x36ACFF5E, _ZNK3sce3Xml3Dom8Document7getTextEy);
//REG_FUNC(0x3028E05D, _ZNK3sce3Xml3Dom8Document13getFirstChildEy);
//REG_FUNC(0x161BA85E, _ZNK3sce3Xml3Dom8Document9getEntityEy);
//REG_FUNC(0xA98B5758, _ZNK3sce3Xml3Dom8Document9getParentEy);
//REG_FUNC(0xD428753A, _ZNK3sce3Xml3Dom8Document9getStatusEv);
//REG_FUNC(0x10530611, _ZNK3sce3Xml3Dom8NodeList11isAvailableEv);
//REG_FUNC(0x35134B85, _ZNK3sce3Xml4Attr7getNameEv);
//REG_FUNC(0x7834A2F7, _ZNK3sce3Xml4Attr8getValueEv);
//REG_FUNC(0x0D119AB3, _ZNK3sce3Xml3Dom4Node11isAvailableEv);
//REG_FUNC(0x1633846D, _ZNK3sce3Xml4Attr11isAvailableEv);
//REG_FUNC(0x58854322, _ZNK3sce3Xml13AttributeList11isAvailableEv);
});

198
rpcs3/Emu/ARMv7/PSVFuncList.cpp
View File

@ -1,29 +1,12 @@
#include "stdafx.h"
#include <unordered_map>
#include "Utilities/Log.h"
#include "Emu/System.h"
#include "ARMv7Thread.h"
#include "PSVFuncList.h"
std::vector<psv_func> g_psv_func_list;
std::vector<psv_log_base*> g_psv_modules;
void add_psv_func(psv_func& data)
{
// setup special functions (without NIDs)
if (!g_psv_func_list.size())
{
psv_func unimplemented;
unimplemented.nid = 0;
unimplemented.name = "Special function (unimplemented stub)";
unimplemented.func.reset(new psv_func_detail::func_binder<void, ARMv7Thread&>([](ARMv7Thread& CPU){ CPU.m_last_syscall = vm::psv::read32(CPU.PC + 4); throw "Unimplemented function executed"; }));
g_psv_func_list.push_back(unimplemented);
psv_func hle_return;
hle_return.nid = 1;
hle_return.name = "Special function (return from HLE)";
hle_return.func.reset(new psv_func_detail::func_binder<void, ARMv7Thread&>([](ARMv7Thread& CPU){ CPU.FastStop(); }));
g_psv_func_list.push_back(hle_return);
}
g_psv_func_list.push_back(data);
}
@ -49,27 +32,182 @@ u32 get_psv_func_index(psv_func* func)
return (u32)res;
}
void execute_psv_func_by_index(ARMv7Thread& CPU, u32 index)
void execute_psv_func_by_index(ARMv7Context& context, u32 index)
{
assert(index < g_psv_func_list.size());
auto old_last_syscall = CPU.m_last_syscall;
CPU.m_last_syscall = g_psv_func_list[index].nid;
auto old_last_syscall = context.thread.m_last_syscall;
context.thread.m_last_syscall = g_psv_func_list[index].nid;
(*g_psv_func_list[index].func)(CPU);
(*g_psv_func_list[index].func)(context);
CPU.m_last_syscall = old_last_syscall;
context.thread.m_last_syscall = old_last_syscall;
}
extern psv_log_base sceAppMgr;
extern psv_log_base sceAppUtil;
extern psv_log_base sceAudio;
extern psv_log_base sceAudiodec;
extern psv_log_base sceAudioenc;
extern psv_log_base sceAudioIn;
extern psv_log_base sceCamera;
extern psv_log_base sceCodecEngine;
extern psv_log_base sceCommonDialog;
extern psv_log_base sceCtrl;
extern psv_log_base sceDbg;
extern psv_log_base sceDeci4p;
extern psv_log_base sceDeflt;
extern psv_log_base sceDisplay;
extern psv_log_base sceFiber;
extern psv_log_base sceFios;
extern psv_log_base sceFpu;
extern psv_log_base sceGxm;
extern psv_log_base sceHttp;
extern psv_log_base sceIme;
extern psv_log_base sceJpeg;
extern psv_log_base sceJpegEnc;
extern psv_log_base sceLibc;
extern psv_log_base sceLibKernel;
extern psv_log_base sceLibm;
extern psv_log_base sceLibstdcxx;
extern psv_log_base sceLibKernel;
extern psv_log_base sceLiveArea;
extern psv_log_base sceLocation;
extern psv_log_base sceMd5;
extern psv_log_base sceMotion;
extern psv_log_base sceMt19937;
extern psv_log_base sceNet;
extern psv_log_base sceNetCtl;
extern psv_log_base sceNgs;
extern psv_log_base sceNpBasic;
extern psv_log_base sceNpCommon;
extern psv_log_base sceNpManager;
extern psv_log_base sceNpMatching;
extern psv_log_base sceNpScore;
extern psv_log_base sceNpUtility;
extern psv_log_base scePerf;
extern psv_log_base scePgf;
extern psv_log_base scePhotoExport;
extern psv_log_base sceRazorCapture;
extern psv_log_base sceRtc;
extern psv_log_base sceSas;
extern psv_log_base sceScreenShot;
extern psv_log_base sceSfmt;
extern psv_log_base sceSha;
extern psv_log_base sceSqlite;
extern psv_log_base sceSsl;
extern psv_log_base sceSulpha;
extern psv_log_base sceSysmodule;
extern psv_log_base sceSystemGesture;
extern psv_log_base sceTouch;
extern psv_log_base sceUlt;
extern psv_log_base sceVideodec;
extern psv_log_base sceVoice;
extern psv_log_base sceVoiceQoS;
extern psv_log_base sceXml;
void list_known_psv_modules()
void initialize_psv_modules()
{
sceLibc.Log("");
sceLibm.Log("");
sceLibstdcxx.Log("");
sceLibKernel.Log("");
assert(!g_psv_func_list.size() && !g_psv_modules.size());
// fill module list
g_psv_modules.push_back(&sceAppMgr);
g_psv_modules.push_back(&sceAppUtil);
g_psv_modules.push_back(&sceAudio);
g_psv_modules.push_back(&sceAudiodec);
g_psv_modules.push_back(&sceAudioenc);
g_psv_modules.push_back(&sceAudioIn);
g_psv_modules.push_back(&sceCamera);
g_psv_modules.push_back(&sceCodecEngine);
g_psv_modules.push_back(&sceCommonDialog);
g_psv_modules.push_back(&sceCtrl);
g_psv_modules.push_back(&sceDbg);
g_psv_modules.push_back(&sceDeci4p);
g_psv_modules.push_back(&sceDeflt);
g_psv_modules.push_back(&sceDisplay);
g_psv_modules.push_back(&sceFiber);
g_psv_modules.push_back(&sceFios);
g_psv_modules.push_back(&sceFpu);
g_psv_modules.push_back(&sceGxm);
g_psv_modules.push_back(&sceHttp);
g_psv_modules.push_back(&sceIme);
g_psv_modules.push_back(&sceJpeg);
g_psv_modules.push_back(&sceJpegEnc);
g_psv_modules.push_back(&sceLibc);
g_psv_modules.push_back(&sceLibKernel);
g_psv_modules.push_back(&sceLibm);
g_psv_modules.push_back(&sceLibstdcxx);
g_psv_modules.push_back(&sceLiveArea);
g_psv_modules.push_back(&sceLocation);
g_psv_modules.push_back(&sceMd5);
g_psv_modules.push_back(&sceMotion);
g_psv_modules.push_back(&sceMt19937);
g_psv_modules.push_back(&sceNet);
g_psv_modules.push_back(&sceNetCtl);
g_psv_modules.push_back(&sceNgs);
g_psv_modules.push_back(&sceNpBasic);
g_psv_modules.push_back(&sceNpCommon);
g_psv_modules.push_back(&sceNpManager);
g_psv_modules.push_back(&sceNpMatching);
g_psv_modules.push_back(&sceNpScore);
g_psv_modules.push_back(&sceNpUtility);
g_psv_modules.push_back(&scePerf);
g_psv_modules.push_back(&scePgf);
g_psv_modules.push_back(&scePhotoExport);
g_psv_modules.push_back(&sceRazorCapture);
g_psv_modules.push_back(&sceRtc);
g_psv_modules.push_back(&sceSas);
g_psv_modules.push_back(&sceScreenShot);
g_psv_modules.push_back(&sceSfmt);
g_psv_modules.push_back(&sceSha);
g_psv_modules.push_back(&sceSqlite);
g_psv_modules.push_back(&sceSsl);
g_psv_modules.push_back(&sceSulpha);
g_psv_modules.push_back(&sceSysmodule);
g_psv_modules.push_back(&sceSystemGesture);
g_psv_modules.push_back(&sceTouch);
g_psv_modules.push_back(&sceUlt);
g_psv_modules.push_back(&sceVideodec);
g_psv_modules.push_back(&sceVoice);
g_psv_modules.push_back(&sceVoiceQoS);
g_psv_modules.push_back(&sceXml);
// setup special functions (without NIDs)
psv_func unimplemented;
unimplemented.nid = 0;
unimplemented.name = "Special function (unimplemented stub)";
unimplemented.func.reset(new psv_func_detail::func_binder<void, ARMv7Context&>([](ARMv7Context& context)
{
context.thread.m_last_syscall = vm::psv::read32(context.thread.PC + 4);
throw "Unimplemented function";
}));
g_psv_func_list.push_back(unimplemented);
psv_func hle_return;
hle_return.nid = 1;
hle_return.name = "Special function (return from HLE)";
hle_return.func.reset(new psv_func_detail::func_binder<void, ARMv7Context&>([](ARMv7Context& context)
{
context.thread.FastStop();
}));
g_psv_func_list.push_back(hle_return);
// load functions
for (auto module : g_psv_modules)
{
module->Init();
}
}
void finalize_psv_modules()
{
for (auto module : g_psv_modules)
{
if (module->on_stop)
{
module->on_stop();
}
}
g_psv_func_list.clear();
g_psv_modules.clear();
}

870
rpcs3/Emu/ARMv7/PSVFuncList.h
View File

File diff suppressed because it is too large Load Diff

16
rpcs3/Emu/ARMv7/PSVObjectList.cpp Normal file
View File

@ -0,0 +1,16 @@
#include "stdafx.h"
#include "Emu/Memory/Memory.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "Emu/ARMv7/PSVObjectList.h"
#include "Modules/sceLibKernel.h"
#include "Modules/psv_sema.h"
#include "Modules/psv_event_flag.h"
psv_object_list_t<psv_sema_t, SCE_KERNEL_THREADMGR_UID_CLASS_SEMA> g_psv_sema_list;
psv_object_list_t<psv_event_flag_t, SCE_KERNEL_THREADMGR_UID_CLASS_EVENT_FLAG> g_psv_ef_list;
void clear_all_psv_objects()
{
g_psv_sema_list.clear();
g_psv_ef_list.clear();
}

109
rpcs3/Emu/ARMv7/PSVObjectList.h Normal file
View File

@ -0,0 +1,109 @@
#pragma once
union psv_uid_t
{
// true UID format is partially unknown
s32 uid;
struct
{
u32 oddness : 1; // always 1 for UIDs (to not mess it up with addresses)
u32 number : 15; // ID from 0 to 2^15-1
u32 type : 15; // UID class (psv_object_class_t)
u32 sign : 1; // UIDs are positive, error codes are negative
};
static psv_uid_t make(s32 uid)
{
psv_uid_t result;
result.uid = uid;
return result;
}
};
template<typename T, u32 type>
class psv_object_list_t // Class for managing object data
{
std::array<std::shared_ptr<T>, 0x8000> m_data;
std::mutex m_mutex; // TODO: remove it when shared_ptr atomic ops are fully available
public:
static const u32 uid_class = type;
// check if UID is potentially valid (will return true if the object doesn't exist)
bool check(s32 uid)
{
const psv_uid_t id = psv_uid_t::make(uid);
// check sign bit, uid class and ensure that value is odd
return !id.sign && id.type == uid_class && id.oddness == 1;
}
// share object with UID specified (will return empty pointer if the object doesn't exist or the UID is invalid)
std::shared_ptr<T> find(s32 uid)
{
if (!check(uid))
{
return nullptr;
}
return m_data[psv_uid_t::make(uid).number];
}
std::shared_ptr<T> operator [](s32 uid)
{
return find(uid);
}
// generate UID for newly created object (will return zero if the limit exceeded)
s32 add(std::shared_ptr<T>& data)
{
std::lock_guard<std::mutex> lock(m_mutex);
for (auto& value : m_data)
{
// find an empty position and move the pointer
//std::shared_ptr<T> old_ptr = nullptr;
//if (std::atomic_compare_exchange_strong(&value, &old_ptr, data))
if (!value)
{
value = data;
psv_uid_t id = psv_uid_t::make(1); // odd number
id.type = uid_class; // set type
id.number = &value - m_data.data(); // set position
return id.uid;
}
}
return 0;
}
// remove object with UID specified and share it for the last time (will return empty pointer if the object doesn't exists or the UID is invalid)
std::shared_ptr<T> remove(s32 uid)
{
if (!check(uid))
{
return nullptr;
}
std::lock_guard<std::mutex> lock(m_mutex);
std::shared_ptr<T> old_ptr = nullptr;
m_data[psv_uid_t::make(uid).number].swap(old_ptr);
return old_ptr;
//return std::atomic_exchange<std::shared_ptr<T>>(&m_data[psv_uid_t::make(uid).number], nullptr);
}
// remove all objects
void clear()
{
std::lock_guard<std::mutex> lock(m_mutex);
for (auto& value : m_data)
{
value = nullptr;
}
}
};
void clear_all_psv_objects();

4
rpcs3/Emu/Audio/XAudio2/XAudio2Thread.cpp
View File

@ -15,7 +15,7 @@ void XAudio2Thread::Init()
{
HRESULT hr = S_OK;
#if (_WIN32_WINNT < 0x0602)
#if (FORCED_WINVER < 0x0602)
hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
if (FAILED(hr))
{
@ -53,7 +53,7 @@ void XAudio2Thread::Quit()
m_xaudio2_instance->Release();
m_xaudio2_instance = nullptr;
#if (_WIN32_WINNT < 0x0602)
#if (FORCED_WINVER < 0x0602)
CoUninitialize();
#endif
}

Some files were not shown because too many files have changed in this diff Show More