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

Merge pull request #1019 from Nekotekina/master 

Some cleanup, HLE calls simplified
This commit is contained in:
B1ackDaemon 2015-02-21 18:06:45 +02:00
parent 67c02274cb 55b348f4fc
commit bdad5ef745
90 changed files with 2793 additions and 2904 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
Utilities/Thread.cpp
View File

@ -562,9 +562,27 @@ bool get_x64_reg_value(x64_context* context, x64_reg_t reg, size_t d_size, size_
out_value = (u8)(*X64REG(context, reg - X64R_AH) >> 8); out_value = (u8)(*X64REG(context, reg - X64R_AH) >> 8);
return true; return true;
} }
else if (reg == X64_IMM32) else if (reg == X64_IMM8)
{ {
// load the immediate value (assuming it's at the end of the instruction) // load the immediate value (assuming it's at the end of the instruction)
const s8 imm_value = *(s8*)(RIP(context) + i_size - 1);
switch (d_size)
{
case 1: out_value = (u8)imm_value; return true;
}
}
else if (reg == X64_IMM16)
{
const s16 imm_value = *(s16*)(RIP(context) + i_size - 2);
switch (d_size)
{
case 2: out_value = (u16)imm_value; return true;
}
}
else if (reg == X64_IMM32)
{
const s32 imm_value = *(s32*)(RIP(context) + i_size - 4); const s32 imm_value = *(s32*)(RIP(context) + i_size - 4);
switch (d_size) switch (d_size)
@ -573,18 +591,6 @@ bool get_x64_reg_value(x64_context* context, x64_reg_t reg, size_t d_size, size_
case 8: out_value = (u64)imm_value; return true; // sign-extended case 8: out_value = (u64)imm_value; return true; // sign-extended
} }
} }
else if (reg == X64_IMM16)
{
// load the immediate value (assuming it's at the end of the instruction)
out_value = *(s16*)(RIP(context) + i_size - 2);
return true;
}
else if (reg == X64_IMM8)
{
// load the immediate value (assuming it's at the end of the instruction)
out_value = *(s8*)(RIP(context) + i_size - 1);
return true;
}
else if (reg == X64R_ECX) else if (reg == X64R_ECX)
{ {
out_value = (u32)RCX(context); out_value = (u32)RCX(context);

6
rpcs3/Emu/ARMv7/ARMv7Context.h
View File

@ -174,6 +174,12 @@ struct ARMv7Context
return get_stack_arg(g_count++); return get_stack_arg(g_count++);
} }
} }
template<typename... T>
__noinline void fmt_debug_str(const char* fmt, T... args)
{
debug_str = fmt::format(fmt, args...);
}
}; };
template<typename T, bool is_enum = std::is_enum<T>::value> template<typename T, bool is_enum = std::is_enum<T>::value>

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

@ -294,7 +294,7 @@ namespace ARMv7_instrs
context.debug_str.insert(pos, 8 - pos, ' '); context.debug_str.insert(pos, 8 - pos, ' ');
} }
context.debug_str = fmt::format("0x%08x: %s", context.thread.PC, context.debug_str); context.fmt_debug_str("0x%08x: %s", context.thread.PC, context.debug_str);
LV2_LOCK(0); LV2_LOCK(0);
@ -530,16 +530,16 @@ void ARMv7_instrs::HACK(ARMv7Context& context, const ARMv7Code code, const ARMv7
{ {
if (func->func) if (func->func)
{ {
context.debug_str = fmt::format("hack%s %s", fmt_cond(cond), func->name); context.fmt_debug_str("hack%s %s", fmt_cond(cond), func->name);
} }
else else
{ {
context.debug_str = fmt::format("hack%s UNIMPLEMENTED:0x%08X (%s)", fmt_cond(cond), func->nid, func->name); context.fmt_debug_str("hack%s UNIMPLEMENTED:0x%08X (%s)", fmt_cond(cond), func->nid, func->name);
} }
} }
else else
{ {
context.debug_str = fmt::format("hack%s %d", fmt_cond(cond), index); context.fmt_debug_str("hack%s %d", fmt_cond(cond), index);
} }
} }
if (process_debug(context)) return; if (process_debug(context)) return;
@ -575,9 +575,14 @@ void ARMv7_instrs::MRC_(ARMv7Context& context, const ARMv7Code code, const ARMv7
default: throw __FUNCTION__; default: throw __FUNCTION__;
} }
auto disasm = [&]()
{
context.fmt_debug_str("mrc%s p%d,%d,r%d,c%d,c%d,%d", fmt_cond(cond), cp, opc1, t, cn, cm, opc2);
};
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("mrc%s p%d,%d,r%d,c%d,c%d,%d", fmt_cond(cond), cp, opc1, t, cn, cm, opc2); if (context.debug & DF_DISASM) disasm();
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -598,7 +603,7 @@ void ARMv7_instrs::MRC_(ARMv7Context& context, const ARMv7Code code, const ARMv7
return; return;
} }
throw fmt::format("Bad instruction: mrc%s p%d,%d,r%d,c%d,c%d,%d", fmt_cond(cond), cp, opc1, t, cn, cm, opc2); Error(__FUNCTION__, code, type, (disasm(), context.debug_str.c_str()), "Bad instruction");
} }
} }
@ -626,7 +631,7 @@ void ARMv7_instrs::ADC_IMM(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("adc%s%s %s,%s,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), imm32); if (context.debug & DF_DISASM) context.fmt_debug_str("adc%s%s %s,%s,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), imm32);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -680,7 +685,7 @@ void ARMv7_instrs::ADC_REG(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("adc%s%s %s,%s,%s%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), fmt_reg(m), fmt_shift(shift_t, shift_n)); if (context.debug & DF_DISASM) context.fmt_debug_str("adc%s%s %s,%s,%s%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), fmt_reg(m), fmt_shift(shift_t, shift_n));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -765,7 +770,7 @@ void ARMv7_instrs::ADD_IMM(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("add%s%s %s,%s,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), imm32); if (context.debug & DF_DISASM) context.fmt_debug_str("add%s%s %s,%s,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), imm32);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -836,7 +841,7 @@ void ARMv7_instrs::ADD_REG(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("add%s%s %s,%s,%s%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), fmt_reg(m), fmt_shift(shift_t, shift_n)); if (context.debug & DF_DISASM) context.fmt_debug_str("add%s%s %s,%s,%s%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), fmt_reg(m), fmt_shift(shift_t, shift_n));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -916,7 +921,7 @@ void ARMv7_instrs::ADD_SPI(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("add%s%s %s,sp,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), imm32); if (context.debug & DF_DISASM) context.fmt_debug_str("add%s%s %s,sp,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), imm32);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -982,7 +987,7 @@ void ARMv7_instrs::ADD_SPR(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("add%s%s %s,sp,%s%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(m), fmt_shift(shift_t, shift_n)); if (context.debug & DF_DISASM) context.fmt_debug_str("add%s%s %s,sp,%s%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(m), fmt_shift(shift_t, shift_n));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -1048,7 +1053,7 @@ void ARMv7_instrs::ADR(ARMv7Context& context, const ARMv7Code code, const ARMv7_
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("adr%s r%d, 0x%08X", fmt_cond(cond), d, result); if (context.debug & DF_DISASM) context.fmt_debug_str("adr%s r%d, 0x%08X", fmt_cond(cond), d, result);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -1084,7 +1089,7 @@ void ARMv7_instrs::AND_IMM(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("and%s%s %s,%s,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), imm32); if (context.debug & DF_DISASM) context.fmt_debug_str("and%s%s %s,%s,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), imm32);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -1137,7 +1142,7 @@ void ARMv7_instrs::AND_REG(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("and%s%s %s,%s,%s%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), fmt_reg(m), fmt_shift(shift_t, shift_n)); if (context.debug & DF_DISASM) context.fmt_debug_str("and%s%s %s,%s,%s%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), fmt_reg(m), fmt_shift(shift_t, shift_n));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -1248,7 +1253,7 @@ void ARMv7_instrs::B(ARMv7Context& context, const ARMv7Code code, const ARMv7_en
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("b%s 0x%08X", fmt_cond(cond), context.read_pc() + imm32); if (context.debug & DF_DISASM) context.fmt_debug_str("b%s 0x%08X", fmt_cond(cond), context.read_pc() + imm32);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -1302,7 +1307,7 @@ void ARMv7_instrs::BIC_IMM(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("bic%s%s %s,%s,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), imm32); if (context.debug & DF_DISASM) context.fmt_debug_str("bic%s%s %s,%s,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), imm32);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -1354,7 +1359,7 @@ void ARMv7_instrs::BIC_REG(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("bic%s%s %s,%s,%s%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), fmt_reg(m), fmt_shift(shift_t, shift_n)); if (context.debug & DF_DISASM) context.fmt_debug_str("bic%s%s %s,%s,%s%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), fmt_reg(m), fmt_shift(shift_t, shift_n));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -1427,7 +1432,7 @@ void ARMv7_instrs::BL(ARMv7Context& context, const ARMv7Code code, const ARMv7_e
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("bl%s 0x%08X", fmt_cond(cond), pc); if (context.debug & DF_DISASM) context.fmt_debug_str("bl%s 0x%08X", fmt_cond(cond), pc);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -1492,13 +1497,12 @@ void ARMv7_instrs::BLX(ARMv7Context& context, const ARMv7Code code, const ARMv7_
{ {
if (context.debug & DF_DISASM) if (context.debug & DF_DISASM)
{ {
context.debug_str = fmt::format("blx%s ", fmt_cond(cond));
switch (type) switch (type)
{ {
case T1: context.debug_str += fmt_reg((code.data >> 3) & 0xf); break; case T1: context.fmt_debug_str("blx%s %s", fmt_cond(cond), fmt_reg((code.data >> 3) & 0xf)); break;
case T2: context.debug_str += fmt::format("0x%08X", target); break; case T2: context.fmt_debug_str("blx%s 0x%08X", fmt_cond(cond), target); break;
case A1: context.debug_str += fmt_reg(code.data & 0xf); break; case A1: context.fmt_debug_str("blx%s %s", fmt_cond(cond), fmt_reg(code.data & 0xf)); break;
default: context.debug_str += "???"; default: context.fmt_debug_str("blx%s ???", fmt_cond(cond));
} }
} }
if (process_debug(context)) return; if (process_debug(context)) return;
@ -1536,7 +1540,7 @@ void ARMv7_instrs::BX(ARMv7Context& context, const ARMv7Code code, const ARMv7_e
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("bx%s %s", fmt_cond(cond), fmt_reg(m)); if (context.debug & DF_DISASM) context.fmt_debug_str("bx%s %s", fmt_cond(cond), fmt_reg(m));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -1568,7 +1572,7 @@ void ARMv7_instrs::CB_Z(ARMv7Context& context, const ARMv7Code code, const ARMv7
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("cb%sz 0x%08X", nonzero ? "n" : "", context.read_pc() + imm32); if (context.debug & DF_DISASM) context.fmt_debug_str("cb%sz 0x%08X", nonzero ? "n" : "", context.read_pc() + imm32);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -1601,7 +1605,7 @@ void ARMv7_instrs::CLZ(ARMv7Context& context, const ARMv7Code code, const ARMv7_
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("clz%s %s,%s", fmt_cond(cond), fmt_reg(d), fmt_reg(m)); if (context.debug & DF_DISASM) context.fmt_debug_str("clz%s %s,%s", fmt_cond(cond), fmt_reg(d), fmt_reg(m));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -1668,7 +1672,7 @@ void ARMv7_instrs::CMP_IMM(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("cmp%s %s,#0x%X", fmt_cond(cond), fmt_reg(n), imm32); if (context.debug & DF_DISASM) context.fmt_debug_str("cmp%s %s,#0x%X", fmt_cond(cond), fmt_reg(n), imm32);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -1729,7 +1733,7 @@ void ARMv7_instrs::CMP_REG(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("cmp%s %s,%s%s", fmt_cond(cond), fmt_reg(n), fmt_reg(m), fmt_shift(shift_t, shift_n)); if (context.debug & DF_DISASM) context.fmt_debug_str("cmp%s %s,%s%s", fmt_cond(cond), fmt_reg(n), fmt_reg(m), fmt_shift(shift_t, shift_n));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -1812,7 +1816,7 @@ void ARMv7_instrs::EOR_IMM(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("eor%s%s %s,%s,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), imm32); if (context.debug & DF_DISASM) context.fmt_debug_str("eor%s%s %s,%s,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), imm32);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -1865,7 +1869,7 @@ void ARMv7_instrs::EOR_REG(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("eor%s%s %s,%s,%s%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), fmt_reg(m), fmt_shift(shift_t, shift_n)); if (context.debug & DF_DISASM) context.fmt_debug_str("eor%s%s %s,%s,%s%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), fmt_reg(m), fmt_shift(shift_t, shift_n));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -1917,7 +1921,7 @@ void ARMv7_instrs::IT(ARMv7Context& context, const ARMv7Code code, const ARMv7_e
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("IT%s %s", fmt_it(context.ITSTATE.shift_state), fmt_cond(context.ITSTATE.condition)); if (context.debug & DF_DISASM) context.fmt_debug_str("IT%s %s", fmt_it(context.ITSTATE.shift_state), fmt_cond(context.ITSTATE.condition));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
} }
@ -1959,7 +1963,7 @@ void ARMv7_instrs::LDM(ARMv7Context& context, const ARMv7Code code, const ARMv7_
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("ldm%s %s%s,{%s}", fmt_cond(cond), fmt_reg(n), wback ? "!" : "", fmt_reg_list(reg_list)); if (context.debug & DF_DISASM) context.fmt_debug_str("ldm%s %s%s,{%s}", fmt_cond(cond), fmt_reg(n), wback ? "!" : "", fmt_reg_list(reg_list));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -2076,7 +2080,7 @@ void ARMv7_instrs::LDR_IMM(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("ldr%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_imm(n, imm32, index, add, wback)); if (context.debug & DF_DISASM) context.fmt_debug_str("ldr%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_imm(n, imm32, index, add, wback));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -2127,7 +2131,7 @@ void ARMv7_instrs::LDR_LIT(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("ldr%s %s,0x%08X", fmt_cond(cond), fmt_reg(t), addr); if (context.debug & DF_DISASM) context.fmt_debug_str("ldr%s %s,0x%08X", fmt_cond(cond), fmt_reg(t), addr);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -2181,7 +2185,7 @@ void ARMv7_instrs::LDR_REG(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("ldr%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_reg(n, m, index, add, wback, shift_t, shift_n)); if (context.debug & DF_DISASM) context.fmt_debug_str("ldr%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_reg(n, m, index, add, wback, shift_t, shift_n));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -2256,7 +2260,7 @@ void ARMv7_instrs::LDRB_IMM(ARMv7Context& context, const ARMv7Code code, const A
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("ldrb%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_imm(n, imm32, index, add, wback)); if (context.debug & DF_DISASM) context.fmt_debug_str("ldrb%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_imm(n, imm32, index, add, wback));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -2325,7 +2329,7 @@ void ARMv7_instrs::LDRB_REG(ARMv7Context& context, const ARMv7Code code, const A
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("ldrb%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_reg(n, m, index, add, wback, shift_t, shift_n)); if (context.debug & DF_DISASM) context.fmt_debug_str("ldrb%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_reg(n, m, index, add, wback, shift_t, shift_n));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -2374,7 +2378,7 @@ void ARMv7_instrs::LDRD_IMM(ARMv7Context& context, const ARMv7Code code, const A
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("ldrd%s %s,%s,%s", fmt_cond(cond), fmt_reg(t), fmt_reg(t2), fmt_mem_imm(n, imm32, index, add, wback)); if (context.debug & DF_DISASM) context.fmt_debug_str("ldrd%s %s,%s,%s", fmt_cond(cond), fmt_reg(t), fmt_reg(t2), fmt_mem_imm(n, imm32, index, add, wback));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -2421,7 +2425,7 @@ void ARMv7_instrs::LDRD_LIT(ARMv7Context& context, const ARMv7Code code, const A
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("ldrd%s %s,%s,0x%08X", fmt_cond(cond), fmt_reg(t), fmt_reg(t2), addr); if (context.debug & DF_DISASM) context.fmt_debug_str("ldrd%s %s,%s,0x%08X", fmt_cond(cond), fmt_reg(t), fmt_reg(t2), addr);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -2499,7 +2503,7 @@ void ARMv7_instrs::LDRH_IMM(ARMv7Context& context, const ARMv7Code code, const A
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("ldrh%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_imm(n, imm32, index, add, wback)); if (context.debug & DF_DISASM) context.fmt_debug_str("ldrh%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_imm(n, imm32, index, add, wback));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -2580,7 +2584,7 @@ void ARMv7_instrs::LDRSB_IMM(ARMv7Context& context, const ARMv7Code code, const
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("ldrsb%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_imm(n, imm32, index, add, wback)); if (context.debug & DF_DISASM) context.fmt_debug_str("ldrsb%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_imm(n, imm32, index, add, wback));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -2667,7 +2671,7 @@ void ARMv7_instrs::LDREX(ARMv7Context& context, const ARMv7Code code, const ARMv
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("ldrex%s %s,[%s,#0x%X]", fmt_cond(cond), fmt_reg(t), fmt_reg(n), imm32); if (context.debug & DF_DISASM) context.fmt_debug_str("ldrex%s %s,[%s,#0x%X]", fmt_cond(cond), fmt_reg(t), fmt_reg(n), imm32);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -2745,7 +2749,7 @@ void ARMv7_instrs::LSL_IMM(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("lsl%s%s %s,%s,#%d", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(m), shift_n); if (context.debug & DF_DISASM) context.fmt_debug_str("lsl%s%s %s,%s,#%d", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(m), shift_n);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -2795,7 +2799,7 @@ void ARMv7_instrs::LSL_REG(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("lsl%s%s %s,%s,%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), fmt_reg(m)); if (context.debug & DF_DISASM) context.fmt_debug_str("lsl%s%s %s,%s,%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), fmt_reg(m));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -2847,7 +2851,7 @@ void ARMv7_instrs::LSR_IMM(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("lsr%s%s %s,%s,#%d", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(m), shift_n); if (context.debug & DF_DISASM) context.fmt_debug_str("lsr%s%s %s,%s,#%d", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(m), shift_n);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -2939,8 +2943,8 @@ void ARMv7_instrs::MOV_IMM(ARMv7Context& context, const ARMv7Code code, const AR
{ {
switch (type) switch (type)
{ {
case T3: case A2: context.debug_str = fmt::format("movw%s%s %s,#0x%04X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), imm32); break; case T3: case A2: context.fmt_debug_str("movw%s%s %s,#0x%04X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), imm32); break;
default: context.debug_str = fmt::format("mov%s%s %s,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), imm32); default: context.fmt_debug_str("mov%s%s %s,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), imm32);
} }
} }
if (process_debug(context)) return; if (process_debug(context)) return;
@ -3004,7 +3008,7 @@ void ARMv7_instrs::MOV_REG(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("mov%s%s %s,%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(m)); if (context.debug & DF_DISASM) context.fmt_debug_str("mov%s%s %s,%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(m));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -3043,7 +3047,7 @@ void ARMv7_instrs::MOVT(ARMv7Context& context, const ARMv7Code code, const ARMv7
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("movt%s %s,#0x%04X", fmt_cond(cond), fmt_reg(d), imm16); if (context.debug & DF_DISASM) context.fmt_debug_str("movt%s %s,#0x%04X", fmt_cond(cond), fmt_reg(d), imm16);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -3115,7 +3119,7 @@ void ARMv7_instrs::MUL(ARMv7Context& context, const ARMv7Code code, const ARMv7_
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("mul%s%s %s,%s,%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), fmt_reg(m)); if (context.debug & DF_DISASM) context.fmt_debug_str("mul%s%s %s,%s,%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), fmt_reg(m));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -3158,7 +3162,7 @@ void ARMv7_instrs::MVN_IMM(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("mvn%s%s %s,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), imm32); if (context.debug & DF_DISASM) context.fmt_debug_str("mvn%s%s %s,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), imm32);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -3209,7 +3213,7 @@ void ARMv7_instrs::MVN_REG(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("mvn%s%s %s,%s%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(m), fmt_shift(shift_t, shift_n)); if (context.debug & DF_DISASM) context.fmt_debug_str("mvn%s%s %s,%s%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(m), fmt_shift(shift_t, shift_n));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -3265,7 +3269,7 @@ void ARMv7_instrs::NOP(ARMv7Context& context, const ARMv7Code code, const ARMv7_
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("nop%s", fmt_cond(cond)); if (context.debug & DF_DISASM) context.fmt_debug_str("nop%s", fmt_cond(cond));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -3319,7 +3323,7 @@ void ARMv7_instrs::ORR_IMM(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("orr%s%s %s,%s,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), imm32); if (context.debug & DF_DISASM) context.fmt_debug_str("orr%s%s %s,%s,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), imm32);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -3372,7 +3376,7 @@ void ARMv7_instrs::ORR_REG(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("orr%s%s %s,%s,%s%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), fmt_reg(m), fmt_shift(shift_t, shift_n)); if (context.debug & DF_DISASM) context.fmt_debug_str("orr%s%s %s,%s,%s%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), fmt_reg(m), fmt_shift(shift_t, shift_n));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -3465,7 +3469,7 @@ void ARMv7_instrs::POP(ARMv7Context& context, const ARMv7Code code, const ARMv7_
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("pop%s {%s}", fmt_cond(cond), fmt_reg_list(reg_list)); if (context.debug & DF_DISASM) context.fmt_debug_str("pop%s {%s}", fmt_cond(cond), fmt_reg_list(reg_list));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -3536,7 +3540,7 @@ void ARMv7_instrs::PUSH(ARMv7Context& context, const ARMv7Code code, const ARMv7
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("push%s {%s}", fmt_cond(cond), fmt_reg_list(reg_list)); if (context.debug & DF_DISASM) context.fmt_debug_str("push%s {%s}", fmt_cond(cond), fmt_reg_list(reg_list));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -3686,7 +3690,7 @@ void ARMv7_instrs::REV(ARMv7Context& context, const ARMv7Code code, const ARMv7_
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("rev%s %s,%s", fmt_cond(cond), fmt_reg(d), fmt_reg(m)); if (context.debug & DF_DISASM) context.fmt_debug_str("rev%s %s,%s", fmt_cond(cond), fmt_reg(d), fmt_reg(m));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -3740,7 +3744,7 @@ void ARMv7_instrs::ROR_IMM(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("ror%s%s %s,%s,#%d", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(m), shift_n); if (context.debug & DF_DISASM) context.fmt_debug_str("ror%s%s %s,%s,#%d", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(m), shift_n);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -3790,7 +3794,7 @@ void ARMv7_instrs::ROR_REG(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("ror%s%s %s,%s,%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), fmt_reg(m)); if (context.debug & DF_DISASM) context.fmt_debug_str("ror%s%s %s,%s,%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), fmt_reg(m));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -3853,7 +3857,7 @@ void ARMv7_instrs::RSB_IMM(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("rsb%s%s %s,%s,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), imm32); if (context.debug & DF_DISASM) context.fmt_debug_str("rsb%s%s %s,%s,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), imm32);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -4286,7 +4290,7 @@ void ARMv7_instrs::STM(ARMv7Context& context, const ARMv7Code code, const ARMv7_
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("stm%s %s%s,{%s}", fmt_cond(cond), fmt_reg(n), wback ? "!" : "", fmt_reg_list(reg_list)); if (context.debug & DF_DISASM) context.fmt_debug_str("stm%s %s%s,{%s}", fmt_cond(cond), fmt_reg(n), wback ? "!" : "", fmt_reg_list(reg_list));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -4402,7 +4406,7 @@ void ARMv7_instrs::STR_IMM(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("str%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_imm(n, imm32, index, add, wback)); if (context.debug & DF_DISASM) context.fmt_debug_str("str%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_imm(n, imm32, index, add, wback));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -4461,7 +4465,7 @@ void ARMv7_instrs::STR_REG(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("str%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_reg(n, m, index, add, wback, shift_t, shift_n)); if (context.debug & DF_DISASM) context.fmt_debug_str("str%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_reg(n, m, index, add, wback, shift_t, shift_n));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -4533,7 +4537,7 @@ void ARMv7_instrs::STRB_IMM(ARMv7Context& context, const ARMv7Code code, const A
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("strb%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_imm(n, imm32, index, add, wback)); if (context.debug & DF_DISASM) context.fmt_debug_str("strb%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_imm(n, imm32, index, add, wback));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -4592,7 +4596,7 @@ void ARMv7_instrs::STRB_REG(ARMv7Context& context, const ARMv7Code code, const A
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("strb%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_reg(n, m, index, add, wback, shift_t, shift_n)); if (context.debug & DF_DISASM) context.fmt_debug_str("strb%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_reg(n, m, index, add, wback, shift_t, shift_n));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -4640,7 +4644,7 @@ void ARMv7_instrs::STRD_IMM(ARMv7Context& context, const ARMv7Code code, const A
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("strd%s %s,%s,%s", fmt_cond(cond), fmt_reg(t), fmt_reg(t2), fmt_mem_imm(n, imm32, index, add, wback)); if (context.debug & DF_DISASM) context.fmt_debug_str("strd%s %s,%s,%s", fmt_cond(cond), fmt_reg(t), fmt_reg(t2), fmt_mem_imm(n, imm32, index, add, wback));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -4721,7 +4725,7 @@ void ARMv7_instrs::STRH_IMM(ARMv7Context& context, const ARMv7Code code, const A
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("strh%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_imm(n, imm32, index, add, wback)); if (context.debug & DF_DISASM) context.fmt_debug_str("strh%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_imm(n, imm32, index, add, wback));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -4780,7 +4784,7 @@ void ARMv7_instrs::STRH_REG(ARMv7Context& context, const ARMv7Code code, const A
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("strh%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_reg(n, m, index, add, wback, shift_t, shift_n)); if (context.debug & DF_DISASM) context.fmt_debug_str("strh%s %s,%s", fmt_cond(cond), fmt_reg(t), fmt_mem_reg(n, m, index, add, wback, shift_t, shift_n));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -4823,7 +4827,7 @@ void ARMv7_instrs::STREX(ARMv7Context& context, const ARMv7Code code, const ARMv
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("strex%s %s,%s,[%s,#0x%x]", fmt_cond(cond), fmt_reg(d), fmt_reg(t), fmt_reg(n), imm32); if (context.debug & DF_DISASM) context.fmt_debug_str("strex%s %s,%s,[%s,#0x%x]", fmt_cond(cond), fmt_reg(d), fmt_reg(t), fmt_reg(n), imm32);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -4917,7 +4921,7 @@ void ARMv7_instrs::SUB_IMM(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("sub%s%s %s,%s,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), imm32); if (context.debug & DF_DISASM) context.fmt_debug_str("sub%s%s %s,%s,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), imm32);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -4974,7 +4978,7 @@ void ARMv7_instrs::SUB_REG(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("sub%s%s %s,%s,%s%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), fmt_reg(m), fmt_shift(shift_t, shift_n)); if (context.debug & DF_DISASM) context.fmt_debug_str("sub%s%s %s,%s,%s%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), fmt_reg(n), fmt_reg(m), fmt_shift(shift_t, shift_n));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -5046,7 +5050,7 @@ void ARMv7_instrs::SUB_SPI(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("sub%s%s %s,sp,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), imm32); if (context.debug & DF_DISASM) context.fmt_debug_str("sub%s%s %s,sp,#0x%X", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d), imm32);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -5201,7 +5205,7 @@ void ARMv7_instrs::TST_IMM(ARMv7Context& context, const ARMv7Code code, const AR
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("tst%s %s,#0x%X", fmt_cond(cond), fmt_reg(n), imm32); if (context.debug & DF_DISASM) context.fmt_debug_str("tst%s %s,#0x%X", fmt_cond(cond), fmt_reg(n), imm32);
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -5376,7 +5380,7 @@ void ARMv7_instrs::UMULL(ARMv7Context& context, const ARMv7Code code, const ARMv
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("umull%s%s %s,%s,%s,%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d0), fmt_reg(d1), fmt_reg(n), fmt_reg(m)); if (context.debug & DF_DISASM) context.fmt_debug_str("umull%s%s %s,%s,%s,%s", set_flags ? "s" : "", fmt_cond(cond), fmt_reg(d0), fmt_reg(d1), fmt_reg(n), fmt_reg(m));
if (process_debug(context)) return; if (process_debug(context)) return;
} }
@ -5568,7 +5572,7 @@ void ARMv7_instrs::UXTB(ARMv7Context& context, const ARMv7Code code, const ARMv7
if (context.debug) if (context.debug)
{ {
if (context.debug & DF_DISASM) context.debug_str = fmt::format("uxtb%s %s,%s%s", fmt_cond(cond), fmt_reg(d), fmt_reg(m), fmt_shift(SRType_ROR, rot)); if (context.debug & DF_DISASM) context.fmt_debug_str("uxtb%s %s,%s%s", fmt_cond(cond), fmt_reg(d), fmt_reg(m), fmt_shift(SRType_ROR, rot));
if (process_debug(context)) return; if (process_debug(context)) return;
} }

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

@ -994,7 +994,7 @@ s32 sceIoGetstat(vm::psv::ptr<const char> name, vm::psv::ptr<SceIoStat> buf)
} }
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceLibKernel, #name, &name) #define REG_FUNC(nid, name) reg_psv_func(nid, &sceLibKernel, #name, name)
psv_log_base sceLibKernel("sceLibKernel", []() psv_log_base sceLibKernel("sceLibKernel", []()
{ {

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

@ -246,7 +246,7 @@ namespace sce_libc_func
} }
} }
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceLibc, #name, &sce_libc_func::name) #define REG_FUNC(nid, name) reg_psv_func(nid, &sceLibc, #name, sce_libc_func::name)
psv_log_base sceLibc("SceLibc", []() psv_log_base sceLibc("SceLibc", []()
{ {

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

@ -9,7 +9,7 @@ namespace sce_libm_func
} }
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceLibm, #name, &sce_libm_func::name) #define REG_FUNC(nid, name) reg_psv_func(nid, &sceLibm, #name, sce_libm_func::name)
psv_log_base sceLibm("SceLibm", []() psv_log_base sceLibm("SceLibm", []()
{ {

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

@ -23,7 +23,7 @@ namespace sce_libstdcxx_func
} }
// Attention: find and set correct original mangled name in third parameter, for example: REG_FUNC(0xAE71DC3, operator_new_nothrow, "_ZnwjRKSt9nothrow_t"); // 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) #define REG_FUNC(nid, name, orig_name) reg_psv_func(nid, &sceLibstdcxx, orig_name, sce_libstdcxx_func::name)
psv_log_base sceLibstdcxx("SceLibstdcxx", []() psv_log_base sceLibstdcxx("SceLibstdcxx", []()
{ {

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

@ -75,7 +75,7 @@ void execute_psv_func_by_index(ARMv7Context& context, u32 index)
if (func->func) if (func->func)
{ {
(*func->func)(context); func->func(context);
} }
else else
{ {
@ -223,10 +223,10 @@ void initialize_psv_modules()
psv_func& hle_return = g_psv_func_list[SFI_HLE_RETURN]; psv_func& hle_return = g_psv_func_list[SFI_HLE_RETURN];
hle_return.nid = 0; hle_return.nid = 0;
hle_return.name = "HLE_RETURN"; hle_return.name = "HLE_RETURN";
hle_return.func.reset(new psv_func_detail::func_binder<void, ARMv7Context&>([](ARMv7Context& context) hle_return.func = [](ARMv7Context& context)
{ {
context.thread.FastStop(); context.thread.FastStop();
})); };
// load functions // load functions
for (auto module : g_psv_modules) for (auto module : g_psv_modules)

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

@ -33,13 +33,7 @@ public:
}; };
// Abstract HLE function caller base class typedef void(*psv_func_caller)(ARMv7Context&);
class psv_func_caller
{
public:
virtual void operator()(ARMv7Context& CPU) = 0;
virtual ~psv_func_caller(){};
};
// Utilities for binding ARMv7Context to C++ function arguments received by HLE functions or sent to callbacks // Utilities for binding ARMv7Context to C++ function arguments received by HLE functions or sent to callbacks
namespace psv_func_detail namespace psv_func_detail
@ -361,81 +355,49 @@ namespace psv_func_detail
} }
template<typename RT, typename... T> template<typename RT, typename... T>
class func_binder; struct func_binder;
template<typename... T> template<typename... T>
class func_binder<void, T...> : public psv_func_caller struct func_binder<void, T...>
{ {
typedef void(*func_t)(T...); typedef void(*func_t)(T...);
const func_t m_call;
public: static void do_call(ARMv7Context& context, func_t _func)
func_binder(func_t call)
: psv_func_caller()
, m_call(call)
{ {
} call<void>(_func, get_func_args<0, 0, 0, T...>(context));
virtual void operator()(ARMv7Context& context)
{
call<void>(m_call, get_func_args<0, 0, 0, T...>(context));
} }
}; };
template<typename... T> template<typename... T>
class func_binder<void, ARMv7Context&, T...> : public psv_func_caller struct func_binder<void, ARMv7Context&, T...>
{ {
typedef void(*func_t)(ARMv7Context&, T...); typedef void(*func_t)(ARMv7Context&, T...);
const func_t m_call;
public: static void do_call(ARMv7Context& context, func_t _func)
func_binder(func_t call)
: psv_func_caller()
, m_call(call)
{ {
} call<void>(_func, std::tuple_cat(std::tuple<ARMv7Context&>(context), get_func_args<0, 0, 0, T...>(context)));
virtual void operator()(ARMv7Context& context)
{
call<void>(m_call, std::tuple_cat(std::tuple<ARMv7Context&>(context), get_func_args<0, 0, 0, T...>(context)));
} }
}; };
template<typename RT, typename... T> template<typename RT, typename... T>
class func_binder : public psv_func_caller struct func_binder
{ {
typedef RT(*func_t)(T...); typedef RT(*func_t)(T...);
const func_t m_call;
public: static void do_call(ARMv7Context& context, func_t _func)
func_binder(func_t call)
: psv_func_caller()
, m_call(call)
{ {
} bind_result<RT, result_type<RT>::value>::put_result(context, call<RT>(_func, get_func_args<0, 0, 0, T...>(context)));
virtual void operator()(ARMv7Context& context)
{
bind_result<RT, result_type<RT>::value>::put_result(context, call<RT>(m_call, get_func_args<0, 0, 0, T...>(context)));
} }
}; };
template<typename RT, typename... T> template<typename RT, typename... T>
class func_binder<RT, ARMv7Context&, T...> : public psv_func_caller struct func_binder<RT, ARMv7Context&, T...>
{ {
typedef RT(*func_t)(ARMv7Context&, T...); typedef RT(*func_t)(ARMv7Context&, T...);
const func_t m_call;
public: static void do_call(ARMv7Context& context, func_t _func)
func_binder(func_t call)
: psv_func_caller()
, m_call(call)
{ {
} bind_result<RT, result_type<RT>::value>::put_result(context, call<RT>(_func, std::tuple_cat(std::tuple<ARMv7Context&>(context), get_func_args<0, 0, 0, T...>(context))));
virtual void operator()(ARMv7Context& context)
{
bind_result<RT, result_type<RT>::value>::put_result(context, call<RT>(m_call, std::tuple_cat(std::tuple<ARMv7Context&>(context), get_func_args<0, 0, 0, T...>(context))));
} }
}; };
@ -474,7 +436,7 @@ struct psv_func
{ {
u32 nid; // Unique function ID (should be generated individually for each elf loaded) u32 nid; // Unique function ID (should be generated individually for each elf loaded)
const char* name; // Function name for information const char* name; // Function name for information
std::shared_ptr<psv_func_caller> func; // Function caller instance psv_func_caller func; // Function caller
psv_log_base* module; // Module for information psv_log_base* module; // Module for information
}; };
@ -488,16 +450,24 @@ enum psv_special_function_index : u16
// Do not call directly // Do not call directly
u32 add_psv_func(psv_func data); u32 add_psv_func(psv_func data);
// Do not call directly // Do not call directly
template<typename RT, typename... T> void reg_psv_func(u32 nid, psv_log_base* module, const char* name, RT(*func)(T...)) __forceinline static u32 add_psv_func(u32 nid, psv_log_base* module, const char* name, psv_func_caller func)
{ {
psv_func f; psv_func f;
f.nid = nid; f.nid = nid;
f.name = name; f.name = name;
f.func.reset(new psv_func_detail::func_binder<RT, T...>(func)); f.func = func;
f.module = module; f.module = module;
add_psv_func(f); return add_psv_func(f);
} }
// Do not call directly
template<typename RT, typename... T> __forceinline void call_psv_func(ARMv7Context& context, RT(*func)(T...))
{
psv_func_detail::func_binder<RT, T...>::do_call(context, func);
}
#define reg_psv_func(nid, module, name, func) add_psv_func(nid, module, name, [](ARMv7Context& context){ call_psv_func(context, func); })
// Find registered HLE function by NID // Find registered HLE function by NID
psv_func* get_psv_func_by_nid(u32 nid, u32* out_index = nullptr); psv_func* get_psv_func_by_nid(u32 nid, u32* out_index = nullptr);
// Find registered HLE function by its index // Find registered HLE function by its index

11
rpcs3/Emu/Cell/PPUInterpreter.h
View File

@ -4,7 +4,6 @@
#include "Emu/SysCalls/SysCalls.h" #include "Emu/SysCalls/SysCalls.h"
#include "rpcs3/Ini.h" #include "rpcs3/Ini.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/SysCalls/Static.h"
#include "Emu/SysCalls/Modules.h" #include "Emu/SysCalls/Modules.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/SysCalls/lv2/sys_time.h" #include "Emu/SysCalls/lv2/sys_time.h"
@ -2255,7 +2254,7 @@ private:
} }
void HACK(u32 index) void HACK(u32 index)
{ {
execute_ps3_func_by_index(CPU, index); execute_ppu_func_by_index(CPU, index);
} }
void SC(u32 lev) void SC(u32 lev)
{ {
@ -2263,14 +2262,6 @@ private:
{ {
case 0x0: SysCall(); break; case 0x0: SysCall(); break;
case 0x1: throw "SC(): HyperCall LV1"; case 0x1: throw "SC(): HyperCall LV1";
case 0x2:
Emu.GetSFuncManager().StaticExecute(CPU, (u32)CPU.GPR[11]);
if (Ini.HLELogging.GetValue())
{
LOG_NOTICE(PPU, "'%s' done with code[0x%llx]! #pc: 0x%x",
Emu.GetSFuncManager()[CPU.GPR[11]]->name, CPU.GPR[3], CPU.PC);
}
break;
case 0x3: CPU.FastStop(); break; case 0x3: CPU.FastStop(); break;
default: throw fmt::Format("SC(): unknown level (0x%x)", lev); default: throw fmt::Format("SC(): unknown level (0x%x)", lev);
} }

6
rpcs3/Emu/Cell/PPULLVMRecompiler.cpp
View File

@ -1999,7 +1999,7 @@ void Compiler::BC(u32 bo, u32 bi, s32 bd, u32 aa, u32 lk) {
} }
void Compiler::HACK(u32 index) { void Compiler::HACK(u32 index) {
Call<void>("execute_ps3_func_by_index", &execute_ps3_func_by_index, m_state.args[CompileTaskState::Args::State], m_ir_builder->getInt32(index)); Call<void>("execute_ppu_func_by_index", &execute_ppu_func_by_index, m_state.args[CompileTaskState::Args::State], m_ir_builder->getInt32(index));
} }
void Compiler::SC(u32 lev) { void Compiler::SC(u32 lev) {
@ -2007,10 +2007,6 @@ void Compiler::SC(u32 lev) {
case 0: case 0:
Call<void>("SysCalls.DoSyscall", SysCalls::DoSyscall, m_state.args[CompileTaskState::Args::State], GetGpr(11)); Call<void>("SysCalls.DoSyscall", SysCalls::DoSyscall, m_state.args[CompileTaskState::Args::State], GetGpr(11));
break; break;
case 2:
Call<void>("StaticFuncManager.StaticExecute", &StaticFuncManager::StaticExecute,
m_ir_builder->getInt64((u64)&Emu.GetSFuncManager()), m_state.args[CompileTaskState::Args::State], GetGpr(11, 32));
break;
case 3: case 3:
Call<void>("PPUThread.FastStop", &PPUThread::FastStop, m_state.args[CompileTaskState::Args::State]); Call<void>("PPUThread.FastStop", &PPUThread::FastStop, m_state.args[CompileTaskState::Args::State]);
break; break;

1
rpcs3/Emu/Cell/PPUThread.cpp
View File

@ -6,7 +6,6 @@
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"
#include "Emu/SysCalls/SysCalls.h" #include "Emu/SysCalls/SysCalls.h"
#include "Emu/SysCalls/Modules.h" #include "Emu/SysCalls/Modules.h"
#include "Emu/SysCalls/Static.h"
#include "Emu/Cell/PPUDecoder.h" #include "Emu/Cell/PPUDecoder.h"
#include "Emu/Cell/PPUInterpreter.h" #include "Emu/Cell/PPUInterpreter.h"
#include "Emu/Cell/PPULLVMRecompiler.h" #include "Emu/Cell/PPULLVMRecompiler.h"

2
rpcs3/Emu/SysCalls/ModuleManager.cpp
View File

@ -171,6 +171,8 @@ void ModuleManager::Init()
{ {
if (!initialized) if (!initialized)
{ {
clear_ppu_functions();
for (auto& m : g_module_list) for (auto& m : g_module_list)
{ {
if (m.module) if (m.module)

326
rpcs3/Emu/SysCalls/Modules.cpp
View File

@ -1,20 +1,21 @@
#include "stdafx.h" #include "stdafx.h"
#include "Ini.h"
#include "Utilities/Log.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/SysCalls/Modules.h" #include "Emu/SysCalls/Modules.h"
#include "Emu/SysCalls/SysCalls.h" #include "Emu/SysCalls/SysCalls.h"
#include "Emu/SysCalls/Static.h"
#include "Emu/SysCalls/CB_FUNC.h" #include "Emu/SysCalls/CB_FUNC.h"
#include "Crypto/sha1.h" #include "Crypto/sha1.h"
#include "ModuleManager.h" #include "ModuleManager.h"
#include "Emu/Cell/PPUInstrTable.h" #include "Emu/Cell/PPUInstrTable.h"
std::vector<ModuleFunc> g_ps3_func_list; std::vector<ModuleFunc> g_ppu_func_list;
std::vector<StaticFunc> g_ppu_func_subs;
u32 add_ps3_func(ModuleFunc func) u32 add_ppu_func(ModuleFunc func)
{ {
for (auto& f : g_ps3_func_list) for (auto& f : g_ppu_func_list)
{ {
if (f.id == func.id) if (f.id == func.id)
{ {
@ -30,23 +31,50 @@ u32 add_ps3_func(ModuleFunc func)
f.lle_func = func.lle_func; f.lle_func = func.lle_func;
} }
return (u32)(&f - g_ps3_func_list.data()); return (u32)(&f - g_ppu_func_list.data());
} }
} }
g_ps3_func_list.push_back(func); g_ppu_func_list.push_back(func);
return (u32)g_ps3_func_list.size() - 1; return (u32)g_ppu_func_list.size() - 1;
} }
ModuleFunc* get_ps3_func_by_nid(u32 nid, u32* out_index) u32 add_ppu_func_sub(StaticFunc func)
{ {
for (auto& f : g_ps3_func_list) g_ppu_func_subs.push_back(func);
return func.index;
}
u32 add_ppu_func_sub(const char group[8], const u64 ops[], const char* name, Module* module, ppu_func_caller func)
{
StaticFunc sf;
sf.index = add_ppu_func(ModuleFunc(get_function_id(name), module, func));
sf.name = name;
sf.group = *(u64*)group;
sf.found = 0;
// TODO: check for self-inclusions, use CRC
for (u32 i = 0; ops[i]; i++)
{
SFuncOp op;
op.mask = re32((u32)(ops[i] >> 32));
op.crc = re32((u32)(ops[i]));
if (op.mask) op.crc &= op.mask;
sf.ops.push_back(op);
}
return add_ppu_func_sub(sf);
}
ModuleFunc* get_ppu_func_by_nid(u32 nid, u32* out_index)
{
for (auto& f : g_ppu_func_list)
{ {
if (f.id == nid) if (f.id == nid)
{ {
if (out_index) if (out_index)
{ {
*out_index = (u32)(&f - g_ps3_func_list.data()); *out_index = (u32)(&f - g_ppu_func_list.data());
} }
return &f; return &f;
@ -56,19 +84,19 @@ ModuleFunc* get_ps3_func_by_nid(u32 nid, u32* out_index)
return nullptr; return nullptr;
} }
ModuleFunc* get_ps3_func_by_index(u32 index) ModuleFunc* get_ppu_func_by_index(u32 index)
{ {
if (index >= g_ps3_func_list.size()) if (index >= g_ppu_func_list.size())
{ {
return nullptr; return nullptr;
} }
return &g_ps3_func_list[index]; return &g_ppu_func_list[index];
} }
void execute_ps3_func_by_index(PPUThread& CPU, u32 index) void execute_ppu_func_by_index(PPUThread& CPU, u32 index)
{ {
if (auto func = get_ps3_func_by_index(index)) if (auto func = get_ppu_func_by_index(index))
{ {
// save RTOC // save RTOC
vm::write64(vm::cast(CPU.GPR[1] + 0x28), CPU.GPR[2]); vm::write64(vm::cast(CPU.GPR[1] + 0x28), CPU.GPR[2]);
@ -82,7 +110,7 @@ void execute_ps3_func_by_index(PPUThread& CPU, u32 index)
} }
else if (func->func) else if (func->func)
{ {
(*func->func)(CPU); func->func(CPU);
} }
else else
{ {
@ -98,9 +126,10 @@ void execute_ps3_func_by_index(PPUThread& CPU, u32 index)
} }
} }
void clear_ps3_functions() void clear_ppu_functions()
{ {
g_ps3_func_list.clear(); g_ppu_func_list.clear();
g_ppu_func_subs.clear();
} }
u32 get_function_id(const char* name) u32 get_function_id(const char* name)
@ -119,6 +148,180 @@ u32 get_function_id(const char* name)
return (u32&)output[0]; return (u32&)output[0];
} }
void hook_ppu_funcs(u32* base, u32 size)
{
size /= 4;
if (!Ini.HLEHookStFunc.GetValue())
return;
// TODO: optimize search
for (u32 i = 0; i < size; i++)
{
for (u32 j = 0; j < g_ppu_func_subs.size(); j++)
{
if ((base[i] & g_ppu_func_subs[j].ops[0].mask) == g_ppu_func_subs[j].ops[0].crc)
{
bool found = true;
u32 can_skip = 0;
for (u32 k = i, x = 0; x + 1 <= g_ppu_func_subs[j].ops.size(); k++, x++)
{
if (k >= size)
{
found = false;
break;
}
// skip NOP
if (base[k] == se32(0x60000000))
{
x--;
continue;
}
const u32 mask = g_ppu_func_subs[j].ops[x].mask;
const u32 crc = g_ppu_func_subs[j].ops[x].crc;
if (!mask)
{
// TODO: define syntax
if (crc < 4) // skip various number of instructions that don't match next pattern entry
{
can_skip += crc;
k--; // process this position again
}
else if (base[k] != crc) // skippable pattern ("optional" instruction), no mask allowed
{
k--;
if (can_skip) // cannot define this behaviour properly
{
LOG_WARNING(LOADER, "hook_ppu_funcs(): can_skip = %d (unchanged)", can_skip);
}
}
else
{
if (can_skip) // cannot define this behaviour properly
{
LOG_WARNING(LOADER, "hook_ppu_funcs(): can_skip = %d (set to 0)", can_skip);
can_skip = 0;
}
}
}
else if ((base[k] & mask) != crc) // masked pattern
{
if (can_skip)
{
can_skip--;
}
else
{
found = false;
break;
}
}
else
{
can_skip = 0;
}
}
if (found)
{
LOG_NOTICE(LOADER, "Function '%s' hooked (addr=0x%x)", g_ppu_func_subs[j].name, vm::get_addr(base + i * 4));
g_ppu_func_subs[j].found++;
base[i + 0] = re32(0x04000000 | g_ppu_func_subs[j].index); // hack
base[i + 1] = se32(0x4e800020); // blr
i += 1; // skip modified code
}
}
}
}
// check function groups
for (u32 i = 0; i < g_ppu_func_subs.size(); i++)
{
if (g_ppu_func_subs[i].found) // start from some group
{
const u64 group = g_ppu_func_subs[i].group;
enum GroupSearchResult : u32
{
GSR_SUCCESS = 0, // every function from this group has been found once
GSR_MISSING = 1, // (error) some function not found
GSR_EXCESS = 2, // (error) some function found twice or more
};
u32 res = GSR_SUCCESS;
// analyse
for (u32 j = 0; j < g_ppu_func_subs.size(); j++) if (g_ppu_func_subs[j].group == group)
{
u32 count = g_ppu_func_subs[j].found;
if (count == 0) // not found
{
// check if this function has been found with different pattern
for (u32 k = 0; k < g_ppu_func_subs.size(); k++) if (g_ppu_func_subs[k].group == group)
{
if (k != j && g_ppu_func_subs[k].index == g_ppu_func_subs[j].index)
{
count += g_ppu_func_subs[k].found;
}
}
if (count == 0)
{
res |= GSR_MISSING;
LOG_ERROR(LOADER, "Function '%s' not found", g_ppu_func_subs[j].name);
}
else if (count > 1)
{
res |= GSR_EXCESS;
}
}
else if (count == 1) // found
{
// ensure that this function has NOT been found with different pattern
for (u32 k = 0; k < g_ppu_func_subs.size(); k++) if (g_ppu_func_subs[k].group == group)
{
if (k != j && g_ppu_func_subs[k].index == g_ppu_func_subs[j].index)
{
if (g_ppu_func_subs[k].found)
{
res |= GSR_EXCESS;
LOG_ERROR(LOADER, "Function '%s' hooked twice", g_ppu_func_subs[j].name);
}
}
}
}
else
{
res |= GSR_EXCESS;
LOG_ERROR(LOADER, "Function '%s' hooked twice", g_ppu_func_subs[j].name);
}
}
// clear data
for (u32 j = 0; j < g_ppu_func_subs.size(); j++)
{
if (g_ppu_func_subs[j].group == group) g_ppu_func_subs[j].found = 0;
}
char name[9] = "????????";
*(u64*)name = group;
if (res == GSR_SUCCESS)
{
LOG_SUCCESS(LOADER, "Function group [%s] successfully hooked", std::string(name, 9).c_str());
}
else
{
LOG_ERROR(LOADER, "Function group [%s] failed:%s%s", std::string(name, 9).c_str(),
(res & GSR_MISSING ? " missing;" : ""),
(res & GSR_EXCESS ? " excess;" : ""));
}
}
}
}
Module::Module(const char* name, void(*init)()) Module::Module(const char* name, void(*init)())
: m_is_loaded(false) : m_is_loaded(false)
, m_name(name) , m_name(name)
@ -204,90 +407,3 @@ IdManager& Module::GetIdManager() const
{ {
return Emu.GetIdManager(); return Emu.GetIdManager();
} }
void Module::PushNewFuncSub(SFunc* func)
{
Emu.GetSFuncManager().push_back(func);
}
void fix_import(Module* module, u32 nid, u32 addr)
{
using namespace PPU_instr;
vm::ptr<u32> ptr = vm::ptr<u32>::make(addr);
u32 index;
if (auto func = get_ps3_func_by_nid(nid, &index))
{
*ptr++ = HACK(index);
*ptr++ = BLR();
}
else
{
module->Error("Unimplemented function 0x%x (0x%x)", nid, addr);
}
//*ptr++ = ADDIS(11, 0, func >> 16);
//*ptr++ = ORI(11, 11, func & 0xffff);
//*ptr++ = NOP();
//++ptr;
//*ptr++ = SC(0);
//*ptr++ = BLR();
//*ptr++ = NOP();
//*ptr++ = NOP();
}
void fix_relocs(Module* module, u32 lib, u32 start, u32 end, u32 seg2)
{
// start of table:
// addr = (u64) addr - seg2, (u32) 1, (u32) 1, (u64) ptr
// addr = (u64) addr - seg2, (u32) 0x101, (u32) 1, (u64) ptr - seg2 (???)
// addr = (u64) addr, (u32) 0x100, (u32) 1, (u64) ptr - seg2 (???)
// addr = (u64) addr, (u32) 0, (u32) 1, (u64) ptr (???)
for (u32 i = lib + start; i < lib + end; i += 24)
{
u64 addr = vm::read64(i) + lib;
const u64 flag = vm::read64(i + 8);
if ((u32)addr != addr || (u32)(addr + seg2) != (addr + seg2))
{
module->Error("fix_relocs(): invalid address (0x%llx)", addr);
}
else if (flag == 0x10100000001ull)
{
addr = addr + seg2;
u32 value = vm::read32((u32)addr);
assert(value == vm::read64(i + 16) + seg2);
vm::write32((u32)addr, value + lib);
}
else if (flag == 0x100000001ull)
{
addr = addr + seg2;
u32 value = vm::read32((u32)addr);
assert(value == vm::read64(i + 16));
vm::write32((u32)addr, value + lib);
}
else if (flag == 0x10000000001ull)
{
u32 value = vm::read32((u32)addr);
assert(value == vm::read64(i + 16) + seg2);
vm::write32((u32)addr, value + lib);
}
else if (flag == 1)
{
u32 value = vm::read32((u32)addr);
assert(value == vm::read64(i + 16));
vm::write32((u32)addr, value + lib);
}
else if (flag == 0x10000000004ull || flag == 0x10000000006ull)
{
// seems to be instruction modifiers for imports (done in other way in FIX_IMPORT)
}
else
{
module->Notice("fix_relocs(): 0x%x : 0x%llx", i - lib, flag);
}
}
}

80
rpcs3/Emu/SysCalls/Modules.h
View File

@ -10,10 +10,10 @@ struct ModuleFunc
{ {
u32 id; u32 id;
Module* module; Module* module;
std::shared_ptr<func_caller> func; ppu_func_caller func;
vm::ptr<void()> lle_func; vm::ptr<void()> lle_func;
ModuleFunc(u32 id, Module* module, func_caller* func, vm::ptr<void()> lle_func = vm::ptr<void()>::make(0)) ModuleFunc(u32 id, Module* module, ppu_func_caller func, vm::ptr<void()> lle_func = vm::ptr<void()>::make(0))
: id(id) : id(id)
, module(module) , module(module)
, func(func) , func(func)
@ -28,23 +28,15 @@ struct SFuncOp
u32 mask; u32 mask;
}; };
struct SFunc struct StaticFunc
{ {
func_caller* func; u32 index;
void* ptr;
const char* name; const char* name;
std::vector<SFuncOp> ops; std::vector<SFuncOp> ops;
u64 group; u64 group;
u32 found; u32 found;
~SFunc()
{
delete func;
}
}; };
class StaticFuncManager;
class Module : public LogBase class Module : public LogBase
{ {
std::string m_name; std::string m_name;
@ -52,7 +44,6 @@ class Module : public LogBase
void(*m_init)(); void(*m_init)();
IdManager& GetIdManager() const; IdManager& GetIdManager() const;
void PushNewFuncSub(SFunc* func);
Module() = delete; Module() = delete;
@ -116,67 +107,26 @@ public:
} }
bool RemoveId(u32 id); bool RemoveId(u32 id);
template<typename T> __forceinline void AddFunc(u32 id, T func);
template<typename T> __forceinline void AddFunc(const char* name, T func);
template<typename T> __forceinline void AddFuncSub(const char group[8], const u64 ops[], const char* name, T func);
}; };
u32 add_ps3_func(ModuleFunc func); u32 add_ppu_func(ModuleFunc func);
ModuleFunc* get_ps3_func_by_nid(u32 nid, u32* out_index = nullptr); ModuleFunc* get_ppu_func_by_nid(u32 nid, u32* out_index = nullptr);
ModuleFunc* get_ps3_func_by_index(u32 index); ModuleFunc* get_ppu_func_by_index(u32 index);
void execute_ps3_func_by_index(PPUThread& CPU, u32 id); void execute_ppu_func_by_index(PPUThread& CPU, u32 id);
void clear_ps3_functions(); void clear_ppu_functions();
u32 get_function_id(const char* name); u32 get_function_id(const char* name);
template<typename T> u32 add_ppu_func_sub(StaticFunc sf);
__forceinline void Module::AddFunc(u32 id, T func) u32 add_ppu_func_sub(const char group[8], const u64 ops[], const char* name, Module* module, ppu_func_caller func);
{
add_ps3_func(ModuleFunc(id, this, bind_func(func)));
}
template<typename T> void hook_ppu_funcs(u32* base, u32 size);
__forceinline void Module::AddFunc(const char* name, T func)
{
AddFunc(get_function_id(name), func);
}
template<typename T> #define REG_FUNC(module, name) add_ppu_func(ModuleFunc(get_function_id(#name), &module, bind_func(name)))
__forceinline void Module::AddFuncSub(const char group[8], const u64 ops[], const char* name, T func)
{
if (!ops[0]) return;
SFunc* sf = new SFunc; #define REG_UNNAMED(module, nid) add_ppu_func(ModuleFunc(0x##nid, &module, bind_func(_nid_##nid)))
sf->ptr = (void *)func;
sf->func = bind_func(func);
sf->name = name;
sf->group = *(u64*)group;
sf->found = 0;
// TODO: check for self-inclusions, use CRC
for (u32 i = 0; ops[i]; i++)
{
SFuncOp op;
op.mask = ops[i] >> 32;
op.crc = (u32)ops[i];
if (op.mask) op.crc &= op.mask;
op.mask = re32(op.mask);
op.crc = re32(op.crc);
sf->ops.push_back(op);
}
PushNewFuncSub(sf);
}
void fix_import(Module* module, u32 nid, u32 addr);
#define FIX_IMPORT(module, func, addr) fix_import(module, get_function_id(#func), addr)
void fix_relocs(Module* module, u32 lib, u32 start, u32 end, u32 seg2);
#define REG_SUB(module, group, name, ...) \ #define REG_SUB(module, group, name, ...) \
static const u64 name ## _table[] = {__VA_ARGS__ , 0}; \ static const u64 name ## _table[] = {__VA_ARGS__ , 0}; \
module.AddFuncSub(group, name ## _table, #name, name) if (name ## _table[0]) add_ppu_func_sub(group, name ## _table, #name, &module, bind_func(name))
#define REG_FUNC(module, name) module.AddFunc(get_function_id(#name), name)
#define UNIMPLEMENTED_FUNC(module) module.Error("%s", __FUNCTION__) #define UNIMPLEMENTED_FUNC(module) module.Error("%s", __FUNCTION__)

46
rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp
View File

@ -212,34 +212,34 @@ s32 cellAtracGetInternalErrorInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32>
Module cellAtrac("cellAtrac", []() Module cellAtrac("cellAtrac", []()
{ {
cellAtrac.AddFunc(0x66afc68e, cellAtracSetDataAndGetMemSize); REG_FUNC(cellAtrac, cellAtracSetDataAndGetMemSize);
cellAtrac.AddFunc(0xfa293e88, cellAtracCreateDecoder); REG_FUNC(cellAtrac, cellAtracCreateDecoder);
cellAtrac.AddFunc(0x2642d4cc, cellAtracCreateDecoderExt); REG_FUNC(cellAtrac, cellAtracCreateDecoderExt);
cellAtrac.AddFunc(0x761cb9be, cellAtracDeleteDecoder); REG_FUNC(cellAtrac, cellAtracDeleteDecoder);
cellAtrac.AddFunc(0x8eb0e65f, cellAtracDecode); REG_FUNC(cellAtrac, cellAtracDecode);
cellAtrac.AddFunc(0x2bfff084, cellAtracGetStreamDataInfo); REG_FUNC(cellAtrac, cellAtracGetStreamDataInfo);
cellAtrac.AddFunc(0x46cfc013, cellAtracAddStreamData); REG_FUNC(cellAtrac, cellAtracAddStreamData);
cellAtrac.AddFunc(0xdfab73aa, cellAtracGetRemainFrame); REG_FUNC(cellAtrac, cellAtracGetRemainFrame);
cellAtrac.AddFunc(0xc9a95fcb, cellAtracGetVacantSize); REG_FUNC(cellAtrac, cellAtracGetVacantSize);
cellAtrac.AddFunc(0x99efe171, cellAtracIsSecondBufferNeeded); REG_FUNC(cellAtrac, cellAtracIsSecondBufferNeeded);
cellAtrac.AddFunc(0xbe07f05e, cellAtracGetSecondBufferInfo); REG_FUNC(cellAtrac, cellAtracGetSecondBufferInfo);
cellAtrac.AddFunc(0x06ddb53e, cellAtracSetSecondBuffer); REG_FUNC(cellAtrac, cellAtracSetSecondBuffer);
cellAtrac.AddFunc(0x0f9667b6, cellAtracGetChannel); REG_FUNC(cellAtrac, cellAtracGetChannel);
cellAtrac.AddFunc(0x5f62d546, cellAtracGetMaxSample); REG_FUNC(cellAtrac, cellAtracGetMaxSample);
cellAtrac.AddFunc(0x4797d1ff, cellAtracGetNextSample); REG_FUNC(cellAtrac, cellAtracGetNextSample);
cellAtrac.AddFunc(0xcf01d5d4, cellAtracGetSoundInfo); REG_FUNC(cellAtrac, cellAtracGetSoundInfo);
cellAtrac.AddFunc(0x7b22e672, cellAtracGetNextDecodePosition); REG_FUNC(cellAtrac, cellAtracGetNextDecodePosition);
cellAtrac.AddFunc(0x006016da, cellAtracGetBitrate); REG_FUNC(cellAtrac, cellAtracGetBitrate);
cellAtrac.AddFunc(0xab6b6dbf, cellAtracGetLoopInfo); REG_FUNC(cellAtrac, cellAtracGetLoopInfo);
cellAtrac.AddFunc(0x78ba5c41, cellAtracSetLoopNum); REG_FUNC(cellAtrac, cellAtracSetLoopNum);
cellAtrac.AddFunc(0x99fb73d1, cellAtracGetBufferInfoForResetting); REG_FUNC(cellAtrac, cellAtracGetBufferInfoForResetting);
cellAtrac.AddFunc(0x7772eb2b, cellAtracResetPlayPosition); REG_FUNC(cellAtrac, cellAtracResetPlayPosition);
cellAtrac.AddFunc(0xb5c11938, cellAtracGetInternalErrorInfo); REG_FUNC(cellAtrac, cellAtracGetInternalErrorInfo);
}); });

8
rpcs3/Emu/SysCalls/Modules/cellBgdl.cpp
View File

@ -41,9 +41,9 @@ int cellBGDLGetMode()
void cellBgdl_init() void cellBgdl_init()
{ {
cellBgdl.AddFunc(0x4e9bb95b, cellBGDLGetInfo); REG_FUNC(cellBgdl, cellBGDLGetInfo);
cellBgdl.AddFunc(0x2ab0d183, cellBGDLGetInfo2); REG_FUNC(cellBgdl, cellBGDLGetInfo2);
cellBgdl.AddFunc(0x7e134a90, cellBGDLSetMode); REG_FUNC(cellBgdl, cellBGDLSetMode);
cellBgdl.AddFunc(0x74e57bdf, cellBGDLGetMode); REG_FUNC(cellBgdl, cellBGDLGetMode);
} }
#endif #endif

60
rpcs3/Emu/SysCalls/Modules/cellCamera.cpp
View File

@ -569,38 +569,38 @@ void cellCamera_unload()
Module cellCamera("cellCamera", []() Module cellCamera("cellCamera", []()
{ {
cellCamera.AddFunc(0xbf47c5dd, cellCameraInit); REG_FUNC(cellCamera, cellCameraInit);
cellCamera.AddFunc(0x5ad46570, cellCameraEnd); REG_FUNC(cellCamera, cellCameraEnd);
cellCamera.AddFunc(0x85e1b8da, cellCameraOpen); REG_FUNC(cellCamera, cellCameraOpen);
cellCamera.AddFunc(0x5d25f866, cellCameraOpenEx); REG_FUNC(cellCamera, cellCameraOpenEx);
cellCamera.AddFunc(0x379c5dd6, cellCameraClose); REG_FUNC(cellCamera, cellCameraClose);
cellCamera.AddFunc(0x602e2052, cellCameraGetDeviceGUID); REG_FUNC(cellCamera, cellCameraGetDeviceGUID);
cellCamera.AddFunc(0x58bc5870, cellCameraGetType); REG_FUNC(cellCamera, cellCameraGetType);
cellCamera.AddFunc(0x8ca53dde, cellCameraIsAvailable); REG_FUNC(cellCamera, cellCameraIsAvailable);
cellCamera.AddFunc(0x7e063bbc, cellCameraIsAttached); REG_FUNC(cellCamera, cellCameraIsAttached);
cellCamera.AddFunc(0xfa160f24, cellCameraIsOpen); REG_FUNC(cellCamera, cellCameraIsOpen);
cellCamera.AddFunc(0x5eebf24e, cellCameraIsStarted); REG_FUNC(cellCamera, cellCameraIsStarted);
cellCamera.AddFunc(0x532b8aaa, cellCameraGetAttribute); REG_FUNC(cellCamera, cellCameraGetAttribute);
cellCamera.AddFunc(0x8cd56eee, cellCameraSetAttribute); REG_FUNC(cellCamera, cellCameraSetAttribute);
cellCamera.AddFunc(0x7dac520c, cellCameraGetBufferSize); REG_FUNC(cellCamera, cellCameraGetBufferSize);
cellCamera.AddFunc(0x10697d7f, cellCameraGetBufferInfo); REG_FUNC(cellCamera, cellCameraGetBufferInfo);
cellCamera.AddFunc(0x0e63c444, cellCameraGetBufferInfoEx); REG_FUNC(cellCamera, cellCameraGetBufferInfoEx);
cellCamera.AddFunc(0x61dfbe83, cellCameraPrepExtensionUnit); REG_FUNC(cellCamera, cellCameraPrepExtensionUnit);
cellCamera.AddFunc(0xeb6f95fb, cellCameraCtrlExtensionUnit); REG_FUNC(cellCamera, cellCameraCtrlExtensionUnit);
cellCamera.AddFunc(0xb602e328, cellCameraGetExtensionUnit); REG_FUNC(cellCamera, cellCameraGetExtensionUnit);
cellCamera.AddFunc(0x2dea3e9b, cellCameraSetExtensionUnit); REG_FUNC(cellCamera, cellCameraSetExtensionUnit);
cellCamera.AddFunc(0x81f83db9, cellCameraReset); REG_FUNC(cellCamera, cellCameraReset);
cellCamera.AddFunc(0x456dc4aa, cellCameraStart); REG_FUNC(cellCamera, cellCameraStart);
cellCamera.AddFunc(0x3845d39b, cellCameraRead); REG_FUNC(cellCamera, cellCameraRead);
cellCamera.AddFunc(0x21fc151f, cellCameraReadEx); REG_FUNC(cellCamera, cellCameraReadEx);
cellCamera.AddFunc(0xe28b206b, cellCameraReadComplete); REG_FUNC(cellCamera, cellCameraReadComplete);
cellCamera.AddFunc(0x02f5ced0, cellCameraStop); REG_FUNC(cellCamera, cellCameraStop);
cellCamera.AddFunc(0xb0647e5a, cellCameraSetNotifyEventQueue); REG_FUNC(cellCamera, cellCameraSetNotifyEventQueue);
cellCamera.AddFunc(0x9b98d258, cellCameraRemoveNotifyEventQueue); REG_FUNC(cellCamera, cellCameraRemoveNotifyEventQueue);
cellCamera.AddFunc(0xa7fd2f5b, cellCameraSetNotifyEventQueue2); REG_FUNC(cellCamera, cellCameraSetNotifyEventQueue2);
cellCamera.AddFunc(0x44673f07, cellCameraRemoveNotifyEventQueue2); REG_FUNC(cellCamera, cellCameraRemoveNotifyEventQueue2);
}); });

18
rpcs3/Emu/SysCalls/Modules/cellCelp8Enc.cpp
View File

@ -71,14 +71,14 @@ int cellCelp8EncGetAu()
void cellCelp8Enc_init() void cellCelp8Enc_init()
{ {
cellCelp8Enc.AddFunc(0x2d677e0c, cellCelp8EncQueryAttr); REG_FUNC(cellCelp8Enc, cellCelp8EncQueryAttr);
cellCelp8Enc.AddFunc(0x2eb6efee, cellCelp8EncOpen); REG_FUNC(cellCelp8Enc, cellCelp8EncOpen);
cellCelp8Enc.AddFunc(0xcd48ad62, cellCelp8EncOpenEx); REG_FUNC(cellCelp8Enc, cellCelp8EncOpenEx);
cellCelp8Enc.AddFunc(0xfd2566b4, cellCelp8EncClose); REG_FUNC(cellCelp8Enc, cellCelp8EncClose);
cellCelp8Enc.AddFunc(0x0f6ab57b, cellCelp8EncStart); REG_FUNC(cellCelp8Enc, cellCelp8EncStart);
cellCelp8Enc.AddFunc(0xbbbc2c1c, cellCelp8EncEnd); REG_FUNC(cellCelp8Enc, cellCelp8EncEnd);
cellCelp8Enc.AddFunc(0x2099f86e, cellCelp8EncEncodeFrame); REG_FUNC(cellCelp8Enc, cellCelp8EncEncodeFrame);
cellCelp8Enc.AddFunc(0x29da1ea6, cellCelp8EncWaitForOutput); REG_FUNC(cellCelp8Enc, cellCelp8EncWaitForOutput);
cellCelp8Enc.AddFunc(0x48c5020d, cellCelp8EncGetAu); REG_FUNC(cellCelp8Enc, cellCelp8EncGetAu);
} }
#endif #endif

18
rpcs3/Emu/SysCalls/Modules/cellCelpEnc.cpp
View File

@ -71,14 +71,14 @@ int cellCelpEncGetAu()
void cellCelpEnc_init() void cellCelpEnc_init()
{ {
cellCelpEnc.AddFunc(0x6b148570, cellCelpEncQueryAttr); REG_FUNC(cellCelpEnc, cellCelpEncQueryAttr);
cellCelpEnc.AddFunc(0x77b3b29a, cellCelpEncOpen); REG_FUNC(cellCelpEnc, cellCelpEncOpen);
cellCelpEnc.AddFunc(0x9eb084db, cellCelpEncOpenEx); REG_FUNC(cellCelpEnc, cellCelpEncOpenEx);
cellCelpEnc.AddFunc(0x15ec0cca, cellCelpEncClose); REG_FUNC(cellCelpEnc, cellCelpEncClose);
cellCelpEnc.AddFunc(0x55dc23de, cellCelpEncStart); REG_FUNC(cellCelpEnc, cellCelpEncStart);
cellCelpEnc.AddFunc(0xf2b85dff, cellCelpEncEnd); REG_FUNC(cellCelpEnc, cellCelpEncEnd);
cellCelpEnc.AddFunc(0x81fe030c, cellCelpEncEncodeFrame); REG_FUNC(cellCelpEnc, cellCelpEncEncodeFrame);
cellCelpEnc.AddFunc(0x9b244272, cellCelpEncWaitForOutput); REG_FUNC(cellCelpEnc, cellCelpEncWaitForOutput);
cellCelpEnc.AddFunc(0x3773692f, cellCelpEncGetAu); REG_FUNC(cellCelpEnc, cellCelpEncGetAu);
} }
#endif #endif

40
rpcs3/Emu/SysCalls/Modules/cellDmux.cpp
View File

@ -1170,24 +1170,24 @@ int cellDmuxFlushEs(u32 esHandle)
Module cellDmux("cellDmux", []() Module cellDmux("cellDmux", []()
{ {
cellDmux.AddFunc(0xa2d4189b, cellDmuxQueryAttr); REG_FUNC(cellDmux, cellDmuxQueryAttr);
cellDmux.AddFunc(0x3f76e3cd, cellDmuxQueryAttr2); REG_FUNC(cellDmux, cellDmuxQueryAttr2);
cellDmux.AddFunc(0x68492de9, cellDmuxOpen); REG_FUNC(cellDmux, cellDmuxOpen);
cellDmux.AddFunc(0xf6c23560, cellDmuxOpenEx); REG_FUNC(cellDmux, cellDmuxOpenEx);
cellDmux.AddFunc(0x11bc3a6c, cellDmuxOpen2); REG_FUNC(cellDmux, cellDmuxOpen2);
cellDmux.AddFunc(0x8c692521, cellDmuxClose); REG_FUNC(cellDmux, cellDmuxClose);
cellDmux.AddFunc(0x04e7499f, cellDmuxSetStream); REG_FUNC(cellDmux, cellDmuxSetStream);
cellDmux.AddFunc(0x5d345de9, cellDmuxResetStream); REG_FUNC(cellDmux, cellDmuxResetStream);
cellDmux.AddFunc(0xccff1284, cellDmuxResetStreamAndWaitDone); REG_FUNC(cellDmux, cellDmuxResetStreamAndWaitDone);
cellDmux.AddFunc(0x02170d1a, cellDmuxQueryEsAttr); REG_FUNC(cellDmux, cellDmuxQueryEsAttr);
cellDmux.AddFunc(0x52911bcf, cellDmuxQueryEsAttr2); REG_FUNC(cellDmux, cellDmuxQueryEsAttr2);
cellDmux.AddFunc(0x7b56dc3f, cellDmuxEnableEs); REG_FUNC(cellDmux, cellDmuxEnableEs);
cellDmux.AddFunc(0x05371c8d, cellDmuxDisableEs); REG_FUNC(cellDmux, cellDmuxDisableEs);
cellDmux.AddFunc(0x21d424f0, cellDmuxResetEs); REG_FUNC(cellDmux, cellDmuxResetEs);
cellDmux.AddFunc(0x42c716b5, cellDmuxGetAu); REG_FUNC(cellDmux, cellDmuxGetAu);
cellDmux.AddFunc(0x2750c5e0, cellDmuxPeekAu); REG_FUNC(cellDmux, cellDmuxPeekAu);
cellDmux.AddFunc(0x2c9a5857, cellDmuxGetAuEx); REG_FUNC(cellDmux, cellDmuxGetAuEx);
cellDmux.AddFunc(0x002e8da2, cellDmuxPeekAuEx); REG_FUNC(cellDmux, cellDmuxPeekAuEx);
cellDmux.AddFunc(0x24ea6474, cellDmuxReleaseAu); REG_FUNC(cellDmux, cellDmuxReleaseAu);
cellDmux.AddFunc(0xebb3b2bd, cellDmuxFlushEs); REG_FUNC(cellDmux, cellDmuxFlushEs);
}); });

94
rpcs3/Emu/SysCalls/Modules/cellFiber.cpp
View File

@ -293,57 +293,57 @@ int cellFiberPpuUtilWorkerControlInitializeWithAttribute()
Module cellFiber("cellFiber", []() Module cellFiber("cellFiber", []()
{ {
cellFiber.AddFunc(0x55870804, _cellFiberPpuInitialize); REG_FUNC(cellFiber, _cellFiberPpuInitialize);
cellFiber.AddFunc(0x9e25c72d, _cellFiberPpuSchedulerAttributeInitialize); REG_FUNC(cellFiber, _cellFiberPpuSchedulerAttributeInitialize);
cellFiber.AddFunc(0xee3b604d, cellFiberPpuInitializeScheduler); REG_FUNC(cellFiber, cellFiberPpuInitializeScheduler);
cellFiber.AddFunc(0x8b6baa01, cellFiberPpuFinalizeScheduler); REG_FUNC(cellFiber, cellFiberPpuFinalizeScheduler);
cellFiber.AddFunc(0x12b1acf0, cellFiberPpuRunFibers); REG_FUNC(cellFiber, cellFiberPpuRunFibers);
cellFiber.AddFunc(0xf6c6900c, cellFiberPpuCheckFlags); REG_FUNC(cellFiber, cellFiberPpuCheckFlags);
cellFiber.AddFunc(0xe492a675, cellFiberPpuHasRunnableFiber); REG_FUNC(cellFiber, cellFiberPpuHasRunnableFiber);
cellFiber.AddFunc(0xc11f8056, _cellFiberPpuAttributeInitialize); REG_FUNC(cellFiber, _cellFiberPpuAttributeInitialize);
cellFiber.AddFunc(0x7c2f4034, cellFiberPpuCreateFiber); REG_FUNC(cellFiber, cellFiberPpuCreateFiber);
cellFiber.AddFunc(0xfa8d5f95, cellFiberPpuExit); REG_FUNC(cellFiber, cellFiberPpuExit);
cellFiber.AddFunc(0x0c44f441, cellFiberPpuYield); REG_FUNC(cellFiber, cellFiberPpuYield);
cellFiber.AddFunc(0xa6004249, cellFiberPpuJoinFiber); REG_FUNC(cellFiber, cellFiberPpuJoinFiber);
cellFiber.AddFunc(0x5d9a7034, cellFiberPpuSelf); REG_FUNC(cellFiber, cellFiberPpuSelf);
cellFiber.AddFunc(0x8afb8356, cellFiberPpuSendSignal); REG_FUNC(cellFiber, cellFiberPpuSendSignal);
cellFiber.AddFunc(0x6c164b3b, cellFiberPpuWaitSignal); REG_FUNC(cellFiber, cellFiberPpuWaitSignal);
cellFiber.AddFunc(0xa4599cf3, cellFiberPpuWaitFlag); REG_FUNC(cellFiber, cellFiberPpuWaitFlag);
cellFiber.AddFunc(0xb0594b2d, cellFiberPpuGetScheduler); REG_FUNC(cellFiber, cellFiberPpuGetScheduler);
cellFiber.AddFunc(0xfbf5fe40, cellFiberPpuSetPriority); REG_FUNC(cellFiber, cellFiberPpuSetPriority);
cellFiber.AddFunc(0xf3e81219, cellFiberPpuCheckStackLimit); REG_FUNC(cellFiber, cellFiberPpuCheckStackLimit);
cellFiber.AddFunc(0x31252ec3, _cellFiberPpuContextAttributeInitialize); REG_FUNC(cellFiber, _cellFiberPpuContextAttributeInitialize);
cellFiber.AddFunc(0x72086315, cellFiberPpuContextInitialize); REG_FUNC(cellFiber, cellFiberPpuContextInitialize);
cellFiber.AddFunc(0xb3a48079, cellFiberPpuContextFinalize); REG_FUNC(cellFiber, cellFiberPpuContextFinalize);
cellFiber.AddFunc(0xaba1c563, cellFiberPpuContextRun); REG_FUNC(cellFiber, cellFiberPpuContextRun);
cellFiber.AddFunc(0xd0066b17, cellFiberPpuContextSwitch); REG_FUNC(cellFiber, cellFiberPpuContextSwitch);
cellFiber.AddFunc(0x34a81091, cellFiberPpuContextSelf); REG_FUNC(cellFiber, cellFiberPpuContextSelf);
cellFiber.AddFunc(0x01036193, cellFiberPpuContextReturnToThread); REG_FUNC(cellFiber, cellFiberPpuContextReturnToThread);
cellFiber.AddFunc(0xb90c871b, cellFiberPpuContextCheckStackLimit); REG_FUNC(cellFiber, cellFiberPpuContextCheckStackLimit);
cellFiber.AddFunc(0x081c98be, cellFiberPpuContextRunScheduler); REG_FUNC(cellFiber, cellFiberPpuContextRunScheduler);
cellFiber.AddFunc(0x0a25b6c8, cellFiberPpuContextEnterScheduler); REG_FUNC(cellFiber, cellFiberPpuContextEnterScheduler);
cellFiber.AddFunc(0xbf9cd933, cellFiberPpuSchedulerTraceInitialize); REG_FUNC(cellFiber, cellFiberPpuSchedulerTraceInitialize);
cellFiber.AddFunc(0x3860a12a, cellFiberPpuSchedulerTraceFinalize); REG_FUNC(cellFiber, cellFiberPpuSchedulerTraceFinalize);
cellFiber.AddFunc(0xadedbebf, cellFiberPpuSchedulerTraceStart); REG_FUNC(cellFiber, cellFiberPpuSchedulerTraceStart);
cellFiber.AddFunc(0xe665f9a9, cellFiberPpuSchedulerTraceStop); REG_FUNC(cellFiber, cellFiberPpuSchedulerTraceStop);
cellFiber.AddFunc(0x68ba4568, _cellFiberPpuUtilWorkerControlAttributeInitialize); REG_FUNC(cellFiber, _cellFiberPpuUtilWorkerControlAttributeInitialize);
cellFiber.AddFunc(0x1e7a247a, cellFiberPpuUtilWorkerControlRunFibers); REG_FUNC(cellFiber, cellFiberPpuUtilWorkerControlRunFibers);
cellFiber.AddFunc(0x3204b146, cellFiberPpuUtilWorkerControlInitialize); REG_FUNC(cellFiber, cellFiberPpuUtilWorkerControlInitialize);
cellFiber.AddFunc(0x392c5aa5, cellFiberPpuUtilWorkerControlSetPollingMode); REG_FUNC(cellFiber, cellFiberPpuUtilWorkerControlSetPollingMode);
cellFiber.AddFunc(0x3b417f82, cellFiberPpuUtilWorkerControlJoinFiber); REG_FUNC(cellFiber, cellFiberPpuUtilWorkerControlJoinFiber);
cellFiber.AddFunc(0x4fc86b2c, cellFiberPpuUtilWorkerControlDisconnectEventQueue); REG_FUNC(cellFiber, cellFiberPpuUtilWorkerControlDisconnectEventQueue);
cellFiber.AddFunc(0x5d3992dd, cellFiberPpuUtilWorkerControlSendSignal); REG_FUNC(cellFiber, cellFiberPpuUtilWorkerControlSendSignal);
cellFiber.AddFunc(0x62a20f0d, cellFiberPpuUtilWorkerControlConnectEventQueueToSpurs); REG_FUNC(cellFiber, cellFiberPpuUtilWorkerControlConnectEventQueueToSpurs);
cellFiber.AddFunc(0xa27c95ca, cellFiberPpuUtilWorkerControlFinalize); REG_FUNC(cellFiber, cellFiberPpuUtilWorkerControlFinalize);
cellFiber.AddFunc(0xbabf714b, cellFiberPpuUtilWorkerControlWakeup); REG_FUNC(cellFiber, cellFiberPpuUtilWorkerControlWakeup);
cellFiber.AddFunc(0xbfca88d3, cellFiberPpuUtilWorkerControlCreateFiber); REG_FUNC(cellFiber, cellFiberPpuUtilWorkerControlCreateFiber);
cellFiber.AddFunc(0xc04e2438, cellFiberPpuUtilWorkerControlShutdown); REG_FUNC(cellFiber, cellFiberPpuUtilWorkerControlShutdown);
cellFiber.AddFunc(0xea6dc1ad, cellFiberPpuUtilWorkerControlCheckFlags); REG_FUNC(cellFiber, cellFiberPpuUtilWorkerControlCheckFlags);
cellFiber.AddFunc(0xf2ccad4f, cellFiberPpuUtilWorkerControlInitializeWithAttribute); REG_FUNC(cellFiber, cellFiberPpuUtilWorkerControlInitializeWithAttribute);
}); });

100
rpcs3/Emu/SysCalls/Modules/cellFont.cpp
View File

@ -588,54 +588,54 @@ Module cellFont("cellFont", []()
delete s_fontInternalInstance; delete s_fontInternalInstance;
}; };
cellFont.AddFunc(0x25c107e6, cellFontInit); REG_FUNC(cellFont, cellFontInit);
cellFont.AddFunc(0x6bf6f832, cellFontSetFontsetOpenMode); REG_FUNC(cellFont, cellFontSetFontsetOpenMode);
cellFont.AddFunc(0x6cfada83, cellFontSetFontOpenMode); REG_FUNC(cellFont, cellFontSetFontOpenMode);
cellFont.AddFunc(0x042e74e3, cellFontCreateRenderer); REG_FUNC(cellFont, cellFontCreateRenderer);
cellFont.AddFunc(0x1387c45c, cellFontGetHorizontalLayout); REG_FUNC(cellFont, cellFontGetHorizontalLayout);
cellFont.AddFunc(0x21ebb248, cellFontDestroyRenderer); REG_FUNC(cellFont, cellFontDestroyRenderer);
cellFont.AddFunc(0x227e1e3c, cellFontSetupRenderScalePixel); REG_FUNC(cellFont, cellFontSetupRenderScalePixel);
cellFont.AddFunc(0x29329541, cellFontOpenFontInstance); REG_FUNC(cellFont, cellFontOpenFontInstance);
cellFont.AddFunc(0x297f0e93, cellFontSetScalePixel); REG_FUNC(cellFont, cellFontSetScalePixel);
cellFont.AddFunc(0x2da9fd9d, cellFontGetRenderCharGlyphMetrics); REG_FUNC(cellFont, cellFontGetRenderCharGlyphMetrics);
cellFont.AddFunc(0x40d40544, cellFontEndLibrary); REG_FUNC(cellFont, cellFontEndLibrary);
cellFont.AddFunc(0x66a23100, cellFontBindRenderer); REG_FUNC(cellFont, cellFontBindRenderer);
cellFont.AddFunc(0x7ab47f7e, cellFontEnd); REG_FUNC(cellFont, cellFontEnd);
cellFont.AddFunc(0x8657c8f5, cellFontSetEffectSlant); REG_FUNC(cellFont, cellFontSetEffectSlant);
cellFont.AddFunc(0xe16e679a, cellFontGetEffectSlant); REG_FUNC(cellFont, cellFontGetEffectSlant);
cellFont.AddFunc(0x88be4799, cellFontRenderCharGlyphImage); REG_FUNC(cellFont, cellFontRenderCharGlyphImage);
cellFont.AddFunc(0x90b9465e, cellFontRenderSurfaceInit); REG_FUNC(cellFont, cellFontRenderSurfaceInit);
cellFont.AddFunc(0x98ac5524, cellFontGetFontIdCode); REG_FUNC(cellFont, cellFontGetFontIdCode);
cellFont.AddFunc(0xa885cc9b, cellFontOpenFontset); REG_FUNC(cellFont, cellFontOpenFontset);
cellFont.AddFunc(0xb276f1f6, cellFontCloseFont); REG_FUNC(cellFont, cellFontCloseFont);
cellFont.AddFunc(0xb422b005, cellFontRenderSurfaceSetScissor); REG_FUNC(cellFont, cellFontRenderSurfaceSetScissor);
cellFont.AddFunc(0xd8eaee9f, cellFontGetCharGlyphMetrics); REG_FUNC(cellFont, cellFontGetCharGlyphMetrics);
cellFont.AddFunc(0xf03dcc29, cellFontInitializeWithRevision); REG_FUNC(cellFont, cellFontInitializeWithRevision);
cellFont.AddFunc(0x061049ad, cellFontGraphicsSetFontRGBA); REG_FUNC(cellFont, cellFontGraphicsSetFontRGBA);
cellFont.AddFunc(0x073fa321, cellFontOpenFontsetOnMemory); REG_FUNC(cellFont, cellFontOpenFontsetOnMemory);
cellFont.AddFunc(0x0a7306a4, cellFontOpenFontFile); REG_FUNC(cellFont, cellFontOpenFontFile);
cellFont.AddFunc(0x16322df1, cellFontGraphicsSetScalePixel); REG_FUNC(cellFont, cellFontGraphicsSetScalePixel);
cellFont.AddFunc(0x2388186c, cellFontGraphicsGetScalePixel); REG_FUNC(cellFont, cellFontGraphicsGetScalePixel);
cellFont.AddFunc(0x25253fe4, cellFontSetEffectWeight); REG_FUNC(cellFont, cellFontSetEffectWeight);
cellFont.AddFunc(0x53f529fe, cellFontGlyphSetupVertexesGlyph); REG_FUNC(cellFont, cellFontGlyphSetupVertexesGlyph);
cellFont.AddFunc(0x698897f8, cellFontGetVerticalLayout); REG_FUNC(cellFont, cellFontGetVerticalLayout);
cellFont.AddFunc(0x700e6223, cellFontGetRenderCharGlyphMetricsVertical); REG_FUNC(cellFont, cellFontGetRenderCharGlyphMetricsVertical);
cellFont.AddFunc(0x70f3e728, cellFontSetScalePoint); REG_FUNC(cellFont, cellFontSetScalePoint);
cellFont.AddFunc(0x78d05e08, cellFontSetupRenderEffectSlant); REG_FUNC(cellFont, cellFontSetupRenderEffectSlant);
cellFont.AddFunc(0x7c83bc15, cellFontGraphicsSetLineRGBA); REG_FUNC(cellFont, cellFontGraphicsSetLineRGBA);
cellFont.AddFunc(0x87bd650f, cellFontGraphicsSetDrawType); REG_FUNC(cellFont, cellFontGraphicsSetDrawType);
cellFont.AddFunc(0x8a35c887, cellFontEndGraphics); REG_FUNC(cellFont, cellFontEndGraphics);
cellFont.AddFunc(0x970d4c22, cellFontGraphicsSetupDrawContext); REG_FUNC(cellFont, cellFontGraphicsSetupDrawContext);
cellFont.AddFunc(0x9e19072b, cellFontOpenFontMemory); REG_FUNC(cellFont, cellFontOpenFontMemory);
cellFont.AddFunc(0xa6dc25d1, cellFontSetupRenderEffectWeight); REG_FUNC(cellFont, cellFontSetupRenderEffectWeight);
cellFont.AddFunc(0xa8fae920, cellFontGlyphGetOutlineControlDistance); REG_FUNC(cellFont, cellFontGlyphGetOutlineControlDistance);
cellFont.AddFunc(0xb4d112af, cellFontGlyphGetVertexesGlyphSize); REG_FUNC(cellFont, cellFontGlyphGetVertexesGlyphSize);
cellFont.AddFunc(0xc17259de, cellFontGenerateCharGlyph); REG_FUNC(cellFont, cellFontGenerateCharGlyph);
cellFont.AddFunc(0xd62f5d76, cellFontDeleteGlyph); REG_FUNC(cellFont, cellFontDeleteGlyph);
cellFont.AddFunc(0xdee0836c, cellFontExtend); REG_FUNC(cellFont, cellFontExtend);
cellFont.AddFunc(0xe857a0ca, cellFontRenderCharGlyphImageVertical); REG_FUNC(cellFont, cellFontRenderCharGlyphImageVertical);
cellFont.AddFunc(0xfb3341ba, cellFontSetResolutionDpi); REG_FUNC(cellFont, cellFontSetResolutionDpi);
cellFont.AddFunc(0xfe9a6dd7, cellFontGetCharGlyphMetricsVertical); REG_FUNC(cellFont, cellFontGetCharGlyphMetricsVertical);
cellFont.AddFunc(0xf16379fa, cellFontUnbindRenderer); REG_FUNC(cellFont, cellFontUnbindRenderer);
cellFont.AddFunc(0xb015a84e, cellFontGetRevisionFlags); REG_FUNC(cellFont, cellFontGetRevisionFlags);
}); });

6
rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp
View File

@ -43,7 +43,7 @@ Module cellFontFT("cellFontFT", []()
delete s_fontFtInternalInstance; delete s_fontFtInternalInstance;
}; };
cellFontFT.AddFunc(0x7a0a83c4, cellFontInitLibraryFreeTypeWithRevision); REG_FUNC(cellFontFT, cellFontInitLibraryFreeTypeWithRevision);
cellFontFT.AddFunc(0xec89a187, cellFontFTGetRevisionFlags); REG_FUNC(cellFontFT, cellFontFTGetRevisionFlags);
cellFontFT.AddFunc(0xfa0c2de0, cellFontFTGetInitializedRevisionFlags); REG_FUNC(cellFontFT, cellFontFTGetInitializedRevisionFlags);
}); });

30
rpcs3/Emu/SysCalls/Modules/cellGame.cpp
View File

@ -495,25 +495,25 @@ Module cellGame("cellGame", []()
// (TODO: Disc Exchange functions missing) // (TODO: Disc Exchange functions missing)
cellGame.AddFunc(0xf52639ea, cellGameBootCheck); REG_FUNC(cellGame, cellGameBootCheck);
cellGame.AddFunc(0xce4374f6, cellGamePatchCheck); REG_FUNC(cellGame, cellGamePatchCheck);
cellGame.AddFunc(0xdb9819f3, cellGameDataCheck); REG_FUNC(cellGame, cellGameDataCheck);
cellGame.AddFunc(0x70acec67, cellGameContentPermit); REG_FUNC(cellGame, cellGameContentPermit);
cellGame.AddFunc(0x42a2e133, cellGameCreateGameData); REG_FUNC(cellGame, cellGameCreateGameData);
cellGame.AddFunc(0xb367c6e3, cellGameDeleteGameData); REG_FUNC(cellGame, cellGameDeleteGameData);
cellGame.AddFunc(0xb7a45caf, cellGameGetParamInt); REG_FUNC(cellGame, cellGameGetParamInt);
//cellGame.AddFunc(, cellGameSetParamInt); //cellGame.AddFunc(, cellGameSetParamInt);
cellGame.AddFunc(0x3a5d726a, cellGameGetParamString); REG_FUNC(cellGame, cellGameGetParamString);
cellGame.AddFunc(0xdaa5cd20, cellGameSetParamString); REG_FUNC(cellGame, cellGameSetParamString);
cellGame.AddFunc(0xef9d42d5, cellGameGetSizeKB); REG_FUNC(cellGame, cellGameGetSizeKB);
cellGame.AddFunc(0x2a8e6b92, cellGameGetDiscContentInfoUpdatePath); REG_FUNC(cellGame, cellGameGetDiscContentInfoUpdatePath);
cellGame.AddFunc(0xa80bf223, cellGameGetLocalWebContentPath); REG_FUNC(cellGame, cellGameGetLocalWebContentPath);
cellGame.AddFunc(0xb0a1f8c6, cellGameContentErrorDialog); REG_FUNC(cellGame, cellGameContentErrorDialog);
cellGame.AddFunc(0xd24e3928, cellGameThemeInstall); REG_FUNC(cellGame, cellGameThemeInstall);
cellGame.AddFunc(0x87406734, cellGameThemeInstallFromBuffer); REG_FUNC(cellGame, cellGameThemeInstallFromBuffer);
//cellGame.AddFunc(, CellGameThemeInstallCallback); //cellGame.AddFunc(, CellGameThemeInstallCallback);
}); });

160
rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
View File

@ -1090,14 +1090,14 @@ void cellGcmSetDefaultCommandBuffer()
// Other // Other
//------------------------------------------------------------------------ //------------------------------------------------------------------------
s32 cellGcmSetFlipCommand(vm::ptr<CellGcmContextData> ctx, u32 id) s32 _cellGcmSetFlipCommand(vm::ptr<CellGcmContextData> ctx, u32 id)
{ {
cellGcmSys.Log("cellGcmSetFlipCommand(ctx_addr=0x%x, id=0x%x)", ctx.addr(), id); cellGcmSys.Log("cellGcmSetFlipCommand(ctx_addr=0x%x, id=0x%x)", ctx.addr(), id);
return cellGcmSetPrepareFlip(ctx, id); return cellGcmSetPrepareFlip(ctx, id);
} }
s32 cellGcmSetFlipCommandWithWaitLabel(vm::ptr<CellGcmContextData> ctx, u32 id, u32 label_index, u32 label_value) s32 _cellGcmSetFlipCommandWithWaitLabel(vm::ptr<CellGcmContextData> ctx, u32 id, u32 label_index, u32 label_value)
{ {
cellGcmSys.Log("cellGcmSetFlipCommandWithWaitLabel(ctx_addr=0x%x, id=0x%x, label_index=0x%x, label_value=0x%x)", cellGcmSys.Log("cellGcmSetFlipCommandWithWaitLabel(ctx_addr=0x%x, id=0x%x, label_index=0x%x, label_value=0x%x)",
ctx.addr(), id, label_index, label_value); ctx.addr(), id, label_index, label_value);
@ -1218,23 +1218,23 @@ Module cellGcmSys("cellGcmSys", []()
local_addr = 0; local_addr = 0;
// Data Retrieval // Data Retrieval
cellGcmSys.AddFunc(0xc8f3bd09, cellGcmGetCurrentField); REG_FUNC(cellGcmSys, cellGcmGetCurrentField);
cellGcmSys.AddFunc(0xf80196c1, cellGcmGetLabelAddress); REG_FUNC(cellGcmSys, cellGcmGetLabelAddress);
cellGcmSys.AddFunc(0x21cee035, cellGcmGetNotifyDataAddress); REG_FUNC(cellGcmSys, cellGcmGetNotifyDataAddress);
cellGcmSys.AddFunc(0x661fe266, _cellGcmFunc12); REG_FUNC(cellGcmSys, _cellGcmFunc12);
cellGcmSys.AddFunc(0x99d397ac, cellGcmGetReport); REG_FUNC(cellGcmSys, cellGcmGetReport);
cellGcmSys.AddFunc(0x9a0159af, cellGcmGetReportDataAddress); REG_FUNC(cellGcmSys, cellGcmGetReportDataAddress);
cellGcmSys.AddFunc(0x8572bce2, cellGcmGetReportDataAddressLocation); REG_FUNC(cellGcmSys, cellGcmGetReportDataAddressLocation);
cellGcmSys.AddFunc(0xa6b180ac, cellGcmGetReportDataLocation); REG_FUNC(cellGcmSys, cellGcmGetReportDataLocation);
cellGcmSys.AddFunc(0x5a41c10f, cellGcmGetTimeStamp); REG_FUNC(cellGcmSys, cellGcmGetTimeStamp);
cellGcmSys.AddFunc(0x2ad4951b, cellGcmGetTimeStampLocation); REG_FUNC(cellGcmSys, cellGcmGetTimeStampLocation);
// Command Buffer Control // Command Buffer Control
cellGcmSys.AddFunc(0xa547adde, cellGcmGetControlRegister); REG_FUNC(cellGcmSys, cellGcmGetControlRegister);
cellGcmSys.AddFunc(0x5e2ee0f0, cellGcmGetDefaultCommandWordSize); REG_FUNC(cellGcmSys, cellGcmGetDefaultCommandWordSize);
cellGcmSys.AddFunc(0x8cdf8c70, cellGcmGetDefaultSegmentWordSize); REG_FUNC(cellGcmSys, cellGcmGetDefaultSegmentWordSize);
cellGcmSys.AddFunc(0xcaabd992, cellGcmInitDefaultFifoMode); REG_FUNC(cellGcmSys, cellGcmInitDefaultFifoMode);
cellGcmSys.AddFunc(0x9ba451e4, cellGcmSetDefaultFifoSize); REG_FUNC(cellGcmSys, cellGcmSetDefaultFifoSize);
//cellGcmSys.AddFunc(, cellGcmReserveMethodSize); //cellGcmSys.AddFunc(, cellGcmReserveMethodSize);
//cellGcmSys.AddFunc(, cellGcmResetDefaultCommandBuffer); //cellGcmSys.AddFunc(, cellGcmResetDefaultCommandBuffer);
//cellGcmSys.AddFunc(, cellGcmSetupContextData); //cellGcmSys.AddFunc(, cellGcmSetupContextData);
@ -1243,80 +1243,80 @@ Module cellGcmSys("cellGcmSys", []()
//cellGcmSys.AddFunc(, cellGcmFlush); //cellGcmSys.AddFunc(, cellGcmFlush);
// Hardware Resource Management // Hardware Resource Management
cellGcmSys.AddFunc(0x4524cccd, cellGcmBindTile); REG_FUNC(cellGcmSys, cellGcmBindTile);
cellGcmSys.AddFunc(0x9dc04436, cellGcmBindZcull); REG_FUNC(cellGcmSys, cellGcmBindZcull);
cellGcmSys.AddFunc(0x1f61b3ff, cellGcmDumpGraphicsError); REG_FUNC(cellGcmSys, cellGcmDumpGraphicsError);
cellGcmSys.AddFunc(0xe315a0b2, cellGcmGetConfiguration); REG_FUNC(cellGcmSys, cellGcmGetConfiguration);
cellGcmSys.AddFunc(0x371674cf, cellGcmGetDisplayBufferByFlipIndex); REG_FUNC(cellGcmSys, cellGcmGetDisplayBufferByFlipIndex);
cellGcmSys.AddFunc(0x72a577ce, cellGcmGetFlipStatus); REG_FUNC(cellGcmSys, cellGcmGetFlipStatus);
cellGcmSys.AddFunc(0x63387071, cellGcmGetLastFlipTime); REG_FUNC(cellGcmSys, cellGcmGetLastFlipTime);
cellGcmSys.AddFunc(0x23ae55a3, cellGcmGetLastSecondVTime); REG_FUNC(cellGcmSys, cellGcmGetLastSecondVTime);
cellGcmSys.AddFunc(0x055bd74d, cellGcmGetTiledPitchSize); REG_FUNC(cellGcmSys, cellGcmGetTiledPitchSize);
cellGcmSys.AddFunc(0x723bbc7e, cellGcmGetVBlankCount); REG_FUNC(cellGcmSys, cellGcmGetVBlankCount);
cellGcmSys.AddFunc(0x5f909b17, _cellGcmFunc1); REG_FUNC(cellGcmSys, _cellGcmFunc1);
cellGcmSys.AddFunc(0x3a33c1fd, _cellGcmFunc15); REG_FUNC(cellGcmSys, _cellGcmFunc15);
cellGcmSys.AddFunc(0x15bae46b, _cellGcmInitBody); REG_FUNC(cellGcmSys, _cellGcmInitBody);
cellGcmSys.AddFunc(0xfce9e764, cellGcmInitSystemMode); REG_FUNC(cellGcmSys, cellGcmInitSystemMode);
cellGcmSys.AddFunc(0xb2e761d4, cellGcmResetFlipStatus); REG_FUNC(cellGcmSys, cellGcmResetFlipStatus);
cellGcmSys.AddFunc(0x51c9d62b, cellGcmSetDebugOutputLevel); REG_FUNC(cellGcmSys, cellGcmSetDebugOutputLevel);
cellGcmSys.AddFunc(0xa53d12ae, cellGcmSetDisplayBuffer); REG_FUNC(cellGcmSys, cellGcmSetDisplayBuffer);
cellGcmSys.AddFunc(0xdc09357e, cellGcmSetFlip); REG_FUNC(cellGcmSys, cellGcmSetFlip);
cellGcmSys.AddFunc(0xa41ef7e8, cellGcmSetFlipHandler); REG_FUNC(cellGcmSys, cellGcmSetFlipHandler);
cellGcmSys.AddFunc(0xacee8542, cellGcmSetFlipImmediate); REG_FUNC(cellGcmSys, cellGcmSetFlipImmediate);
cellGcmSys.AddFunc(0x4ae8d215, cellGcmSetFlipMode); REG_FUNC(cellGcmSys, cellGcmSetFlipMode);
cellGcmSys.AddFunc(0xa47c09ff, cellGcmSetFlipStatus); REG_FUNC(cellGcmSys, cellGcmSetFlipStatus);
cellGcmSys.AddFunc(0xd01b570d, cellGcmSetGraphicsHandler); REG_FUNC(cellGcmSys, cellGcmSetGraphicsHandler);
cellGcmSys.AddFunc(0x0b4b62d5, cellGcmSetPrepareFlip); REG_FUNC(cellGcmSys, cellGcmSetPrepareFlip);
cellGcmSys.AddFunc(0x0a862772, cellGcmSetQueueHandler); REG_FUNC(cellGcmSys, cellGcmSetQueueHandler);
cellGcmSys.AddFunc(0x4d7ce993, cellGcmSetSecondVFrequency); REG_FUNC(cellGcmSys, cellGcmSetSecondVFrequency);
cellGcmSys.AddFunc(0xdc494430, cellGcmSetSecondVHandler); REG_FUNC(cellGcmSys, cellGcmSetSecondVHandler);
cellGcmSys.AddFunc(0xbd100dbc, cellGcmSetTileInfo); REG_FUNC(cellGcmSys, cellGcmSetTileInfo);
cellGcmSys.AddFunc(0x06edea9e, cellGcmSetUserHandler); REG_FUNC(cellGcmSys, cellGcmSetUserHandler);
cellGcmSys.AddFunc(0xffe0160e, cellGcmSetVBlankFrequency); REG_FUNC(cellGcmSys, cellGcmSetVBlankFrequency);
cellGcmSys.AddFunc(0xa91b0402, cellGcmSetVBlankHandler); REG_FUNC(cellGcmSys, cellGcmSetVBlankHandler);
cellGcmSys.AddFunc(0x983fb9aa, cellGcmSetWaitFlip); REG_FUNC(cellGcmSys, cellGcmSetWaitFlip);
cellGcmSys.AddFunc(0xd34a420d, cellGcmSetZcull); REG_FUNC(cellGcmSys, cellGcmSetZcull);
cellGcmSys.AddFunc(0x25b40ab4, cellGcmSortRemapEaIoAddress); REG_FUNC(cellGcmSys, cellGcmSortRemapEaIoAddress);
cellGcmSys.AddFunc(0xd9b7653e, cellGcmUnbindTile); REG_FUNC(cellGcmSys, cellGcmUnbindTile);
cellGcmSys.AddFunc(0xa75640e8, cellGcmUnbindZcull); REG_FUNC(cellGcmSys, cellGcmUnbindZcull);
cellGcmSys.AddFunc(0x657571f7, cellGcmGetTileInfo); REG_FUNC(cellGcmSys, cellGcmGetTileInfo);
cellGcmSys.AddFunc(0xd9a0a879, cellGcmGetZcullInfo); REG_FUNC(cellGcmSys, cellGcmGetZcullInfo);
cellGcmSys.AddFunc(0x0e6b0dae, cellGcmGetDisplayInfo); REG_FUNC(cellGcmSys, cellGcmGetDisplayInfo);
cellGcmSys.AddFunc(0x93806525, cellGcmGetCurrentDisplayBufferId); REG_FUNC(cellGcmSys, cellGcmGetCurrentDisplayBufferId);
cellGcmSys.AddFunc(0xbd6d60d9, cellGcmSetInvalidateTile); REG_FUNC(cellGcmSys, cellGcmSetInvalidateTile);
//cellGcmSys.AddFunc(, cellGcmSetFlipWithWaitLabel); //cellGcmSys.AddFunc(, cellGcmSetFlipWithWaitLabel);
// Memory Mapping // Memory Mapping
cellGcmSys.AddFunc(0x21ac3697, cellGcmAddressToOffset); REG_FUNC(cellGcmSys, cellGcmAddressToOffset);
cellGcmSys.AddFunc(0xfb81c03e, cellGcmGetMaxIoMapSize); REG_FUNC(cellGcmSys, cellGcmGetMaxIoMapSize);
cellGcmSys.AddFunc(0x2922aed0, cellGcmGetOffsetTable); REG_FUNC(cellGcmSys, cellGcmGetOffsetTable);
cellGcmSys.AddFunc(0x2a6fba9c, cellGcmIoOffsetToAddress); REG_FUNC(cellGcmSys, cellGcmIoOffsetToAddress);
cellGcmSys.AddFunc(0x63441cb4, cellGcmMapEaIoAddress); REG_FUNC(cellGcmSys, cellGcmMapEaIoAddress);
cellGcmSys.AddFunc(0x626e8518, cellGcmMapEaIoAddressWithFlags); REG_FUNC(cellGcmSys, cellGcmMapEaIoAddressWithFlags);
cellGcmSys.AddFunc(0xdb769b32, cellGcmMapLocalMemory); REG_FUNC(cellGcmSys, cellGcmMapLocalMemory);
cellGcmSys.AddFunc(0xa114ec67, cellGcmMapMainMemory); REG_FUNC(cellGcmSys, cellGcmMapMainMemory);
cellGcmSys.AddFunc(0xa7ede268, cellGcmReserveIoMapSize); REG_FUNC(cellGcmSys, cellGcmReserveIoMapSize);
cellGcmSys.AddFunc(0xefd00f54, cellGcmUnmapEaIoAddress); REG_FUNC(cellGcmSys, cellGcmUnmapEaIoAddress);
cellGcmSys.AddFunc(0xdb23e867, cellGcmUnmapIoAddress); REG_FUNC(cellGcmSys, cellGcmUnmapIoAddress);
cellGcmSys.AddFunc(0x3b9bd5bd, cellGcmUnreserveIoMapSize); REG_FUNC(cellGcmSys, cellGcmUnreserveIoMapSize);
// Cursor // Cursor
cellGcmSys.AddFunc(0x107bf3a1, cellGcmInitCursor); REG_FUNC(cellGcmSys, cellGcmInitCursor);
cellGcmSys.AddFunc(0xc47d0812, cellGcmSetCursorEnable); REG_FUNC(cellGcmSys, cellGcmSetCursorEnable);
cellGcmSys.AddFunc(0x69c6cc82, cellGcmSetCursorDisable); REG_FUNC(cellGcmSys, cellGcmSetCursorDisable);
cellGcmSys.AddFunc(0xf9bfdc72, cellGcmSetCursorImageOffset); REG_FUNC(cellGcmSys, cellGcmSetCursorImageOffset);
cellGcmSys.AddFunc(0x1a0de550, cellGcmSetCursorPosition); REG_FUNC(cellGcmSys, cellGcmSetCursorPosition);
cellGcmSys.AddFunc(0xbd2fa0a7, cellGcmUpdateCursor); REG_FUNC(cellGcmSys, cellGcmUpdateCursor);
// Functions for Maintaining Compatibility // Functions for Maintaining Compatibility
cellGcmSys.AddFunc(0xbc982946, cellGcmSetDefaultCommandBuffer); REG_FUNC(cellGcmSys, cellGcmSetDefaultCommandBuffer);
//cellGcmSys.AddFunc(, cellGcmGetCurrentBuffer); //cellGcmSys.AddFunc(, cellGcmGetCurrentBuffer);
//cellGcmSys.AddFunc(, cellGcmSetCurrentBuffer); //cellGcmSys.AddFunc(, cellGcmSetCurrentBuffer);
//cellGcmSys.AddFunc(, cellGcmSetDefaultCommandBufferAndSegmentWordSize); //cellGcmSys.AddFunc(, cellGcmSetDefaultCommandBufferAndSegmentWordSize);
//cellGcmSys.AddFunc(, cellGcmSetUserCallback); //cellGcmSys.AddFunc(, cellGcmSetUserCallback);
// Other // Other
cellGcmSys.AddFunc(0x21397818, cellGcmSetFlipCommand); REG_FUNC(cellGcmSys, _cellGcmSetFlipCommand);
cellGcmSys.AddFunc(0xd8f88e1a, cellGcmSetFlipCommandWithWaitLabel); REG_FUNC(cellGcmSys, _cellGcmSetFlipCommandWithWaitLabel);
cellGcmSys.AddFunc(0xd0b1d189, cellGcmSetTile); REG_FUNC(cellGcmSys, cellGcmSetTile);
}); });

72
rpcs3/Emu/SysCalls/Modules/cellGem.cpp
View File

@ -390,44 +390,44 @@ void cellGem_unload()
Module cellGem("cellGem", []() Module cellGem("cellGem", []()
{ {
//cellGem.AddFunc(, cellGemAttributeInit); //cellGem.AddFunc(, cellGemAttributeInit);
cellGem.AddFunc(0xafa99ead, cellGemCalibrate); REG_FUNC(cellGem, cellGemCalibrate);
cellGem.AddFunc(0x9b9714a4, cellGemClearStatusFlags); REG_FUNC(cellGem, cellGemClearStatusFlags);
cellGem.AddFunc(0x1a13d010, cellGemConvertVideoFinish); REG_FUNC(cellGem, cellGemConvertVideoFinish);
cellGem.AddFunc(0x6dce048c, cellGemConvertVideoStart); REG_FUNC(cellGem, cellGemConvertVideoStart);
cellGem.AddFunc(0x4219de31, cellGemEnableCameraPitchAngleCorrection); REG_FUNC(cellGem, cellGemEnableCameraPitchAngleCorrection);
cellGem.AddFunc(0x1a2518a2, cellGemEnableMagnetometer); REG_FUNC(cellGem, cellGemEnableMagnetometer);
cellGem.AddFunc(0xe1f85a80, cellGemEnd); REG_FUNC(cellGem, cellGemEnd);
cellGem.AddFunc(0x6fc4c791, cellGemFilterState); REG_FUNC(cellGem, cellGemFilterState);
cellGem.AddFunc(0xce6d7791, cellGemForceRGB); REG_FUNC(cellGem, cellGemForceRGB);
cellGem.AddFunc(0x6a5b7048, cellGemGetAccelerometerPositionInDevice); REG_FUNC(cellGem, cellGemGetAccelerometerPositionInDevice);
cellGem.AddFunc(0x2d2c2764, cellGemGetAllTrackableHues); REG_FUNC(cellGem, cellGemGetAllTrackableHues);
cellGem.AddFunc(0x8befac67, cellGemGetCameraState); REG_FUNC(cellGem, cellGemGetCameraState);
cellGem.AddFunc(0x02eb41bb, cellGemGetEnvironmentLightingColor); REG_FUNC(cellGem, cellGemGetEnvironmentLightingColor);
cellGem.AddFunc(0xb8ef56a6, cellGemGetHuePixels); REG_FUNC(cellGem, cellGemGetHuePixels);
cellGem.AddFunc(0x92cc4b34, cellGemGetImageState); REG_FUNC(cellGem, cellGemGetImageState);
cellGem.AddFunc(0xd37b127a, cellGemGetInertialState); REG_FUNC(cellGem, cellGemGetInertialState);
cellGem.AddFunc(0x9e1dff96, cellGemGetInfo); REG_FUNC(cellGem, cellGemGetInfo);
cellGem.AddFunc(0x2e0a170d, cellGemGetMemorySize); REG_FUNC(cellGem, cellGemGetMemorySize);
cellGem.AddFunc(0x1b30cc22, cellGemGetRGB); REG_FUNC(cellGem, cellGemGetRGB);
cellGem.AddFunc(0x6db6b007, cellGemGetRumble); REG_FUNC(cellGem, cellGemGetRumble);
cellGem.AddFunc(0x6441d38d, cellGemGetState); REG_FUNC(cellGem, cellGemGetState);
cellGem.AddFunc(0xfee33481, cellGemGetStatusFlags); REG_FUNC(cellGem, cellGemGetStatusFlags);
cellGem.AddFunc(0x18ea899a, cellGemGetTrackerHue); REG_FUNC(cellGem, cellGemGetTrackerHue);
//cellGem.AddFunc(, cellGemGetVideoConvertSize); //cellGem.AddFunc(, cellGemGetVideoConvertSize);
cellGem.AddFunc(0xc7622586, cellGemHSVtoRGB); REG_FUNC(cellGem, cellGemHSVtoRGB);
cellGem.AddFunc(0x13ea7c64, cellGemInit); REG_FUNC(cellGem, cellGemInit);
cellGem.AddFunc(0xe3e4f0d6, cellGemInvalidateCalibration); REG_FUNC(cellGem, cellGemInvalidateCalibration);
cellGem.AddFunc(0xfb5887f9, cellGemIsTrackableHue); REG_FUNC(cellGem, cellGemIsTrackableHue);
cellGem.AddFunc(0xa03ef587, cellGemPrepareCamera); REG_FUNC(cellGem, cellGemPrepareCamera);
cellGem.AddFunc(0xc07896f9, cellGemPrepareVideoConvert); REG_FUNC(cellGem, cellGemPrepareVideoConvert);
//cellGem.AddFunc(, cellGemReadExternalPortDeviceInfo); //cellGem.AddFunc(, cellGemReadExternalPortDeviceInfo);
cellGem.AddFunc(0xde54e2fc, cellGemReset); REG_FUNC(cellGem, cellGemReset);
cellGem.AddFunc(0x49609306, cellGemSetRumble); REG_FUNC(cellGem, cellGemSetRumble);
cellGem.AddFunc(0x77e08704, cellGemSetYaw); REG_FUNC(cellGem, cellGemSetYaw);
cellGem.AddFunc(0x928ac5f8, cellGemTrackHues); REG_FUNC(cellGem, cellGemTrackHues);
cellGem.AddFunc(0x41ae9c31, cellGemUpdateFinish); REG_FUNC(cellGem, cellGemUpdateFinish);
cellGem.AddFunc(0x0ecd2261, cellGemUpdateStart); REG_FUNC(cellGem, cellGemUpdateStart);
//cellGem.AddFunc(, cellGemVideoConvertAttributeInit); //cellGem.AddFunc(, cellGemVideoConvertAttributeInit);
//cellGem.AddFunc(, cellGemVideoConvertAttributeInitRgba); //cellGem.AddFunc(, cellGemVideoConvertAttributeInitRgba);
cellGem.AddFunc(0x1f6328d8, cellGemWriteExternalPort); REG_FUNC(cellGem, cellGemWriteExternalPort);
}); });

24
rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
View File

@ -277,17 +277,17 @@ int cellGifDecDestroy(u32 mainHandle)
Module cellGifDec("cellGifDec", []() Module cellGifDec("cellGifDec", []()
{ {
cellGifDec.AddFunc(0xb60d42a5, cellGifDecCreate); REG_FUNC(cellGifDec, cellGifDecCreate);
cellGifDec.AddFunc(0x4711cb7f, cellGifDecExtCreate); REG_FUNC(cellGifDec, cellGifDecExtCreate);
cellGifDec.AddFunc(0x75745079, cellGifDecOpen); REG_FUNC(cellGifDec, cellGifDecOpen);
cellGifDec.AddFunc(0xf0da95de, cellGifDecReadHeader); REG_FUNC(cellGifDec, cellGifDecReadHeader);
cellGifDec.AddFunc(0x41a90dc4, cellGifDecSetParameter); REG_FUNC(cellGifDec, cellGifDecSetParameter);
cellGifDec.AddFunc(0x44b1bc61, cellGifDecDecodeData); REG_FUNC(cellGifDec, cellGifDecDecodeData);
cellGifDec.AddFunc(0x116a7da9, cellGifDecClose); REG_FUNC(cellGifDec, cellGifDecClose);
cellGifDec.AddFunc(0xe74b2cb1, cellGifDecDestroy); REG_FUNC(cellGifDec, cellGifDecDestroy);
/*cellGifDec.AddFunc(0x17fb83c1, cellGifDecExtOpen); /*REG_FUNC(cellGifDec, cellGifDecExtOpen);
cellGifDec.AddFunc(0xe53f91f2, cellGifDecExtReadHeader); REG_FUNC(cellGifDec, cellGifDecExtReadHeader);
cellGifDec.AddFunc(0x95cae771, cellGifDecExtSetParameter); REG_FUNC(cellGifDec, cellGifDecExtSetParameter);
cellGifDec.AddFunc(0x02e7e03e, cellGifDecExtDecodeData);*/ REG_FUNC(cellGifDec, cellGifDecExtDecodeData);*/
}); });

40
rpcs3/Emu/SysCalls/Modules/cellHttpUtil.cpp
View File

@ -126,28 +126,28 @@ int cellHttpUtilBase64Decoder()
void cellHttpUtil_init() void cellHttpUtil_init()
{ {
cellHttpUtil.AddFunc(0x32faaf58, cellHttpUtilParseUri); REG_FUNC(cellHttpUtil, cellHttpUtilParseUri);
cellHttpUtil.AddFunc(0x8bb608e4, cellHttpUtilParseUriPath); REG_FUNC(cellHttpUtil, cellHttpUtilParseUriPath);
cellHttpUtil.AddFunc(0xa3457869, cellHttpUtilParseProxy); REG_FUNC(cellHttpUtil, cellHttpUtilParseProxy);
cellHttpUtil.AddFunc(0x2bcbced4, cellHttpUtilParseStatusLine); REG_FUNC(cellHttpUtil, cellHttpUtilParseStatusLine);
cellHttpUtil.AddFunc(0xe1fb0ebd, cellHttpUtilParseHeader); REG_FUNC(cellHttpUtil, cellHttpUtilParseHeader);
cellHttpUtil.AddFunc(0x1c6e4dbb, cellHttpUtilBuildRequestLine); REG_FUNC(cellHttpUtil, cellHttpUtilBuildRequestLine);
cellHttpUtil.AddFunc(0x04accebf, cellHttpUtilBuildHeader); REG_FUNC(cellHttpUtil, cellHttpUtilBuildHeader);
cellHttpUtil.AddFunc(0x6f0f7667, cellHttpUtilBuildUri); REG_FUNC(cellHttpUtil, cellHttpUtilBuildUri);
cellHttpUtil.AddFunc(0xf05df789, cellHttpUtilCopyUri); REG_FUNC(cellHttpUtil, cellHttpUtilCopyUri);
cellHttpUtil.AddFunc(0x8ea23deb, cellHttpUtilMergeUriPath); REG_FUNC(cellHttpUtil, cellHttpUtilMergeUriPath);
cellHttpUtil.AddFunc(0xaabeb869, cellHttpUtilSweepPath); REG_FUNC(cellHttpUtil, cellHttpUtilSweepPath);
cellHttpUtil.AddFunc(0x50ea75bc, cellHttpUtilCopyStatusLine); REG_FUNC(cellHttpUtil, cellHttpUtilCopyStatusLine);
cellHttpUtil.AddFunc(0x97f9fbe5, cellHttpUtilCopyHeader); REG_FUNC(cellHttpUtil, cellHttpUtilCopyHeader);
cellHttpUtil.AddFunc(0x37bb53a2, cellHttpUtilAppendHeaderValue); REG_FUNC(cellHttpUtil, cellHttpUtilAppendHeaderValue);
cellHttpUtil.AddFunc(0x9003b1f2, cellHttpUtilEscapeUri); REG_FUNC(cellHttpUtil, cellHttpUtilEscapeUri);
cellHttpUtil.AddFunc(0x2763fd66, cellHttpUtilUnescapeUri); REG_FUNC(cellHttpUtil, cellHttpUtilUnescapeUri);
cellHttpUtil.AddFunc(0x44d756d6, cellHttpUtilFormUrlEncode); REG_FUNC(cellHttpUtil, cellHttpUtilFormUrlEncode);
cellHttpUtil.AddFunc(0x8e6c5bb9, cellHttpUtilFormUrlDecode); REG_FUNC(cellHttpUtil, cellHttpUtilFormUrlDecode);
cellHttpUtil.AddFunc(0x83faa354, cellHttpUtilBase64Encoder); REG_FUNC(cellHttpUtil, cellHttpUtilBase64Encoder);
cellHttpUtil.AddFunc(0x8e52ee08, cellHttpUtilBase64Decoder); REG_FUNC(cellHttpUtil, cellHttpUtilBase64Decoder);
} }
#endif #endif

80
rpcs3/Emu/SysCalls/Modules/cellImejp.cpp
View File

@ -258,49 +258,49 @@ int cellImeJpConfirmPrediction()
void cellImejp_init() void cellImejp_init()
{ {
cellImejp.AddFunc(0x44608862, cellImeJpOpen); REG_FUNC(cellImejp, cellImeJpOpen);
cellImejp.AddFunc(0x47b43dd4, cellImeJpOpen2); REG_FUNC(cellImejp, cellImeJpOpen2);
cellImejp.AddFunc(0x1b119958, cellImeJpOpen3); REG_FUNC(cellImejp, cellImeJpOpen3);
cellImejp.AddFunc(0x46d1234a, cellImeJpClose); REG_FUNC(cellImejp, cellImeJpClose);
cellImejp.AddFunc(0x24e9d8fc, cellImeJpSetKanaInputMode); REG_FUNC(cellImejp, cellImeJpSetKanaInputMode);
cellImejp.AddFunc(0xf5992ec8, cellImeJpSetInputCharType); REG_FUNC(cellImejp, cellImeJpSetInputCharType);
cellImejp.AddFunc(0xc1786c81, cellImeJpSetFixInputMode); REG_FUNC(cellImejp, cellImeJpSetFixInputMode);
//cellImejp.AddFunc(, cellImeJpAllowExtensionCharacters); //cellImejp.AddFunc(, cellImeJpAllowExtensionCharacters);
cellImejp.AddFunc(0x36d38701, cellImeJpReset); REG_FUNC(cellImejp, cellImeJpReset);
cellImejp.AddFunc(0x66c6cc78, cellImeJpGetStatus); REG_FUNC(cellImejp, cellImeJpGetStatus);
cellImejp.AddFunc(0x6ccbe3d6, cellImeJpEnterChar); REG_FUNC(cellImejp, cellImeJpEnterChar);
cellImejp.AddFunc(0x5b6ada55, cellImeJpEnterCharExt); REG_FUNC(cellImejp, cellImeJpEnterCharExt);
cellImejp.AddFunc(0x441a1c2b, cellImeJpEnterString); REG_FUNC(cellImejp, cellImeJpEnterString);
cellImejp.AddFunc(0x6298b55a, cellImeJpEnterStringExt); REG_FUNC(cellImejp, cellImeJpEnterStringExt);
cellImejp.AddFunc(0xac6693d8, cellImeJpModeCaretRight); REG_FUNC(cellImejp, cellImeJpModeCaretRight);
cellImejp.AddFunc(0xe76c9700, cellImeJpModeCaretLeft); REG_FUNC(cellImejp, cellImeJpModeCaretLeft);
cellImejp.AddFunc(0xaa1d1f57, cellImeJpBackspaceWord); REG_FUNC(cellImejp, cellImeJpBackspaceWord);
cellImejp.AddFunc(0x72257652, cellImeJpDeleteWord); REG_FUNC(cellImejp, cellImeJpDeleteWord);
cellImejp.AddFunc(0x6319eda3, cellImeJpAllDeleteConvertString); REG_FUNC(cellImejp, cellImeJpAllDeleteConvertString);
cellImejp.AddFunc(0x1e29103b, cellImeJpConvertForward); REG_FUNC(cellImejp, cellImeJpConvertForward);
cellImejp.AddFunc(0xc2bb48bc, cellImeJpConvertBackward); REG_FUNC(cellImejp, cellImeJpConvertBackward);
cellImejp.AddFunc(0x7a18c2b9, cellImeJpCurrentPartConfirm); REG_FUNC(cellImejp, cellImeJpCurrentPartConfirm);
cellImejp.AddFunc(0x7189430b, cellImeJpAllConfirm); REG_FUNC(cellImejp, cellImeJpAllConfirm);
cellImejp.AddFunc(0xeae879dc, cellImeJpConvertCancel); REG_FUNC(cellImejp, cellImeJpConvertCancel);
cellImejp.AddFunc(0xcbbc20b7, cellImeJpAllConvertCancel); REG_FUNC(cellImejp, cellImeJpAllConvertCancel);
cellImejp.AddFunc(0x37961cc1, cellImeJpExtendConvertArea); REG_FUNC(cellImejp, cellImeJpExtendConvertArea);
cellImejp.AddFunc(0xaa2a3287, cellImeJpShortenConvertArea); REG_FUNC(cellImejp, cellImeJpShortenConvertArea);
cellImejp.AddFunc(0xbd679cc1, cellImeJpTemporalConfirm); REG_FUNC(cellImejp, cellImeJpTemporalConfirm);
cellImejp.AddFunc(0x8bb41f47, cellImeJpPostConvert); REG_FUNC(cellImejp, cellImeJpPostConvert);
cellImejp.AddFunc(0x1e411261, cellImeJpMoveFocusClause); REG_FUNC(cellImejp, cellImeJpMoveFocusClause);
cellImejp.AddFunc(0x0e363ae7, cellImeJpGetFocusTop); REG_FUNC(cellImejp, cellImeJpGetFocusTop);
cellImejp.AddFunc(0x5f5b3227, cellImeJpGetFocusLength); REG_FUNC(cellImejp, cellImeJpGetFocusLength);
cellImejp.AddFunc(0x89f8a567, cellImeJpGetConfirmYomiString); REG_FUNC(cellImejp, cellImeJpGetConfirmYomiString);
cellImejp.AddFunc(0xd3fc3606, cellImeJpGetConfirmString); REG_FUNC(cellImejp, cellImeJpGetConfirmString);
cellImejp.AddFunc(0xea2d4881, cellImeJpGetConvertYomiString); REG_FUNC(cellImejp, cellImeJpGetConvertYomiString);
cellImejp.AddFunc(0xf91abda3, cellImeJpGetConvertString); REG_FUNC(cellImejp, cellImeJpGetConvertString);
cellImejp.AddFunc(0xc4796a45, cellImeJpGetCandidateListSize); REG_FUNC(cellImejp, cellImeJpGetCandidateListSize);
cellImejp.AddFunc(0xe4cc15ba, cellImeJpGetCandidateList); REG_FUNC(cellImejp, cellImeJpGetCandidateList);
cellImejp.AddFunc(0x177bd218, cellImeJpGetCandidateSelect); REG_FUNC(cellImejp, cellImeJpGetCandidateSelect);
cellImejp.AddFunc(0x1986f2cd, cellImeJpGetPredictList); REG_FUNC(cellImejp, cellImeJpGetPredictList);
cellImejp.AddFunc(0xeede898c, cellImeJpConfirmPrediction); REG_FUNC(cellImejp, cellImeJpConfirmPrediction);
} }
#endif #endif

24
rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
View File

@ -322,17 +322,17 @@ int cellJpgDecSetParameter(u32 mainHandle, u32 subHandle, vm::ptr<const CellJpgD
Module cellJpgDec("cellJpgDec", []() Module cellJpgDec("cellJpgDec", []()
{ {
cellJpgDec.AddFunc(0xa7978f59, cellJpgDecCreate); REG_FUNC(cellJpgDec, cellJpgDecCreate);
cellJpgDec.AddFunc(0x8b300f66, cellJpgDecExtCreate); REG_FUNC(cellJpgDec, cellJpgDecExtCreate);
cellJpgDec.AddFunc(0x976ca5c2, cellJpgDecOpen); REG_FUNC(cellJpgDec, cellJpgDecOpen);
cellJpgDec.AddFunc(0x6d9ebccf, cellJpgDecReadHeader); REG_FUNC(cellJpgDec, cellJpgDecReadHeader);
cellJpgDec.AddFunc(0xe08f3910, cellJpgDecSetParameter); REG_FUNC(cellJpgDec, cellJpgDecSetParameter);
cellJpgDec.AddFunc(0xaf8bb012, cellJpgDecDecodeData); REG_FUNC(cellJpgDec, cellJpgDecDecodeData);
cellJpgDec.AddFunc(0x9338a07a, cellJpgDecClose); REG_FUNC(cellJpgDec, cellJpgDecClose);
cellJpgDec.AddFunc(0xd8ea91f8, cellJpgDecDestroy); REG_FUNC(cellJpgDec, cellJpgDecDestroy);
/*cellJpgDec.AddFunc(0xa9f703e3, cellJpgDecExtOpen); /*REG_FUNC(cellJpgDec, cellJpgDecExtOpen);
cellJpgDec.AddFunc(0xb91eb3d2, cellJpgDecExtReadHeader); REG_FUNC(cellJpgDec, cellJpgDecExtReadHeader);
cellJpgDec.AddFunc(0x65cbbb16, cellJpgDecExtSetParameter); REG_FUNC(cellJpgDec, cellJpgDecExtSetParameter);
cellJpgDec.AddFunc(0x716f8792, cellJpgDecExtDecodeData);*/ REG_FUNC(cellJpgDec, cellJpgDecExtDecodeData);*/
}); });

20
rpcs3/Emu/SysCalls/Modules/cellJpgEnc.cpp
View File

@ -77,15 +77,15 @@ int cellJpgEncReset()
void cellJpgEnc_init() void cellJpgEnc_init()
{ {
cellJpgEnc.AddFunc(0x12d9b6c5, cellJpgEncQueryAttr); REG_FUNC(cellJpgEnc, cellJpgEncQueryAttr);
cellJpgEnc.AddFunc(0xa4bfae51, cellJpgEncOpen); REG_FUNC(cellJpgEnc, cellJpgEncOpen);
cellJpgEnc.AddFunc(0x6f2d371c, cellJpgEncOpenEx); REG_FUNC(cellJpgEnc, cellJpgEncOpenEx);
cellJpgEnc.AddFunc(0x969fc5f7, cellJpgEncClose); REG_FUNC(cellJpgEnc, cellJpgEncClose);
cellJpgEnc.AddFunc(0x2ae79be8, cellJpgEncWaitForInput); REG_FUNC(cellJpgEnc, cellJpgEncWaitForInput);
cellJpgEnc.AddFunc(0xa9e81214, cellJpgEncEncodePicture); REG_FUNC(cellJpgEnc, cellJpgEncEncodePicture);
cellJpgEnc.AddFunc(0x636dc89e, cellJpgEncEncodePicture2); REG_FUNC(cellJpgEnc, cellJpgEncEncodePicture2);
cellJpgEnc.AddFunc(0x9b4e3a74, cellJpgEncWaitForOutput); REG_FUNC(cellJpgEnc, cellJpgEncWaitForOutput);
cellJpgEnc.AddFunc(0x4262e880, cellJpgEncGetStreamInfo); REG_FUNC(cellJpgEnc, cellJpgEncGetStreamInfo);
cellJpgEnc.AddFunc(0x0cf2b78b, cellJpgEncReset); REG_FUNC(cellJpgEnc, cellJpgEncReset);
} }
#endif #endif

20
rpcs3/Emu/SysCalls/Modules/cellKb.cpp
View File

@ -188,14 +188,14 @@ int cellKbGetConfiguration(u32 port_no, vm::ptr<CellKbConfig> config)
void cellKb_init() void cellKb_init()
{ {
sys_io.AddFunc(0x433f6ec0, cellKbInit); REG_FUNC(sys_io, cellKbInit);
sys_io.AddFunc(0xbfce3285, cellKbEnd); REG_FUNC(sys_io, cellKbEnd);
sys_io.AddFunc(0x2073b7f6, cellKbClearBuf); REG_FUNC(sys_io, cellKbClearBuf);
sys_io.AddFunc(0x4ab1fa77, cellKbCnvRawCode); REG_FUNC(sys_io, cellKbCnvRawCode);
sys_io.AddFunc(0x2f1774d5, cellKbGetInfo); REG_FUNC(sys_io, cellKbGetInfo);
sys_io.AddFunc(0xff0a21b7, cellKbRead); REG_FUNC(sys_io, cellKbRead);
sys_io.AddFunc(0xa5f85e4d, cellKbSetCodeType); REG_FUNC(sys_io, cellKbSetCodeType);
sys_io.AddFunc(0x3f72c56e, cellKbSetLEDStatus); REG_FUNC(sys_io, cellKbSetLEDStatus);
sys_io.AddFunc(0xdeefdfa7, cellKbSetReadMode); REG_FUNC(sys_io, cellKbSetReadMode);
sys_io.AddFunc(0x1f71ecbe, cellKbGetConfiguration); REG_FUNC(sys_io, cellKbGetConfiguration);
} }

10
rpcs3/Emu/SysCalls/Modules/cellKey2char.cpp
View File

@ -48,10 +48,10 @@ int cellKey2CharSetArrangement()
void cellKey2char_init() void cellKey2char_init()
{ {
cellKey2char.AddFunc(0xabf629c1, cellKey2CharOpen); REG_FUNC(cellKey2char, cellKey2CharOpen);
cellKey2char.AddFunc(0x14bf2dc1, cellKey2CharClose); REG_FUNC(cellKey2char, cellKey2CharClose);
cellKey2char.AddFunc(0x56776c0d, cellKey2CharGetChar); REG_FUNC(cellKey2char, cellKey2CharGetChar);
cellKey2char.AddFunc(0xbfc03768, cellKey2CharSetMode); REG_FUNC(cellKey2char, cellKey2CharSetMode);
cellKey2char.AddFunc(0x0dfbadfa, cellKey2CharSetArrangement); REG_FUNC(cellKey2char, cellKey2CharSetArrangement);
} }
#endif #endif

330
rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
View File

@ -339,169 +339,169 @@ Module cellL10n("cellL10n", []()
{ {
// NOTE: I think this module should be LLE'd instead of implementing all its functions // NOTE: I think this module should be LLE'd instead of implementing all its functions
// cellL10n.AddFunc(0x005200e6, UCS2toEUCJP); // REG_FUNC(cellL10n, UCS2toEUCJP);
// cellL10n.AddFunc(0x01b0cbf4, l10n_convert); // REG_FUNC(cellL10n, l10n_convert);
// cellL10n.AddFunc(0x0356038c, UCS2toUTF32); // REG_FUNC(cellL10n, UCS2toUTF32);
// cellL10n.AddFunc(0x05028763, jis2kuten); // REG_FUNC(cellL10n, jis2kuten);
// cellL10n.AddFunc(0x058addc8, UTF8toGB18030); // REG_FUNC(cellL10n, UTF8toGB18030);
// cellL10n.AddFunc(0x060ee3b2, JISstoUTF8s); // REG_FUNC(cellL10n, JISstoUTF8s);
// cellL10n.AddFunc(0x07168a83, SjisZen2Han); // REG_FUNC(cellL10n, SjisZen2Han);
// cellL10n.AddFunc(0x0bc386c8, ToSjisLower); // REG_FUNC(cellL10n, ToSjisLower);
// cellL10n.AddFunc(0x0bedf77d, UCS2toGB18030); // REG_FUNC(cellL10n, UCS2toGB18030);
// cellL10n.AddFunc(0x0bf867e2, HZstoUCS2s); // REG_FUNC(cellL10n, HZstoUCS2s);
// cellL10n.AddFunc(0x0ce278fd, UCS2stoHZs); // REG_FUNC(cellL10n, UCS2stoHZs);
// cellL10n.AddFunc(0x0d90a48d, UCS2stoSJISs); // REG_FUNC(cellL10n, UCS2stoSJISs);
// cellL10n.AddFunc(0x0f624540, kuten2eucjp); // REG_FUNC(cellL10n, kuten2eucjp);
// cellL10n.AddFunc(0x14ee3649, sjis2jis); // REG_FUNC(cellL10n, sjis2jis);
// cellL10n.AddFunc(0x14f504b8, EUCKRstoUCS2s); // REG_FUNC(cellL10n, EUCKRstoUCS2s);
// cellL10n.AddFunc(0x16eaf5f1, UHCstoEUCKRs); // REG_FUNC(cellL10n, UHCstoEUCKRs);
// cellL10n.AddFunc(0x1758053c, jis2sjis); // REG_FUNC(cellL10n, jis2sjis);
// cellL10n.AddFunc(0x1906ce6b, jstrnchk); // REG_FUNC(cellL10n, jstrnchk);
// cellL10n.AddFunc(0x1ac0d23d, L10nConvert); // REG_FUNC(cellL10n, L10nConvert);
// cellL10n.AddFunc(0x1ae2acee, EUCCNstoUTF8s); // REG_FUNC(cellL10n, EUCCNstoUTF8s);
// cellL10n.AddFunc(0x1cb1138f, GBKstoUCS2s); // REG_FUNC(cellL10n, GBKstoUCS2s);
// cellL10n.AddFunc(0x1da42d70, eucjphan2zen); // REG_FUNC(cellL10n, eucjphan2zen);
// cellL10n.AddFunc(0x1ec712e0, ToSjisHira); // REG_FUNC(cellL10n, ToSjisHira);
// cellL10n.AddFunc(0x1fb50183, GBKtoUCS2); // REG_FUNC(cellL10n, GBKtoUCS2);
// cellL10n.AddFunc(0x21948c03, eucjp2jis); // REG_FUNC(cellL10n, eucjp2jis);
// cellL10n.AddFunc(0x21aa3045, UTF32stoUTF8s); // REG_FUNC(cellL10n, UTF32stoUTF8s);
// cellL10n.AddFunc(0x24fd32a9, sjishan2zen); // REG_FUNC(cellL10n, sjishan2zen);
// cellL10n.AddFunc(0x256b6861, UCS2toSBCS); // REG_FUNC(cellL10n, UCS2toSBCS);
// cellL10n.AddFunc(0x262a5ae2, UTF8stoGBKs); // REG_FUNC(cellL10n, UTF8stoGBKs);
// cellL10n.AddFunc(0x28724522, UTF8toUCS2); // REG_FUNC(cellL10n, UTF8toUCS2);
// cellL10n.AddFunc(0x2ad091c6, UCS2stoUTF8s); // REG_FUNC(cellL10n, UCS2stoUTF8s);
// cellL10n.AddFunc(0x2b84030c, EUCKRstoUTF8s); // REG_FUNC(cellL10n, EUCKRstoUTF8s);
// cellL10n.AddFunc(0x2efa7294, UTF16stoUTF32s); // REG_FUNC(cellL10n, UTF16stoUTF32s);
// cellL10n.AddFunc(0x2f9eb543, UTF8toEUCKR); // REG_FUNC(cellL10n, UTF8toEUCKR);
// cellL10n.AddFunc(0x317ab7c2, UTF16toUTF8); // REG_FUNC(cellL10n, UTF16toUTF8);
// cellL10n.AddFunc(0x32689828, ARIBstoUTF8s); // REG_FUNC(cellL10n, ARIBstoUTF8s);
// cellL10n.AddFunc(0x33435818, SJISstoUTF8s); // REG_FUNC(cellL10n, SJISstoUTF8s);
// cellL10n.AddFunc(0x33f8b35c, sjiszen2han); // REG_FUNC(cellL10n, sjiszen2han);
// cellL10n.AddFunc(0x3968f176, ToEucJpLower); // REG_FUNC(cellL10n, ToEucJpLower);
// cellL10n.AddFunc(0x398a3dee, MSJIStoUTF8); // REG_FUNC(cellL10n, MSJIStoUTF8);
// cellL10n.AddFunc(0x3a20bc34, UCS2stoMSJISs); // REG_FUNC(cellL10n, UCS2stoMSJISs);
// cellL10n.AddFunc(0x3dabd5a7, EUCJPtoUTF8); // REG_FUNC(cellL10n, EUCJPtoUTF8);
// cellL10n.AddFunc(0x3df65b64, eucjp2sjis); // REG_FUNC(cellL10n, eucjp2sjis);
// cellL10n.AddFunc(0x408a622b, ToEucJpHira); // REG_FUNC(cellL10n, ToEucJpHira);
// cellL10n.AddFunc(0x41b4a5ae, UHCstoUCS2s); // REG_FUNC(cellL10n, UHCstoUCS2s);
// cellL10n.AddFunc(0x41ccf033, ToEucJpKata); // REG_FUNC(cellL10n, ToEucJpKata);
// cellL10n.AddFunc(0x42838145, HZstoUTF8s); // REG_FUNC(cellL10n, HZstoUTF8s);
// cellL10n.AddFunc(0x4931b44e, UTF8toMSJIS); // REG_FUNC(cellL10n, UTF8toMSJIS);
// cellL10n.AddFunc(0x4b3bbacb, BIG5toUTF8); // REG_FUNC(cellL10n, BIG5toUTF8);
// cellL10n.AddFunc(0x511d386b, EUCJPstoSJISs); // REG_FUNC(cellL10n, EUCJPstoSJISs);
// cellL10n.AddFunc(0x52b7883f, UTF8stoBIG5s); // REG_FUNC(cellL10n, UTF8stoBIG5s);
// cellL10n.AddFunc(0x53558b6b, UTF16stoUCS2s); // REG_FUNC(cellL10n, UTF16stoUCS2s);
// cellL10n.AddFunc(0x53764725, UCS2stoGB18030s); // REG_FUNC(cellL10n, UCS2stoGB18030s);
// cellL10n.AddFunc(0x53c71ac2, EUCJPtoSJIS); // REG_FUNC(cellL10n, EUCJPtoSJIS);
// cellL10n.AddFunc(0x54f59807, EUCJPtoUCS2); // REG_FUNC(cellL10n, EUCJPtoUCS2);
// cellL10n.AddFunc(0x55f6921c, UCS2stoGBKs); // REG_FUNC(cellL10n, UCS2stoGBKs);
// cellL10n.AddFunc(0x58246762, EUCKRtoUHC); // REG_FUNC(cellL10n, EUCKRtoUHC);
// cellL10n.AddFunc(0x596df41c, UCS2toSJIS); // REG_FUNC(cellL10n, UCS2toSJIS);
// cellL10n.AddFunc(0x5a4ab223, MSJISstoUTF8s); // REG_FUNC(cellL10n, MSJISstoUTF8s);
// cellL10n.AddFunc(0x5ac783dc, EUCJPstoUTF8s); // REG_FUNC(cellL10n, EUCJPstoUTF8s);
// cellL10n.AddFunc(0x5b684dfb, UCS2toBIG5); // REG_FUNC(cellL10n, UCS2toBIG5);
// cellL10n.AddFunc(0x5cd29270, UTF8stoEUCKRs); // REG_FUNC(cellL10n, UTF8stoEUCKRs);
// cellL10n.AddFunc(0x5e1d9330, UHCstoUTF8s); // REG_FUNC(cellL10n, UHCstoUTF8s);
// cellL10n.AddFunc(0x60ffa0ec, GB18030stoUCS2s); // REG_FUNC(cellL10n, GB18030stoUCS2s);
// cellL10n.AddFunc(0x6122e000, SJIStoUTF8); // REG_FUNC(cellL10n, SJIStoUTF8);
// cellL10n.AddFunc(0x6169f205, JISstoSJISs); // REG_FUNC(cellL10n, JISstoSJISs);
// cellL10n.AddFunc(0x61fb9442, UTF8toUTF16); // REG_FUNC(cellL10n, UTF8toUTF16);
// cellL10n.AddFunc(0x62b36bcf, UTF8stoMSJISs); // REG_FUNC(cellL10n, UTF8stoMSJISs);
// cellL10n.AddFunc(0x63219199, EUCKRtoUTF8); // REG_FUNC(cellL10n, EUCKRtoUTF8);
// cellL10n.AddFunc(0x638c2fc1, SjisHan2Zen); // REG_FUNC(cellL10n, SjisHan2Zen);
// cellL10n.AddFunc(0x64a10ec8, UCS2toUTF16); // REG_FUNC(cellL10n, UCS2toUTF16);
// cellL10n.AddFunc(0x65444204, UCS2toMSJIS); // REG_FUNC(cellL10n, UCS2toMSJIS);
// cellL10n.AddFunc(0x6621a82c, sjis2kuten); // REG_FUNC(cellL10n, sjis2kuten);
// cellL10n.AddFunc(0x6a6f25d1, UCS2toUHC); // REG_FUNC(cellL10n, UCS2toUHC);
// cellL10n.AddFunc(0x6c62d879, UTF32toUCS2); // REG_FUNC(cellL10n, UTF32toUCS2);
// cellL10n.AddFunc(0x6de4b508, ToSjisUpper); // REG_FUNC(cellL10n, ToSjisUpper);
// cellL10n.AddFunc(0x6e0705c4, UTF8toEUCJP); // REG_FUNC(cellL10n, UTF8toEUCJP);
// cellL10n.AddFunc(0x6e5906fd, UCS2stoEUCJPs); // REG_FUNC(cellL10n, UCS2stoEUCJPs);
// cellL10n.AddFunc(0x6fc530b3, UTF16toUCS2); // REG_FUNC(cellL10n, UTF16toUCS2);
// cellL10n.AddFunc(0x714a9b4a, UCS2stoUTF16s); // REG_FUNC(cellL10n, UCS2stoUTF16s);
// cellL10n.AddFunc(0x71804d64, UCS2stoEUCCNs); // REG_FUNC(cellL10n, UCS2stoEUCCNs);
// cellL10n.AddFunc(0x72632e53, SBCSstoUTF8s); // REG_FUNC(cellL10n, SBCSstoUTF8s);
// cellL10n.AddFunc(0x73f2cd21, SJISstoJISs); // REG_FUNC(cellL10n, SJISstoJISs);
// cellL10n.AddFunc(0x74496718, SBCStoUTF8); // REG_FUNC(cellL10n, SBCStoUTF8);
// cellL10n.AddFunc(0x74871fe0, UTF8toUTF32); // REG_FUNC(cellL10n, UTF8toUTF32);
cellL10n.AddFunc(0x750c363d, jstrchk); REG_FUNC(cellL10n, jstrchk);
// cellL10n.AddFunc(0x7c5bde1c, UHCtoEUCKR); // REG_FUNC(cellL10n, UHCtoEUCKR);
// cellL10n.AddFunc(0x7c912bda, kuten2jis); // REG_FUNC(cellL10n, kuten2jis);
// cellL10n.AddFunc(0x7d07a1c2, UTF8toEUCCN); // REG_FUNC(cellL10n, UTF8toEUCCN);
// cellL10n.AddFunc(0x8171c1cc, EUCCNtoUTF8); // REG_FUNC(cellL10n, EUCCNtoUTF8);
// cellL10n.AddFunc(0x82d5ecdf, EucJpZen2Han); // REG_FUNC(cellL10n, EucJpZen2Han);
// cellL10n.AddFunc(0x8555fe15, UTF32stoUTF16s); // REG_FUNC(cellL10n, UTF32stoUTF16s);
// cellL10n.AddFunc(0x860fc741, GBKtoUTF8); // REG_FUNC(cellL10n, GBKtoUTF8);
// cellL10n.AddFunc(0x867f7b8b, ToEucJpUpper); // REG_FUNC(cellL10n, ToEucJpUpper);
// cellL10n.AddFunc(0x88f8340b, UCS2stoJISs); // REG_FUNC(cellL10n, UCS2stoJISs);
// cellL10n.AddFunc(0x89236c86, UTF8stoGB18030s); // REG_FUNC(cellL10n, UTF8stoGB18030s);
// cellL10n.AddFunc(0x8a56f148, EUCKRstoUHCs); // REG_FUNC(cellL10n, EUCKRstoUHCs);
// cellL10n.AddFunc(0x8ccdba38, UTF8stoUTF32s); // REG_FUNC(cellL10n, UTF8stoUTF32s);
// cellL10n.AddFunc(0x8f472054, UTF8stoEUCCNs); // REG_FUNC(cellL10n, UTF8stoEUCCNs);
// cellL10n.AddFunc(0x90e9b5d2, EUCJPstoUCS2s); // REG_FUNC(cellL10n, EUCJPstoUCS2s);
// cellL10n.AddFunc(0x91a99765, UHCtoUCS2); // REG_FUNC(cellL10n, UHCtoUCS2);
cellL10n.AddFunc(0x931ff25a, L10nConvertStr); REG_FUNC(cellL10n, L10nConvertStr);
// cellL10n.AddFunc(0x949bb14c, GBKstoUTF8s); // REG_FUNC(cellL10n, GBKstoUTF8s);
// cellL10n.AddFunc(0x9557ac9b, UTF8toUHC); // REG_FUNC(cellL10n, UTF8toUHC);
// cellL10n.AddFunc(0x9768b6d3, UTF32toUTF8); // REG_FUNC(cellL10n, UTF32toUTF8);
// cellL10n.AddFunc(0x9874020d, sjis2eucjp); // REG_FUNC(cellL10n, sjis2eucjp);
// cellL10n.AddFunc(0x9a0e7d23, UCS2toEUCCN); // REG_FUNC(cellL10n, UCS2toEUCCN);
// cellL10n.AddFunc(0x9a13d6b8, UTF8stoUHCs); // REG_FUNC(cellL10n, UTF8stoUHCs);
// cellL10n.AddFunc(0x9a72059d, EUCKRtoUCS2); // REG_FUNC(cellL10n, EUCKRtoUCS2);
// cellL10n.AddFunc(0x9b1210c6, UTF32toUTF16); // REG_FUNC(cellL10n, UTF32toUTF16);
// cellL10n.AddFunc(0x9cd8135b, EUCCNstoUCS2s); // REG_FUNC(cellL10n, EUCCNstoUCS2s);
// cellL10n.AddFunc(0x9ce52809, SBCSstoUCS2s); // REG_FUNC(cellL10n, SBCSstoUCS2s);
// cellL10n.AddFunc(0x9cf1ab77, UTF8stoJISs); // REG_FUNC(cellL10n, UTF8stoJISs);
// cellL10n.AddFunc(0x9d14dc46, ToSjisKata); // REG_FUNC(cellL10n, ToSjisKata);
// cellL10n.AddFunc(0x9dcde367, jis2eucjp); // REG_FUNC(cellL10n, jis2eucjp);
// cellL10n.AddFunc(0x9ec52258, BIG5toUCS2); // REG_FUNC(cellL10n, BIG5toUCS2);
// cellL10n.AddFunc(0xa0d463c0, UCS2toGBK); // REG_FUNC(cellL10n, UCS2toGBK);
// cellL10n.AddFunc(0xa19fb9de, UTF16toUTF32); // REG_FUNC(cellL10n, UTF16toUTF32);
// cellL10n.AddFunc(0xa298cad2, l10n_convert_str); // REG_FUNC(cellL10n, l10n_convert_str);
// cellL10n.AddFunc(0xa34fa0eb, EUCJPstoJISs); // REG_FUNC(cellL10n, EUCJPstoJISs);
// cellL10n.AddFunc(0xa5146299, UTF8stoARIBs); // REG_FUNC(cellL10n, UTF8stoARIBs);
// cellL10n.AddFunc(0xa609f3e9, JISstoEUCJPs); // REG_FUNC(cellL10n, JISstoEUCJPs);
// cellL10n.AddFunc(0xa60ff5c9, EucJpHan2Zen); // REG_FUNC(cellL10n, EucJpHan2Zen);
// cellL10n.AddFunc(0xa963619c, isEucJpKigou); // REG_FUNC(cellL10n, isEucJpKigou);
// cellL10n.AddFunc(0xa9a76fb8, UCS2toUTF8); // REG_FUNC(cellL10n, UCS2toUTF8);
// cellL10n.AddFunc(0xaf18d499, GB18030toUCS2); // REG_FUNC(cellL10n, GB18030toUCS2);
// cellL10n.AddFunc(0xb3361be6, UHCtoUTF8); // REG_FUNC(cellL10n, UHCtoUTF8);
// cellL10n.AddFunc(0xb6e45343, MSJIStoUCS2); // REG_FUNC(cellL10n, MSJIStoUCS2);
// cellL10n.AddFunc(0xb7cef4a6, UTF8toGBK); // REG_FUNC(cellL10n, UTF8toGBK);
// cellL10n.AddFunc(0xb7e08f7a, kuten2sjis); // REG_FUNC(cellL10n, kuten2sjis);
// cellL10n.AddFunc(0xb9cf473d, UTF8toSBCS); // REG_FUNC(cellL10n, UTF8toSBCS);
// cellL10n.AddFunc(0xbdd44ee3, SJIStoUCS2); // REG_FUNC(cellL10n, SJIStoUCS2);
// cellL10n.AddFunc(0xbe42e661, eucjpzen2han); // REG_FUNC(cellL10n, eucjpzen2han);
// cellL10n.AddFunc(0xbe8d5485, UCS2stoARIBs); // REG_FUNC(cellL10n, UCS2stoARIBs);
// cellL10n.AddFunc(0xbefe3869, isSjisKigou); // REG_FUNC(cellL10n, isSjisKigou);
// cellL10n.AddFunc(0xc62b758d, UTF8stoEUCJPs); // REG_FUNC(cellL10n, UTF8stoEUCJPs);
// cellL10n.AddFunc(0xc7bdcb4c, UCS2toEUCKR); // REG_FUNC(cellL10n, UCS2toEUCKR);
// cellL10n.AddFunc(0xc944fa56, SBCStoUCS2); // REG_FUNC(cellL10n, SBCStoUCS2);
// cellL10n.AddFunc(0xc9b78f58, MSJISstoUCS2s); // REG_FUNC(cellL10n, MSJISstoUCS2s);
// cellL10n.AddFunc(0xcc1633cc, l10n_get_converter); // REG_FUNC(cellL10n, l10n_get_converter);
// cellL10n.AddFunc(0xd02ef83d, GB18030stoUTF8s); // REG_FUNC(cellL10n, GB18030stoUTF8s);
// cellL10n.AddFunc(0xd8721e2c, SJISstoEUCJPs); // REG_FUNC(cellL10n, SJISstoEUCJPs);
// cellL10n.AddFunc(0xd8cb24cb, UTF32stoUCS2s); // REG_FUNC(cellL10n, UTF32stoUCS2s);
// cellL10n.AddFunc(0xd990858b, BIG5stoUTF8s); // REG_FUNC(cellL10n, BIG5stoUTF8s);
// cellL10n.AddFunc(0xd9fb1224, EUCCNtoUCS2); // REG_FUNC(cellL10n, EUCCNtoUCS2);
// cellL10n.AddFunc(0xda67b37f, UTF8stoSBCSs); // REG_FUNC(cellL10n, UTF8stoSBCSs);
// cellL10n.AddFunc(0xdc54886c, UCS2stoEUCKRs); // REG_FUNC(cellL10n, UCS2stoEUCKRs);
// cellL10n.AddFunc(0xdd5ebdeb, UTF8stoSJISs); // REG_FUNC(cellL10n, UTF8stoSJISs);
// cellL10n.AddFunc(0xdefa1c17, UTF8stoHZs); // REG_FUNC(cellL10n, UTF8stoHZs);
// cellL10n.AddFunc(0xe2eabb32, eucjp2kuten); // REG_FUNC(cellL10n, eucjp2kuten);
// cellL10n.AddFunc(0xe6d9e234, UTF8toBIG5); // REG_FUNC(cellL10n, UTF8toBIG5);
// cellL10n.AddFunc(0xe6f5711b, UTF16stoUTF8s); // REG_FUNC(cellL10n, UTF16stoUTF8s);
// cellL10n.AddFunc(0xe956dc64, JISstoUCS2s); // REG_FUNC(cellL10n, JISstoUCS2s);
// cellL10n.AddFunc(0xeabc3d00, GB18030toUTF8); // REG_FUNC(cellL10n, GB18030toUTF8);
// cellL10n.AddFunc(0xeb3dc670, UTF8toSJIS); // REG_FUNC(cellL10n, UTF8toSJIS);
// cellL10n.AddFunc(0xeb41cc68, ARIBstoUCS2s); // REG_FUNC(cellL10n, ARIBstoUCS2s);
// cellL10n.AddFunc(0xeb685b83, UCS2stoUTF32s); // REG_FUNC(cellL10n, UCS2stoUTF32s);
// cellL10n.AddFunc(0xebae29c0, UCS2stoSBCSs); // REG_FUNC(cellL10n, UCS2stoSBCSs);
// cellL10n.AddFunc(0xee6c6a39, UCS2stoBIG5s); // REG_FUNC(cellL10n, UCS2stoBIG5s);
// cellL10n.AddFunc(0xf1dcfa71, UCS2stoUHCs); // REG_FUNC(cellL10n, UCS2stoUHCs);
// cellL10n.AddFunc(0xf439728e, SJIStoEUCJP); // REG_FUNC(cellL10n, SJIStoEUCJP);
// cellL10n.AddFunc(0xf7681b9a, UTF8stoUTF16s); // REG_FUNC(cellL10n, UTF8stoUTF16s);
// cellL10n.AddFunc(0xf9b1896d, SJISstoUCS2s); // REG_FUNC(cellL10n, SJISstoUCS2s);
// cellL10n.AddFunc(0xfa4a675a, BIG5stoUCS2s); // REG_FUNC(cellL10n, BIG5stoUCS2s);
// cellL10n.AddFunc(0xfdbf6ac5, UTF8stoUCS2s); // REG_FUNC(cellL10n, UTF8stoUCS2s);
}); });

70
rpcs3/Emu/SysCalls/Modules/cellLv2dbg.cpp
View File

@ -223,47 +223,47 @@ int sys_dbg_get_coredump_params()
void cellLv2dbg_init() void cellLv2dbg_init()
{ {
cellLv2dbg.AddFunc(0xc21ee635, sys_dbg_read_spu_thread_context); REG_FUNC(cellLv2dbg, sys_dbg_read_spu_thread_context);
cellLv2dbg.AddFunc(0xc353353a, sys_dbg_initialize_ppu_exception_handler); REG_FUNC(cellLv2dbg, sys_dbg_initialize_ppu_exception_handler);
cellLv2dbg.AddFunc(0x22916f45, sys_dbg_register_ppu_exception_handler); REG_FUNC(cellLv2dbg, sys_dbg_register_ppu_exception_handler);
cellLv2dbg.AddFunc(0xc0eb9266, sys_dbg_finalize_ppu_exception_handler); REG_FUNC(cellLv2dbg, sys_dbg_finalize_ppu_exception_handler);
cellLv2dbg.AddFunc(0xc6d7ec13, sys_dbg_unregister_ppu_exception_handler); REG_FUNC(cellLv2dbg, sys_dbg_unregister_ppu_exception_handler);
cellLv2dbg.AddFunc(0x06a840f5, sys_dbg_set_stacksize_ppu_exception_handler); REG_FUNC(cellLv2dbg, sys_dbg_set_stacksize_ppu_exception_handler);
cellLv2dbg.AddFunc(0x4ded9f6c, sys_dbg_signal_to_ppu_exception_handler); REG_FUNC(cellLv2dbg, sys_dbg_signal_to_ppu_exception_handler);
cellLv2dbg.AddFunc(0x3147c6ca, sys_dbg_enable_floating_point_enabled_exception); REG_FUNC(cellLv2dbg, sys_dbg_enable_floating_point_enabled_exception);
cellLv2dbg.AddFunc(0xf254768c, sys_dbg_disable_floating_point_enabled_exception); REG_FUNC(cellLv2dbg, sys_dbg_disable_floating_point_enabled_exception);
cellLv2dbg.AddFunc(0xdb14b37b, sys_dbg_set_address_to_dabr); REG_FUNC(cellLv2dbg, sys_dbg_set_address_to_dabr);
cellLv2dbg.AddFunc(0xbb0ae221, sys_dbg_get_address_from_dabr); REG_FUNC(cellLv2dbg, sys_dbg_get_address_from_dabr);
cellLv2dbg.AddFunc(0xab475d53, sys_dbg_set_mask_to_ppu_exception_handler); REG_FUNC(cellLv2dbg, sys_dbg_set_mask_to_ppu_exception_handler);
cellLv2dbg.AddFunc(0xc5eef17f, sys_dbg_read_ppu_thread_context); REG_FUNC(cellLv2dbg, sys_dbg_read_ppu_thread_context);
cellLv2dbg.AddFunc(0x266c2bd3, sys_dbg_read_spu_thread_context2); REG_FUNC(cellLv2dbg, sys_dbg_read_spu_thread_context2);
cellLv2dbg.AddFunc(0x4b55f456, sys_dbg_get_ppu_thread_name); REG_FUNC(cellLv2dbg, sys_dbg_get_ppu_thread_name);
cellLv2dbg.AddFunc(0x3e5eed36, sys_dbg_get_spu_thread_name); REG_FUNC(cellLv2dbg, sys_dbg_get_spu_thread_name);
cellLv2dbg.AddFunc(0xbd69e584, sys_dbg_get_spu_thread_group_name); REG_FUNC(cellLv2dbg, sys_dbg_get_spu_thread_group_name);
cellLv2dbg.AddFunc(0x6b413178, sys_dbg_get_ppu_thread_status); REG_FUNC(cellLv2dbg, sys_dbg_get_ppu_thread_status);
cellLv2dbg.AddFunc(0x9ddb9dc3, sys_dbg_get_spu_thread_group_status); REG_FUNC(cellLv2dbg, sys_dbg_get_spu_thread_group_status);
cellLv2dbg.AddFunc(0x113b0bea, sys_dbg_get_ppu_thread_ids); REG_FUNC(cellLv2dbg, sys_dbg_get_ppu_thread_ids);
cellLv2dbg.AddFunc(0x1860f909, sys_dbg_get_spu_thread_ids); REG_FUNC(cellLv2dbg, sys_dbg_get_spu_thread_ids);
cellLv2dbg.AddFunc(0x08ef08a9, sys_dbg_get_spu_thread_group_ids); REG_FUNC(cellLv2dbg, sys_dbg_get_spu_thread_group_ids);
cellLv2dbg.AddFunc(0x50453aa8, sys_dbg_get_mutex_information); REG_FUNC(cellLv2dbg, sys_dbg_get_mutex_information);
cellLv2dbg.AddFunc(0xcb377e36, sys_dbg_get_lwmutex_information); REG_FUNC(cellLv2dbg, sys_dbg_get_lwmutex_information);
cellLv2dbg.AddFunc(0x9794bb53, sys_dbg_get_rwlock_information); REG_FUNC(cellLv2dbg, sys_dbg_get_rwlock_information);
cellLv2dbg.AddFunc(0xa2d6cbd2, sys_dbg_get_semaphore_information); REG_FUNC(cellLv2dbg, sys_dbg_get_semaphore_information);
cellLv2dbg.AddFunc(0x63bd413e, sys_dbg_get_cond_information); REG_FUNC(cellLv2dbg, sys_dbg_get_cond_information);
cellLv2dbg.AddFunc(0x7bdadb01, sys_dbg_get_lwcond_information); REG_FUNC(cellLv2dbg, sys_dbg_get_lwcond_information);
cellLv2dbg.AddFunc(0x381ae33e, sys_dbg_get_event_queue_information); REG_FUNC(cellLv2dbg, sys_dbg_get_event_queue_information);
cellLv2dbg.AddFunc(0xdf856979, sys_dbg_get_event_flag_information); REG_FUNC(cellLv2dbg, sys_dbg_get_event_flag_information);
cellLv2dbg.AddFunc(0x580f8203, sys_dbg_vm_get_page_information); REG_FUNC(cellLv2dbg, sys_dbg_vm_get_page_information);
cellLv2dbg.AddFunc(0x24a3d413, sys_dbg_mat_set_condition); REG_FUNC(cellLv2dbg, sys_dbg_mat_set_condition);
cellLv2dbg.AddFunc(0x590a276e, sys_dbg_mat_get_condition); REG_FUNC(cellLv2dbg, sys_dbg_mat_get_condition);
cellLv2dbg.AddFunc(0xd830062a, sys_dbg_signal_to_coredump_handler); REG_FUNC(cellLv2dbg, sys_dbg_signal_to_coredump_handler);
cellLv2dbg.AddFunc(0xb9da87d3, sys_dbg_get_coredump_params); REG_FUNC(cellLv2dbg, sys_dbg_get_coredump_params);
} }
#endif #endif

84
rpcs3/Emu/SysCalls/Modules/cellMic.cpp
View File

@ -290,51 +290,51 @@ void cellMic_unload()
Module cellMic("cellMic", []() Module cellMic("cellMic", []()
{ {
cellMic.AddFunc(0x8325e02d, cellMicInit); REG_FUNC(cellMic, cellMicInit);
cellMic.AddFunc(0xc6328caa, cellMicEnd); REG_FUNC(cellMic, cellMicEnd);
cellMic.AddFunc(0xdd1b59f0, cellMicOpen); REG_FUNC(cellMic, cellMicOpen);
cellMic.AddFunc(0x8d229f8e, cellMicClose); REG_FUNC(cellMic, cellMicClose);
cellMic.AddFunc(0x017024a8, cellMicGetDeviceGUID); REG_FUNC(cellMic, cellMicGetDeviceGUID);
cellMic.AddFunc(0xa52d2ae4, cellMicGetType); REG_FUNC(cellMic, cellMicGetType);
cellMic.AddFunc(0x1b42101b, cellMicIsAttached); REG_FUNC(cellMic, cellMicIsAttached);
cellMic.AddFunc(0x186cb1fb, cellMicIsOpen); REG_FUNC(cellMic, cellMicIsOpen);
cellMic.AddFunc(0x6a024aa0, cellMicGetDeviceAttr); REG_FUNC(cellMic, cellMicGetDeviceAttr);
cellMic.AddFunc(0xb2c16321, cellMicSetDeviceAttr); REG_FUNC(cellMic, cellMicSetDeviceAttr);
cellMic.AddFunc(0xac5ba03a, cellMicGetSignalAttr); REG_FUNC(cellMic, cellMicGetSignalAttr);
cellMic.AddFunc(0x323deb41, cellMicSetSignalAttr); REG_FUNC(cellMic, cellMicSetSignalAttr);
cellMic.AddFunc(0xb30780eb, cellMicGetSignalState); REG_FUNC(cellMic, cellMicGetSignalState);
cellMic.AddFunc(0xdd724314, cellMicStart); REG_FUNC(cellMic, cellMicStart);
cellMic.AddFunc(0x07e1b12c, cellMicRead); REG_FUNC(cellMic, cellMicRead);
cellMic.AddFunc(0xfcfaf246, cellMicStop); REG_FUNC(cellMic, cellMicStop);
cellMic.AddFunc(0x6bc46aab, cellMicReset); REG_FUNC(cellMic, cellMicReset);
cellMic.AddFunc(0x7903400e, cellMicSetNotifyEventQueue); REG_FUNC(cellMic, cellMicSetNotifyEventQueue);
cellMic.AddFunc(0x6cc7ae00, cellMicSetNotifyEventQueue2); REG_FUNC(cellMic, cellMicSetNotifyEventQueue2);
cellMic.AddFunc(0x65336418, cellMicRemoveNotifyEventQueue); REG_FUNC(cellMic, cellMicRemoveNotifyEventQueue);
cellMic.AddFunc(0x05709bbf, cellMicOpenEx); REG_FUNC(cellMic, cellMicOpenEx);
cellMic.AddFunc(0xddd19a89, cellMicStartEx); REG_FUNC(cellMic, cellMicStartEx);
cellMic.AddFunc(0x4e0b69ee, cellMicGetFormatRaw); REG_FUNC(cellMic, cellMicGetFormatRaw);
cellMic.AddFunc(0xfda12276, cellMicGetFormatAux); REG_FUNC(cellMic, cellMicGetFormatAux);
cellMic.AddFunc(0x87a08d29, cellMicGetFormatDsp); REG_FUNC(cellMic, cellMicGetFormatDsp);
cellMic.AddFunc(0xa42ac07a, cellMicOpenRaw); REG_FUNC(cellMic, cellMicOpenRaw);
cellMic.AddFunc(0x72165a7f, cellMicReadRaw); REG_FUNC(cellMic, cellMicReadRaw);
cellMic.AddFunc(0x3acc118e, cellMicReadAux); REG_FUNC(cellMic, cellMicReadAux);
cellMic.AddFunc(0xc414faa5, cellMicReadDsp); REG_FUNC(cellMic, cellMicReadDsp);
cellMic.AddFunc(0x25c5723f, cellMicGetStatus); REG_FUNC(cellMic, cellMicGetStatus);
cellMic.AddFunc(0xe839380f, cellMicStopEx); REG_FUNC(cellMic, cellMicStopEx);
cellMic.AddFunc(0x3ace58f3, cellMicSysShareClose); REG_FUNC(cellMic, cellMicSysShareClose);
cellMic.AddFunc(0x48108a23, cellMicGetFormat); REG_FUNC(cellMic, cellMicGetFormat);
cellMic.AddFunc(0x891c6291, cellMicSetMultiMicNotifyEventQueue); REG_FUNC(cellMic, cellMicSetMultiMicNotifyEventQueue);
cellMic.AddFunc(0xad049ecf, cellMicGetFormatEx); REG_FUNC(cellMic, cellMicGetFormatEx);
cellMic.AddFunc(0xbdfd51e2, cellMicSysShareStop); REG_FUNC(cellMic, cellMicSysShareStop);
cellMic.AddFunc(0xc3610dbd, cellMicSysShareOpen); REG_FUNC(cellMic, cellMicSysShareOpen);
cellMic.AddFunc(0xc461563c, cellMicCommand); REG_FUNC(cellMic, cellMicCommand);
cellMic.AddFunc(0xcac7e7d7, cellMicSysShareStart); REG_FUNC(cellMic, cellMicSysShareStart);
cellMic.AddFunc(0xd127cd3e, cellMicSysShareInit); REG_FUNC(cellMic, cellMicSysShareInit);
cellMic.AddFunc(0xf82bbf7c, cellMicSysShareEnd); REG_FUNC(cellMic, cellMicSysShareEnd);
cellMic.AddFunc(0xfdbbe469, cellMicGetDeviceIdentifier); REG_FUNC(cellMic, cellMicGetDeviceIdentifier);
}); });

20
rpcs3/Emu/SysCalls/Modules/cellMouse.cpp
View File

@ -131,14 +131,14 @@ int cellMouseGetRawData(u32 port_no, u32 data_addr)
void cellMouse_init() void cellMouse_init()
{ {
sys_io.AddFunc(0xc9030138, cellMouseInit); REG_FUNC(sys_io, cellMouseInit);
sys_io.AddFunc(0x3ef66b95, cellMouseClearBuf); REG_FUNC(sys_io, cellMouseClearBuf);
sys_io.AddFunc(0xe10183ce, cellMouseEnd); REG_FUNC(sys_io, cellMouseEnd);
sys_io.AddFunc(0x5baf30fb, cellMouseGetInfo); REG_FUNC(sys_io, cellMouseGetInfo);
sys_io.AddFunc(0x4d0b3b1f, cellMouseInfoTabletMode); REG_FUNC(sys_io, cellMouseInfoTabletMode);
sys_io.AddFunc(0x3138e632, cellMouseGetData); REG_FUNC(sys_io, cellMouseGetData);
sys_io.AddFunc(0x6bd131f0, cellMouseGetDataList); REG_FUNC(sys_io, cellMouseGetDataList);
sys_io.AddFunc(0x2d16da4f, cellMouseSetTabletMode); REG_FUNC(sys_io, cellMouseSetTabletMode);
sys_io.AddFunc(0x21a62e9b, cellMouseGetTabletDataList); REG_FUNC(sys_io, cellMouseGetTabletDataList);
sys_io.AddFunc(0xa328cc35, cellMouseGetRawData); REG_FUNC(sys_io, cellMouseGetRawData);
} }

20
rpcs3/Emu/SysCalls/Modules/cellMusicDecode.cpp
View File

@ -86,15 +86,15 @@ int cellMusicDecodeGetContentsId()
void cellMusicDecode_init() void cellMusicDecode_init()
{ {
cellMusicDecode.AddFunc(0xd55dbc11, cellMusicDecodeInitialize); REG_FUNC(cellMusicDecode, cellMusicDecodeInitialize);
cellMusicDecode.AddFunc(0x84f154b2, cellMusicDecodeInitializeSystemWorkload); REG_FUNC(cellMusicDecode, cellMusicDecodeInitializeSystemWorkload);
cellMusicDecode.AddFunc(0xa8615dc8, cellMusicDecodeFinalize); REG_FUNC(cellMusicDecode, cellMusicDecodeFinalize);
cellMusicDecode.AddFunc(0xf24cb963, cellMusicDecodeSelectContents); REG_FUNC(cellMusicDecode, cellMusicDecodeSelectContents);
cellMusicDecode.AddFunc(0x066bb1cf, cellMusicDecodeSetDecodeCommand); REG_FUNC(cellMusicDecode, cellMusicDecodeSetDecodeCommand);
cellMusicDecode.AddFunc(0x5af74c50, cellMusicDecodeGetDecodeStatus); REG_FUNC(cellMusicDecode, cellMusicDecodeGetDecodeStatus);
cellMusicDecode.AddFunc(0xa881b744, cellMusicDecodeRead); REG_FUNC(cellMusicDecode, cellMusicDecodeRead);
cellMusicDecode.AddFunc(0xdbf70550, cellMusicDecodeGetSelectionContext); REG_FUNC(cellMusicDecode, cellMusicDecodeGetSelectionContext);
cellMusicDecode.AddFunc(0xb84f5c81, cellMusicDecodeSetSelectionContext); REG_FUNC(cellMusicDecode, cellMusicDecodeSetSelectionContext);
cellMusicDecode.AddFunc(0x58ab1999, cellMusicDecodeGetContentsId); REG_FUNC(cellMusicDecode, cellMusicDecodeGetContentsId);
} }
#endif #endif

10
rpcs3/Emu/SysCalls/Modules/cellMusicExport.cpp
View File

@ -53,10 +53,10 @@ int cellMusicExportProgress()
void cellMusicExport_init() void cellMusicExport_init()
{ {
cellMusicExport.AddFunc(0xb4c9b4f9, cellMusicExportInitialize); REG_FUNC(cellMusicExport, cellMusicExportInitialize);
cellMusicExport.AddFunc(0xe0443a44, cellMusicExportInitialize2); REG_FUNC(cellMusicExport, cellMusicExportInitialize2);
cellMusicExport.AddFunc(0xe90effea, cellMusicExportFinalize); REG_FUNC(cellMusicExport, cellMusicExportFinalize);
cellMusicExport.AddFunc(0xb202f0e8, cellMusicExportFromFile); REG_FUNC(cellMusicExport, cellMusicExportFromFile);
cellMusicExport.AddFunc(0x92b50ebc, cellMusicExportProgress); REG_FUNC(cellMusicExport, cellMusicExportProgress);
} }
#endif #endif

20
rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp
View File

@ -125,18 +125,18 @@ void cellNetCtl_unload()
Module cellNetCtl("cellNetCtl", []() Module cellNetCtl("cellNetCtl", []()
{ {
cellNetCtl.AddFunc(0xbd5a59fc, cellNetCtlInit); REG_FUNC(cellNetCtl, cellNetCtlInit);
cellNetCtl.AddFunc(0x105ee2cb, cellNetCtlTerm); REG_FUNC(cellNetCtl, cellNetCtlTerm);
cellNetCtl.AddFunc(0x8b3eba69, cellNetCtlGetState); REG_FUNC(cellNetCtl, cellNetCtlGetState);
cellNetCtl.AddFunc(0x0ce13c6b, cellNetCtlAddHandler); REG_FUNC(cellNetCtl, cellNetCtlAddHandler);
cellNetCtl.AddFunc(0x901815c3, cellNetCtlDelHandler); REG_FUNC(cellNetCtl, cellNetCtlDelHandler);
cellNetCtl.AddFunc(0x1e585b5d, cellNetCtlGetInfo); REG_FUNC(cellNetCtl, cellNetCtlGetInfo);
cellNetCtl.AddFunc(0x04459230, cellNetCtlNetStartDialogLoadAsync); REG_FUNC(cellNetCtl, cellNetCtlNetStartDialogLoadAsync);
cellNetCtl.AddFunc(0x71d53210, cellNetCtlNetStartDialogAbortAsync); REG_FUNC(cellNetCtl, cellNetCtlNetStartDialogAbortAsync);
cellNetCtl.AddFunc(0x0f1f13d3, cellNetCtlNetStartDialogUnloadAsync); REG_FUNC(cellNetCtl, cellNetCtlNetStartDialogUnloadAsync);
cellNetCtl.AddFunc(0x3a12865f, cellNetCtlGetNatInfo); REG_FUNC(cellNetCtl, cellNetCtlGetNatInfo);
}); });

8
rpcs3/Emu/SysCalls/Modules/cellOvis.cpp
View File

@ -38,8 +38,8 @@ int cellOvisInvalidateOverlappedSegments()
Module cellOvis("cellOvis", []() Module cellOvis("cellOvis", []()
{ {
cellOvis.AddFunc(0x82f294b2, cellOvisGetOverlayTableSize); REG_FUNC(cellOvis, cellOvisGetOverlayTableSize);
cellOvis.AddFunc(0xa876c911, cellOvisInitializeOverlayTable); REG_FUNC(cellOvis, cellOvisInitializeOverlayTable);
cellOvis.AddFunc(0xce6cb776, cellOvisFixSpuSegments); REG_FUNC(cellOvis, cellOvisFixSpuSegments);
cellOvis.AddFunc(0x629ba0c0, cellOvisInvalidateOverlappedSegments); REG_FUNC(cellOvis, cellOvisInvalidateOverlappedSegments);
}); });

30
rpcs3/Emu/SysCalls/Modules/cellPad.cpp
View File

@ -424,19 +424,19 @@ int cellPadSetSensorMode(u32 port_no, u32 mode)
void cellPad_init() void cellPad_init()
{ {
sys_io.AddFunc(0x1cf98800, cellPadInit); REG_FUNC(sys_io, cellPadInit);
sys_io.AddFunc(0x4d9b75d5, cellPadEnd); REG_FUNC(sys_io, cellPadEnd);
sys_io.AddFunc(0x0d5f2c14, cellPadClearBuf); REG_FUNC(sys_io, cellPadClearBuf);
sys_io.AddFunc(0x8b72cda1, cellPadGetData); REG_FUNC(sys_io, cellPadGetData);
sys_io.AddFunc(0x6bc09c61, cellPadGetDataExtra); REG_FUNC(sys_io, cellPadGetDataExtra);
sys_io.AddFunc(0xf65544ee, cellPadSetActDirect); REG_FUNC(sys_io, cellPadSetActDirect);
sys_io.AddFunc(0x3aaad464, cellPadGetInfo); REG_FUNC(sys_io, cellPadGetInfo);
sys_io.AddFunc(0xa703a51d, cellPadGetInfo2); REG_FUNC(sys_io, cellPadGetInfo2);
sys_io.AddFunc(0x4cc9b68d, cellPadPeriphGetInfo); REG_FUNC(sys_io, cellPadPeriphGetInfo);
sys_io.AddFunc(0x578e3c98, cellPadSetPortSetting); REG_FUNC(sys_io, cellPadSetPortSetting);
sys_io.AddFunc(0x0e2dfaad, cellPadInfoPressMode); REG_FUNC(sys_io, cellPadInfoPressMode);
sys_io.AddFunc(0x78200559, cellPadInfoSensorMode); REG_FUNC(sys_io, cellPadInfoSensorMode);
sys_io.AddFunc(0xf83f8182, cellPadSetPressMode); REG_FUNC(sys_io, cellPadSetPressMode);
sys_io.AddFunc(0xbe5be3ba, cellPadSetSensorMode); REG_FUNC(sys_io, cellPadSetSensorMode);
sys_io.AddFunc(0xdbf4c59c, cellPadGetCapabilityInfo); REG_FUNC(sys_io, cellPadGetCapabilityInfo);
} }

46
rpcs3/Emu/SysCalls/Modules/cellPamf.cpp
View File

@ -736,27 +736,27 @@ s32 cellPamfEpIteratorMove(vm::ptr<CellPamfEpIterator> pIt, s32 steps, vm::ptr<C
Module cellPamf("cellPamf", []() Module cellPamf("cellPamf", []()
{ {
cellPamf.AddFunc(0xca8181c1, cellPamfGetHeaderSize); REG_FUNC(cellPamf, cellPamfGetHeaderSize);
cellPamf.AddFunc(0x90fc9a59, cellPamfGetHeaderSize2); REG_FUNC(cellPamf, cellPamfGetHeaderSize2);
cellPamf.AddFunc(0x44f5c9e3, cellPamfGetStreamOffsetAndSize); REG_FUNC(cellPamf, cellPamfGetStreamOffsetAndSize);
cellPamf.AddFunc(0xd1a40ef4, cellPamfVerify); REG_FUNC(cellPamf, cellPamfVerify);
cellPamf.AddFunc(0xb8436ee5, cellPamfReaderInitialize); REG_FUNC(cellPamf, cellPamfReaderInitialize);
cellPamf.AddFunc(0x4de501b1, cellPamfReaderGetPresentationStartTime); REG_FUNC(cellPamf, cellPamfReaderGetPresentationStartTime);
cellPamf.AddFunc(0xf61609d6, cellPamfReaderGetPresentationEndTime); REG_FUNC(cellPamf, cellPamfReaderGetPresentationEndTime);
cellPamf.AddFunc(0xdb70296c, cellPamfReaderGetMuxRateBound); REG_FUNC(cellPamf, cellPamfReaderGetMuxRateBound);
cellPamf.AddFunc(0x37f723f7, cellPamfReaderGetNumberOfStreams); REG_FUNC(cellPamf, cellPamfReaderGetNumberOfStreams);
cellPamf.AddFunc(0xd0230671, cellPamfReaderGetNumberOfSpecificStreams); REG_FUNC(cellPamf, cellPamfReaderGetNumberOfSpecificStreams);
cellPamf.AddFunc(0x461534b4, cellPamfReaderSetStreamWithIndex); REG_FUNC(cellPamf, cellPamfReaderSetStreamWithIndex);
cellPamf.AddFunc(0x03fd2caa, cellPamfReaderSetStreamWithTypeAndChannel); REG_FUNC(cellPamf, cellPamfReaderSetStreamWithTypeAndChannel);
cellPamf.AddFunc(0x28b4e2c1, cellPamfReaderSetStreamWithTypeAndIndex); REG_FUNC(cellPamf, cellPamfReaderSetStreamWithTypeAndIndex);
cellPamf.AddFunc(0x01067e22, cellPamfStreamTypeToEsFilterId); REG_FUNC(cellPamf, cellPamfStreamTypeToEsFilterId);
cellPamf.AddFunc(0x041cc708, cellPamfReaderGetStreamIndex); REG_FUNC(cellPamf, cellPamfReaderGetStreamIndex);
cellPamf.AddFunc(0x9ab20793, cellPamfReaderGetStreamTypeAndChannel); REG_FUNC(cellPamf, cellPamfReaderGetStreamTypeAndChannel);
cellPamf.AddFunc(0x71df326a, cellPamfReaderGetEsFilterId); REG_FUNC(cellPamf, cellPamfReaderGetEsFilterId);
cellPamf.AddFunc(0x67fd273b, cellPamfReaderGetStreamInfo); REG_FUNC(cellPamf, cellPamfReaderGetStreamInfo);
cellPamf.AddFunc(0xd9ea3457, cellPamfReaderGetNumberOfEp); REG_FUNC(cellPamf, cellPamfReaderGetNumberOfEp);
cellPamf.AddFunc(0xe8586ec6, cellPamfReaderGetEpIteratorWithIndex); REG_FUNC(cellPamf, cellPamfReaderGetEpIteratorWithIndex);
cellPamf.AddFunc(0x439fba17, cellPamfReaderGetEpIteratorWithTimeStamp); REG_FUNC(cellPamf, cellPamfReaderGetEpIteratorWithTimeStamp);
cellPamf.AddFunc(0x1abeb9d6, cellPamfEpIteratorGetEp); REG_FUNC(cellPamf, cellPamfEpIteratorGetEp);
cellPamf.AddFunc(0x50b83205, cellPamfEpIteratorMove); REG_FUNC(cellPamf, cellPamfEpIteratorMove);
}); });

8
rpcs3/Emu/SysCalls/Modules/cellPhotoDecode.cpp
View File

@ -58,9 +58,9 @@ int cellPhotoDecodeFromFile()
void cellPhotoDecode_init() void cellPhotoDecode_init()
{ {
cellPhotoDecode.AddFunc(0x596f0a56, cellPhotoDecodeInitialize); REG_FUNC(cellPhotoDecode, cellPhotoDecodeInitialize);
cellPhotoDecode.AddFunc(0x0f424ecb, cellPhotoDecodeInitialize2); REG_FUNC(cellPhotoDecode, cellPhotoDecodeInitialize2);
cellPhotoDecode.AddFunc(0xad7d8f38, cellPhotoDecodeFinalize); REG_FUNC(cellPhotoDecode, cellPhotoDecodeFinalize);
cellPhotoDecode.AddFunc(0x28b22e44, cellPhotoDecodeFromFile); REG_FUNC(cellPhotoDecode, cellPhotoDecodeFromFile);
} }
#endif #endif

10
rpcs3/Emu/SysCalls/Modules/cellPhotoExport.cpp
View File

@ -53,11 +53,11 @@ int cellPhotoExportProgress()
void cellPhotoExport_init() void cellPhotoExport_init()
{ {
cellPhotoExport.AddFunc(0x4357c77f, cellPhotoExportInitialize); REG_FUNC(cellPhotoExport, cellPhotoExportInitialize);
cellPhotoExport.AddFunc(0x08cbd8e1, cellPhotoExportInitialize2); REG_FUNC(cellPhotoExport, cellPhotoExportInitialize2);
cellPhotoExport.AddFunc(0xed4a0148, cellPhotoExportFinalize); REG_FUNC(cellPhotoExport, cellPhotoExportFinalize);
cellPhotoExport.AddFunc(0x09ce84ac, cellPhotoExportFromFile); REG_FUNC(cellPhotoExport, cellPhotoExportFromFile);
//cellPhotoExport.AddFunc(, cellPhotoExportFromFileWithCopy); //cellPhotoExport.AddFunc(, cellPhotoExportFromFileWithCopy);
cellPhotoExport.AddFunc(0xde509ead, cellPhotoExportProgress); REG_FUNC(cellPhotoExport, cellPhotoExportProgress);
} }
#endif #endif

4
rpcs3/Emu/SysCalls/Modules/cellPhotoImport.cpp
View File

@ -55,7 +55,7 @@ int _cellPhotoImport2()
void cellPhotoImport_init() void cellPhotoImport_init()
{ {
cellPhotoImport.AddFunc(0x0783bce0, _cellPhotoImport); REG_FUNC(cellPhotoImport, _cellPhotoImport);
cellPhotoImport.AddFunc(0x1ab8df55, _cellPhotoImport2); REG_FUNC(cellPhotoImport, _cellPhotoImport2);
} }
#endif #endif

18
rpcs3/Emu/SysCalls/Modules/cellPngEnc.cpp
View File

@ -71,14 +71,14 @@ int cellPngEncReset()
void cellPngEnc_init() void cellPngEnc_init()
{ {
cellPngEnc.AddFunc(0x496cfcd0, cellPngEncQueryAttr); REG_FUNC(cellPngEnc, cellPngEncQueryAttr);
cellPngEnc.AddFunc(0x19256dc5, cellPngEncOpen); REG_FUNC(cellPngEnc, cellPngEncOpen);
cellPngEnc.AddFunc(0xc82558ce, cellPngEncOpenEx); REG_FUNC(cellPngEnc, cellPngEncOpenEx);
cellPngEnc.AddFunc(0x117cd726, cellPngEncClose); REG_FUNC(cellPngEnc, cellPngEncClose);
cellPngEnc.AddFunc(0x662bd637, cellPngEncWaitForInput); REG_FUNC(cellPngEnc, cellPngEncWaitForInput);
cellPngEnc.AddFunc(0x5b546ca4, cellPngEncEncodePicture); REG_FUNC(cellPngEnc, cellPngEncEncodePicture);
cellPngEnc.AddFunc(0x90ef2963, cellPngEncWaitForOutput); REG_FUNC(cellPngEnc, cellPngEncWaitForOutput);
cellPngEnc.AddFunc(0x585269bc, cellPngEncGetStreamInfo); REG_FUNC(cellPngEnc, cellPngEncGetStreamInfo);
cellPngEnc.AddFunc(0x6ac91de3, cellPngEncReset); REG_FUNC(cellPngEnc, cellPngEncReset);
} }
#endif #endif

24
rpcs3/Emu/SysCalls/Modules/cellPrint.cpp
View File

@ -91,17 +91,17 @@ int cellPrintSendBand()
void cellPrint_init() void cellPrint_init()
{ {
cellPrint.AddFunc(0xc9c3ef14, cellPrintLoadAsync); REG_FUNC(cellPrint, cellPrintLoadAsync);
cellPrint.AddFunc(0xf0865182, cellPrintLoadAsync2); REG_FUNC(cellPrint, cellPrintLoadAsync2);
cellPrint.AddFunc(0xeb51aa38, cellPrintUnloadAsync); REG_FUNC(cellPrint, cellPrintUnloadAsync);
cellPrint.AddFunc(0x6802dfb5, cellPrintGetStatus); REG_FUNC(cellPrint, cellPrintGetStatus);
cellPrint.AddFunc(0xf9a53f35, cellPrintOpenConfig); REG_FUNC(cellPrint, cellPrintOpenConfig);
cellPrint.AddFunc(0x6e952645, cellPrintGetPrintableArea); REG_FUNC(cellPrint, cellPrintGetPrintableArea);
cellPrint.AddFunc(0x795b12b3, cellPrintStartJob); REG_FUNC(cellPrint, cellPrintStartJob);
cellPrint.AddFunc(0xc04a7d42, cellPrintEndJob); REG_FUNC(cellPrint, cellPrintEndJob);
cellPrint.AddFunc(0x293d9e9c, cellPrintCancelJob); REG_FUNC(cellPrint, cellPrintCancelJob);
cellPrint.AddFunc(0x865acf74, cellPrintStartPage); REG_FUNC(cellPrint, cellPrintStartPage);
cellPrint.AddFunc(0x0d44f661, cellPrintEndPage); REG_FUNC(cellPrint, cellPrintEndPage);
cellPrint.AddFunc(0x0a373522, cellPrintSendBand); REG_FUNC(cellPrint, cellPrintSendBand);
} }
#endif #endif

44
rpcs3/Emu/SysCalls/Modules/cellResc.cpp
View File

@ -1258,26 +1258,26 @@ Module cellResc("cellResc", []()
delete s_rescInternalInstance; delete s_rescInternalInstance;
}; };
cellResc.AddFunc(0x25c107e6, cellRescSetConvertAndFlip); REG_FUNC(cellResc, cellRescSetConvertAndFlip);
cellResc.AddFunc(0x0d3c22ce, cellRescSetWaitFlip); REG_FUNC(cellResc, cellRescSetWaitFlip);
cellResc.AddFunc(0x2ea94661, cellRescSetFlipHandler); REG_FUNC(cellResc, cellRescSetFlipHandler);
cellResc.AddFunc(0x01220224, cellRescGcmSurface2RescSrc); REG_FUNC(cellResc, cellRescGcmSurface2RescSrc);
cellResc.AddFunc(0x0a2069c7, cellRescGetNumColorBuffers); REG_FUNC(cellResc, cellRescGetNumColorBuffers);
cellResc.AddFunc(0x10db5b1a, cellRescSetDsts); REG_FUNC(cellResc, cellRescSetDsts);
cellResc.AddFunc(0x129922a0, cellRescResetFlipStatus); REG_FUNC(cellResc, cellRescResetFlipStatus);
cellResc.AddFunc(0x19a2a967, cellRescSetPalInterpolateDropFlexRatio); REG_FUNC(cellResc, cellRescSetPalInterpolateDropFlexRatio);
cellResc.AddFunc(0x1dd3c4cd, cellRescGetRegisterCount); REG_FUNC(cellResc, cellRescGetRegisterCount);
cellResc.AddFunc(0x22ae06d8, cellRescAdjustAspectRatio); REG_FUNC(cellResc, cellRescAdjustAspectRatio);
cellResc.AddFunc(0x23134710, cellRescSetDisplayMode); REG_FUNC(cellResc, cellRescSetDisplayMode);
cellResc.AddFunc(0x2ea3061e, cellRescExit); REG_FUNC(cellResc, cellRescExit);
cellResc.AddFunc(0x516ee89e, cellRescInit); REG_FUNC(cellResc, cellRescInit);
cellResc.AddFunc(0x5a338cdb, cellRescGetBufferSize); REG_FUNC(cellResc, cellRescGetBufferSize);
cellResc.AddFunc(0x66f5e388, cellRescGetLastFlipTime); REG_FUNC(cellResc, cellRescGetLastFlipTime);
cellResc.AddFunc(0x6cd0f95f, cellRescSetSrc); REG_FUNC(cellResc, cellRescSetSrc);
cellResc.AddFunc(0x7af8a37f, cellRescSetRegisterCount); REG_FUNC(cellResc, cellRescSetRegisterCount);
cellResc.AddFunc(0x8107277c, cellRescSetBufferAddress); REG_FUNC(cellResc, cellRescSetBufferAddress);
cellResc.AddFunc(0xc47c5c22, cellRescGetFlipStatus); REG_FUNC(cellResc, cellRescGetFlipStatus);
cellResc.AddFunc(0xd1ca0503, cellRescVideoOutResolutionId2RescBufferMode); REG_FUNC(cellResc, cellRescVideoOutResolutionId2RescBufferMode);
cellResc.AddFunc(0xd3758645, cellRescSetVBlankHandler); REG_FUNC(cellResc, cellRescSetVBlankHandler);
cellResc.AddFunc(0xe0cef79e, cellRescCreateInterlaceTable); REG_FUNC(cellResc, cellRescCreateInterlaceTable);
}); });

66
rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
View File

@ -447,44 +447,44 @@ int cellRtcCompareTick(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1)
Module cellRtc("cellRtc", []() Module cellRtc("cellRtc", []()
{ {
cellRtc.AddFunc(0x9dafc0d9, cellRtcGetCurrentTick); REG_FUNC(cellRtc, cellRtcGetCurrentTick);
cellRtc.AddFunc(0x32c941cf, cellRtcGetCurrentClock); REG_FUNC(cellRtc, cellRtcGetCurrentClock);
cellRtc.AddFunc(0x2cce9cf5, cellRtcGetCurrentClockLocalTime); REG_FUNC(cellRtc, cellRtcGetCurrentClockLocalTime);
cellRtc.AddFunc(0x5491b9d5, cellRtcFormatRfc2822); REG_FUNC(cellRtc, cellRtcFormatRfc2822);
cellRtc.AddFunc(0xa07c3d2f, cellRtcFormatRfc2822LocalTime); REG_FUNC(cellRtc, cellRtcFormatRfc2822LocalTime);
cellRtc.AddFunc(0xd9c0b463, cellRtcFormatRfc3339); REG_FUNC(cellRtc, cellRtcFormatRfc3339);
cellRtc.AddFunc(0x1324948a, cellRtcFormatRfc3339LocalTime); REG_FUNC(cellRtc, cellRtcFormatRfc3339LocalTime);
cellRtc.AddFunc(0xc5bc0fac, cellRtcParseDateTime); REG_FUNC(cellRtc, cellRtcParseDateTime);
cellRtc.AddFunc(0xcf11c3d6, cellRtcParseRfc3339); REG_FUNC(cellRtc, cellRtcParseRfc3339);
cellRtc.AddFunc(0xc7bdb7eb, cellRtcGetTick); REG_FUNC(cellRtc, cellRtcGetTick);
cellRtc.AddFunc(0x99b13034, cellRtcSetTick); REG_FUNC(cellRtc, cellRtcSetTick);
cellRtc.AddFunc(0x269a1882, cellRtcTickAddTicks); REG_FUNC(cellRtc, cellRtcTickAddTicks);
cellRtc.AddFunc(0xf8509925, cellRtcTickAddMicroseconds); REG_FUNC(cellRtc, cellRtcTickAddMicroseconds);
cellRtc.AddFunc(0xccce71bd, cellRtcTickAddSeconds); REG_FUNC(cellRtc, cellRtcTickAddSeconds);
cellRtc.AddFunc(0x2f010bfa, cellRtcTickAddMinutes); REG_FUNC(cellRtc, cellRtcTickAddMinutes);
cellRtc.AddFunc(0xd41d3bd2, cellRtcTickAddHours); REG_FUNC(cellRtc, cellRtcTickAddHours);
cellRtc.AddFunc(0x75744e2a, cellRtcTickAddDays); REG_FUNC(cellRtc, cellRtcTickAddDays);
cellRtc.AddFunc(0x64c63fd5, cellRtcTickAddWeeks); REG_FUNC(cellRtc, cellRtcTickAddWeeks);
cellRtc.AddFunc(0xe0ecbb45, cellRtcTickAddMonths); REG_FUNC(cellRtc, cellRtcTickAddMonths);
cellRtc.AddFunc(0x332a74dd, cellRtcTickAddYears); REG_FUNC(cellRtc, cellRtcTickAddYears);
cellRtc.AddFunc(0xc48d5002, cellRtcConvertUtcToLocalTime); REG_FUNC(cellRtc, cellRtcConvertUtcToLocalTime);
cellRtc.AddFunc(0x46ca7fe0, cellRtcConvertLocalTimeToUtc); REG_FUNC(cellRtc, cellRtcConvertLocalTimeToUtc);
// (TODO: Time Information Manipulation Functions missing) // (TODO: Time Information Manipulation Functions missing)
cellRtc.AddFunc(0xdfff32cf, cellRtcGetDosTime); REG_FUNC(cellRtc, cellRtcGetDosTime);
cellRtc.AddFunc(0xcb90c761, cellRtcGetTime_t); REG_FUNC(cellRtc, cellRtcGetTime_t);
cellRtc.AddFunc(0xe7086f05, cellRtcGetWin32FileTime); REG_FUNC(cellRtc, cellRtcGetWin32FileTime);
cellRtc.AddFunc(0x9598d4b3, cellRtcSetDosTime); REG_FUNC(cellRtc, cellRtcSetDosTime);
cellRtc.AddFunc(0xbb543189, cellRtcSetTime_t); REG_FUNC(cellRtc, cellRtcSetTime_t);
cellRtc.AddFunc(0x5f68c268, cellRtcSetWin32FileTime); REG_FUNC(cellRtc, cellRtcSetWin32FileTime);
cellRtc.AddFunc(0x5316b4a8, cellRtcIsLeapYear); REG_FUNC(cellRtc, cellRtcIsLeapYear);
cellRtc.AddFunc(0x5b6a0a1d, cellRtcGetDaysInMonth); REG_FUNC(cellRtc, cellRtcGetDaysInMonth);
cellRtc.AddFunc(0xc2d8cf95, cellRtcGetDayOfWeek); REG_FUNC(cellRtc, cellRtcGetDayOfWeek);
cellRtc.AddFunc(0x7f1086e6, cellRtcCheckValid); REG_FUNC(cellRtc, cellRtcCheckValid);
cellRtc.AddFunc(0xfb51fc61, cellRtcCompareTick); REG_FUNC(cellRtc, cellRtcCompareTick);
}); });

56
rpcs3/Emu/SysCalls/Modules/cellRudp.cpp
View File

@ -218,40 +218,40 @@ int cellRudpProcessEvents()
void cellRudp_init() void cellRudp_init()
{ {
cellRudp.AddFunc(0x63f63545, cellRudpInit); REG_FUNC(cellRudp, cellRudpInit);
cellRudp.AddFunc(0xb6bcb4a1, cellRudpEnd); REG_FUNC(cellRudp, cellRudpEnd);
cellRudp.AddFunc(0x6c0cff03, cellRudpEnableInternalIOThread); REG_FUNC(cellRudp, cellRudpEnableInternalIOThread);
cellRudp.AddFunc(0x7ed95e60, cellRudpSetEventHandler); REG_FUNC(cellRudp, cellRudpSetEventHandler);
cellRudp.AddFunc(0x54f81789, cellRudpSetMaxSegmentSize); REG_FUNC(cellRudp, cellRudpSetMaxSegmentSize);
cellRudp.AddFunc(0xfbf7e9e4, cellRudpGetMaxSegmentSize); REG_FUNC(cellRudp, cellRudpGetMaxSegmentSize);
cellRudp.AddFunc(0x7dadc739, cellRudpCreateContext); REG_FUNC(cellRudp, cellRudpCreateContext);
cellRudp.AddFunc(0x384ba777, cellRudpSetOption); REG_FUNC(cellRudp, cellRudpSetOption);
cellRudp.AddFunc(0xff9d259c, cellRudpGetOption); REG_FUNC(cellRudp, cellRudpGetOption);
cellRudp.AddFunc(0x74bfad12, cellRudpGetContextStatus); REG_FUNC(cellRudp, cellRudpGetContextStatus);
cellRudp.AddFunc(0xcd1a3f23, cellRudpGetStatus); REG_FUNC(cellRudp, cellRudpGetStatus);
cellRudp.AddFunc(0xd666931f, cellRudpGetLocalInfo); REG_FUNC(cellRudp, cellRudpGetLocalInfo);
cellRudp.AddFunc(0x576831ae, cellRudpGetRemoteInfo); REG_FUNC(cellRudp, cellRudpGetRemoteInfo);
cellRudp.AddFunc(0xee41e16a, cellRudpBind); REG_FUNC(cellRudp, cellRudpBind);
cellRudp.AddFunc(0xc407844f, cellRudpInitiate); REG_FUNC(cellRudp, cellRudpInitiate);
cellRudp.AddFunc(0xc1ad7ced, cellRudpActivate); REG_FUNC(cellRudp, cellRudpActivate);
cellRudp.AddFunc(0x48d3eeac, cellRudpTerminate); REG_FUNC(cellRudp, cellRudpTerminate);
cellRudp.AddFunc(0x92e4d899, cellRudpRead); REG_FUNC(cellRudp, cellRudpRead);
cellRudp.AddFunc(0x48c001b0, cellRudpWrite); REG_FUNC(cellRudp, cellRudpWrite);
cellRudp.AddFunc(0x2cde989f, cellRudpGetSizeReadable); REG_FUNC(cellRudp, cellRudpGetSizeReadable);
cellRudp.AddFunc(0xa86b28e3, cellRudpGetSizeWritable); REG_FUNC(cellRudp, cellRudpGetSizeWritable);
cellRudp.AddFunc(0xa70737da, cellRudpFlush); REG_FUNC(cellRudp, cellRudpFlush);
cellRudp.AddFunc(0x6bc587e9, cellRudpPollCreate); REG_FUNC(cellRudp, cellRudpPollCreate);
cellRudp.AddFunc(0x8ac398f1, cellRudpPollDestroy); REG_FUNC(cellRudp, cellRudpPollDestroy);
cellRudp.AddFunc(0xa3db855c, cellRudpPollControl); REG_FUNC(cellRudp, cellRudpPollControl);
cellRudp.AddFunc(0xd8310700, cellRudpPollWait); REG_FUNC(cellRudp, cellRudpPollWait);
//cellRudp.AddFunc(, cellRudpPollCancel); //cellRudp.AddFunc(, cellRudpPollCancel);
cellRudp.AddFunc(0x6ee04954, cellRudpNetReceived); REG_FUNC(cellRudp, cellRudpNetReceived);
cellRudp.AddFunc(0xfade48b2, cellRudpProcessEvents); REG_FUNC(cellRudp, cellRudpProcessEvents);
} }
#endif #endif

248
rpcs3/Emu/SysCalls/Modules/cellSail.cpp
View File

@ -880,141 +880,141 @@ int cellSailPlayerUnregisterSource()
Module cellSail("cellSail", []() Module cellSail("cellSail", []()
{ {
cellSail.AddFunc(0x346ebba3, cellSailMemAllocatorInitialize); REG_FUNC(cellSail, cellSailMemAllocatorInitialize);
cellSail.AddFunc(0x4cc54f8e, cellSailFutureInitialize); REG_FUNC(cellSail, cellSailFutureInitialize);
cellSail.AddFunc(0x9553af65, cellSailFutureFinalize); REG_FUNC(cellSail, cellSailFutureFinalize);
cellSail.AddFunc(0x0c4cb439, cellSailFutureReset); REG_FUNC(cellSail, cellSailFutureReset);
cellSail.AddFunc(0xa37fed15, cellSailFutureSet); REG_FUNC(cellSail, cellSailFutureSet);
cellSail.AddFunc(0x3a2d806c, cellSailFutureGet); REG_FUNC(cellSail, cellSailFutureGet);
cellSail.AddFunc(0x51ecf361, cellSailFutureIsDone); REG_FUNC(cellSail, cellSailFutureIsDone);
cellSail.AddFunc(0xd5f9a15b, cellSailDescriptorGetStreamType); REG_FUNC(cellSail, cellSailDescriptorGetStreamType);
cellSail.AddFunc(0x4c191088, cellSailDescriptorGetUri); REG_FUNC(cellSail, cellSailDescriptorGetUri);
cellSail.AddFunc(0xbd1635f4, cellSailDescriptorGetMediaInfo); REG_FUNC(cellSail, cellSailDescriptorGetMediaInfo);
cellSail.AddFunc(0x76b1a425, cellSailDescriptorSetAutoSelection); REG_FUNC(cellSail, cellSailDescriptorSetAutoSelection);
cellSail.AddFunc(0x277adf21, cellSailDescriptorIsAutoSelection); REG_FUNC(cellSail, cellSailDescriptorIsAutoSelection);
cellSail.AddFunc(0x0abb318b, cellSailDescriptorCreateDatabase); REG_FUNC(cellSail, cellSailDescriptorCreateDatabase);
cellSail.AddFunc(0x28336e89, cellSailDescriptorDestroyDatabase); REG_FUNC(cellSail, cellSailDescriptorDestroyDatabase);
cellSail.AddFunc(0xc044fab1, cellSailDescriptorOpen); REG_FUNC(cellSail, cellSailDescriptorOpen);
cellSail.AddFunc(0x15fd6a2a, cellSailDescriptorClose); REG_FUNC(cellSail, cellSailDescriptorClose);
cellSail.AddFunc(0x0d0c2f0c, cellSailDescriptorSetEs); REG_FUNC(cellSail, cellSailDescriptorSetEs);
cellSail.AddFunc(0xdf5553ef, cellSailDescriptorClearEs); REG_FUNC(cellSail, cellSailDescriptorClearEs);
cellSail.AddFunc(0xac9c3b1f, cellSailDescriptorGetCapabilities); REG_FUNC(cellSail, cellSailDescriptorGetCapabilities);
cellSail.AddFunc(0x92590d52, cellSailDescriptorInquireCapability); REG_FUNC(cellSail, cellSailDescriptorInquireCapability);
cellSail.AddFunc(0xee94b99b, cellSailDescriptorSetParameter); REG_FUNC(cellSail, cellSailDescriptorSetParameter);
cellSail.AddFunc(0x3d0d3b72, cellSailSoundAdapterInitialize); REG_FUNC(cellSail, cellSailSoundAdapterInitialize);
cellSail.AddFunc(0xd1462438, cellSailSoundAdapterFinalize); REG_FUNC(cellSail, cellSailSoundAdapterFinalize);
cellSail.AddFunc(0x1c9d5e5a, cellSailSoundAdapterSetPreferredFormat); REG_FUNC(cellSail, cellSailSoundAdapterSetPreferredFormat);
cellSail.AddFunc(0x7eb8d6b5, cellSailSoundAdapterGetFrame); REG_FUNC(cellSail, cellSailSoundAdapterGetFrame);
cellSail.AddFunc(0xf25f197d, cellSailSoundAdapterGetFormat); REG_FUNC(cellSail, cellSailSoundAdapterGetFormat);
cellSail.AddFunc(0xeec22809, cellSailSoundAdapterUpdateAvSync); REG_FUNC(cellSail, cellSailSoundAdapterUpdateAvSync);
cellSail.AddFunc(0x4ae979df, cellSailSoundAdapterPtsToTimePosition); REG_FUNC(cellSail, cellSailSoundAdapterPtsToTimePosition);
cellSail.AddFunc(0x1c983864, cellSailGraphicsAdapterInitialize); REG_FUNC(cellSail, cellSailGraphicsAdapterInitialize);
cellSail.AddFunc(0x76488bb1, cellSailGraphicsAdapterFinalize); REG_FUNC(cellSail, cellSailGraphicsAdapterFinalize);
cellSail.AddFunc(0x2e3ccb5e, cellSailGraphicsAdapterSetPreferredFormat); REG_FUNC(cellSail, cellSailGraphicsAdapterSetPreferredFormat);
cellSail.AddFunc(0x0247c69e, cellSailGraphicsAdapterGetFrame); REG_FUNC(cellSail, cellSailGraphicsAdapterGetFrame);
cellSail.AddFunc(0x018281a8, cellSailGraphicsAdapterGetFrame2); REG_FUNC(cellSail, cellSailGraphicsAdapterGetFrame2);
cellSail.AddFunc(0xffd58aa4, cellSailGraphicsAdapterGetFormat); REG_FUNC(cellSail, cellSailGraphicsAdapterGetFormat);
cellSail.AddFunc(0x44a20e79, cellSailGraphicsAdapterUpdateAvSync); REG_FUNC(cellSail, cellSailGraphicsAdapterUpdateAvSync);
cellSail.AddFunc(0x1872331b, cellSailGraphicsAdapterPtsToTimePosition); REG_FUNC(cellSail, cellSailGraphicsAdapterPtsToTimePosition);
cellSail.AddFunc(0x3dd9639a, cellSailAuReceiverInitialize); REG_FUNC(cellSail, cellSailAuReceiverInitialize);
cellSail.AddFunc(0xed58e3ec, cellSailAuReceiverFinalize); REG_FUNC(cellSail, cellSailAuReceiverFinalize);
cellSail.AddFunc(0x3a1132ed, cellSailAuReceiverGet); REG_FUNC(cellSail, cellSailAuReceiverGet);
cellSail.AddFunc(0x67b4d01f, cellSailRendererAudioInitialize); REG_FUNC(cellSail, cellSailRendererAudioInitialize);
cellSail.AddFunc(0x06dd4174, cellSailRendererAudioFinalize); REG_FUNC(cellSail, cellSailRendererAudioFinalize);
cellSail.AddFunc(0xb7b4ecee, cellSailRendererAudioNotifyCallCompleted); REG_FUNC(cellSail, cellSailRendererAudioNotifyCallCompleted);
cellSail.AddFunc(0xf841a537, cellSailRendererAudioNotifyFrameDone); REG_FUNC(cellSail, cellSailRendererAudioNotifyFrameDone);
cellSail.AddFunc(0x325039b9, cellSailRendererAudioNotifyOutputEos); REG_FUNC(cellSail, cellSailRendererAudioNotifyOutputEos);
cellSail.AddFunc(0x8d1ff475, cellSailRendererVideoInitialize); REG_FUNC(cellSail, cellSailRendererVideoInitialize);
cellSail.AddFunc(0x47055fea, cellSailRendererVideoFinalize); REG_FUNC(cellSail, cellSailRendererVideoFinalize);
cellSail.AddFunc(0x954f48f8, cellSailRendererVideoNotifyCallCompleted); REG_FUNC(cellSail, cellSailRendererVideoNotifyCallCompleted);
cellSail.AddFunc(0x5f77e8df, cellSailRendererVideoNotifyFrameDone); REG_FUNC(cellSail, cellSailRendererVideoNotifyFrameDone);
cellSail.AddFunc(0xdff1cda2, cellSailRendererVideoNotifyOutputEos); REG_FUNC(cellSail, cellSailRendererVideoNotifyOutputEos);
cellSail.AddFunc(0x9d30bdce, cellSailSourceInitialize); REG_FUNC(cellSail, cellSailSourceInitialize);
cellSail.AddFunc(0xee724c99, cellSailSourceFinalize); REG_FUNC(cellSail, cellSailSourceFinalize);
cellSail.AddFunc(0x764ec2d2, cellSailSourceNotifyCallCompleted); REG_FUNC(cellSail, cellSailSourceNotifyCallCompleted);
cellSail.AddFunc(0x54c53688, cellSailSourceNotifyInputEos); REG_FUNC(cellSail, cellSailSourceNotifyInputEos);
cellSail.AddFunc(0x95ee1695, cellSailSourceNotifyStreamOut); REG_FUNC(cellSail, cellSailSourceNotifyStreamOut);
cellSail.AddFunc(0xf289f0cd, cellSailSourceNotifySessionError); REG_FUNC(cellSail, cellSailSourceNotifySessionError);
cellSail.AddFunc(0xf4009a94, cellSailSourceNotifyMediaStateChanged); REG_FUNC(cellSail, cellSailSourceNotifyMediaStateChanged);
//cellSail.AddFunc(, cellSailSourceCheck); //cellSail.AddFunc(, cellSailSourceCheck);
cellSail.AddFunc(0x3df98d41, cellSailSourceNotifyOpenCompleted); REG_FUNC(cellSail, cellSailSourceNotifyOpenCompleted);
cellSail.AddFunc(0x640c7278, cellSailSourceNotifyStartCompleted); REG_FUNC(cellSail, cellSailSourceNotifyStartCompleted);
cellSail.AddFunc(0x7473970a, cellSailSourceNotifyStopCompleted); REG_FUNC(cellSail, cellSailSourceNotifyStopCompleted);
cellSail.AddFunc(0x946ecca0, cellSailSourceNotifyReadCompleted); REG_FUNC(cellSail, cellSailSourceNotifyReadCompleted);
cellSail.AddFunc(0xbdb2251a, cellSailSourceSetDiagHandler); REG_FUNC(cellSail, cellSailSourceSetDiagHandler);
cellSail.AddFunc(0xc457b203, cellSailSourceNotifyCloseCompleted); REG_FUNC(cellSail, cellSailSourceNotifyCloseCompleted);
cellSail.AddFunc(0xb980b76e, cellSailMp4MovieGetBrand); REG_FUNC(cellSail, cellSailMp4MovieGetBrand);
cellSail.AddFunc(0xd4049de0, cellSailMp4MovieIsCompatibleBrand); REG_FUNC(cellSail, cellSailMp4MovieIsCompatibleBrand);
cellSail.AddFunc(0x5783a454, cellSailMp4MovieGetMovieInfo); REG_FUNC(cellSail, cellSailMp4MovieGetMovieInfo);
cellSail.AddFunc(0x5faf802b, cellSailMp4MovieGetTrackByIndex); REG_FUNC(cellSail, cellSailMp4MovieGetTrackByIndex);
cellSail.AddFunc(0x85b07126, cellSailMp4MovieGetTrackById); REG_FUNC(cellSail, cellSailMp4MovieGetTrackById);
cellSail.AddFunc(0xc2d90ec9, cellSailMp4MovieGetTrackByTypeAndIndex); REG_FUNC(cellSail, cellSailMp4MovieGetTrackByTypeAndIndex);
cellSail.AddFunc(0xa48be428, cellSailMp4TrackGetTrackInfo); REG_FUNC(cellSail, cellSailMp4TrackGetTrackInfo);
cellSail.AddFunc(0x72236ec1, cellSailMp4TrackGetTrackReferenceCount); REG_FUNC(cellSail, cellSailMp4TrackGetTrackReferenceCount);
cellSail.AddFunc(0x5f44f64f, cellSailMp4TrackGetTrackReference); REG_FUNC(cellSail, cellSailMp4TrackGetTrackReference);
//cellSail.AddFunc(, cellSailMp4ConvertTimeScale); //cellSail.AddFunc(, cellSailMp4ConvertTimeScale);
cellSail.AddFunc(0x6e83f5c0, cellSailAviMovieGetMovieInfo); REG_FUNC(cellSail, cellSailAviMovieGetMovieInfo);
cellSail.AddFunc(0x3e908c56, cellSailAviMovieGetStreamByIndex); REG_FUNC(cellSail, cellSailAviMovieGetStreamByIndex);
cellSail.AddFunc(0xddebd2a5, cellSailAviMovieGetStreamByTypeAndIndex); REG_FUNC(cellSail, cellSailAviMovieGetStreamByTypeAndIndex);
cellSail.AddFunc(0x10298371, cellSailAviMovieGetHeader); REG_FUNC(cellSail, cellSailAviMovieGetHeader);
cellSail.AddFunc(0xc09e2f23, cellSailAviStreamGetMediaType); REG_FUNC(cellSail, cellSailAviStreamGetMediaType);
cellSail.AddFunc(0xcc3cca60, cellSailAviStreamGetHeader); REG_FUNC(cellSail, cellSailAviStreamGetHeader);
cellSail.AddFunc(0x17932b26, cellSailPlayerInitialize); REG_FUNC(cellSail, cellSailPlayerInitialize);
cellSail.AddFunc(0x23654375, cellSailPlayerInitialize2); REG_FUNC(cellSail, cellSailPlayerInitialize2);
cellSail.AddFunc(0x18b4629d, cellSailPlayerFinalize); REG_FUNC(cellSail, cellSailPlayerFinalize);
cellSail.AddFunc(0xbedccc74, cellSailPlayerRegisterSource); REG_FUNC(cellSail, cellSailPlayerRegisterSource);
cellSail.AddFunc(0x186b98d3, cellSailPlayerGetRegisteredProtocols); REG_FUNC(cellSail, cellSailPlayerGetRegisteredProtocols);
cellSail.AddFunc(0x1139a206, cellSailPlayerSetSoundAdapter); REG_FUNC(cellSail, cellSailPlayerSetSoundAdapter);
cellSail.AddFunc(0x18bcd21b, cellSailPlayerSetGraphicsAdapter); REG_FUNC(cellSail, cellSailPlayerSetGraphicsAdapter);
cellSail.AddFunc(0xf5747e1f, cellSailPlayerSetAuReceiver); REG_FUNC(cellSail, cellSailPlayerSetAuReceiver);
cellSail.AddFunc(0x92eaf6ca, cellSailPlayerSetRendererAudio); REG_FUNC(cellSail, cellSailPlayerSetRendererAudio);
cellSail.AddFunc(0xecf56150, cellSailPlayerSetRendererVideo); REG_FUNC(cellSail, cellSailPlayerSetRendererVideo);
cellSail.AddFunc(0x5f7c7a6f, cellSailPlayerSetParameter); REG_FUNC(cellSail, cellSailPlayerSetParameter);
cellSail.AddFunc(0x952269c9, cellSailPlayerGetParameter); REG_FUNC(cellSail, cellSailPlayerGetParameter);
cellSail.AddFunc(0x6f0b1002, cellSailPlayerSubscribeEvent); REG_FUNC(cellSail, cellSailPlayerSubscribeEvent);
cellSail.AddFunc(0x69793952, cellSailPlayerUnsubscribeEvent); REG_FUNC(cellSail, cellSailPlayerUnsubscribeEvent);
cellSail.AddFunc(0x47632810, cellSailPlayerReplaceEventHandler); REG_FUNC(cellSail, cellSailPlayerReplaceEventHandler);
cellSail.AddFunc(0xbdf21b0f, cellSailPlayerBoot); REG_FUNC(cellSail, cellSailPlayerBoot);
cellSail.AddFunc(0xd7938b8d, cellSailPlayerCreateDescriptor); REG_FUNC(cellSail, cellSailPlayerCreateDescriptor);
cellSail.AddFunc(0xfc839bd4, cellSailPlayerDestroyDescriptor); REG_FUNC(cellSail, cellSailPlayerDestroyDescriptor);
cellSail.AddFunc(0x7c8dff3b, cellSailPlayerAddDescriptor); REG_FUNC(cellSail, cellSailPlayerAddDescriptor);
cellSail.AddFunc(0x9897fbd1, cellSailPlayerRemoveDescriptor); REG_FUNC(cellSail, cellSailPlayerRemoveDescriptor);
cellSail.AddFunc(0x752f8585, cellSailPlayerGetDescriptorCount); REG_FUNC(cellSail, cellSailPlayerGetDescriptorCount);
cellSail.AddFunc(0x75fca288, cellSailPlayerGetCurrentDescriptor); REG_FUNC(cellSail, cellSailPlayerGetCurrentDescriptor);
cellSail.AddFunc(0x34ecc1b9, cellSailPlayerOpenStream); REG_FUNC(cellSail, cellSailPlayerOpenStream);
cellSail.AddFunc(0x85beffcc, cellSailPlayerCloseStream); REG_FUNC(cellSail, cellSailPlayerCloseStream);
cellSail.AddFunc(0x145f9b11, cellSailPlayerOpenEsAudio); REG_FUNC(cellSail, cellSailPlayerOpenEsAudio);
cellSail.AddFunc(0x477501f6, cellSailPlayerOpenEsVideo); REG_FUNC(cellSail, cellSailPlayerOpenEsVideo);
cellSail.AddFunc(0xa849d0a7, cellSailPlayerOpenEsUser); REG_FUNC(cellSail, cellSailPlayerOpenEsUser);
cellSail.AddFunc(0x4fa5ad09, cellSailPlayerReopenEsAudio); REG_FUNC(cellSail, cellSailPlayerReopenEsAudio);
cellSail.AddFunc(0xf60a8a69, cellSailPlayerReopenEsVideo); REG_FUNC(cellSail, cellSailPlayerReopenEsVideo);
cellSail.AddFunc(0x7b6fa92e, cellSailPlayerReopenEsUser); REG_FUNC(cellSail, cellSailPlayerReopenEsUser);
cellSail.AddFunc(0xbf9b8d72, cellSailPlayerCloseEsAudio); REG_FUNC(cellSail, cellSailPlayerCloseEsAudio);
cellSail.AddFunc(0x07924359, cellSailPlayerCloseEsVideo); REG_FUNC(cellSail, cellSailPlayerCloseEsVideo);
cellSail.AddFunc(0xaed9d6cd, cellSailPlayerCloseEsUser); REG_FUNC(cellSail, cellSailPlayerCloseEsUser);
cellSail.AddFunc(0xe535b0d3, cellSailPlayerStart); REG_FUNC(cellSail, cellSailPlayerStart);
cellSail.AddFunc(0xeba8d4ec, cellSailPlayerStop); REG_FUNC(cellSail, cellSailPlayerStop);
cellSail.AddFunc(0x26563ddc, cellSailPlayerNext); REG_FUNC(cellSail, cellSailPlayerNext);
cellSail.AddFunc(0x950d53c1, cellSailPlayerCancel); REG_FUNC(cellSail, cellSailPlayerCancel);
cellSail.AddFunc(0xd1d55a90, cellSailPlayerSetPaused); REG_FUNC(cellSail, cellSailPlayerSetPaused);
cellSail.AddFunc(0xaafa17b8, cellSailPlayerIsPaused); REG_FUNC(cellSail, cellSailPlayerIsPaused);
cellSail.AddFunc(0xfc5baf8a, cellSailPlayerSetRepeatMode); REG_FUNC(cellSail, cellSailPlayerSetRepeatMode);
cellSail.AddFunc(0x38144ecf, cellSailPlayerGetRepeatMode); REG_FUNC(cellSail, cellSailPlayerGetRepeatMode);
cellSail.AddFunc(0x91d287f6, cellSailPlayerSetEsAudioMuted); REG_FUNC(cellSail, cellSailPlayerSetEsAudioMuted);
cellSail.AddFunc(0xf1446a40, cellSailPlayerSetEsVideoMuted); REG_FUNC(cellSail, cellSailPlayerSetEsVideoMuted);
cellSail.AddFunc(0x09de25fd, cellSailPlayerIsEsAudioMuted); REG_FUNC(cellSail, cellSailPlayerIsEsAudioMuted);
cellSail.AddFunc(0xdbe32ed4, cellSailPlayerIsEsVideoMuted); REG_FUNC(cellSail, cellSailPlayerIsEsVideoMuted);
cellSail.AddFunc(0xcc987ba6, cellSailPlayerDumpImage); REG_FUNC(cellSail, cellSailPlayerDumpImage);
cellSail.AddFunc(0x025b4974, cellSailPlayerUnregisterSource); REG_FUNC(cellSail, cellSailPlayerUnregisterSource);
}); });

72
rpcs3/Emu/SysCalls/Modules/cellSailRec.cpp
View File

@ -239,50 +239,50 @@ int cellSailRecorderDumpImage()
void cellSailRec_init() void cellSailRec_init()
{ {
cellSailRec.AddFunc(0xe14cae97, cellSailProfileSetEsAudioParameter); REG_FUNC(cellSailRec, cellSailProfileSetEsAudioParameter);
cellSailRec.AddFunc(0x1422a425, cellSailProfileSetEsVideoParameter); REG_FUNC(cellSailRec, cellSailProfileSetEsVideoParameter);
cellSailRec.AddFunc(0xe8d86c43, cellSailProfileSetStreamParameter); REG_FUNC(cellSailRec, cellSailProfileSetStreamParameter);
cellSailRec.AddFunc(0xb3d30b0d, cellSailVideoConverterCanProcess); REG_FUNC(cellSailRec, cellSailVideoConverterCanProcess);
cellSailRec.AddFunc(0x855da8c6, cellSailVideoConverterProcess); REG_FUNC(cellSailRec, cellSailVideoConverterProcess);
cellSailRec.AddFunc(0xe16de678, cellSailVideoConverterCanGetResult); REG_FUNC(cellSailRec, cellSailVideoConverterCanGetResult);
cellSailRec.AddFunc(0xe15679fe, cellSailVideoConverterGetResult); REG_FUNC(cellSailRec, cellSailVideoConverterGetResult);
//cellSailRec.AddFunc(, CellSailVideoConverterFuncProcessDone); //cellSailRec.AddFunc(, CellSailVideoConverterFuncProcessDone);
cellSailRec.AddFunc(0xbd591197, cellSailFeederAudioInitialize); REG_FUNC(cellSailRec, cellSailFeederAudioInitialize);
cellSailRec.AddFunc(0x899d1587, cellSailFeederAudioFinalize); REG_FUNC(cellSailRec, cellSailFeederAudioFinalize);
cellSailRec.AddFunc(0xc2e2f30d, cellSailFeederAudioNotifyCallCompleted); REG_FUNC(cellSailRec, cellSailFeederAudioNotifyCallCompleted);
cellSailRec.AddFunc(0x3c775cea, cellSailFeederAudioNotifyFrameOut); REG_FUNC(cellSailRec, cellSailFeederAudioNotifyFrameOut);
cellSailRec.AddFunc(0x999c0dc5, cellSailFeederAudioNotifySessionEnd); REG_FUNC(cellSailRec, cellSailFeederAudioNotifySessionEnd);
cellSailRec.AddFunc(0xaf310ae6, cellSailFeederAudioNotifySessionError); REG_FUNC(cellSailRec, cellSailFeederAudioNotifySessionError);
cellSailRec.AddFunc(0x57415dd3, cellSailFeederVideoInitialize); REG_FUNC(cellSailRec, cellSailFeederVideoInitialize);
cellSailRec.AddFunc(0x81bfeae8, cellSailFeederVideoFinalize); REG_FUNC(cellSailRec, cellSailFeederVideoFinalize);
cellSailRec.AddFunc(0xd84daeb9, cellSailFeederVideoNotifyCallCompleted); REG_FUNC(cellSailRec, cellSailFeederVideoNotifyCallCompleted);
cellSailRec.AddFunc(0xe5e0572a, cellSailFeederVideoNotifyFrameOut); REG_FUNC(cellSailRec, cellSailFeederVideoNotifyFrameOut);
cellSailRec.AddFunc(0xbff6e8d3, cellSailFeederVideoNotifySessionEnd); REG_FUNC(cellSailRec, cellSailFeederVideoNotifySessionEnd);
cellSailRec.AddFunc(0x86cae679, cellSailFeederVideoNotifySessionError); REG_FUNC(cellSailRec, cellSailFeederVideoNotifySessionError);
cellSailRec.AddFunc(0x7a52bf69, cellSailRecorderInitialize); REG_FUNC(cellSailRec, cellSailRecorderInitialize);
cellSailRec.AddFunc(0xf57d74e3, cellSailRecorderFinalize); REG_FUNC(cellSailRec, cellSailRecorderFinalize);
cellSailRec.AddFunc(0x3deae857, cellSailRecorderSetFeederAudio); REG_FUNC(cellSailRec, cellSailRecorderSetFeederAudio);
cellSailRec.AddFunc(0x4fec43a9, cellSailRecorderSetFeederVideo); REG_FUNC(cellSailRec, cellSailRecorderSetFeederVideo);
cellSailRec.AddFunc(0x0a3ea2a9, cellSailRecorderSetParameter); REG_FUNC(cellSailRec, cellSailRecorderSetParameter);
cellSailRec.AddFunc(0xff20157b, cellSailRecorderGetParameter); REG_FUNC(cellSailRec, cellSailRecorderGetParameter);
//cellSailRec.AddFunc(, cellSailRecorderSubscribeEvent); //cellSailRec.AddFunc(, cellSailRecorderSubscribeEvent);
//cellSailRec.AddFunc(, cellSailRecorderUnsubscribeEvent); //cellSailRec.AddFunc(, cellSailRecorderUnsubscribeEvent);
//cellSailRec.AddFunc(, cellSailRecorderReplaceEventHandler); //cellSailRec.AddFunc(, cellSailRecorderReplaceEventHandler);
cellSailRec.AddFunc(0xc4617ddc, cellSailRecorderBoot); REG_FUNC(cellSailRec, cellSailRecorderBoot);
cellSailRec.AddFunc(0x50affdc1, cellSailRecorderCreateProfile); REG_FUNC(cellSailRec, cellSailRecorderCreateProfile);
cellSailRec.AddFunc(0x376c3926, cellSailRecorderDestroyProfile); REG_FUNC(cellSailRec, cellSailRecorderDestroyProfile);
cellSailRec.AddFunc(0x49476a3d, cellSailRecorderCreateVideoConverter); REG_FUNC(cellSailRec, cellSailRecorderCreateVideoConverter);
cellSailRec.AddFunc(0x455c4709, cellSailRecorderDestroyVideoConverter); REG_FUNC(cellSailRec, cellSailRecorderDestroyVideoConverter);
cellSailRec.AddFunc(0x10c81457, cellSailRecorderOpenStream); REG_FUNC(cellSailRec, cellSailRecorderOpenStream);
cellSailRec.AddFunc(0xe3f56f62, cellSailRecorderCloseStream); REG_FUNC(cellSailRec, cellSailRecorderCloseStream);
cellSailRec.AddFunc(0x4830faf8, cellSailRecorderStart); REG_FUNC(cellSailRec, cellSailRecorderStart);
cellSailRec.AddFunc(0x18ecc741, cellSailRecorderStop); REG_FUNC(cellSailRec, cellSailRecorderStop);
cellSailRec.AddFunc(0xd37fb694, cellSailRecorderCancel); REG_FUNC(cellSailRec, cellSailRecorderCancel);
cellSailRec.AddFunc(0x37aad85f, cellSailRecorderDumpImage); REG_FUNC(cellSailRec, cellSailRecorderDumpImage);
} }
#endif #endif

8
rpcs3/Emu/SysCalls/Modules/cellScreenshot.cpp
View File

@ -50,9 +50,9 @@ int cellScreenShotDisable()
void cellScreenshot_init() void cellScreenshot_init()
{ {
cellScreenshot.AddFunc(0xd3ad63e4, cellScreenShotSetParameter); REG_FUNC(cellScreenshot, cellScreenShotSetParameter);
cellScreenshot.AddFunc(0x7a9c2243, cellScreenShotSetOverlayImage); REG_FUNC(cellScreenshot, cellScreenShotSetOverlayImage);
cellScreenshot.AddFunc(0x9e33ab8f, cellScreenShotEnable); REG_FUNC(cellScreenshot, cellScreenShotEnable);
cellScreenshot.AddFunc(0xfc6f4e74, cellScreenShotDisable); REG_FUNC(cellScreenshot, cellScreenShotDisable);
} }
#endif #endif

40
rpcs3/Emu/SysCalls/Modules/cellSearch.cpp
View File

@ -152,25 +152,25 @@ int cellSearchEnd()
void cellSearch_init() void cellSearch_init()
{ {
cellSearch.AddFunc(0xc81ccf8a, cellSearchInitialize); REG_FUNC(cellSearch, cellSearchInitialize);
cellSearch.AddFunc(0xbfab7616, cellSearchFinalize); REG_FUNC(cellSearch, cellSearchFinalize);
cellSearch.AddFunc(0x0a4c8295, cellSearchStartListSearch); REG_FUNC(cellSearch, cellSearchStartListSearch);
cellSearch.AddFunc(0x64fb0b76, cellSearchStartContentSearchInList); REG_FUNC(cellSearch, cellSearchStartContentSearchInList);
cellSearch.AddFunc(0x0591826f, cellSearchStartContentSearch); REG_FUNC(cellSearch, cellSearchStartContentSearch);
cellSearch.AddFunc(0xc0ed0522, cellSearchStartSceneSearchInVideo); REG_FUNC(cellSearch, cellSearchStartSceneSearchInVideo);
cellSearch.AddFunc(0x13524faa, cellSearchStartSceneSearch); REG_FUNC(cellSearch, cellSearchStartSceneSearch);
cellSearch.AddFunc(0x3b210319, cellSearchGetContentInfoByOffset); REG_FUNC(cellSearch, cellSearchGetContentInfoByOffset);
cellSearch.AddFunc(0x9663a44b, cellSearchGetContentInfoByContentId); REG_FUNC(cellSearch, cellSearchGetContentInfoByContentId);
cellSearch.AddFunc(0x540d9068, cellSearchGetOffsetByContentId); REG_FUNC(cellSearch, cellSearchGetOffsetByContentId);
cellSearch.AddFunc(0x94e21701, cellSearchGetContentIdByOffset); REG_FUNC(cellSearch, cellSearchGetContentIdByOffset);
cellSearch.AddFunc(0xd7a7a433, cellSearchGetContentInfoGameComment); REG_FUNC(cellSearch, cellSearchGetContentInfoGameComment);
cellSearch.AddFunc(0x025ce169, cellSearchGetMusicSelectionContext); REG_FUNC(cellSearch, cellSearchGetMusicSelectionContext);
cellSearch.AddFunc(0xed20e079, cellSearchGetMusicSelectionContextOfSingleTrack); REG_FUNC(cellSearch, cellSearchGetMusicSelectionContextOfSingleTrack);
cellSearch.AddFunc(0xffb28491, cellSearchGetContentInfoPath); REG_FUNC(cellSearch, cellSearchGetContentInfoPath);
cellSearch.AddFunc(0x37b5ba0c, cellSearchGetContentInfoPathMovieThumb); REG_FUNC(cellSearch, cellSearchGetContentInfoPathMovieThumb);
cellSearch.AddFunc(0xe73cb0d2, cellSearchPrepareFile); REG_FUNC(cellSearch, cellSearchPrepareFile);
cellSearch.AddFunc(0x35cda406, cellSearchGetContentInfoDeveloperData); REG_FUNC(cellSearch, cellSearchGetContentInfoDeveloperData);
cellSearch.AddFunc(0x8fe376a6, cellSearchCancel); REG_FUNC(cellSearch, cellSearchCancel);
cellSearch.AddFunc(0x774033d6, cellSearchEnd); REG_FUNC(cellSearch, cellSearchEnd);
} }
#endif #endif

36
rpcs3/Emu/SysCalls/Modules/cellSheap.cpp
View File

@ -123,26 +123,26 @@ int cellKeySheapQueueDelete()
void cellSheap_init() void cellSheap_init()
{ {
cellSheap.AddFunc(0xbbb47cd8, cellSheapInitialize); REG_FUNC(cellSheap, cellSheapInitialize);
cellSheap.AddFunc(0x4b1383fb, cellSheapAllocate); REG_FUNC(cellSheap, cellSheapAllocate);
cellSheap.AddFunc(0x5c5994bd, cellSheapFree); REG_FUNC(cellSheap, cellSheapFree);
cellSheap.AddFunc(0x37968718, cellSheapQueryMax); REG_FUNC(cellSheap, cellSheapQueryMax);
cellSheap.AddFunc(0x7fa23275, cellSheapQueryFree); REG_FUNC(cellSheap, cellSheapQueryFree);
// (TODO: Some cellKeySheap* functions are missing) // (TODO: Some cellKeySheap* functions are missing)
cellSheap.AddFunc(0xa1b25841, cellKeySheapInitialize); REG_FUNC(cellSheap, cellKeySheapInitialize);
cellSheap.AddFunc(0x4a5b9659, cellKeySheapBufferNew); REG_FUNC(cellSheap, cellKeySheapBufferNew);
cellSheap.AddFunc(0xe6b37362, cellKeySheapBufferDelete); REG_FUNC(cellSheap, cellKeySheapBufferDelete);
cellSheap.AddFunc(0x3478e1e6, cellKeySheapMutexNew); REG_FUNC(cellSheap, cellKeySheapMutexNew);
cellSheap.AddFunc(0x2452679f, cellKeySheapMutexDelete); REG_FUNC(cellSheap, cellKeySheapMutexDelete);
cellSheap.AddFunc(0xe897c835, cellKeySheapBarrierNew); REG_FUNC(cellSheap, cellKeySheapBarrierNew);
cellSheap.AddFunc(0xf6f5fbca, cellKeySheapBarrierDelete); REG_FUNC(cellSheap, cellKeySheapBarrierDelete);
cellSheap.AddFunc(0x69a5861d, cellKeySheapSemaphoreNew); REG_FUNC(cellSheap, cellKeySheapSemaphoreNew);
cellSheap.AddFunc(0x73a45cf8, cellKeySheapSemaphoreDelete); REG_FUNC(cellSheap, cellKeySheapSemaphoreDelete);
cellSheap.AddFunc(0xf01ac471, cellKeySheapRwmNew); REG_FUNC(cellSheap, cellKeySheapRwmNew);
cellSheap.AddFunc(0xed136702, cellKeySheapRwmDelete); REG_FUNC(cellSheap, cellKeySheapRwmDelete);
cellSheap.AddFunc(0x987e260e, cellKeySheapQueueNew); REG_FUNC(cellSheap, cellKeySheapQueueNew);
cellSheap.AddFunc(0x79a6abd0, cellKeySheapQueueDelete); REG_FUNC(cellSheap, cellKeySheapQueueDelete);
} }
#endif #endif

28
rpcs3/Emu/SysCalls/Modules/cellSsl.cpp
View File

@ -90,21 +90,21 @@ int cellSslCertGetMd5Fingerprint()
void cellSsl_init() void cellSsl_init()
{ {
cellSsl.AddFunc(0xfb02c9d2, cellSslInit); REG_FUNC(cellSsl, cellSslInit);
cellSsl.AddFunc(0x1650aea4, cellSslEnd); REG_FUNC(cellSsl, cellSslEnd);
cellSsl.AddFunc(0x571afaca, cellSslCertificateLoader); REG_FUNC(cellSsl, cellSslCertificateLoader);
cellSsl.AddFunc(0x7b689ebc, cellSslCertGetSerialNumber); REG_FUNC(cellSsl, cellSslCertGetSerialNumber);
cellSsl.AddFunc(0xf8206492, cellSslCertGetPublicKey); REG_FUNC(cellSsl, cellSslCertGetPublicKey);
cellSsl.AddFunc(0x8e505175, cellSslCertGetRsaPublicKeyModulus); REG_FUNC(cellSsl, cellSslCertGetRsaPublicKeyModulus);
cellSsl.AddFunc(0x033c4905, cellSslCertGetRsaPublicKeyExponent); REG_FUNC(cellSsl, cellSslCertGetRsaPublicKeyExponent);
cellSsl.AddFunc(0x31d9ba8d, cellSslCertGetNotBefore); REG_FUNC(cellSsl, cellSslCertGetNotBefore);
cellSsl.AddFunc(0x218b64da, cellSslCertGetNotAfter); REG_FUNC(cellSsl, cellSslCertGetNotAfter);
cellSsl.AddFunc(0x32c61bdf, cellSslCertGetSubjectName); REG_FUNC(cellSsl, cellSslCertGetSubjectName);
cellSsl.AddFunc(0xae6eb491, cellSslCertGetIssuerName); REG_FUNC(cellSsl, cellSslCertGetIssuerName);
cellSsl.AddFunc(0x766d3ca1, cellSslCertGetNameEntryCount); REG_FUNC(cellSsl, cellSslCertGetNameEntryCount);
cellSsl.AddFunc(0x006c4900, cellSslCertGetNameEntryInfo); REG_FUNC(cellSsl, cellSslCertGetNameEntryInfo);
cellSsl.AddFunc(0x5e9253ca, cellSslCertGetMd5Fingerprint); REG_FUNC(cellSsl, cellSslCertGetMd5Fingerprint);
} }
#endif #endif

20
rpcs3/Emu/SysCalls/Modules/cellSubdisplay.cpp
View File

@ -76,16 +76,16 @@ int cellSubDisplayGetPeerList()
Module cellSubdisplay("cellSubdisplay", []() Module cellSubdisplay("cellSubdisplay", []()
{ {
cellSubdisplay.AddFunc(0xf9a7e8a5, cellSubDisplayInit); REG_FUNC(cellSubdisplay, cellSubDisplayInit);
cellSubdisplay.AddFunc(0x551d80a5, cellSubDisplayEnd); REG_FUNC(cellSubdisplay, cellSubDisplayEnd);
cellSubdisplay.AddFunc(0x6595ce22, cellSubDisplayGetRequiredMemory); REG_FUNC(cellSubdisplay, cellSubDisplayGetRequiredMemory);
cellSubdisplay.AddFunc(0xa5bccb47, cellSubDisplayStart); REG_FUNC(cellSubdisplay, cellSubDisplayStart);
cellSubdisplay.AddFunc(0x6d85ddb3, cellSubDisplayStop); REG_FUNC(cellSubdisplay, cellSubDisplayStop);
cellSubdisplay.AddFunc(0x938ac642, cellSubDisplayGetVideoBuffer); REG_FUNC(cellSubdisplay, cellSubDisplayGetVideoBuffer);
cellSubdisplay.AddFunc(0xaee1e0c2, cellSubDisplayAudioOutBlocking); REG_FUNC(cellSubdisplay, cellSubDisplayAudioOutBlocking);
cellSubdisplay.AddFunc(0x5468d6b0, cellSubDisplayAudioOutNonBlocking); REG_FUNC(cellSubdisplay, cellSubDisplayAudioOutNonBlocking);
cellSubdisplay.AddFunc(0x8a264d71, cellSubDisplayGetPeerNum); REG_FUNC(cellSubdisplay, cellSubDisplayGetPeerNum);
cellSubdisplay.AddFunc(0xe2485f79, cellSubDisplayGetPeerList); REG_FUNC(cellSubdisplay, cellSubDisplayGetPeerList);
}); });

84
rpcs3/Emu/SysCalls/Modules/cellSync.cpp
View File

@ -1858,50 +1858,50 @@ s32 _cellSyncLFQueueDetachLv2EventQueue(vm::ptr<u32> spus, u32 num, vm::ptr<Cell
Module cellSync("cellSync", []() Module cellSync("cellSync", []()
{ {
cellSync.AddFunc(0xa9072dee, cellSyncMutexInitialize); REG_FUNC(cellSync, cellSyncMutexInitialize);
cellSync.AddFunc(0x1bb675c2, cellSyncMutexLock); REG_FUNC(cellSync, cellSyncMutexLock);
cellSync.AddFunc(0xd06918c4, cellSyncMutexTryLock); REG_FUNC(cellSync, cellSyncMutexTryLock);
cellSync.AddFunc(0x91f2b7b0, cellSyncMutexUnlock); REG_FUNC(cellSync, cellSyncMutexUnlock);
cellSync.AddFunc(0x07254fda, cellSyncBarrierInitialize); REG_FUNC(cellSync, cellSyncBarrierInitialize);
cellSync.AddFunc(0xf06a6415, cellSyncBarrierNotify); REG_FUNC(cellSync, cellSyncBarrierNotify);
cellSync.AddFunc(0x268edd6d, cellSyncBarrierTryNotify); REG_FUNC(cellSync, cellSyncBarrierTryNotify);
cellSync.AddFunc(0x35f21355, cellSyncBarrierWait); REG_FUNC(cellSync, cellSyncBarrierWait);
cellSync.AddFunc(0x6c272124, cellSyncBarrierTryWait); REG_FUNC(cellSync, cellSyncBarrierTryWait);
cellSync.AddFunc(0xfc48b03f, cellSyncRwmInitialize); REG_FUNC(cellSync, cellSyncRwmInitialize);
cellSync.AddFunc(0xcece771f, cellSyncRwmRead); REG_FUNC(cellSync, cellSyncRwmRead);
cellSync.AddFunc(0xa6669751, cellSyncRwmTryRead); REG_FUNC(cellSync, cellSyncRwmTryRead);
cellSync.AddFunc(0xed773f5f, cellSyncRwmWrite); REG_FUNC(cellSync, cellSyncRwmWrite);
cellSync.AddFunc(0xba5bee48, cellSyncRwmTryWrite); REG_FUNC(cellSync, cellSyncRwmTryWrite);
cellSync.AddFunc(0x3929948d, cellSyncQueueInitialize); REG_FUNC(cellSync, cellSyncQueueInitialize);
cellSync.AddFunc(0x5ae841e5, cellSyncQueuePush); REG_FUNC(cellSync, cellSyncQueuePush);
cellSync.AddFunc(0x705985cd, cellSyncQueueTryPush); REG_FUNC(cellSync, cellSyncQueueTryPush);
cellSync.AddFunc(0x4da6d7e0, cellSyncQueuePop); REG_FUNC(cellSync, cellSyncQueuePop);
cellSync.AddFunc(0xa58df87f, cellSyncQueueTryPop); REG_FUNC(cellSync, cellSyncQueueTryPop);
cellSync.AddFunc(0x48154c9b, cellSyncQueuePeek); REG_FUNC(cellSync, cellSyncQueuePeek);
cellSync.AddFunc(0x68af923c, cellSyncQueueTryPeek); REG_FUNC(cellSync, cellSyncQueueTryPeek);
cellSync.AddFunc(0x4da349b2, cellSyncQueueSize); REG_FUNC(cellSync, cellSyncQueueSize);
cellSync.AddFunc(0xa5362e73, cellSyncQueueClear); REG_FUNC(cellSync, cellSyncQueueClear);
cellSync.AddFunc(0x0c7cb9f7, cellSyncLFQueueGetEntrySize); REG_FUNC(cellSync, cellSyncLFQueueGetEntrySize);
cellSync.AddFunc(0x167ea63e, cellSyncLFQueueSize); REG_FUNC(cellSync, cellSyncLFQueueSize);
cellSync.AddFunc(0x2af0c515, cellSyncLFQueueClear); REG_FUNC(cellSync, cellSyncLFQueueClear);
cellSync.AddFunc(0x35bbdad2, _cellSyncLFQueueCompletePushPointer2); REG_FUNC(cellSync, _cellSyncLFQueueCompletePushPointer2);
cellSync.AddFunc(0x46356fe0, _cellSyncLFQueueGetPopPointer2); REG_FUNC(cellSync, _cellSyncLFQueueGetPopPointer2);
cellSync.AddFunc(0x4e88c68d, _cellSyncLFQueueCompletePushPointer); REG_FUNC(cellSync, _cellSyncLFQueueCompletePushPointer);
cellSync.AddFunc(0x54fc2032, _cellSyncLFQueueAttachLv2EventQueue); REG_FUNC(cellSync, _cellSyncLFQueueAttachLv2EventQueue);
cellSync.AddFunc(0x6bb4ef9d, _cellSyncLFQueueGetPushPointer2); REG_FUNC(cellSync, _cellSyncLFQueueGetPushPointer2);
cellSync.AddFunc(0x74c37666, _cellSyncLFQueueGetPopPointer); REG_FUNC(cellSync, _cellSyncLFQueueGetPopPointer);
cellSync.AddFunc(0x7a51deee, _cellSyncLFQueueCompletePopPointer2); REG_FUNC(cellSync, _cellSyncLFQueueCompletePopPointer2);
cellSync.AddFunc(0x811d148e, _cellSyncLFQueueDetachLv2EventQueue); REG_FUNC(cellSync, _cellSyncLFQueueDetachLv2EventQueue);
cellSync.AddFunc(0xaa355278, cellSyncLFQueueInitialize); REG_FUNC(cellSync, cellSyncLFQueueInitialize);
cellSync.AddFunc(0xaff7627a, _cellSyncLFQueueGetSignalAddress); REG_FUNC(cellSync, _cellSyncLFQueueGetSignalAddress);
cellSync.AddFunc(0xba5961ca, _cellSyncLFQueuePushBody); REG_FUNC(cellSync, _cellSyncLFQueuePushBody);
cellSync.AddFunc(0xd59aa307, cellSyncLFQueueGetDirection); REG_FUNC(cellSync, cellSyncLFQueueGetDirection);
cellSync.AddFunc(0xe18c273c, cellSyncLFQueueDepth); REG_FUNC(cellSync, cellSyncLFQueueDepth);
cellSync.AddFunc(0xe1bc7add, _cellSyncLFQueuePopBody); REG_FUNC(cellSync, _cellSyncLFQueuePopBody);
cellSync.AddFunc(0xe9bf2110, _cellSyncLFQueueGetPushPointer); REG_FUNC(cellSync, _cellSyncLFQueueGetPushPointer);
cellSync.AddFunc(0xfe74e8e7, _cellSyncLFQueueCompletePopPointer); REG_FUNC(cellSync, _cellSyncLFQueueCompletePopPointer);
}); });

64
rpcs3/Emu/SysCalls/Modules/cellSync2.cpp
View File

@ -251,39 +251,39 @@ s32 cellSync2QueueGetDepth()
Module cellSync2("cellSync2", []() Module cellSync2("cellSync2", []()
{ {
cellSync2.AddFunc(0x55836e73, _cellSync2MutexAttributeInitialize); REG_FUNC(cellSync2, _cellSync2MutexAttributeInitialize);
cellSync2.AddFunc(0xd51bfae7, cellSync2MutexEstimateBufferSize); REG_FUNC(cellSync2, cellSync2MutexEstimateBufferSize);
cellSync2.AddFunc(0xeb81a467, cellSync2MutexInitialize); REG_FUNC(cellSync2, cellSync2MutexInitialize);
cellSync2.AddFunc(0x27f2d61c, cellSync2MutexFinalize); REG_FUNC(cellSync2, cellSync2MutexFinalize);
cellSync2.AddFunc(0xa400d82e, cellSync2MutexLock); REG_FUNC(cellSync2, cellSync2MutexLock);
cellSync2.AddFunc(0xa69c749c, cellSync2MutexTryLock); REG_FUNC(cellSync2, cellSync2MutexTryLock);
cellSync2.AddFunc(0x0080fe88, cellSync2MutexUnlock); REG_FUNC(cellSync2, cellSync2MutexUnlock);
cellSync2.AddFunc(0xdf3c532a, _cellSync2CondAttributeInitialize); REG_FUNC(cellSync2, _cellSync2CondAttributeInitialize);
cellSync2.AddFunc(0x5b1e4d7a, cellSync2CondEstimateBufferSize); REG_FUNC(cellSync2, cellSync2CondEstimateBufferSize);
cellSync2.AddFunc(0x58be9a0f, cellSync2CondInitialize); REG_FUNC(cellSync2, cellSync2CondInitialize);
cellSync2.AddFunc(0x63062249, cellSync2CondFinalize); REG_FUNC(cellSync2, cellSync2CondFinalize);
cellSync2.AddFunc(0xbc96d751, cellSync2CondWait); REG_FUNC(cellSync2, cellSync2CondWait);
cellSync2.AddFunc(0x871af804, cellSync2CondSignal); REG_FUNC(cellSync2, cellSync2CondSignal);
cellSync2.AddFunc(0x8aae07c2, cellSync2CondSignalAll); REG_FUNC(cellSync2, cellSync2CondSignalAll);
cellSync2.AddFunc(0x2d77fe17, _cellSync2SemaphoreAttributeInitialize); REG_FUNC(cellSync2, _cellSync2SemaphoreAttributeInitialize);
cellSync2.AddFunc(0x74c2780f, cellSync2SemaphoreEstimateBufferSize); REG_FUNC(cellSync2, cellSync2SemaphoreEstimateBufferSize);
cellSync2.AddFunc(0xc5dee254, cellSync2SemaphoreInitialize); REG_FUNC(cellSync2, cellSync2SemaphoreInitialize);
cellSync2.AddFunc(0x164843a7, cellSync2SemaphoreFinalize); REG_FUNC(cellSync2, cellSync2SemaphoreFinalize);
cellSync2.AddFunc(0xd1b0d146, cellSync2SemaphoreAcquire); REG_FUNC(cellSync2, cellSync2SemaphoreAcquire);
cellSync2.AddFunc(0x5e4b0f87, cellSync2SemaphoreTryAcquire); REG_FUNC(cellSync2, cellSync2SemaphoreTryAcquire);
cellSync2.AddFunc(0x0c2983ac, cellSync2SemaphoreRelease); REG_FUNC(cellSync2, cellSync2SemaphoreRelease);
cellSync2.AddFunc(0x4e2ee031, cellSync2SemaphoreGetCount); REG_FUNC(cellSync2, cellSync2SemaphoreGetCount);
cellSync2.AddFunc(0x5e00d433, _cellSync2QueueAttributeInitialize); REG_FUNC(cellSync2, _cellSync2QueueAttributeInitialize);
cellSync2.AddFunc(0xc08cc0f9, cellSync2QueueEstimateBufferSize); REG_FUNC(cellSync2, cellSync2QueueEstimateBufferSize);
cellSync2.AddFunc(0xf125e044, cellSync2QueueInitialize); REG_FUNC(cellSync2, cellSync2QueueInitialize);
cellSync2.AddFunc(0x6af85cdf, cellSync2QueueFinalize); REG_FUNC(cellSync2, cellSync2QueueFinalize);
cellSync2.AddFunc(0x7d967d91, cellSync2QueuePush); REG_FUNC(cellSync2, cellSync2QueuePush);
cellSync2.AddFunc(0x7fd479fe, cellSync2QueueTryPush); REG_FUNC(cellSync2, cellSync2QueueTryPush);
cellSync2.AddFunc(0xd83ab0c9, cellSync2QueuePop); REG_FUNC(cellSync2, cellSync2QueuePop);
cellSync2.AddFunc(0x0c9a0ea9, cellSync2QueueTryPop); REG_FUNC(cellSync2, cellSync2QueueTryPop);
cellSync2.AddFunc(0x12f0a27d, cellSync2QueueGetSize); REG_FUNC(cellSync2, cellSync2QueueGetSize);
cellSync2.AddFunc(0xf0e1471c, cellSync2QueueGetDepth); REG_FUNC(cellSync2, cellSync2QueueGetDepth);
}); });

12
rpcs3/Emu/SysCalls/Modules/cellSysmodule.cpp
View File

@ -224,10 +224,10 @@ s32 cellSysmoduleIsLoaded(u16 id)
Module cellSysmodule("cellSysmodule", []() Module cellSysmodule("cellSysmodule", []()
{ {
cellSysmodule.AddFunc(0x63ff6ff9, cellSysmoduleInitialize); REG_FUNC(cellSysmodule, cellSysmoduleInitialize);
cellSysmodule.AddFunc(0x96c07adf, cellSysmoduleFinalize); REG_FUNC(cellSysmodule, cellSysmoduleFinalize);
cellSysmodule.AddFunc(0xa193143c, cellSysmoduleSetMemcontainer); REG_FUNC(cellSysmodule, cellSysmoduleSetMemcontainer);
cellSysmodule.AddFunc(0x32267a31, cellSysmoduleLoadModule); REG_FUNC(cellSysmodule, cellSysmoduleLoadModule);
cellSysmodule.AddFunc(0x112a5ee9, cellSysmoduleUnloadModule); REG_FUNC(cellSysmodule, cellSysmoduleUnloadModule);
cellSysmodule.AddFunc(0x5a59e258, cellSysmoduleIsLoaded); REG_FUNC(cellSysmodule, cellSysmoduleIsLoaded);
}); });

94
rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
View File

@ -851,64 +851,64 @@ Module cellSysutil("cellSysutil", []()
v.arg.set(0); v.arg.set(0);
} }
cellSysutil.AddFunc(0x40e895d3, cellSysutilGetSystemParamInt); REG_FUNC(cellSysutil, cellSysutilGetSystemParamInt);
cellSysutil.AddFunc(0x938013a0, cellSysutilGetSystemParamString); REG_FUNC(cellSysutil, cellSysutilGetSystemParamString);
cellSysutil.AddFunc(0x887572d5, cellVideoOutGetState); REG_FUNC(cellSysutil, cellVideoOutGetState);
cellSysutil.AddFunc(0xe558748d, cellVideoOutGetResolution); REG_FUNC(cellSysutil, cellVideoOutGetResolution);
cellSysutil.AddFunc(0x0bae8772, cellVideoOutConfigure); REG_FUNC(cellSysutil, cellVideoOutConfigure);
cellSysutil.AddFunc(0x15b0b0cd, cellVideoOutGetConfiguration); REG_FUNC(cellSysutil, cellVideoOutGetConfiguration);
cellSysutil.AddFunc(0x1e930eef, cellVideoOutGetDeviceInfo); REG_FUNC(cellSysutil, cellVideoOutGetDeviceInfo);
cellSysutil.AddFunc(0x75bbb672, cellVideoOutGetNumberOfDevice); REG_FUNC(cellSysutil, cellVideoOutGetNumberOfDevice);
cellSysutil.AddFunc(0xa322db75, cellVideoOutGetResolutionAvailability); REG_FUNC(cellSysutil, cellVideoOutGetResolutionAvailability);
cellSysutil.AddFunc(0x189a74da, cellSysutilCheckCallback); REG_FUNC(cellSysutil, cellSysutilCheckCallback);
cellSysutil.AddFunc(0x9d98afa0, cellSysutilRegisterCallback); REG_FUNC(cellSysutil, cellSysutilRegisterCallback);
cellSysutil.AddFunc(0x02ff3c1b, cellSysutilUnregisterCallback); REG_FUNC(cellSysutil, cellSysutilUnregisterCallback);
cellSysutil.AddFunc(0x7603d3db, cellMsgDialogOpen2); REG_FUNC(cellSysutil, cellMsgDialogOpen2);
cellSysutil.AddFunc(0x3e22cb4b, cellMsgDialogOpenErrorCode); REG_FUNC(cellSysutil, cellMsgDialogOpenErrorCode);
cellSysutil.AddFunc(0x9d6af72a, cellMsgDialogProgressBarSetMsg); REG_FUNC(cellSysutil, cellMsgDialogProgressBarSetMsg);
cellSysutil.AddFunc(0x7bc2c8a8, cellMsgDialogProgressBarReset); REG_FUNC(cellSysutil, cellMsgDialogProgressBarReset);
cellSysutil.AddFunc(0x94862702, cellMsgDialogProgressBarInc); REG_FUNC(cellSysutil, cellMsgDialogProgressBarInc);
cellSysutil.AddFunc(0x20543730, cellMsgDialogClose); REG_FUNC(cellSysutil, cellMsgDialogClose);
cellSysutil.AddFunc(0x62b0f803, cellMsgDialogAbort); REG_FUNC(cellSysutil, cellMsgDialogAbort);
cellSysutil.AddFunc(0xf4e3caa0, cellAudioOutGetState); REG_FUNC(cellSysutil, cellAudioOutGetState);
cellSysutil.AddFunc(0x4692ab35, cellAudioOutConfigure); REG_FUNC(cellSysutil, cellAudioOutConfigure);
cellSysutil.AddFunc(0xc01b4e7c, cellAudioOutGetSoundAvailability); REG_FUNC(cellSysutil, cellAudioOutGetSoundAvailability);
cellSysutil.AddFunc(0x2beac488, cellAudioOutGetSoundAvailability2); REG_FUNC(cellSysutil, cellAudioOutGetSoundAvailability2);
cellSysutil.AddFunc(0x7663e368, cellAudioOutGetDeviceInfo); REG_FUNC(cellSysutil, cellAudioOutGetDeviceInfo);
cellSysutil.AddFunc(0xe5e2b09d, cellAudioOutGetNumberOfDevice); REG_FUNC(cellSysutil, cellAudioOutGetNumberOfDevice);
cellSysutil.AddFunc(0xed5d96af, cellAudioOutGetConfiguration); REG_FUNC(cellSysutil, cellAudioOutGetConfiguration);
cellSysutil.AddFunc(0xc96e89e9, cellAudioOutSetCopyControl); REG_FUNC(cellSysutil, cellAudioOutSetCopyControl);
cellSysutil.AddFunc(0xa11552f6, cellSysutilGetBgmPlaybackStatus); REG_FUNC(cellSysutil, cellSysutilGetBgmPlaybackStatus);
cellSysutil.AddFunc(0x6cfd856f, cellSysutilGetBgmPlaybackStatus2); REG_FUNC(cellSysutil, cellSysutilGetBgmPlaybackStatus2);
cellSysutil.AddFunc(0x220894e3, cellSysutilEnableBgmPlayback); REG_FUNC(cellSysutil, cellSysutilEnableBgmPlayback);
cellSysutil.AddFunc(0xac58ad2b, cellSysutilEnableBgmPlaybackEx); REG_FUNC(cellSysutil, cellSysutilEnableBgmPlaybackEx);
cellSysutil.AddFunc(0xcfdd8e87, cellSysutilDisableBgmPlayback); REG_FUNC(cellSysutil, cellSysutilDisableBgmPlayback);
cellSysutil.AddFunc(0xa36335a5, cellSysutilDisableBgmPlaybackEx); REG_FUNC(cellSysutil, cellSysutilDisableBgmPlaybackEx);
cellSysutil.AddFunc(0x1e7bff94, cellSysCacheMount); REG_FUNC(cellSysutil, cellSysCacheMount);
cellSysutil.AddFunc(0x744c1544, cellSysCacheClear); REG_FUNC(cellSysutil, cellSysCacheClear);
cellSysutil.AddFunc(0x9117df20, cellHddGameCheck); REG_FUNC(cellSysutil, cellHddGameCheck);
//cellSysutil.AddFunc(0x4bdec82a, cellHddGameCheck2); //REG_FUNC(cellSysutil, cellHddGameCheck2);
//cellSysutil.AddFunc(0xf82e2ef7, cellHddGameGetSizeKB); //REG_FUNC(cellSysutil, cellHddGameGetSizeKB);
//cellSysutil.AddFunc(0x9ca9ffa7, cellHddGameSetSystemVer); //REG_FUNC(cellSysutil, cellHddGameSetSystemVer);
//cellSysutil.AddFunc(0xafd605b3, cellHddGameExitBroken); //REG_FUNC(cellSysutil, cellHddGameExitBroken);
//cellSysutil.AddFunc(0x886D0747, cellSysutilRegisterCallbackDispatcher); //REG_FUNC(cellSysutil, cellSysutilRegisterCallbackDispatcher);
//cellSysutil.AddFunc(0xA2720DF2, cellSysutilPacketWrite); //REG_FUNC(cellSysutil, cellSysutilPacketWrite);
//cellSysutil.AddFunc(0x75AA7373, doc.write); //REG_FUNC(cellSysutil, doc.write);
//cellSysutil.AddFunc(0x2D96313F, packet_read); //REG_FUNC(cellSysutil, packet_read);
// cellSaveData functions // cellSaveData functions
cellSysutil_SaveData_init(); cellSysutil_SaveData_init();
cellSysutil.AddFunc(0x6d087930, cellWebBrowserEstimate2); REG_FUNC(cellSysutil, cellWebBrowserEstimate2);
cellSysutil.AddFunc(0xe7951dee, cellGameDataCheckCreate); REG_FUNC(cellSysutil, cellGameDataCheckCreate);
cellSysutil.AddFunc(0xc9645c41, cellGameDataCheckCreate2); REG_FUNC(cellSysutil, cellGameDataCheckCreate2);
}); });

6
rpcs3/Emu/SysCalls/Modules/cellSysutilAp.cpp
View File

@ -37,7 +37,7 @@ int cellSysutilApOff()
Module cellSysutilAp("cellSysutilAp", []() Module cellSysutilAp("cellSysutilAp", []()
{ {
cellSysutilAp.AddFunc(0x9e67e0dd, cellSysutilApGetRequiredMemSize); REG_FUNC(cellSysutilAp, cellSysutilApGetRequiredMemSize);
cellSysutilAp.AddFunc(0x3343824c, cellSysutilApOn); REG_FUNC(cellSysutilAp, cellSysutilApOn);
cellSysutilAp.AddFunc(0x90c2bb19, cellSysutilApOff); REG_FUNC(cellSysutilAp, cellSysutilApOff);
}); });

48
rpcs3/Emu/SysCalls/Modules/cellUsbd.cpp
View File

@ -173,36 +173,36 @@ int cellUsbdFreeMemory()
void cellUsbd_init() void cellUsbd_init()
{ {
cellUsbd.AddFunc(0xd0e766fe, cellUsbdInit); REG_FUNC(cellUsbd, cellUsbdInit);
cellUsbd.AddFunc(0x35f22ac3, cellUsbdEnd); REG_FUNC(cellUsbd, cellUsbdEnd);
cellUsbd.AddFunc(0xc24af1d7, cellUsbdSetThreadPriority); REG_FUNC(cellUsbd, cellUsbdSetThreadPriority);
cellUsbd.AddFunc(0x5c832bd7, cellUsbdSetThreadPriority2); REG_FUNC(cellUsbd, cellUsbdSetThreadPriority2);
cellUsbd.AddFunc(0xd5263dea, cellUsbdGetThreadPriority); REG_FUNC(cellUsbd, cellUsbdGetThreadPriority);
cellUsbd.AddFunc(0x359befba, cellUsbdRegisterLdd); REG_FUNC(cellUsbd, cellUsbdRegisterLdd);
cellUsbd.AddFunc(0x7fe92c54, cellUsbdRegisterExtraLdd); REG_FUNC(cellUsbd, cellUsbdRegisterExtraLdd);
cellUsbd.AddFunc(0xbd554bcb, cellUsbdRegisterExtraLdd2); REG_FUNC(cellUsbd, cellUsbdRegisterExtraLdd2);
cellUsbd.AddFunc(0x64951ac7, cellUsbdUnregisterLdd); REG_FUNC(cellUsbd, cellUsbdUnregisterLdd);
cellUsbd.AddFunc(0x90460081, cellUsbdUnregisterExtraLdd); REG_FUNC(cellUsbd, cellUsbdUnregisterExtraLdd);
cellUsbd.AddFunc(0x254289ac, cellUsbdOpenPipe); REG_FUNC(cellUsbd, cellUsbdOpenPipe);
cellUsbd.AddFunc(0x9763e962, cellUsbdClosePipe); REG_FUNC(cellUsbd, cellUsbdClosePipe);
cellUsbd.AddFunc(0x97cf128e, cellUsbdControlTransfer); REG_FUNC(cellUsbd, cellUsbdControlTransfer);
cellUsbd.AddFunc(0xac77eb78, cellUsbdBulkTransfer); REG_FUNC(cellUsbd, cellUsbdBulkTransfer);
cellUsbd.AddFunc(0x0f411262, cellUsbdInterruptTransfer); REG_FUNC(cellUsbd, cellUsbdInterruptTransfer);
cellUsbd.AddFunc(0xde58c4c2, cellUsbdIsochronousTransfer); REG_FUNC(cellUsbd, cellUsbdIsochronousTransfer);
cellUsbd.AddFunc(0x7a1b6eab, cellUsbdHSIsochronousTransfer); REG_FUNC(cellUsbd, cellUsbdHSIsochronousTransfer);
cellUsbd.AddFunc(0x2fb08e1e, cellUsbdScanStaticDescriptor); REG_FUNC(cellUsbd, cellUsbdScanStaticDescriptor);
cellUsbd.AddFunc(0xbdbd2428, cellUsbdGetDeviceSpeed); REG_FUNC(cellUsbd, cellUsbdGetDeviceSpeed);
cellUsbd.AddFunc(0xdb819e03, cellUsbdGetDeviceLocation); REG_FUNC(cellUsbd, cellUsbdGetDeviceLocation);
cellUsbd.AddFunc(0x63bfdb97, cellUsbdSetPrivateData); REG_FUNC(cellUsbd, cellUsbdSetPrivateData);
cellUsbd.AddFunc(0x5de3af36, cellUsbdGetPrivateData); REG_FUNC(cellUsbd, cellUsbdGetPrivateData);
cellUsbd.AddFunc(0x074dbb39, cellUsbdAllocateMemory); REG_FUNC(cellUsbd, cellUsbdAllocateMemory);
cellUsbd.AddFunc(0x4e456e81, cellUsbdFreeMemory); REG_FUNC(cellUsbd, cellUsbdFreeMemory);
} }
#endif #endif

54
rpcs3/Emu/SysCalls/Modules/cellUsbpspcm.cpp
View File

@ -185,32 +185,32 @@ int cellUsbPspcmCancelWaitData()
void cellUsbpspcm_init() void cellUsbpspcm_init()
{ {
cellUsbpspcm.AddFunc(0x657fcd36, cellUsbPspcmInit); REG_FUNC(cellUsbpspcm, cellUsbPspcmInit);
cellUsbpspcm.AddFunc(0x0f7b3b6d, cellUsbPspcmEnd); REG_FUNC(cellUsbpspcm, cellUsbPspcmEnd);
cellUsbpspcm.AddFunc(0xf20df7fc, cellUsbPspcmCalcPoolSize); REG_FUNC(cellUsbpspcm, cellUsbPspcmCalcPoolSize);
cellUsbpspcm.AddFunc(0xe3fbf64d, cellUsbPspcmRegister); REG_FUNC(cellUsbpspcm, cellUsbPspcmRegister);
cellUsbpspcm.AddFunc(0x7ff72b42, cellUsbPspcmUnregister); REG_FUNC(cellUsbpspcm, cellUsbPspcmUnregister);
cellUsbpspcm.AddFunc(0x97670a90, cellUsbPspcmGetAddr); REG_FUNC(cellUsbpspcm, cellUsbPspcmGetAddr);
cellUsbpspcm.AddFunc(0xabe090e3, cellUsbPspcmBind); REG_FUNC(cellUsbpspcm, cellUsbPspcmBind);
cellUsbpspcm.AddFunc(0x17f42197, cellUsbPspcmBindAsync); REG_FUNC(cellUsbpspcm, cellUsbPspcmBindAsync);
cellUsbpspcm.AddFunc(0x4abe830e, cellUsbPspcmWaitBindAsync); REG_FUNC(cellUsbpspcm, cellUsbPspcmWaitBindAsync);
cellUsbpspcm.AddFunc(0x01a4cde0, cellUsbPspcmPollBindAsync); REG_FUNC(cellUsbpspcm, cellUsbPspcmPollBindAsync);
cellUsbpspcm.AddFunc(0xa4a5ddb4, cellUsbPspcmCancelBind); REG_FUNC(cellUsbpspcm, cellUsbPspcmCancelBind);
cellUsbpspcm.AddFunc(0xfa07d320, cellUsbPspcmClose); REG_FUNC(cellUsbpspcm, cellUsbPspcmClose);
cellUsbpspcm.AddFunc(0x7277d7c3, cellUsbPspcmSend); REG_FUNC(cellUsbpspcm, cellUsbPspcmSend);
cellUsbpspcm.AddFunc(0x4af23efa, cellUsbPspcmSendAsync); REG_FUNC(cellUsbpspcm, cellUsbPspcmSendAsync);
cellUsbpspcm.AddFunc(0x3caddf6c, cellUsbPspcmWaitSendAsync); REG_FUNC(cellUsbpspcm, cellUsbPspcmWaitSendAsync);
cellUsbpspcm.AddFunc(0x7f0a3eaf, cellUsbPspcmPollSendAsync); REG_FUNC(cellUsbpspcm, cellUsbPspcmPollSendAsync);
cellUsbpspcm.AddFunc(0xf9883d3b, cellUsbPspcmRecv); REG_FUNC(cellUsbpspcm, cellUsbPspcmRecv);
cellUsbpspcm.AddFunc(0x02955295, cellUsbPspcmRecvAsync); REG_FUNC(cellUsbpspcm, cellUsbPspcmRecvAsync);
cellUsbpspcm.AddFunc(0x461dc8cc, cellUsbPspcmWaitRecvAsync); REG_FUNC(cellUsbpspcm, cellUsbPspcmWaitRecvAsync);
cellUsbpspcm.AddFunc(0x7b249315, cellUsbPspcmPollRecvAsync); REG_FUNC(cellUsbpspcm, cellUsbPspcmPollRecvAsync);
cellUsbpspcm.AddFunc(0xe68a65ac, cellUsbPspcmReset); REG_FUNC(cellUsbpspcm, cellUsbPspcmReset);
cellUsbpspcm.AddFunc(0x4ef182dd, cellUsbPspcmResetAsync); REG_FUNC(cellUsbpspcm, cellUsbPspcmResetAsync);
cellUsbpspcm.AddFunc(0xe840f449, cellUsbPspcmWaitResetAsync); REG_FUNC(cellUsbpspcm, cellUsbPspcmWaitResetAsync);
cellUsbpspcm.AddFunc(0x3f22403e, cellUsbPspcmPollResetAsync); REG_FUNC(cellUsbpspcm, cellUsbPspcmPollResetAsync);
cellUsbpspcm.AddFunc(0xdb864d11, cellUsbPspcmWaitData); REG_FUNC(cellUsbpspcm, cellUsbPspcmWaitData);
cellUsbpspcm.AddFunc(0x816799dd, cellUsbPspcmPollData); REG_FUNC(cellUsbpspcm, cellUsbPspcmPollData);
cellUsbpspcm.AddFunc(0xe76e79ab, cellUsbPspcmCancelWaitData); REG_FUNC(cellUsbpspcm, cellUsbPspcmCancelWaitData);
} }
#endif #endif

10
rpcs3/Emu/SysCalls/Modules/cellUserInfo.cpp
View File

@ -76,9 +76,9 @@ int cellUserInfoGetList(vm::ptr<u32> listNum, vm::ptr<CellUserInfoUserList> list
Module cellUserInfo("cellUserInfo", []() Module cellUserInfo("cellUserInfo", []()
{ {
cellUserInfo.AddFunc(0x2b761140, cellUserInfoGetStat); REG_FUNC(cellUserInfo, cellUserInfoGetStat);
cellUserInfo.AddFunc(0x3097cc1c, cellUserInfoSelectUser_ListType); REG_FUNC(cellUserInfo, cellUserInfoSelectUser_ListType);
cellUserInfo.AddFunc(0x55123a25, cellUserInfoSelectUser_SetList); REG_FUNC(cellUserInfo, cellUserInfoSelectUser_SetList);
cellUserInfo.AddFunc(0xb3516536, cellUserInfoEnableOverlay); REG_FUNC(cellUserInfo, cellUserInfoEnableOverlay);
cellUserInfo.AddFunc(0xc55e338b, cellUserInfoGetList); REG_FUNC(cellUserInfo, cellUserInfoGetList);
}); });

22
rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
View File

@ -889,15 +889,15 @@ int cellVdecSetFrameRate(u32 handle, CellVdecFrameRate frc)
Module cellVdec("cellVdec", []() Module cellVdec("cellVdec", []()
{ {
cellVdec.AddFunc(0xff6f6ebe, cellVdecQueryAttr); REG_FUNC(cellVdec, cellVdecQueryAttr);
cellVdec.AddFunc(0xc982a84a, cellVdecQueryAttrEx); REG_FUNC(cellVdec, cellVdecQueryAttrEx);
cellVdec.AddFunc(0xb6bbcd5d, cellVdecOpen); REG_FUNC(cellVdec, cellVdecOpen);
cellVdec.AddFunc(0x0053e2d8, cellVdecOpenEx); REG_FUNC(cellVdec, cellVdecOpenEx);
cellVdec.AddFunc(0x16698e83, cellVdecClose); REG_FUNC(cellVdec, cellVdecClose);
cellVdec.AddFunc(0xc757c2aa, cellVdecStartSeq); REG_FUNC(cellVdec, cellVdecStartSeq);
cellVdec.AddFunc(0x824433f0, cellVdecEndSeq); REG_FUNC(cellVdec, cellVdecEndSeq);
cellVdec.AddFunc(0x2bf4ddd2, cellVdecDecodeAu); REG_FUNC(cellVdec, cellVdecDecodeAu);
cellVdec.AddFunc(0x807c861a, cellVdecGetPicture); REG_FUNC(cellVdec, cellVdecGetPicture);
cellVdec.AddFunc(0x17c702b9, cellVdecGetPicItem); REG_FUNC(cellVdec, cellVdecGetPicItem);
cellVdec.AddFunc(0xe13ef6fc, cellVdecSetFrameRate); REG_FUNC(cellVdec, cellVdecSetFrameRate);
}); });

68
rpcs3/Emu/SysCalls/Modules/cellVoice.cpp
View File

@ -233,39 +233,39 @@ int cellVoiceDebugTopology()
void cellVoice_init() void cellVoice_init()
{ {
cellVoice.AddFunc(0xae6a21d5, cellVoiceConnectIPortToOPort); REG_FUNC(cellVoice, cellVoiceConnectIPortToOPort);
cellVoice.AddFunc(0x2a01013e, cellVoiceCreateNotifyEventQueue); REG_FUNC(cellVoice, cellVoiceCreateNotifyEventQueue);
cellVoice.AddFunc(0x2de54871, cellVoiceCreatePort); REG_FUNC(cellVoice, cellVoiceCreatePort);
cellVoice.AddFunc(0x9f70c475, cellVoiceDeletePort); REG_FUNC(cellVoice, cellVoiceDeletePort);
cellVoice.AddFunc(0x18d3df30, cellVoiceDisconnectIPortFromOPort); REG_FUNC(cellVoice, cellVoiceDisconnectIPortFromOPort);
cellVoice.AddFunc(0xe0e1ae12, cellVoiceEnd); REG_FUNC(cellVoice, cellVoiceEnd);
cellVoice.AddFunc(0xbef53a2b, cellVoiceGetBitRate); REG_FUNC(cellVoice, cellVoiceGetBitRate);
cellVoice.AddFunc(0x474609e2, cellVoiceGetMuteFlag); REG_FUNC(cellVoice, cellVoiceGetMuteFlag);
cellVoice.AddFunc(0xf629ed67, cellVoiceGetPortAttr); REG_FUNC(cellVoice, cellVoiceGetPortAttr);
cellVoice.AddFunc(0x54ac3519, cellVoiceGetPortInfo); REG_FUNC(cellVoice, cellVoiceGetPortInfo);
cellVoice.AddFunc(0xd6811aa7, cellVoiceGetSignalState); REG_FUNC(cellVoice, cellVoiceGetSignalState);
cellVoice.AddFunc(0x762dc193, cellVoiceGetVolume); REG_FUNC(cellVoice, cellVoiceGetVolume);
cellVoice.AddFunc(0xc7cf1182, cellVoiceInit); REG_FUNC(cellVoice, cellVoiceInit);
cellVoice.AddFunc(0xb1a2c38f, cellVoiceInitEx); REG_FUNC(cellVoice, cellVoiceInitEx);
cellVoice.AddFunc(0x87c71b06, cellVoicePausePort); REG_FUNC(cellVoice, cellVoicePausePort);
cellVoice.AddFunc(0xd14e784d, cellVoicePausePortAll); REG_FUNC(cellVoice, cellVoicePausePortAll);
cellVoice.AddFunc(0xdd000886, cellVoiceRemoveNotifyEventQueue); REG_FUNC(cellVoice, cellVoiceRemoveNotifyEventQueue);
cellVoice.AddFunc(0xff0fa43a, cellVoiceResetPort); REG_FUNC(cellVoice, cellVoiceResetPort);
cellVoice.AddFunc(0x7bf17b15, cellVoiceResumePort); REG_FUNC(cellVoice, cellVoiceResumePort);
cellVoice.AddFunc(0x7f3963f7, cellVoiceResumePortAll); REG_FUNC(cellVoice, cellVoiceResumePortAll);
cellVoice.AddFunc(0x7e60adc6, cellVoiceSetBitRate); REG_FUNC(cellVoice, cellVoiceSetBitRate);
cellVoice.AddFunc(0xdde35a0c, cellVoiceSetMuteFlag); REG_FUNC(cellVoice, cellVoiceSetMuteFlag);
cellVoice.AddFunc(0xd4d80ea5, cellVoiceSetMuteFlagAll); REG_FUNC(cellVoice, cellVoiceSetMuteFlagAll);
cellVoice.AddFunc(0x35d84910, cellVoiceSetNotifyEventQueue); REG_FUNC(cellVoice, cellVoiceSetNotifyEventQueue);
cellVoice.AddFunc(0x9d0f4af1, cellVoiceSetPortAttr); REG_FUNC(cellVoice, cellVoiceSetPortAttr);
cellVoice.AddFunc(0xd5ae37d8, cellVoiceSetVolume); REG_FUNC(cellVoice, cellVoiceSetVolume);
cellVoice.AddFunc(0x0a563878, cellVoiceStart); REG_FUNC(cellVoice, cellVoiceStart);
cellVoice.AddFunc(0x94d51f92, cellVoiceStartEx); REG_FUNC(cellVoice, cellVoiceStartEx);
cellVoice.AddFunc(0xd3a84be1, cellVoiceStop); REG_FUNC(cellVoice, cellVoiceStop);
cellVoice.AddFunc(0x2f24fea3, cellVoiceUpdatePort); REG_FUNC(cellVoice, cellVoiceUpdatePort);
cellVoice.AddFunc(0x3dad26e7, cellVoiceWriteToIPort); REG_FUNC(cellVoice, cellVoiceWriteToIPort);
cellVoice.AddFunc(0x30f0b5ab, cellVoiceWriteToIPortEx); REG_FUNC(cellVoice, cellVoiceWriteToIPortEx);
cellVoice.AddFunc(0x36472c57, cellVoiceReadFromOPort); REG_FUNC(cellVoice, cellVoiceReadFromOPort);
cellVoice.AddFunc(0x20bafe31, cellVoiceDebugTopology); REG_FUNC(cellVoice, cellVoiceDebugTopology);
} }
#endif #endif

10
rpcs3/Emu/SysCalls/Modules/cellVpost.cpp
View File

@ -150,9 +150,9 @@ int cellVpostExec(u32 handle, vm::ptr<const u8> inPicBuff, vm::ptr<const CellVpo
Module cellVpost("cellVpost", []() Module cellVpost("cellVpost", []()
{ {
cellVpost.AddFunc(0x95e788c3, cellVpostQueryAttr); REG_FUNC(cellVpost, cellVpostQueryAttr);
cellVpost.AddFunc(0xcd33f3e2, cellVpostOpen); REG_FUNC(cellVpost, cellVpostOpen);
cellVpost.AddFunc(0x40524325, cellVpostOpenEx); REG_FUNC(cellVpost, cellVpostOpenEx);
cellVpost.AddFunc(0x10ef39f6, cellVpostClose); REG_FUNC(cellVpost, cellVpostClose);
cellVpost.AddFunc(0xabb8cc3d, cellVpostExec); REG_FUNC(cellVpost, cellVpostExec);
}); });

14
rpcs3/Emu/SysCalls/Modules/libmixer.cpp
View File

@ -312,10 +312,15 @@ int cellSurMixerCreate(vm::ptr<const CellSurMixerConfig> config)
port.channel = 8; port.channel = 8;
port.block = 16; port.block = 16;
port.attr = 0; port.attr = 0;
port.level = 1.0f; port.addr = g_audio.buffer + AUDIO_PORT_OFFSET * g_surmx.audio_port;
port.read_index_addr = g_audio.indexes + sizeof(u64) * g_surmx.audio_port;
port.size = port.channel * port.block * AUDIO_SAMPLES * sizeof(float);
port.tag = 0; port.tag = 0;
port.level = 1.0f;
port.level_set = 1.0f;
port.level_inc = 0.0f;
libmixer.Warning("*** audio port opened(default)"); libmixer.Warning("*** audio port opened (port=%d)", g_surmx.audio_port);
mixcount = 0; mixcount = 0;
surMixerCb.set(0); surMixerCb.set(0);
@ -628,6 +633,11 @@ Module libmixer("libmixer", []()
{ {
g_surmx.audio_port = ~0; g_surmx.audio_port = ~0;
libmixer.on_stop = []()
{
ssp.clear();
};
REG_SUB(libmixer, "surmxAAN", cellAANAddData, REG_SUB(libmixer, "surmxAAN", cellAANAddData,
0xffffffff7c691b78, 0xffffffff7c691b78,
0xffffffff7c0802a6, 0xffffffff7c0802a6,

456
rpcs3/Emu/SysCalls/Modules/sceNp.cpp
View File

@ -1645,232 +1645,232 @@ void sceNp_unload()
Module sceNp("sceNp", []() Module sceNp("sceNp", []()
{ {
sceNp.AddFunc(0xbd28fdbf, sceNpInit); REG_FUNC(sceNp, sceNpInit);
sceNp.AddFunc(0x41251f74, sceNp2Init); REG_FUNC(sceNp, sceNp2Init);
sceNp.AddFunc(0xc2ced2b7, sceNpUtilBandwidthTestInitStart); REG_FUNC(sceNp, sceNpUtilBandwidthTestInitStart);
sceNp.AddFunc(0x4885aa18, sceNpTerm); REG_FUNC(sceNp, sceNpTerm);
sceNp.AddFunc(0xaadb7c12, sceNp2Term); REG_FUNC(sceNp, sceNp2Term);
sceNp.AddFunc(0x432b3cbf, sceNpUtilBandwidthTestShutdown); REG_FUNC(sceNp, sceNpUtilBandwidthTestShutdown);
sceNp.AddFunc(0xad218faf, sceNpDrmIsAvailable); REG_FUNC(sceNp, sceNpDrmIsAvailable);
sceNp.AddFunc(0xf042b14f, sceNpDrmIsAvailable2); REG_FUNC(sceNp, sceNpDrmIsAvailable2);
sceNp.AddFunc(0x2ecd48ed, sceNpDrmVerifyUpgradeLicense); REG_FUNC(sceNp, sceNpDrmVerifyUpgradeLicense);
sceNp.AddFunc(0xbe0e3ee2, sceNpDrmVerifyUpgradeLicense2); REG_FUNC(sceNp, sceNpDrmVerifyUpgradeLicense2);
sceNp.AddFunc(0xf283c143, sceNpDrmExecuteGamePurchase); REG_FUNC(sceNp, sceNpDrmExecuteGamePurchase);
sceNp.AddFunc(0xcf51864b, sceNpDrmGetTimelimit); REG_FUNC(sceNp, sceNpDrmGetTimelimit);
sceNp.AddFunc(0xaa16695f, sceNpDrmProcessExitSpawn); REG_FUNC(sceNp, sceNpDrmProcessExitSpawn);
sceNp.AddFunc(0xe6c8f3f9, sceNpDrmProcessExitSpawn2); REG_FUNC(sceNp, sceNpDrmProcessExitSpawn2);
sceNp.AddFunc(0xbcc09fe7, sceNpBasicRegisterHandler); REG_FUNC(sceNp, sceNpBasicRegisterHandler);
sceNp.AddFunc(0x4026eac5, sceNpBasicRegisterContextSensitiveHandler); REG_FUNC(sceNp, sceNpBasicRegisterContextSensitiveHandler);
sceNp.AddFunc(0xacb9ee8e, sceNpBasicUnregisterHandler); REG_FUNC(sceNp, sceNpBasicUnregisterHandler);
sceNp.AddFunc(0x3f0808aa, sceNpBasicSetPresence); REG_FUNC(sceNp, sceNpBasicSetPresence);
sceNp.AddFunc(0xbe81c71c, sceNpBasicSetPresenceDetails); REG_FUNC(sceNp, sceNpBasicSetPresenceDetails);
sceNp.AddFunc(0x5e849303, sceNpBasicSetPresenceDetails2); REG_FUNC(sceNp, sceNpBasicSetPresenceDetails2);
sceNp.AddFunc(0xec0a1fbf, sceNpBasicSendMessage); REG_FUNC(sceNp, sceNpBasicSendMessage);
sceNp.AddFunc(0x01fbbc9b, sceNpBasicSendMessageGui); REG_FUNC(sceNp, sceNpBasicSendMessageGui);
sceNp.AddFunc(0x43b989f5, sceNpBasicSendMessageAttachment); REG_FUNC(sceNp, sceNpBasicSendMessageAttachment);
sceNp.AddFunc(0xb5cb2d56, sceNpBasicRecvMessageAttachment); REG_FUNC(sceNp, sceNpBasicRecvMessageAttachment);
sceNp.AddFunc(0x64a704cc, sceNpBasicRecvMessageAttachmentLoad); REG_FUNC(sceNp, sceNpBasicRecvMessageAttachmentLoad);
sceNp.AddFunc(0x806960ab, sceNpBasicRecvMessageCustom); REG_FUNC(sceNp, sceNpBasicRecvMessageCustom);
sceNp.AddFunc(0xe1c9f675, sceNpBasicMarkMessageAsUsed); REG_FUNC(sceNp, sceNpBasicMarkMessageAsUsed);
sceNp.AddFunc(0x481ce0e8, sceNpBasicAbortGui); REG_FUNC(sceNp, sceNpBasicAbortGui);
sceNp.AddFunc(0x27c69eba, sceNpBasicAddFriend); REG_FUNC(sceNp, sceNpBasicAddFriend);
sceNp.AddFunc(0xafef640d, sceNpBasicGetFriendListEntryCount); REG_FUNC(sceNp, sceNpBasicGetFriendListEntryCount);
sceNp.AddFunc(0x04372385, sceNpBasicGetFriendListEntry); REG_FUNC(sceNp, sceNpBasicGetFriendListEntry);
sceNp.AddFunc(0x32c78a6a, sceNpBasicGetFriendPresenceByIndex); REG_FUNC(sceNp, sceNpBasicGetFriendPresenceByIndex);
sceNp.AddFunc(0x6453b27b, sceNpBasicGetFriendPresenceByIndex2); REG_FUNC(sceNp, sceNpBasicGetFriendPresenceByIndex2);
sceNp.AddFunc(0xfd39ae13, sceNpBasicGetFriendPresenceByNpId); REG_FUNC(sceNp, sceNpBasicGetFriendPresenceByNpId);
sceNp.AddFunc(0x260caedd, sceNpBasicGetFriendPresenceByNpId2); REG_FUNC(sceNp, sceNpBasicGetFriendPresenceByNpId2);
sceNp.AddFunc(0x168a3117, sceNpBasicAddPlayersHistory); REG_FUNC(sceNp, sceNpBasicAddPlayersHistory);
sceNp.AddFunc(0xbcdbb2ab, sceNpBasicAddPlayersHistoryAsync); REG_FUNC(sceNp, sceNpBasicAddPlayersHistoryAsync);
sceNp.AddFunc(0xa15f35fe, sceNpBasicGetPlayersHistoryEntryCount); REG_FUNC(sceNp, sceNpBasicGetPlayersHistoryEntryCount);
sceNp.AddFunc(0xbab91fc9, sceNpBasicGetPlayersHistoryEntry); REG_FUNC(sceNp, sceNpBasicGetPlayersHistoryEntry);
sceNp.AddFunc(0x1ae8a549, sceNpBasicAddBlockListEntry); REG_FUNC(sceNp, sceNpBasicAddBlockListEntry);
sceNp.AddFunc(0x73931bd0, sceNpBasicGetBlockListEntryCount); REG_FUNC(sceNp, sceNpBasicGetBlockListEntryCount);
sceNp.AddFunc(0xf2b3338a, sceNpBasicGetBlockListEntry); REG_FUNC(sceNp, sceNpBasicGetBlockListEntry);
sceNp.AddFunc(0x9153bdf4, sceNpBasicGetMessageAttachmentEntryCount); REG_FUNC(sceNp, sceNpBasicGetMessageAttachmentEntryCount);
sceNp.AddFunc(0x5d543bbe, sceNpBasicGetMessageAttachmentEntry); REG_FUNC(sceNp, sceNpBasicGetMessageAttachmentEntry);
sceNp.AddFunc(0xa8afa7d4, sceNpBasicGetCustomInvitationEntryCount); REG_FUNC(sceNp, sceNpBasicGetCustomInvitationEntryCount);
sceNp.AddFunc(0xd053f113, sceNpBasicGetCustomInvitationEntry); REG_FUNC(sceNp, sceNpBasicGetCustomInvitationEntry);
sceNp.AddFunc(0xaf505def, sceNpBasicGetMatchingInvitationEntryCount); REG_FUNC(sceNp, sceNpBasicGetMatchingInvitationEntryCount);
sceNp.AddFunc(0x05af1cb8, sceNpBasicGetMatchingInvitationEntry); REG_FUNC(sceNp, sceNpBasicGetMatchingInvitationEntry);
sceNp.AddFunc(0xbf607ec6, sceNpBasicGetClanMessageEntryCount); REG_FUNC(sceNp, sceNpBasicGetClanMessageEntryCount);
sceNp.AddFunc(0x4d9c615d, sceNpBasicGetClanMessageEntry); REG_FUNC(sceNp, sceNpBasicGetClanMessageEntry);
sceNp.AddFunc(0xecd503de, sceNpBasicGetMessageEntryCount); REG_FUNC(sceNp, sceNpBasicGetMessageEntryCount);
sceNp.AddFunc(0x30d1cbde, sceNpBasicGetMessageEntry); REG_FUNC(sceNp, sceNpBasicGetMessageEntry);
sceNp.AddFunc(0xe035f7d6, sceNpBasicGetEvent); REG_FUNC(sceNp, sceNpBasicGetEvent);
sceNp.AddFunc(0xfcac355a, sceNpCommerceCreateCtx); REG_FUNC(sceNp, sceNpCommerceCreateCtx);
sceNp.AddFunc(0xe2877bea, sceNpCommerceDestroyCtx); REG_FUNC(sceNp, sceNpCommerceDestroyCtx);
sceNp.AddFunc(0x8d1d096c, sceNpCommerceInitProductCategory); REG_FUNC(sceNp, sceNpCommerceInitProductCategory);
sceNp.AddFunc(0x6cb81eb2, sceNpCommerceDestroyProductCategory); REG_FUNC(sceNp, sceNpCommerceDestroyProductCategory);
sceNp.AddFunc(0x26f33146, sceNpCommerceGetProductCategoryStart); REG_FUNC(sceNp, sceNpCommerceGetProductCategoryStart);
sceNp.AddFunc(0xcfd469e4, sceNpCommerceGetProductCategoryFinish); REG_FUNC(sceNp, sceNpCommerceGetProductCategoryFinish);
sceNp.AddFunc(0x3f195b3a, sceNpCommerceGetProductCategoryResult); REG_FUNC(sceNp, sceNpCommerceGetProductCategoryResult);
sceNp.AddFunc(0x674bb9ff, sceNpCommerceGetProductCategoryAbort); REG_FUNC(sceNp, sceNpCommerceGetProductCategoryAbort);
sceNp.AddFunc(0x936df4aa, sceNpCommerceGetProductId); REG_FUNC(sceNp, sceNpCommerceGetProductId);
sceNp.AddFunc(0xeb5f2544, sceNpCommerceGetProductName); REG_FUNC(sceNp, sceNpCommerceGetProductName);
sceNp.AddFunc(0x359642a6, sceNpCommerceGetCategoryDescription); REG_FUNC(sceNp, sceNpCommerceGetCategoryDescription);
sceNp.AddFunc(0xaee8cf71, sceNpCommerceGetCategoryId); REG_FUNC(sceNp, sceNpCommerceGetCategoryId);
sceNp.AddFunc(0x9452f4f8, sceNpCommerceGetCategoryImageURL); REG_FUNC(sceNp, sceNpCommerceGetCategoryImageURL);
sceNp.AddFunc(0xeb9df054, sceNpCommerceGetCategoryInfo); REG_FUNC(sceNp, sceNpCommerceGetCategoryInfo);
sceNp.AddFunc(0x6e2ab18b, sceNpCommerceGetCategoryName); REG_FUNC(sceNp, sceNpCommerceGetCategoryName);
sceNp.AddFunc(0x79225aa3, sceNpCommerceGetCurrencyCode); REG_FUNC(sceNp, sceNpCommerceGetCurrencyCode);
sceNp.AddFunc(0xaf57d9c9, sceNpCommerceGetCurrencyDecimals); REG_FUNC(sceNp, sceNpCommerceGetCurrencyDecimals);
sceNp.AddFunc(0xb1c02d66, sceNpCommerceGetCurrencyInfo); REG_FUNC(sceNp, sceNpCommerceGetCurrencyInfo);
sceNp.AddFunc(0x2be41ece, sceNpCommerceGetNumOfChildCategory); REG_FUNC(sceNp, sceNpCommerceGetNumOfChildCategory);
sceNp.AddFunc(0x7208dc08, sceNpCommerceGetNumOfChildProductSku); REG_FUNC(sceNp, sceNpCommerceGetNumOfChildProductSku);
sceNp.AddFunc(0xa85a4951, sceNpCommerceGetSkuDescription); REG_FUNC(sceNp, sceNpCommerceGetSkuDescription);
sceNp.AddFunc(0x39a69619, sceNpCommerceGetSkuId); REG_FUNC(sceNp, sceNpCommerceGetSkuId);
sceNp.AddFunc(0xccbe2e69, sceNpCommerceGetSkuImageURL); REG_FUNC(sceNp, sceNpCommerceGetSkuImageURL);
sceNp.AddFunc(0xee530059, sceNpCommerceGetSkuName); REG_FUNC(sceNp, sceNpCommerceGetSkuName);
sceNp.AddFunc(0x78d7f9ad, sceNpCommerceGetSkuPrice); REG_FUNC(sceNp, sceNpCommerceGetSkuPrice);
sceNp.AddFunc(0x1a3fcb69, sceNpCommerceGetSkuUserData); REG_FUNC(sceNp, sceNpCommerceGetSkuUserData);
sceNp.AddFunc(0x99ac9952, sceNpCommerceSetDataFlagStart); REG_FUNC(sceNp, sceNpCommerceSetDataFlagStart);
sceNp.AddFunc(0xdbdb909f, sceNpCommerceGetDataFlagStart); REG_FUNC(sceNp, sceNpCommerceGetDataFlagStart);
sceNp.AddFunc(0x8d4518a0, sceNpCommerceSetDataFlagFinish); REG_FUNC(sceNp, sceNpCommerceSetDataFlagFinish);
sceNp.AddFunc(0x9281e87a, sceNpCommerceGetDataFlagFinish); REG_FUNC(sceNp, sceNpCommerceGetDataFlagFinish);
sceNp.AddFunc(0xd03cea35, sceNpCommerceGetDataFlagState); REG_FUNC(sceNp, sceNpCommerceGetDataFlagState);
sceNp.AddFunc(0x0561448b, sceNpCommerceGetDataFlagAbort); REG_FUNC(sceNp, sceNpCommerceGetDataFlagAbort);
sceNp.AddFunc(0xba65de6d, sceNpCommerceGetChildCategoryInfo); REG_FUNC(sceNp, sceNpCommerceGetChildCategoryInfo);
sceNp.AddFunc(0x01cd9cfd, sceNpCommerceGetChildProductSkuInfo); REG_FUNC(sceNp, sceNpCommerceGetChildProductSkuInfo);
sceNp.AddFunc(0xe36c660e, sceNpCommerceDoCheckoutStartAsync); REG_FUNC(sceNp, sceNpCommerceDoCheckoutStartAsync);
sceNp.AddFunc(0xaf3eba5a, sceNpCommerceDoCheckoutFinishAsync); REG_FUNC(sceNp, sceNpCommerceDoCheckoutFinishAsync);
sceNp.AddFunc(0x45f8f3aa, sceNpCustomMenuRegisterActions); REG_FUNC(sceNp, sceNpCustomMenuRegisterActions);
sceNp.AddFunc(0xf9732ac8, sceNpCustomMenuActionSetActivation); REG_FUNC(sceNp, sceNpCustomMenuActionSetActivation);
sceNp.AddFunc(0x9458f464, sceNpCustomMenuRegisterExceptionList); REG_FUNC(sceNp, sceNpCustomMenuRegisterExceptionList);
sceNp.AddFunc(0xf0a9182b, sceNpFriendlist); REG_FUNC(sceNp, sceNpFriendlist);
sceNp.AddFunc(0xd7fb1fa6, sceNpFriendlistCustom); REG_FUNC(sceNp, sceNpFriendlistCustom);
sceNp.AddFunc(0xf59e1da8, sceNpFriendlistAbortGui); REG_FUNC(sceNp, sceNpFriendlistAbortGui);
sceNp.AddFunc(0x5f2d9257, sceNpLookupInit); REG_FUNC(sceNp, sceNpLookupInit);
sceNp.AddFunc(0x8440537c, sceNpLookupTerm); REG_FUNC(sceNp, sceNpLookupTerm);
sceNp.AddFunc(0xce81c7f0, sceNpLookupCreateTitleCtx); REG_FUNC(sceNp, sceNpLookupCreateTitleCtx);
sceNp.AddFunc(0x5de61626, sceNpLookupDestroyTitleCtx); REG_FUNC(sceNp, sceNpLookupDestroyTitleCtx);
sceNp.AddFunc(0xea2e9ffc, sceNpLookupCreateTransactionCtx); REG_FUNC(sceNp, sceNpLookupCreateTransactionCtx);
sceNp.AddFunc(0xfb87cf5e, sceNpLookupDestroyTransactionCtx); REG_FUNC(sceNp, sceNpLookupDestroyTransactionCtx);
sceNp.AddFunc(0x71e5af7e, sceNpLookupSetTimeout); REG_FUNC(sceNp, sceNpLookupSetTimeout);
sceNp.AddFunc(0x3d1760dc, sceNpLookupAbortTransaction); REG_FUNC(sceNp, sceNpLookupAbortTransaction);
sceNp.AddFunc(0xd737fd2d, sceNpLookupWaitAsync); REG_FUNC(sceNp, sceNpLookupWaitAsync);
sceNp.AddFunc(0x7508112e, sceNpLookupPollAsync); REG_FUNC(sceNp, sceNpLookupPollAsync);
sceNp.AddFunc(0x166dcc11, sceNpLookupNpId); REG_FUNC(sceNp, sceNpLookupNpId);
sceNp.AddFunc(0xd12e40ae, sceNpLookupNpIdAsync); REG_FUNC(sceNp, sceNpLookupNpIdAsync);
sceNp.AddFunc(0xdfd63b62, sceNpLookupUserProfile); REG_FUNC(sceNp, sceNpLookupUserProfile);
sceNp.AddFunc(0xff0a2378, sceNpLookupUserProfileAsync); REG_FUNC(sceNp, sceNpLookupUserProfileAsync);
sceNp.AddFunc(0x2fccbfe0, sceNpLookupUserProfileWithAvatarSize); REG_FUNC(sceNp, sceNpLookupUserProfileWithAvatarSize);
sceNp.AddFunc(0x1fdb3ec2, sceNpLookupUserProfileWithAvatarSizeAsync); REG_FUNC(sceNp, sceNpLookupUserProfileWithAvatarSizeAsync);
sceNp.AddFunc(0xb6017827, sceNpLookupAvatarImage); REG_FUNC(sceNp, sceNpLookupAvatarImage);
sceNp.AddFunc(0xbf9eea93, sceNpLookupAvatarImageAsync); REG_FUNC(sceNp, sceNpLookupAvatarImageAsync);
sceNp.AddFunc(0x9ee9f97e, sceNpLookupTitleStorage); REG_FUNC(sceNp, sceNpLookupTitleStorage);
sceNp.AddFunc(0x5e117ed5, sceNpLookupTitleStorageAsync); REG_FUNC(sceNp, sceNpLookupTitleStorageAsync);
sceNp.AddFunc(0xca39c4b2, sceNpLookupTitleSmallStorage); REG_FUNC(sceNp, sceNpLookupTitleSmallStorage);
sceNp.AddFunc(0x860b1756, sceNpLookupTitleSmallStorageAsync); REG_FUNC(sceNp, sceNpLookupTitleSmallStorageAsync);
sceNp.AddFunc(0xe7dcd3b4, sceNpManagerRegisterCallback); REG_FUNC(sceNp, sceNpManagerRegisterCallback);
sceNp.AddFunc(0x52a6b523, sceNpManagerUnregisterCallback); REG_FUNC(sceNp, sceNpManagerUnregisterCallback);
sceNp.AddFunc(0xa7bff757, sceNpManagerGetStatus); REG_FUNC(sceNp, sceNpManagerGetStatus);
sceNp.AddFunc(0xbdc07fd5, sceNpManagerGetNetworkTime); REG_FUNC(sceNp, sceNpManagerGetNetworkTime);
sceNp.AddFunc(0xbe07c708, sceNpManagerGetOnlineId); REG_FUNC(sceNp, sceNpManagerGetOnlineId);
sceNp.AddFunc(0xfe37a7f4, sceNpManagerGetNpId); REG_FUNC(sceNp, sceNpManagerGetNpId);
sceNp.AddFunc(0xf42c0df8, sceNpManagerGetOnlineName); REG_FUNC(sceNp, sceNpManagerGetOnlineName);
sceNp.AddFunc(0x36d0c2c5, sceNpManagerGetAvatarUrl); REG_FUNC(sceNp, sceNpManagerGetAvatarUrl);
sceNp.AddFunc(0x32200389, sceNpManagerGetMyLanguages); REG_FUNC(sceNp, sceNpManagerGetMyLanguages);
sceNp.AddFunc(0xb1e0718b, sceNpManagerGetAccountRegion); REG_FUNC(sceNp, sceNpManagerGetAccountRegion);
sceNp.AddFunc(0x168fcece, sceNpManagerGetAccountAge); REG_FUNC(sceNp, sceNpManagerGetAccountAge);
sceNp.AddFunc(0x6ee62ed2, sceNpManagerGetContentRatingFlag); REG_FUNC(sceNp, sceNpManagerGetContentRatingFlag);
sceNp.AddFunc(0xeb7a3d84, sceNpManagerGetChatRestrictionFlag); REG_FUNC(sceNp, sceNpManagerGetChatRestrictionFlag);
sceNp.AddFunc(0x4b9efb7a, sceNpManagerGetCachedInfo); REG_FUNC(sceNp, sceNpManagerGetCachedInfo);
sceNp.AddFunc(0x16f88a6f, sceNpManagerGetPsHandle); REG_FUNC(sceNp, sceNpManagerGetPsHandle);
sceNp.AddFunc(0x7e2fef28, sceNpManagerRequestTicket); REG_FUNC(sceNp, sceNpManagerRequestTicket);
sceNp.AddFunc(0x8297f1ec, sceNpManagerRequestTicket2); REG_FUNC(sceNp, sceNpManagerRequestTicket2);
sceNp.AddFunc(0x0968aa36, sceNpManagerGetTicket); REG_FUNC(sceNp, sceNpManagerGetTicket);
sceNp.AddFunc(0x58fa4fcd, sceNpManagerGetTicketParam); REG_FUNC(sceNp, sceNpManagerGetTicketParam);
sceNp.AddFunc(0xb66d1c46, sceNpManagerGetEntitlementIdList); REG_FUNC(sceNp, sceNpManagerGetEntitlementIdList);
sceNp.AddFunc(0xa1709abd, sceNpManagerGetEntitlementById); REG_FUNC(sceNp, sceNpManagerGetEntitlementById);
sceNp.AddFunc(0x442381f7, sceNpManagerSubSignin); REG_FUNC(sceNp, sceNpManagerSubSignin);
sceNp.AddFunc(0x60440c73, sceNpManagerSubSigninAbortGui); REG_FUNC(sceNp, sceNpManagerSubSigninAbortGui);
sceNp.AddFunc(0x000e53cc, sceNpManagerSubSignout); REG_FUNC(sceNp, sceNpManagerSubSignout);
sceNp.AddFunc(0xac66568c, sceNpMatchingCreateCtx); REG_FUNC(sceNp, sceNpMatchingCreateCtx);
sceNp.AddFunc(0x2e1c5068, sceNpMatchingDestroyCtx); REG_FUNC(sceNp, sceNpMatchingDestroyCtx);
sceNp.AddFunc(0x03c741a7, sceNpMatchingGetResult); REG_FUNC(sceNp, sceNpMatchingGetResult);
sceNp.AddFunc(0x26b3bc94, sceNpMatchingGetResultGUI); REG_FUNC(sceNp, sceNpMatchingGetResultGUI);
sceNp.AddFunc(0x6f8fd267, sceNpMatchingSetRoomInfo); REG_FUNC(sceNp, sceNpMatchingSetRoomInfo);
sceNp.AddFunc(0x4a18a89e, sceNpMatchingSetRoomInfoNoLimit); REG_FUNC(sceNp, sceNpMatchingSetRoomInfoNoLimit);
sceNp.AddFunc(0x691f429d, sceNpMatchingGetRoomInfo); REG_FUNC(sceNp, sceNpMatchingGetRoomInfo);
sceNp.AddFunc(0xb020684e, sceNpMatchingGetRoomInfoNoLimit); REG_FUNC(sceNp, sceNpMatchingGetRoomInfoNoLimit);
sceNp.AddFunc(0xa284bd1d, sceNpMatchingSetRoomSearchFlag); REG_FUNC(sceNp, sceNpMatchingSetRoomSearchFlag);
sceNp.AddFunc(0xee64cf8e, sceNpMatchingGetRoomSearchFlag); REG_FUNC(sceNp, sceNpMatchingGetRoomSearchFlag);
sceNp.AddFunc(0x73a2e36b, sceNpMatchingGetRoomMemberListLocal); REG_FUNC(sceNp, sceNpMatchingGetRoomMemberListLocal);
sceNp.AddFunc(0xe24eea19, sceNpMatchingGetRoomListLimitGUI); REG_FUNC(sceNp, sceNpMatchingGetRoomListLimitGUI);
sceNp.AddFunc(0x34cc0ca4, sceNpMatchingKickRoomMember); REG_FUNC(sceNp, sceNpMatchingKickRoomMember);
sceNp.AddFunc(0xd20d7798, sceNpMatchingKickRoomMemberWithOpt); REG_FUNC(sceNp, sceNpMatchingKickRoomMemberWithOpt);
sceNp.AddFunc(0x14497465, sceNpMatchingQuickMatchGUI); REG_FUNC(sceNp, sceNpMatchingQuickMatchGUI);
sceNp.AddFunc(0x8b7bbd73, sceNpMatchingSendInvitationGUI); REG_FUNC(sceNp, sceNpMatchingSendInvitationGUI);
sceNp.AddFunc(0x2ad7837d, sceNpMatchingAcceptInvitationGUI); REG_FUNC(sceNp, sceNpMatchingAcceptInvitationGUI);
sceNp.AddFunc(0x3cc8588a, sceNpMatchingCreateRoomGUI); REG_FUNC(sceNp, sceNpMatchingCreateRoomGUI);
sceNp.AddFunc(0x474b7b13, sceNpMatchingJoinRoomGUI); REG_FUNC(sceNp, sceNpMatchingJoinRoomGUI);
sceNp.AddFunc(0xf806c54c, sceNpMatchingLeaveRoom); REG_FUNC(sceNp, sceNpMatchingLeaveRoom);
sceNp.AddFunc(0x32febb4c, sceNpMatchingSearchJoinRoomGUI); REG_FUNC(sceNp, sceNpMatchingSearchJoinRoomGUI);
sceNp.AddFunc(0xdae2d351, sceNpMatchingGrantOwnership); REG_FUNC(sceNp, sceNpMatchingGrantOwnership);
sceNp.AddFunc(0xceeebc7a, sceNpProfileCallGui); REG_FUNC(sceNp, sceNpProfileCallGui);
sceNp.AddFunc(0x2f2c6b3e, sceNpProfileAbortGui); REG_FUNC(sceNp, sceNpProfileAbortGui);
sceNp.AddFunc(0x32cf311f, sceNpScoreInit); REG_FUNC(sceNp, sceNpScoreInit);
sceNp.AddFunc(0x9851f805, sceNpScoreTerm); REG_FUNC(sceNp, sceNpScoreTerm);
sceNp.AddFunc(0xb9f93bbb, sceNpScoreCreateTitleCtx); REG_FUNC(sceNp, sceNpScoreCreateTitleCtx);
sceNp.AddFunc(0x259113b8, sceNpScoreDestroyTitleCtx); REG_FUNC(sceNp, sceNpScoreDestroyTitleCtx);
sceNp.AddFunc(0x6f5e8143, sceNpScoreCreateTransactionCtx); REG_FUNC(sceNp, sceNpScoreCreateTransactionCtx);
sceNp.AddFunc(0xc5f4cf82, sceNpScoreDestroyTransactionCtx); REG_FUNC(sceNp, sceNpScoreDestroyTransactionCtx);
sceNp.AddFunc(0x29dd45dc, sceNpScoreSetTimeout); REG_FUNC(sceNp, sceNpScoreSetTimeout);
sceNp.AddFunc(0x2706eaa1, sceNpScoreSetPlayerCharacterId); REG_FUNC(sceNp, sceNpScoreSetPlayerCharacterId);
sceNp.AddFunc(0x1a2704f7, sceNpScoreWaitAsync); REG_FUNC(sceNp, sceNpScoreWaitAsync);
sceNp.AddFunc(0xa7a090e5, sceNpScorePollAsync); REG_FUNC(sceNp, sceNpScorePollAsync);
sceNp.AddFunc(0xf4e0f607, sceNpScoreGetBoardInfo); REG_FUNC(sceNp, sceNpScoreGetBoardInfo);
sceNp.AddFunc(0xddce7d15, sceNpScoreGetBoardInfoAsync); REG_FUNC(sceNp, sceNpScoreGetBoardInfoAsync);
sceNp.AddFunc(0x1672170e, sceNpScoreRecordScore); REG_FUNC(sceNp, sceNpScoreRecordScore);
sceNp.AddFunc(0xf0b1e399, sceNpScoreRecordScoreAsync); REG_FUNC(sceNp, sceNpScoreRecordScoreAsync);
sceNp.AddFunc(0x04ca5e6a, sceNpScoreRecordGameData); REG_FUNC(sceNp, sceNpScoreRecordGameData);
sceNp.AddFunc(0xf76847c2, sceNpScoreRecordGameDataAsync); REG_FUNC(sceNp, sceNpScoreRecordGameDataAsync);
sceNp.AddFunc(0x3b02418d, sceNpScoreGetGameData); REG_FUNC(sceNp, sceNpScoreGetGameData);
sceNp.AddFunc(0xdb2e4dc2, sceNpScoreGetGameDataAsync); REG_FUNC(sceNp, sceNpScoreGetGameDataAsync);
sceNp.AddFunc(0x05d65dff, sceNpScoreGetRankingByNpId); REG_FUNC(sceNp, sceNpScoreGetRankingByNpId);
sceNp.AddFunc(0x3db7914d, sceNpScoreGetRankingByNpIdAsync); REG_FUNC(sceNp, sceNpScoreGetRankingByNpIdAsync);
sceNp.AddFunc(0xfbc82301, sceNpScoreGetRankingByRange); REG_FUNC(sceNp, sceNpScoreGetRankingByRange);
sceNp.AddFunc(0x21206642, sceNpScoreGetRankingByRangeAsync); REG_FUNC(sceNp, sceNpScoreGetRankingByRangeAsync);
sceNp.AddFunc(0x7deb244c, sceNpScoreCensorComment); REG_FUNC(sceNp, sceNpScoreCensorComment);
sceNp.AddFunc(0x7be47e61, sceNpScoreCensorCommentAsync); REG_FUNC(sceNp, sceNpScoreCensorCommentAsync);
sceNp.AddFunc(0xf1b77918, sceNpScoreSanitizeComment); REG_FUNC(sceNp, sceNpScoreSanitizeComment);
sceNp.AddFunc(0x2cd2a1af, sceNpScoreSanitizeCommentAsync); REG_FUNC(sceNp, sceNpScoreSanitizeCommentAsync);
sceNp.AddFunc(0xc3a991ee, sceNpScoreGetRankingByNpIdPcId); REG_FUNC(sceNp, sceNpScoreGetRankingByNpIdPcId);
sceNp.AddFunc(0xc4b6cd8f, sceNpScoreGetRankingByNpIdPcIdAsync); REG_FUNC(sceNp, sceNpScoreGetRankingByNpIdPcIdAsync);
sceNp.AddFunc(0xee5b20d9, sceNpScoreAbortTransaction); REG_FUNC(sceNp, sceNpScoreAbortTransaction);
sceNp.AddFunc(0xded17c26, sceNpScoreGetClansMembersRankingByNpId); REG_FUNC(sceNp, sceNpScoreGetClansMembersRankingByNpId);
sceNp.AddFunc(0xe8a67160, sceNpScoreGetClansMembersRankingByNpIdAsync); REG_FUNC(sceNp, sceNpScoreGetClansMembersRankingByNpIdAsync);
sceNp.AddFunc(0x41ffd4f2, sceNpScoreGetClansMembersRankingByNpIdPcId); REG_FUNC(sceNp, sceNpScoreGetClansMembersRankingByNpIdPcId);
sceNp.AddFunc(0x433fcb30, sceNpScoreGetClansMembersRankingByNpIdPcIdAsync); REG_FUNC(sceNp, sceNpScoreGetClansMembersRankingByNpIdPcIdAsync);
sceNp.AddFunc(0x6d4adc3b, sceNpScoreGetClansMembersRankingByRange); REG_FUNC(sceNp, sceNpScoreGetClansMembersRankingByRange);
sceNp.AddFunc(0x4d5e0670, sceNpScoreGetClansMembersRankingByRangeAsync); REG_FUNC(sceNp, sceNpScoreGetClansMembersRankingByRangeAsync);
sceNp.AddFunc(0x741fbf24, sceNpScoreGetClanMemberGameData); REG_FUNC(sceNp, sceNpScoreGetClanMemberGameData);
sceNp.AddFunc(0xbef887e5, sceNpScoreGetClanMemberGameDataAsync); REG_FUNC(sceNp, sceNpScoreGetClanMemberGameDataAsync);
sceNp.AddFunc(0x2a76895a, sceNpScoreGetClansRankingByClanId); REG_FUNC(sceNp, sceNpScoreGetClansRankingByClanId);
sceNp.AddFunc(0x227f8763, sceNpScoreGetClansRankingByClanIdAsync); REG_FUNC(sceNp, sceNpScoreGetClansRankingByClanIdAsync);
sceNp.AddFunc(0xb082003b, sceNpScoreGetClansRankingByRange); REG_FUNC(sceNp, sceNpScoreGetClansRankingByRange);
sceNp.AddFunc(0x7b7e9137, sceNpScoreGetClansRankingByRangeAsync); REG_FUNC(sceNp, sceNpScoreGetClansRankingByRangeAsync);
sceNp.AddFunc(0x6356082e, sceNpSignalingCreateCtx); REG_FUNC(sceNp, sceNpSignalingCreateCtx);
sceNp.AddFunc(0xa8cf8451, sceNpSignalingDestroyCtx); REG_FUNC(sceNp, sceNpSignalingDestroyCtx);
sceNp.AddFunc(0x50b86d94, sceNpSignalingAddExtendedHandler); REG_FUNC(sceNp, sceNpSignalingAddExtendedHandler);
sceNp.AddFunc(0x276c72b2, sceNpSignalingSetCtxOpt); REG_FUNC(sceNp, sceNpSignalingSetCtxOpt);
sceNp.AddFunc(0x2687a127, sceNpSignalingGetCtxOpt); REG_FUNC(sceNp, sceNpSignalingGetCtxOpt);
sceNp.AddFunc(0x60897c38, sceNpSignalingActivateConnection); REG_FUNC(sceNp, sceNpSignalingActivateConnection);
sceNp.AddFunc(0xfd0eb5ae, sceNpSignalingDeactivateConnection); REG_FUNC(sceNp, sceNpSignalingDeactivateConnection);
sceNp.AddFunc(0x95c7bba3, sceNpSignalingTerminateConnection); REG_FUNC(sceNp, sceNpSignalingTerminateConnection);
sceNp.AddFunc(0xca0a2d04, sceNpSignalingGetConnectionStatus); REG_FUNC(sceNp, sceNpSignalingGetConnectionStatus);
sceNp.AddFunc(0x155de760, sceNpSignalingGetConnectionInfo); REG_FUNC(sceNp, sceNpSignalingGetConnectionInfo);
sceNp.AddFunc(0xe853d388, sceNpSignalingGetConnectionFromNpId); REG_FUNC(sceNp, sceNpSignalingGetConnectionFromNpId);
sceNp.AddFunc(0x34ce82a0, sceNpSignalingGetConnectionFromPeerAddress); REG_FUNC(sceNp, sceNpSignalingGetConnectionFromPeerAddress);
sceNp.AddFunc(0x9ad7fbd1, sceNpSignalingGetLocalNetInfo); REG_FUNC(sceNp, sceNpSignalingGetLocalNetInfo);
sceNp.AddFunc(0x75eb50cb, sceNpSignalingGetPeerNetInfo); REG_FUNC(sceNp, sceNpSignalingGetPeerNetInfo);
sceNp.AddFunc(0x64dbb89d, sceNpSignalingCancelPeerNetInfo); REG_FUNC(sceNp, sceNpSignalingCancelPeerNetInfo);
sceNp.AddFunc(0xd0958814, sceNpSignalingGetPeerNetInfoResult); REG_FUNC(sceNp, sceNpSignalingGetPeerNetInfoResult);
sceNp.AddFunc(0xd208f91d, sceNpUtilCmpNpId); REG_FUNC(sceNp, sceNpUtilCmpNpId);
sceNp.AddFunc(0xf5ff5f31, sceNpUtilCmpNpIdInOrder); REG_FUNC(sceNp, sceNpUtilCmpNpIdInOrder);
sceNp.AddFunc(0xc880f37d, sceNpUtilBandwidthTestGetStatus); REG_FUNC(sceNp, sceNpUtilBandwidthTestGetStatus);
sceNp.AddFunc(0xc99ee313, sceNpUtilBandwidthTestAbort); REG_FUNC(sceNp, sceNpUtilBandwidthTestAbort);
sceNp.AddFunc(0xee0cc40c, _sceNpSysutilClientMalloc); REG_FUNC(sceNp, _sceNpSysutilClientMalloc);
sceNp.AddFunc(0x816c6a5f, _sceNpSysutilClientFree); REG_FUNC(sceNp, _sceNpSysutilClientFree);
}); });

78
rpcs3/Emu/SysCalls/Modules/sceNpClans.cpp
View File

@ -434,43 +434,43 @@ void sceNpClans_unload()
Module sceNpClans("sceNpClans", []() Module sceNpClans("sceNpClans", []()
{ {
sceNpClans.AddFunc(0x9b820047, sceNpClansInit); REG_FUNC(sceNpClans, sceNpClansInit);
sceNpClans.AddFunc(0x42332cb7, sceNpClansTerm); REG_FUNC(sceNpClans, sceNpClansTerm);
sceNpClans.AddFunc(0x9a72232d, sceNpClansCreateRequest); REG_FUNC(sceNpClans, sceNpClansCreateRequest);
sceNpClans.AddFunc(0xd6551cd1, sceNpClansDestroyRequest); REG_FUNC(sceNpClans, sceNpClansDestroyRequest);
sceNpClans.AddFunc(0xe82969e2, sceNpClansAbortRequest); REG_FUNC(sceNpClans, sceNpClansAbortRequest);
sceNpClans.AddFunc(0xa6a31a38, sceNpClansCreateClan); REG_FUNC(sceNpClans, sceNpClansCreateClan);
sceNpClans.AddFunc(0x4826f6d5, sceNpClansDisbandClan); REG_FUNC(sceNpClans, sceNpClansDisbandClan);
sceNpClans.AddFunc(0xca4181b4, sceNpClansGetClanList); REG_FUNC(sceNpClans, sceNpClansGetClanList);
sceNpClans.AddFunc(0x672399a8, sceNpClansGetClanListByNpId); REG_FUNC(sceNpClans, sceNpClansGetClanListByNpId);
sceNpClans.AddFunc(0x1221a1bf, sceNpClansSearchByProfile); REG_FUNC(sceNpClans, sceNpClansSearchByProfile);
sceNpClans.AddFunc(0xace0cfba, sceNpClansSearchByName); REG_FUNC(sceNpClans, sceNpClansSearchByName);
sceNpClans.AddFunc(0x487de998, sceNpClansGetClanInfo); REG_FUNC(sceNpClans, sceNpClansGetClanInfo);
sceNpClans.AddFunc(0x09f9e1a9, sceNpClansUpdateClanInfo); REG_FUNC(sceNpClans, sceNpClansUpdateClanInfo);
sceNpClans.AddFunc(0x856ff5c0, sceNpClansGetMemberList); REG_FUNC(sceNpClans, sceNpClansGetMemberList);
sceNpClans.AddFunc(0x20472da0, sceNpClansGetMemberInfo); REG_FUNC(sceNpClans, sceNpClansGetMemberInfo);
sceNpClans.AddFunc(0xf4a2d52b, sceNpClansUpdateMemberInfo); REG_FUNC(sceNpClans, sceNpClansUpdateMemberInfo);
sceNpClans.AddFunc(0x9cac2085, sceNpClansChangeMemberRole); REG_FUNC(sceNpClans, sceNpClansChangeMemberRole);
sceNpClans.AddFunc(0x38dadf1f, sceNpClansGetAutoAcceptStatus); REG_FUNC(sceNpClans, sceNpClansGetAutoAcceptStatus);
sceNpClans.AddFunc(0x5da94854, sceNpClansUpdateAutoAcceptStatus); REG_FUNC(sceNpClans, sceNpClansUpdateAutoAcceptStatus);
sceNpClans.AddFunc(0xdbf300ca, sceNpClansJoinClan); REG_FUNC(sceNpClans, sceNpClansJoinClan);
sceNpClans.AddFunc(0x560f717b, sceNpClansLeaveClan); REG_FUNC(sceNpClans, sceNpClansLeaveClan);
sceNpClans.AddFunc(0xaa7912b5, sceNpClansKickMember); REG_FUNC(sceNpClans, sceNpClansKickMember);
sceNpClans.AddFunc(0xbc05ef31, sceNpClansSendInvitation); REG_FUNC(sceNpClans, sceNpClansSendInvitation);
sceNpClans.AddFunc(0x726dffd5, sceNpClansCancelInvitation); REG_FUNC(sceNpClans, sceNpClansCancelInvitation);
sceNpClans.AddFunc(0x095e12c6, sceNpClansSendInvitationResponse); REG_FUNC(sceNpClans, sceNpClansSendInvitationResponse);
sceNpClans.AddFunc(0x59743b2b, sceNpClansSendMembershipRequest); REG_FUNC(sceNpClans, sceNpClansSendMembershipRequest);
sceNpClans.AddFunc(0x299ccc9b, sceNpClansCancelMembershipRequest); REG_FUNC(sceNpClans, sceNpClansCancelMembershipRequest);
sceNpClans.AddFunc(0x942dbdc4, sceNpClansSendMembershipResponse); REG_FUNC(sceNpClans, sceNpClansSendMembershipResponse);
sceNpClans.AddFunc(0x56bc5a7c, sceNpClansGetBlacklist); REG_FUNC(sceNpClans, sceNpClansGetBlacklist);
sceNpClans.AddFunc(0x4d06aef7, sceNpClansAddBlacklistEntry); REG_FUNC(sceNpClans, sceNpClansAddBlacklistEntry);
sceNpClans.AddFunc(0x5bff9da1, sceNpClansRemoveBlacklistEntry); REG_FUNC(sceNpClans, sceNpClansRemoveBlacklistEntry);
sceNpClans.AddFunc(0x727aa7f8, sceNpClansRetrieveAnnouncements); REG_FUNC(sceNpClans, sceNpClansRetrieveAnnouncements);
sceNpClans.AddFunc(0xada45b84, sceNpClansPostAnnouncement); REG_FUNC(sceNpClans, sceNpClansPostAnnouncement);
sceNpClans.AddFunc(0xe2590f60, sceNpClansRemoveAnnouncement); REG_FUNC(sceNpClans, sceNpClansRemoveAnnouncement);
sceNpClans.AddFunc(0x83d65529, sceNpClansPostChallenge); REG_FUNC(sceNpClans, sceNpClansPostChallenge);
sceNpClans.AddFunc(0x8e785b97, sceNpClansRetrievePostedChallenges); REG_FUNC(sceNpClans, sceNpClansRetrievePostedChallenges);
sceNpClans.AddFunc(0xd3346dc4, sceNpClansRemovePostedChallenge); REG_FUNC(sceNpClans, sceNpClansRemovePostedChallenge);
sceNpClans.AddFunc(0x0df25834, sceNpClansRetrieveChallenges); REG_FUNC(sceNpClans, sceNpClansRetrieveChallenges);
sceNpClans.AddFunc(0xce6dc0f0, sceNpClansRemoveChallenge); REG_FUNC(sceNpClans, sceNpClansRemoveChallenge);
}); });

94
rpcs3/Emu/SysCalls/Modules/sceNpCommerce2.cpp
View File

@ -319,51 +319,51 @@ void sceNpCommerce2_unload()
Module sceNpCommerce2("sceNpCommerce2", []() Module sceNpCommerce2("sceNpCommerce2", []()
{ {
sceNpCommerce2.AddFunc(0xeef51be0, sceNpCommerce2ExecuteStoreBrowse); REG_FUNC(sceNpCommerce2, sceNpCommerce2ExecuteStoreBrowse);
sceNpCommerce2.AddFunc(0x1fa1b312, sceNpCommerce2GetStoreBrowseUserdata); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetStoreBrowseUserdata);
sceNpCommerce2.AddFunc(0x3539d233, sceNpCommerce2Init); REG_FUNC(sceNpCommerce2, sceNpCommerce2Init);
sceNpCommerce2.AddFunc(0x4d4a094c, sceNpCommerce2Term); REG_FUNC(sceNpCommerce2, sceNpCommerce2Term);
sceNpCommerce2.AddFunc(0xd9fdcec2, sceNpCommerce2CreateCtx); REG_FUNC(sceNpCommerce2, sceNpCommerce2CreateCtx);
sceNpCommerce2.AddFunc(0x6f67ea80, sceNpCommerce2DestroyCtx); REG_FUNC(sceNpCommerce2, sceNpCommerce2DestroyCtx);
sceNpCommerce2.AddFunc(0xcc18cd2c, sceNpCommerce2CreateSessionStart); REG_FUNC(sceNpCommerce2, sceNpCommerce2CreateSessionStart);
sceNpCommerce2.AddFunc(0x62023e98, sceNpCommerce2CreateSessionAbort); REG_FUNC(sceNpCommerce2, sceNpCommerce2CreateSessionAbort);
sceNpCommerce2.AddFunc(0x91f8843d, sceNpCommerce2CreateSessionFinish); REG_FUNC(sceNpCommerce2, sceNpCommerce2CreateSessionFinish);
sceNpCommerce2.AddFunc(0x7370d8d0, sceNpCommerce2GetCategoryContentsCreateReq); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetCategoryContentsCreateReq);
sceNpCommerce2.AddFunc(0x371a2edd, sceNpCommerce2GetCategoryContentsStart); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetCategoryContentsStart);
sceNpCommerce2.AddFunc(0xca0ea996, sceNpCommerce2GetCategoryContentsGetResult); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetCategoryContentsGetResult);
sceNpCommerce2.AddFunc(0xd8a473a3, sceNpCommerce2InitGetCategoryContentsResult); REG_FUNC(sceNpCommerce2, sceNpCommerce2InitGetCategoryContentsResult);
sceNpCommerce2.AddFunc(0xbd49eab2, sceNpCommerce2GetCategoryInfo); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetCategoryInfo);
sceNpCommerce2.AddFunc(0x972ab46c, sceNpCommerce2GetContentInfo); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetContentInfo);
sceNpCommerce2.AddFunc(0xfc216890, sceNpCommerce2GetCategoryInfoFromContentInfo); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetCategoryInfoFromContentInfo);
sceNpCommerce2.AddFunc(0xe51a4944, sceNpCommerce2GetGameProductInfoFromContentInfo); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetGameProductInfoFromContentInfo);
sceNpCommerce2.AddFunc(0x9d9cb96b, sceNpCommerce2DestroyGetCategoryContentsResult); REG_FUNC(sceNpCommerce2, sceNpCommerce2DestroyGetCategoryContentsResult);
sceNpCommerce2.AddFunc(0xa975ebb4, sceNpCommerce2GetProductInfoCreateReq); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetProductInfoCreateReq);
sceNpCommerce2.AddFunc(0x8f46325b, sceNpCommerce2GetProductInfoStart); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetProductInfoStart);
sceNpCommerce2.AddFunc(0xbf5f58ea, sceNpCommerce2GetProductInfoGetResult); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetProductInfoGetResult);
sceNpCommerce2.AddFunc(0xf798f5e3, sceNpCommerce2InitGetProductInfoResult); REG_FUNC(sceNpCommerce2, sceNpCommerce2InitGetProductInfoResult);
sceNpCommerce2.AddFunc(0xef645654, sceNpCommerce2GetGameProductInfo); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetGameProductInfo);
sceNpCommerce2.AddFunc(0xef8eafcd, sceNpCommerce2DestroyGetProductInfoResult); REG_FUNC(sceNpCommerce2, sceNpCommerce2DestroyGetProductInfoResult);
sceNpCommerce2.AddFunc(0xe1e7b5ac, sceNpCommerce2GetProductInfoListCreateReq); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetProductInfoListCreateReq);
sceNpCommerce2.AddFunc(0x9cde07cc, sceNpCommerce2GetProductInfoListStart); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetProductInfoListStart);
sceNpCommerce2.AddFunc(0x146618df, sceNpCommerce2GetProductInfoListGetResult); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetProductInfoListGetResult);
sceNpCommerce2.AddFunc(0xe0f90e44, sceNpCommerce2InitGetProductInfoListResult); REG_FUNC(sceNpCommerce2, sceNpCommerce2InitGetProductInfoListResult);
sceNpCommerce2.AddFunc(0xd9956ce7, sceNpCommerce2GetGameProductInfoFromGetProductInfoListResult); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetGameProductInfoFromGetProductInfoListResult);
sceNpCommerce2.AddFunc(0xf6139b58, sceNpCommerce2DestroyGetProductInfoListResult); REG_FUNC(sceNpCommerce2, sceNpCommerce2DestroyGetProductInfoListResult);
sceNpCommerce2.AddFunc(0xec324c8f, sceNpCommerce2GetContentRatingInfoFromGameProductInfo); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetContentRatingInfoFromGameProductInfo);
sceNpCommerce2.AddFunc(0xac78c1f3, sceNpCommerce2GetContentRatingInfoFromCategoryInfo); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetContentRatingInfoFromCategoryInfo);
sceNpCommerce2.AddFunc(0x150fdca3, sceNpCommerce2GetContentRatingDescriptor); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetContentRatingDescriptor);
sceNpCommerce2.AddFunc(0xdb19194c, sceNpCommerce2GetGameSkuInfoFromGameProductInfo); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetGameSkuInfoFromGameProductInfo);
sceNpCommerce2.AddFunc(0xda8e322d, sceNpCommerce2GetPrice); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetPrice);
sceNpCommerce2.AddFunc(0x104551a6, sceNpCommerce2DoCheckoutStartAsync); REG_FUNC(sceNpCommerce2, sceNpCommerce2DoCheckoutStartAsync);
sceNpCommerce2.AddFunc(0xd43a130e, sceNpCommerce2DoCheckoutFinishAsync); REG_FUNC(sceNpCommerce2, sceNpCommerce2DoCheckoutFinishAsync);
sceNpCommerce2.AddFunc(0x9825a0fc, sceNpCommerce2DoProductBrowseStartAsync); REG_FUNC(sceNpCommerce2, sceNpCommerce2DoProductBrowseStartAsync);
sceNpCommerce2.AddFunc(0xb23e3bd1, sceNpCommerce2DoProductBrowseFinishAsync); REG_FUNC(sceNpCommerce2, sceNpCommerce2DoProductBrowseFinishAsync);
sceNpCommerce2.AddFunc(0x6ca9efd4, sceNpCommerce2DoDlListStartAsync); REG_FUNC(sceNpCommerce2, sceNpCommerce2DoDlListStartAsync);
sceNpCommerce2.AddFunc(0x410d42be, sceNpCommerce2DoDlListFinishAsync); REG_FUNC(sceNpCommerce2, sceNpCommerce2DoDlListFinishAsync);
sceNpCommerce2.AddFunc(0xde7ab33d, sceNpCommerce2DoProductCodeStartAsync); REG_FUNC(sceNpCommerce2, sceNpCommerce2DoProductCodeStartAsync);
sceNpCommerce2.AddFunc(0xa9f945b3, sceNpCommerce2DoProductCodeFinishAsync); REG_FUNC(sceNpCommerce2, sceNpCommerce2DoProductCodeFinishAsync);
sceNpCommerce2.AddFunc(0x3d627d81, sceNpCommerce2GetBGDLAvailability); REG_FUNC(sceNpCommerce2, sceNpCommerce2GetBGDLAvailability);
sceNpCommerce2.AddFunc(0xa5a863fe, sceNpCommerce2SetBGDLAvailability); REG_FUNC(sceNpCommerce2, sceNpCommerce2SetBGDLAvailability);
sceNpCommerce2.AddFunc(0x8df0057f, sceNpCommerce2AbortReq); REG_FUNC(sceNpCommerce2, sceNpCommerce2AbortReq);
sceNpCommerce2.AddFunc(0x2a910f05, sceNpCommerce2DestroyReq); REG_FUNC(sceNpCommerce2, sceNpCommerce2DestroyReq);
}); });

34
rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
View File

@ -455,21 +455,21 @@ void sceNpTrophy_unload()
Module sceNpTrophy("sceNpTrophy", []() Module sceNpTrophy("sceNpTrophy", []()
{ {
sceNpTrophy.AddFunc(0x079f0e87, sceNpTrophyGetGameProgress); REG_FUNC(sceNpTrophy, sceNpTrophyGetGameProgress);
sceNpTrophy.AddFunc(0x1197b52c, sceNpTrophyRegisterContext); REG_FUNC(sceNpTrophy, sceNpTrophyRegisterContext);
sceNpTrophy.AddFunc(0x1c25470d, sceNpTrophyCreateHandle); REG_FUNC(sceNpTrophy, sceNpTrophyCreateHandle);
sceNpTrophy.AddFunc(0x27deda93, sceNpTrophySetSoundLevel); REG_FUNC(sceNpTrophy, sceNpTrophySetSoundLevel);
sceNpTrophy.AddFunc(0x370136fe, sceNpTrophyGetRequiredDiskSpace); REG_FUNC(sceNpTrophy, sceNpTrophyGetRequiredDiskSpace);
sceNpTrophy.AddFunc(0x3741ecc7, sceNpTrophyDestroyContext); REG_FUNC(sceNpTrophy, sceNpTrophyDestroyContext);
sceNpTrophy.AddFunc(0x39567781, sceNpTrophyInit); REG_FUNC(sceNpTrophy, sceNpTrophyInit);
sceNpTrophy.AddFunc(0x48bd97c7, sceNpTrophyAbortHandle); REG_FUNC(sceNpTrophy, sceNpTrophyAbortHandle);
sceNpTrophy.AddFunc(0x49d18217, sceNpTrophyGetGameInfo); REG_FUNC(sceNpTrophy, sceNpTrophyGetGameInfo);
sceNpTrophy.AddFunc(0x623cd2dc, sceNpTrophyDestroyHandle); REG_FUNC(sceNpTrophy, sceNpTrophyDestroyHandle);
sceNpTrophy.AddFunc(0x8ceedd21, sceNpTrophyUnlockTrophy); REG_FUNC(sceNpTrophy, sceNpTrophyUnlockTrophy);
sceNpTrophy.AddFunc(0xa7fabf4d, sceNpTrophyTerm); REG_FUNC(sceNpTrophy, sceNpTrophyTerm);
sceNpTrophy.AddFunc(0xb3ac3478, sceNpTrophyGetTrophyUnlockState); REG_FUNC(sceNpTrophy, sceNpTrophyGetTrophyUnlockState);
sceNpTrophy.AddFunc(0xbaedf689, sceNpTrophyGetTrophyIcon); REG_FUNC(sceNpTrophy, sceNpTrophyGetTrophyIcon);
sceNpTrophy.AddFunc(0xe3bf9a28, sceNpTrophyCreateContext); REG_FUNC(sceNpTrophy, sceNpTrophyCreateContext);
sceNpTrophy.AddFunc(0xfce6d30a, sceNpTrophyGetTrophyInfo); REG_FUNC(sceNpTrophy, sceNpTrophyGetTrophyInfo);
sceNpTrophy.AddFunc(0xff299e03, sceNpTrophyGetGameIcon); REG_FUNC(sceNpTrophy, sceNpTrophyGetGameIcon);
}); });

108
rpcs3/Emu/SysCalls/Modules/sceNpTus.cpp
View File

@ -570,58 +570,58 @@ void sceNpTus_unload()
Module sceNpTus("sceNpTus", []() Module sceNpTus("sceNpTus", []()
{ {
sceNpTus.AddFunc(0x8f87a06b, sceNpTusInit); REG_FUNC(sceNpTus, sceNpTusInit);
sceNpTus.AddFunc(0x225aed26, sceNpTusTerm); REG_FUNC(sceNpTus, sceNpTusTerm);
sceNpTus.AddFunc(0x7caf58ee, sceNpTusCreateTitleCtx); REG_FUNC(sceNpTus, sceNpTusCreateTitleCtx);
sceNpTus.AddFunc(0x2e162a62, sceNpTusDestroyTitleCtx); REG_FUNC(sceNpTus, sceNpTusDestroyTitleCtx);
sceNpTus.AddFunc(0x1904435e, sceNpTusCreateTransactionCtx); REG_FUNC(sceNpTus, sceNpTusCreateTransactionCtx);
sceNpTus.AddFunc(0x44eca8b4, sceNpTusDestroyTransactionCtx); REG_FUNC(sceNpTus, sceNpTusDestroyTransactionCtx);
sceNpTus.AddFunc(0x59432970, sceNpTusSetTimeout); REG_FUNC(sceNpTus, sceNpTusSetTimeout);
sceNpTus.AddFunc(0x325c6284, sceNpTusAbortTransaction); REG_FUNC(sceNpTus, sceNpTusAbortTransaction);
sceNpTus.AddFunc(0xb8e8ff22, sceNpTusWaitAsync); REG_FUNC(sceNpTus, sceNpTusWaitAsync);
sceNpTus.AddFunc(0x19bce18c, sceNpTusPollAsync); REG_FUNC(sceNpTus, sceNpTusPollAsync);
sceNpTus.AddFunc(0xcc86a8f6, sceNpTusSetMultiSlotVariable); REG_FUNC(sceNpTus, sceNpTusSetMultiSlotVariable);
sceNpTus.AddFunc(0xf819be91, sceNpTusSetMultiSlotVariableVUser); REG_FUNC(sceNpTus, sceNpTusSetMultiSlotVariableVUser);
sceNpTus.AddFunc(0x065b610d, sceNpTusSetMultiSlotVariableAsync); REG_FUNC(sceNpTus, sceNpTusSetMultiSlotVariableAsync);
sceNpTus.AddFunc(0x96a06212, sceNpTusSetMultiSlotVariableVUserAsync); REG_FUNC(sceNpTus, sceNpTusSetMultiSlotVariableVUserAsync);
sceNpTus.AddFunc(0x0423e622, sceNpTusGetMultiSlotVariable); REG_FUNC(sceNpTus, sceNpTusGetMultiSlotVariable);
sceNpTus.AddFunc(0x2357ba9e, sceNpTusGetMultiSlotVariableVUser); REG_FUNC(sceNpTus, sceNpTusGetMultiSlotVariableVUser);
sceNpTus.AddFunc(0xbb2877f2, sceNpTusGetMultiSlotVariableAsync); REG_FUNC(sceNpTus, sceNpTusGetMultiSlotVariableAsync);
sceNpTus.AddFunc(0xfc7d346e, sceNpTusGetMultiSlotVariableVUserAsync); REG_FUNC(sceNpTus, sceNpTusGetMultiSlotVariableVUserAsync);
sceNpTus.AddFunc(0x0d15043b, sceNpTusGetMultiUserVariable); REG_FUNC(sceNpTus, sceNpTusGetMultiUserVariable);
sceNpTus.AddFunc(0x6c511024, sceNpTusGetMultiUserVariableVUser); REG_FUNC(sceNpTus, sceNpTusGetMultiUserVariableVUser);
sceNpTus.AddFunc(0xcc7a31cd, sceNpTusGetMultiUserVariableAsync); REG_FUNC(sceNpTus, sceNpTusGetMultiUserVariableAsync);
sceNpTus.AddFunc(0x9549d22c, sceNpTusGetMultiUserVariableVUserAsync); REG_FUNC(sceNpTus, sceNpTusGetMultiUserVariableVUserAsync);
sceNpTus.AddFunc(0x94989003, sceNpTusAddAndGetVariable); REG_FUNC(sceNpTus, sceNpTusAddAndGetVariable);
sceNpTus.AddFunc(0xf60be06f, sceNpTusAddAndGetVariableVUser); REG_FUNC(sceNpTus, sceNpTusAddAndGetVariableVUser);
sceNpTus.AddFunc(0x1fa5c87d, sceNpTusAddAndGetVariableAsync); REG_FUNC(sceNpTus, sceNpTusAddAndGetVariableAsync);
sceNpTus.AddFunc(0xa7993bf3, sceNpTusAddAndGetVariableVUserAsync); REG_FUNC(sceNpTus, sceNpTusAddAndGetVariableVUserAsync);
sceNpTus.AddFunc(0x47e9424a, sceNpTusTryAndSetVariable); REG_FUNC(sceNpTus, sceNpTusTryAndSetVariable);
sceNpTus.AddFunc(0x3602bc80, sceNpTusTryAndSetVariableVUser); REG_FUNC(sceNpTus, sceNpTusTryAndSetVariableVUser);
sceNpTus.AddFunc(0xbbb244b7, sceNpTusTryAndSetVariableAsync); REG_FUNC(sceNpTus, sceNpTusTryAndSetVariableAsync);
sceNpTus.AddFunc(0x17db7aa7, sceNpTusTryAndSetVariableVUserAsync); REG_FUNC(sceNpTus, sceNpTusTryAndSetVariableVUserAsync);
sceNpTus.AddFunc(0xaf985783, sceNpTusDeleteMultiSlotVariable); REG_FUNC(sceNpTus, sceNpTusDeleteMultiSlotVariable);
sceNpTus.AddFunc(0xc4e51fbf, sceNpTusDeleteMultiSlotVariableVUser); REG_FUNC(sceNpTus, sceNpTusDeleteMultiSlotVariableVUser);
sceNpTus.AddFunc(0xf5363608, sceNpTusDeleteMultiSlotVariableAsync); REG_FUNC(sceNpTus, sceNpTusDeleteMultiSlotVariableAsync);
sceNpTus.AddFunc(0xc2e18da8, sceNpTusDeleteMultiSlotVariableVUserAsync); REG_FUNC(sceNpTus, sceNpTusDeleteMultiSlotVariableVUserAsync);
sceNpTus.AddFunc(0x7d5f0f0e, sceNpTusSetData); REG_FUNC(sceNpTus, sceNpTusSetData);
sceNpTus.AddFunc(0x0835deb2, sceNpTusSetDataVUser); REG_FUNC(sceNpTus, sceNpTusSetDataVUser);
sceNpTus.AddFunc(0xe847341f, sceNpTusSetDataAsync); REG_FUNC(sceNpTus, sceNpTusSetDataAsync);
sceNpTus.AddFunc(0x9cc0cf44, sceNpTusSetDataVUserAsync); REG_FUNC(sceNpTus, sceNpTusSetDataVUserAsync);
sceNpTus.AddFunc(0x8ddd0d85, sceNpTusGetData); REG_FUNC(sceNpTus, sceNpTusGetData);
sceNpTus.AddFunc(0xae4e590e, sceNpTusGetDataVUser); REG_FUNC(sceNpTus, sceNpTusGetDataVUser);
sceNpTus.AddFunc(0x5175abb9, sceNpTusGetDataAsync); REG_FUNC(sceNpTus, sceNpTusGetDataAsync);
sceNpTus.AddFunc(0x38f364b0, sceNpTusGetDataVUserAsync); REG_FUNC(sceNpTus, sceNpTusGetDataVUserAsync);
sceNpTus.AddFunc(0xc848d425, sceNpTusGetMultiSlotDataStatus); REG_FUNC(sceNpTus, sceNpTusGetMultiSlotDataStatus);
sceNpTus.AddFunc(0xa3abfadb, sceNpTusGetMultiSlotDataStatusVUser); REG_FUNC(sceNpTus, sceNpTusGetMultiSlotDataStatusVUser);
sceNpTus.AddFunc(0x651fd79f, sceNpTusGetMultiSlotDataStatusAsync); REG_FUNC(sceNpTus, sceNpTusGetMultiSlotDataStatusAsync);
sceNpTus.AddFunc(0x2ab21ea9, sceNpTusGetMultiSlotDataStatusVUserAsync); REG_FUNC(sceNpTus, sceNpTusGetMultiSlotDataStatusVUserAsync);
sceNpTus.AddFunc(0x348dbcb4, sceNpTusGetMultiUserDataStatus); REG_FUNC(sceNpTus, sceNpTusGetMultiUserDataStatus);
sceNpTus.AddFunc(0x2d1b9f1a, sceNpTusGetMultiUserDataStatusVUser); REG_FUNC(sceNpTus, sceNpTusGetMultiUserDataStatusVUser);
sceNpTus.AddFunc(0xc66ba67e, sceNpTusGetMultiUserDataStatusAsync); REG_FUNC(sceNpTus, sceNpTusGetMultiUserDataStatusAsync);
sceNpTus.AddFunc(0x368fec59, sceNpTusGetMultiUserDataStatusVUserAsync); REG_FUNC(sceNpTus, sceNpTusGetMultiUserDataStatusVUserAsync);
sceNpTus.AddFunc(0xe0719847, sceNpTusDeleteMultiSlotData); REG_FUNC(sceNpTus, sceNpTusDeleteMultiSlotData);
sceNpTus.AddFunc(0x01711e81, sceNpTusDeleteMultiSlotDataVUser); REG_FUNC(sceNpTus, sceNpTusDeleteMultiSlotDataVUser);
sceNpTus.AddFunc(0x3175af23, sceNpTusDeleteMultiSlotDataAsync); REG_FUNC(sceNpTus, sceNpTusDeleteMultiSlotDataAsync);
sceNpTus.AddFunc(0xc815b219, sceNpTusDeleteMultiSlotDataVUserAsync); REG_FUNC(sceNpTus, sceNpTusDeleteMultiSlotDataVUserAsync);
}); });

261
rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
View File

@ -1,4 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/SysCalls/Modules.h" #include "Emu/SysCalls/Modules.h"
@ -87,6 +88,139 @@ void ppu_free_tls(u32 thread)
} }
} }
std::string ps3_fmt(PPUThread& context, vm::ptr<const char> fmt, u32 g_count, u32 f_count, u32 v_count)
{
std::string result;
for (char c = *fmt++; c; c = *fmt++)
{
switch (c)
{
case '%':
{
const auto start = fmt - 1;
// read flags
const bool plus_sign = *fmt == '+' ? fmt++, true : false;
const bool minus_sign = *fmt == '-' ? fmt++, true : false;
const bool space_sign = *fmt == ' ' ? fmt++, true : false;
const bool number_sign = *fmt == '#' ? fmt++, true : false;
const bool zero_padding = *fmt == '0' ? fmt++, true : false;
// read width
const u32 width = [&]() -> u32
{
u32 width = 0;
if (*fmt == '*')
{
fmt++;
return context.get_next_gpr_arg(g_count, f_count, v_count);
}
while (*fmt - '0' < 10)
{
width = width * 10 + (*fmt++ - '0');
}
return width;
}();
// read precision
const u32 prec = [&]() -> u32
{
u32 prec = 0;
if (*fmt != '.')
{
return 0;
}
if (*++fmt == '*')
{
fmt++;
return context.get_next_gpr_arg(g_count, f_count, v_count);
}
while (*fmt - '0' < 10)
{
prec = prec * 10 + (*fmt++ - '0');
}
return prec;
}();
switch (char cf = *fmt++)
{
case '%':
{
if (plus_sign || minus_sign || space_sign || number_sign || zero_padding || width || prec) break;
result += '%';
continue;
}
case 'd':
case 'i':
{
// signed decimal
const s64 value = context.get_next_gpr_arg(g_count, f_count, v_count);
if (plus_sign || minus_sign || space_sign || number_sign || zero_padding || width || prec) break;
result += fmt::to_sdec(value);
continue;
}
case 'x':
case 'X':
{
// hexadecimal
const u64 value = context.get_next_gpr_arg(g_count, f_count, v_count);
if (plus_sign || minus_sign || space_sign || prec) break;
if (number_sign && value)
{
result += cf == 'x' ? "0x" : "0X";
}
const std::string& hex = cf == 'x' ? fmt::to_hex(value) : fmt::toupper(fmt::to_hex(value));
if (hex.length() >= width)
{
result += hex;
}
else if (zero_padding)
{
result += std::string(width - hex.length(), '0') + hex;
}
else
{
result += hex + std::string(width - hex.length(), ' ');
}
continue;
}
case 's':
{
// string
auto string = vm::ptr<const char>::make(context.get_next_gpr_arg(g_count, f_count, v_count));
if (plus_sign || minus_sign || space_sign || number_sign || zero_padding || width || prec) break;
result += string.get_ptr();
continue;
}
}
throw fmt::format("ps3_fmt(): unknown formatting: '%s'", start.get_ptr());
}
}
result += c;
}
return result;
}
int _sys_heap_create_heap(const u32 heap_addr, const u32 align, const u32 size) int _sys_heap_create_heap(const u32 heap_addr, const u32 align, const u32 size)
{ {
sysPrxForUser.Warning("_sys_heap_create_heap(heap_addr=0x%x, align=0x%x, size=0x%x)", heap_addr, align, size); sysPrxForUser.Warning("_sys_heap_create_heap(heap_addr=0x%x, align=0x%x, size=0x%x)", heap_addr, align, size);
@ -393,12 +527,26 @@ s32 _sys_spu_printf_detach_thread(PPUThread& CPU, u32 thread)
return spu_printf_dtcb(CPU, thread); return spu_printf_dtcb(CPU, thread);
} }
s32 _sys_snprintf(vm::ptr<char> dst, u32 count, vm::ptr<const char> fmt) // va_args... s32 _sys_snprintf(PPUThread& CPU, vm::ptr<char> dst, u32 count, vm::ptr<const char> fmt) // va_args...
{ {
sysPrxForUser.Todo("_sys_snprintf(dst_addr=0x%x, count=%d, fmt_addr=0x%x['%s'], ...)", dst.addr(), count, fmt.addr(), fmt.get_ptr()); sysPrxForUser.Warning("_sys_snprintf(dst=0x%x, count=%d, fmt=0x%x, ...)", dst, count, fmt);
Emu.Pause(); std::string result = ps3_fmt(CPU, fmt, 3, 0, 0);
return 0;
sysPrxForUser.Warning("*** '%s' -> '%s'", fmt.get_ptr(), result);
if (!count)
{
return 0; // ???
}
else
{
count = (u32)std::min<size_t>(count - 1, result.size());
memcpy(dst.get_ptr(), result.c_str(), count);
dst[count] = 0;
return count;
}
} }
s32 _sys_printf(vm::ptr<const char> fmt) // va_args... s32 _sys_printf(vm::ptr<const char> fmt) // va_args...
@ -411,7 +559,7 @@ s32 _sys_printf(vm::ptr<const char> fmt) // va_args...
return CELL_OK; return CELL_OK;
} }
s32 _unnamed_E75C40F2(u32 dest) s32 _nid_E75C40F2(u32 dest)
{ {
sysPrxForUser.Todo("Unnamed function 0xE75C40F2 (dest=0x%x) -> CELL_ENOENT", dest); sysPrxForUser.Todo("Unnamed function 0xE75C40F2 (dest=0x%x) -> CELL_ENOENT", dest);
@ -444,66 +592,66 @@ Module sysPrxForUser("sysPrxForUser", []()
REG_FUNC(sysPrxForUser, sys_lwmutex_trylock); REG_FUNC(sysPrxForUser, sys_lwmutex_trylock);
REG_FUNC(sysPrxForUser, sys_lwmutex_unlock); REG_FUNC(sysPrxForUser, sys_lwmutex_unlock);
sysPrxForUser.AddFunc(0x8461e528, sys_time_get_system_time); REG_FUNC(sysPrxForUser, sys_time_get_system_time);
sysPrxForUser.AddFunc(0xe6f2c1e7, sys_process_exit); REG_FUNC(sysPrxForUser, sys_process_exit);
sysPrxForUser.AddFunc(0x2c847572, _sys_process_atexitspawn); REG_FUNC(sysPrxForUser, _sys_process_atexitspawn);
sysPrxForUser.AddFunc(0x96328741, _sys_process_at_Exitspawn); REG_FUNC(sysPrxForUser, _sys_process_at_Exitspawn);
sysPrxForUser.AddFunc(0x4f7172c9, sys_process_is_stack); REG_FUNC(sysPrxForUser, sys_process_is_stack);
sysPrxForUser.AddFunc(0x24a1ea07, sys_ppu_thread_create); REG_FUNC(sysPrxForUser, sys_ppu_thread_create);
sysPrxForUser.AddFunc(0x350d454e, sys_ppu_thread_get_id); REG_FUNC(sysPrxForUser, sys_ppu_thread_get_id);
sysPrxForUser.AddFunc(0xaff080a4, sys_ppu_thread_exit); REG_FUNC(sysPrxForUser, sys_ppu_thread_exit);
sysPrxForUser.AddFunc(0xa3e3be68, sys_ppu_thread_once); REG_FUNC(sysPrxForUser, sys_ppu_thread_once);
sysPrxForUser.AddFunc(0x26090058, sys_prx_load_module); REG_FUNC(sysPrxForUser, sys_prx_load_module);
sysPrxForUser.AddFunc(0x9f18429d, sys_prx_start_module); REG_FUNC(sysPrxForUser, sys_prx_start_module);
sysPrxForUser.AddFunc(0x80fb0c19, sys_prx_stop_module); REG_FUNC(sysPrxForUser, sys_prx_stop_module);
sysPrxForUser.AddFunc(0xf0aece0d, sys_prx_unload_module); REG_FUNC(sysPrxForUser, sys_prx_unload_module);
sysPrxForUser.AddFunc(0x42b23552, sys_prx_register_library); REG_FUNC(sysPrxForUser, sys_prx_register_library);
sysPrxForUser.AddFunc(0xd0ea47a7, sys_prx_unregister_library); REG_FUNC(sysPrxForUser, sys_prx_unregister_library);
sysPrxForUser.AddFunc(0xa5d06bf0, sys_prx_get_module_list); REG_FUNC(sysPrxForUser, sys_prx_get_module_list);
sysPrxForUser.AddFunc(0x84bb6774, sys_prx_get_module_info); REG_FUNC(sysPrxForUser, sys_prx_get_module_info);
sysPrxForUser.AddFunc(0xe0998dbf, sys_prx_get_module_id_by_name); REG_FUNC(sysPrxForUser, sys_prx_get_module_id_by_name);
sysPrxForUser.AddFunc(0xaa6d9bff, sys_prx_load_module_on_memcontainer); REG_FUNC(sysPrxForUser, sys_prx_load_module_on_memcontainer);
sysPrxForUser.AddFunc(0xa2c7ba64, sys_prx_exitspawn_with_level); REG_FUNC(sysPrxForUser, sys_prx_exitspawn_with_level);
sysPrxForUser.AddFunc(0x35168520, _sys_heap_malloc); REG_FUNC(sysPrxForUser, _sys_heap_malloc);
//sysPrxForUser.AddFunc(0xaede4b03, _sys_heap_free); //REG_FUNC(sysPrxForUser, _sys_heap_free);
//sysPrxForUser.AddFunc(0x8a561d92, _sys_heap_delete_heap); //REG_FUNC(sysPrxForUser, _sys_heap_delete_heap);
sysPrxForUser.AddFunc(0xb2fcf2c8, _sys_heap_create_heap); REG_FUNC(sysPrxForUser, _sys_heap_create_heap);
sysPrxForUser.AddFunc(0x44265c08, _sys_heap_memalign); REG_FUNC(sysPrxForUser, _sys_heap_memalign);
sysPrxForUser.AddFunc(0xb257540b, sys_mmapper_allocate_memory); REG_FUNC(sysPrxForUser, sys_mmapper_allocate_memory);
sysPrxForUser.AddFunc(0x70258515, sys_mmapper_allocate_memory_from_container); REG_FUNC(sysPrxForUser, sys_mmapper_allocate_memory_from_container);
sysPrxForUser.AddFunc(0xdc578057, sys_mmapper_map_memory); REG_FUNC(sysPrxForUser, sys_mmapper_map_memory);
sysPrxForUser.AddFunc(0x4643ba6e, sys_mmapper_unmap_memory); REG_FUNC(sysPrxForUser, sys_mmapper_unmap_memory);
sysPrxForUser.AddFunc(0x409ad939, sys_mmapper_free_memory); REG_FUNC(sysPrxForUser, sys_mmapper_free_memory);
sysPrxForUser.AddFunc(0x1ed454ce, sys_spu_elf_get_information); REG_FUNC(sysPrxForUser, sys_spu_elf_get_information);
sysPrxForUser.AddFunc(0xdb6b3250, sys_spu_elf_get_segments); REG_FUNC(sysPrxForUser, sys_spu_elf_get_segments);
sysPrxForUser.AddFunc(0xebe5f72f, sys_spu_image_import); REG_FUNC(sysPrxForUser, sys_spu_image_import);
sysPrxForUser.AddFunc(0xe0da8efd, sys_spu_image_close); REG_FUNC(sysPrxForUser, sys_spu_image_close);
sysPrxForUser.AddFunc(0x893305fa, sys_raw_spu_load); REG_FUNC(sysPrxForUser, sys_raw_spu_load);
sysPrxForUser.AddFunc(0xb995662e, sys_raw_spu_image_load); REG_FUNC(sysPrxForUser, sys_raw_spu_image_load);
sysPrxForUser.AddFunc(0xda0eb71a, sys_lwcond_create); REG_FUNC(sysPrxForUser, sys_lwcond_create);
sysPrxForUser.AddFunc(0x1c9a942c, sys_lwcond_destroy); REG_FUNC(sysPrxForUser, sys_lwcond_destroy);
sysPrxForUser.AddFunc(0xef87a695, sys_lwcond_signal); REG_FUNC(sysPrxForUser, sys_lwcond_signal);
sysPrxForUser.AddFunc(0xe9a1bd84, sys_lwcond_signal_all); REG_FUNC(sysPrxForUser, sys_lwcond_signal_all);
sysPrxForUser.AddFunc(0x52aadadf, sys_lwcond_signal_to); REG_FUNC(sysPrxForUser, sys_lwcond_signal_to);
sysPrxForUser.AddFunc(0x2a6d9d51, sys_lwcond_wait); REG_FUNC(sysPrxForUser, sys_lwcond_wait);
sysPrxForUser.AddFunc(0x71a8472a, sys_get_random_number); REG_FUNC(sysPrxForUser, sys_get_random_number);
sysPrxForUser.AddFunc(0x8c2bb498, sys_spinlock_initialize); REG_FUNC(sysPrxForUser, sys_spinlock_initialize);
sysPrxForUser.AddFunc(0xa285139d, sys_spinlock_lock); REG_FUNC(sysPrxForUser, sys_spinlock_lock);
sysPrxForUser.AddFunc(0x722a0254, sys_spinlock_trylock); REG_FUNC(sysPrxForUser, sys_spinlock_trylock);
sysPrxForUser.AddFunc(0x5267cb35, sys_spinlock_unlock); REG_FUNC(sysPrxForUser, sys_spinlock_unlock);
sysPrxForUser.AddFunc(0x67f9fedb, sys_game_process_exitspawn2); REG_FUNC(sysPrxForUser, sys_game_process_exitspawn2);
sysPrxForUser.AddFunc(0xfc52a7a9, sys_game_process_exitspawn); REG_FUNC(sysPrxForUser, sys_game_process_exitspawn);
REG_FUNC(sysPrxForUser, _sys_memset); REG_FUNC(sysPrxForUser, _sys_memset);
REG_FUNC(sysPrxForUser, _sys_memcpy); REG_FUNC(sysPrxForUser, _sys_memcpy);
@ -525,5 +673,6 @@ Module sysPrxForUser("sysPrxForUser", []()
REG_FUNC(sysPrxForUser, _sys_snprintf); REG_FUNC(sysPrxForUser, _sys_snprintf);
REG_FUNC(sysPrxForUser, _sys_printf); REG_FUNC(sysPrxForUser, _sys_printf);
sysPrxForUser.AddFunc(0xe75c40f2, _unnamed_E75C40F2); // real name is unknown
}); REG_UNNAMED(sysPrxForUser, E75C40F2);
});

194
rpcs3/Emu/SysCalls/Modules/sys_http.cpp
View File

@ -590,115 +590,115 @@ void sys_http_init()
{ {
// (TODO: Find addresses for cellHttpClientSetSendBufferSize and cellHttpClientGetSendBufferSize) // (TODO: Find addresses for cellHttpClientSetSendBufferSize and cellHttpClientGetSendBufferSize)
sys_http.AddFunc(0x250c386c, cellHttpInit); REG_FUNC(sys_http, cellHttpInit);
sys_http.AddFunc(0xd276ff1f, cellHttpEnd); REG_FUNC(sys_http, cellHttpEnd);
sys_http.AddFunc(0x522180bc, cellHttpsInit); REG_FUNC(sys_http, cellHttpsInit);
sys_http.AddFunc(0xe6d4202f, cellHttpsEnd); REG_FUNC(sys_http, cellHttpsEnd);
sys_http.AddFunc(0x0d896b97, cellHttpSetProxy); REG_FUNC(sys_http, cellHttpSetProxy);
sys_http.AddFunc(0x2a87603a, cellHttpGetProxy); REG_FUNC(sys_http, cellHttpGetProxy);
sys_http.AddFunc(0x9638f766, cellHttpInitCookie); REG_FUNC(sys_http, cellHttpInitCookie);
sys_http.AddFunc(0x61b2bade, cellHttpEndCookie); REG_FUNC(sys_http, cellHttpEndCookie);
sys_http.AddFunc(0x1b5bdcc6, cellHttpAddCookieWithClientId); REG_FUNC(sys_http, cellHttpAddCookieWithClientId);
sys_http.AddFunc(0xad6a2e5b, cellHttpSessionCookieFlush); REG_FUNC(sys_http, cellHttpSessionCookieFlush);
sys_http.AddFunc(0xf972c733, cellHttpCookieExportWithClientId); REG_FUNC(sys_http, cellHttpCookieExportWithClientId);
sys_http.AddFunc(0x0d846d63, cellHttpCookieImportWithClientId); REG_FUNC(sys_http, cellHttpCookieImportWithClientId);
sys_http.AddFunc(0x4d915204, cellHttpClientSetCookieSendCallback); REG_FUNC(sys_http, cellHttpClientSetCookieSendCallback);
sys_http.AddFunc(0x13fe767b, cellHttpClientSetCookieRecvCallback); REG_FUNC(sys_http, cellHttpClientSetCookieRecvCallback);
sys_http.AddFunc(0x4e4ee53a, cellHttpCreateClient); REG_FUNC(sys_http, cellHttpCreateClient);
sys_http.AddFunc(0x980855ac, cellHttpDestroyClient); REG_FUNC(sys_http, cellHttpDestroyClient);
sys_http.AddFunc(0x660d42a9, cellHttpClientSetAuthenticationCallback); REG_FUNC(sys_http, cellHttpClientSetAuthenticationCallback);
sys_http.AddFunc(0xb6feb84b, cellHttpClientSetTransactionStateCallback); REG_FUNC(sys_http, cellHttpClientSetTransactionStateCallback);
sys_http.AddFunc(0x473cd9f1, cellHttpClientSetRedirectCallback); REG_FUNC(sys_http, cellHttpClientSetRedirectCallback);
sys_http.AddFunc(0xd7d3cd5d, cellHttpClientSetProxy); REG_FUNC(sys_http, cellHttpClientSetProxy);
sys_http.AddFunc(0x4d40cf98, cellHttpClientGetProxy); REG_FUNC(sys_http, cellHttpClientGetProxy);
sys_http.AddFunc(0x40547d8b, cellHttpClientSetVersion); REG_FUNC(sys_http, cellHttpClientSetVersion);
sys_http.AddFunc(0xdc405507, cellHttpClientGetVersion); REG_FUNC(sys_http, cellHttpClientGetVersion);
sys_http.AddFunc(0x296a46cf, cellHttpClientSetPipeline); REG_FUNC(sys_http, cellHttpClientSetPipeline);
sys_http.AddFunc(0x2a1f28f6, cellHttpClientGetPipeline); REG_FUNC(sys_http, cellHttpClientGetPipeline);
sys_http.AddFunc(0x5d473170, cellHttpClientSetKeepAlive); REG_FUNC(sys_http, cellHttpClientSetKeepAlive);
sys_http.AddFunc(0x591c21a8, cellHttpClientGetKeepAlive); REG_FUNC(sys_http, cellHttpClientGetKeepAlive);
sys_http.AddFunc(0x211d8ba3, cellHttpClientSetAutoRedirect); REG_FUNC(sys_http, cellHttpClientSetAutoRedirect);
sys_http.AddFunc(0x2960e309, cellHttpClientGetAutoRedirect); REG_FUNC(sys_http, cellHttpClientGetAutoRedirect);
sys_http.AddFunc(0x8eaf47a3, cellHttpClientSetAutoAuthentication); REG_FUNC(sys_http, cellHttpClientSetAutoAuthentication);
sys_http.AddFunc(0x5980a293, cellHttpClientGetAutoAuthentication); REG_FUNC(sys_http, cellHttpClientGetAutoAuthentication);
sys_http.AddFunc(0x6eed4999, cellHttpClientSetAuthenticationCacheStatus); REG_FUNC(sys_http, cellHttpClientSetAuthenticationCacheStatus);
sys_http.AddFunc(0xfce39343, cellHttpClientGetAuthenticationCacheStatus); REG_FUNC(sys_http, cellHttpClientGetAuthenticationCacheStatus);
sys_http.AddFunc(0x434419c8, cellHttpClientSetCookieStatus); REG_FUNC(sys_http, cellHttpClientSetCookieStatus);
sys_http.AddFunc(0xeb9c1e5e, cellHttpClientGetCookieStatus); REG_FUNC(sys_http, cellHttpClientGetCookieStatus);
sys_http.AddFunc(0xcac9fc34, cellHttpClientSetUserAgent); REG_FUNC(sys_http, cellHttpClientSetUserAgent);
sys_http.AddFunc(0xee05b0c1, cellHttpClientGetUserAgent); REG_FUNC(sys_http, cellHttpClientGetUserAgent);
sys_http.AddFunc(0xadd66b5c, cellHttpClientSetResponseBufferMax); REG_FUNC(sys_http, cellHttpClientSetResponseBufferMax);
sys_http.AddFunc(0x6884cdb7, cellHttpClientGetResponseBufferMax); REG_FUNC(sys_http, cellHttpClientGetResponseBufferMax);
sys_http.AddFunc(0x2033b878, cellHttpClientCloseAllConnections); REG_FUNC(sys_http, cellHttpClientCloseAllConnections);
sys_http.AddFunc(0x27f86d70, cellHttpClientCloseConnections); REG_FUNC(sys_http, cellHttpClientCloseConnections);
sys_http.AddFunc(0xadc0a4b2, cellHttpClientPollConnections); REG_FUNC(sys_http, cellHttpClientPollConnections);
sys_http.AddFunc(0x224e1610, cellHttpClientSetRecvTimeout); REG_FUNC(sys_http, cellHttpClientSetRecvTimeout);
sys_http.AddFunc(0xba78e51f, cellHttpClientGetRecvTimeout); REG_FUNC(sys_http, cellHttpClientGetRecvTimeout);
sys_http.AddFunc(0x71714cdc, cellHttpClientSetSendTimeout); REG_FUNC(sys_http, cellHttpClientSetSendTimeout);
sys_http.AddFunc(0x271a0b06, cellHttpClientGetSendTimeout); REG_FUNC(sys_http, cellHttpClientGetSendTimeout);
sys_http.AddFunc(0xd7471088, cellHttpClientSetConnTimeout); REG_FUNC(sys_http, cellHttpClientSetConnTimeout);
sys_http.AddFunc(0x14bfc765, cellHttpClientGetConnTimeout); REG_FUNC(sys_http, cellHttpClientGetConnTimeout);
sys_http.AddFunc(0x8aa5fcd3, cellHttpClientSetTotalPoolSize); REG_FUNC(sys_http, cellHttpClientSetTotalPoolSize);
sys_http.AddFunc(0x070f1020, cellHttpClientGetTotalPoolSize); REG_FUNC(sys_http, cellHttpClientGetTotalPoolSize);
sys_http.AddFunc(0xab1c55ab, cellHttpClientSetPerHostPoolSize); REG_FUNC(sys_http, cellHttpClientSetPerHostPoolSize);
sys_http.AddFunc(0xffc74003, cellHttpClientGetPerHostPoolSize); REG_FUNC(sys_http, cellHttpClientGetPerHostPoolSize);
sys_http.AddFunc(0x595adee9, cellHttpClientSetPerHostKeepAliveMax); REG_FUNC(sys_http, cellHttpClientSetPerHostKeepAliveMax);
sys_http.AddFunc(0x46bcc9ff, cellHttpClientGetPerHostKeepAliveMax); REG_FUNC(sys_http, cellHttpClientGetPerHostKeepAliveMax);
sys_http.AddFunc(0xdc7ed599, cellHttpClientSetPerPipelineMax); REG_FUNC(sys_http, cellHttpClientSetPerPipelineMax);
sys_http.AddFunc(0xd06c90a4, cellHttpClientGetPerPipelineMax); REG_FUNC(sys_http, cellHttpClientGetPerPipelineMax);
sys_http.AddFunc(0xbf6e3659, cellHttpClientSetRecvBufferSize); REG_FUNC(sys_http, cellHttpClientSetRecvBufferSize);
sys_http.AddFunc(0x130150ea, cellHttpClientGetRecvBufferSize); REG_FUNC(sys_http, cellHttpClientGetRecvBufferSize);
//sys_http.AddFunc(, cellHttpClientSetSendBufferSize); //sys_http.AddFunc(, cellHttpClientSetSendBufferSize);
//sys_http.AddFunc(, cellHttpClientGetSendBufferSize); //sys_http.AddFunc(, cellHttpClientGetSendBufferSize);
sys_http.AddFunc(0x0d9c65be, cellHttpClientGetAllHeaders); REG_FUNC(sys_http, cellHttpClientGetAllHeaders);
sys_http.AddFunc(0xa34c4b6f, cellHttpClientSetHeader); REG_FUNC(sys_http, cellHttpClientSetHeader);
sys_http.AddFunc(0xd1ec0b25, cellHttpClientGetHeader); REG_FUNC(sys_http, cellHttpClientGetHeader);
sys_http.AddFunc(0x4b33942a, cellHttpClientAddHeader); REG_FUNC(sys_http, cellHttpClientAddHeader);
sys_http.AddFunc(0x617eec02, cellHttpClientDeleteHeader); REG_FUNC(sys_http, cellHttpClientDeleteHeader);
sys_http.AddFunc(0x1395d8d1, cellHttpClientSetSslCallback); REG_FUNC(sys_http, cellHttpClientSetSslCallback);
sys_http.AddFunc(0xd8352a40, cellHttpClientSetSslClientCertificate); REG_FUNC(sys_http, cellHttpClientSetSslClientCertificate);
sys_http.AddFunc(0x052a80d9, cellHttpCreateTransaction); REG_FUNC(sys_http, cellHttpCreateTransaction);
sys_http.AddFunc(0x32f5cae2, cellHttpDestroyTransaction); REG_FUNC(sys_http, cellHttpDestroyTransaction);
sys_http.AddFunc(0x0ef17399, cellHttpTransactionGetUri); REG_FUNC(sys_http, cellHttpTransactionGetUri);
sys_http.AddFunc(0xa0d9223c, cellHttpTransactionCloseConnection); REG_FUNC(sys_http, cellHttpTransactionCloseConnection);
sys_http.AddFunc(0xd47cc666, cellHttpTransactionReleaseConnection); REG_FUNC(sys_http, cellHttpTransactionReleaseConnection);
sys_http.AddFunc(0x2d52848b, cellHttpTransactionAbortConnection); REG_FUNC(sys_http, cellHttpTransactionAbortConnection);
sys_http.AddFunc(0xa755b005, cellHttpSendRequest); REG_FUNC(sys_http, cellHttpSendRequest);
sys_http.AddFunc(0xaf73a64e, cellHttpRequestSetContentLength); REG_FUNC(sys_http, cellHttpRequestSetContentLength);
sys_http.AddFunc(0x958323cf, cellHttpRequestGetContentLength); REG_FUNC(sys_http, cellHttpRequestGetContentLength);
sys_http.AddFunc(0x8e3f7ee1, cellHttpRequestSetChunkedTransferStatus); REG_FUNC(sys_http, cellHttpRequestSetChunkedTransferStatus);
sys_http.AddFunc(0x4137a1f6, cellHttpRequestGetChunkedTransferStatus); REG_FUNC(sys_http, cellHttpRequestGetChunkedTransferStatus);
sys_http.AddFunc(0x42205fe0, cellHttpRequestGetAllHeaders); REG_FUNC(sys_http, cellHttpRequestGetAllHeaders);
sys_http.AddFunc(0x54f2a4de, cellHttpRequestSetHeader); REG_FUNC(sys_http, cellHttpRequestSetHeader);
sys_http.AddFunc(0x0b9fea5f, cellHttpRequestGetHeader); REG_FUNC(sys_http, cellHttpRequestGetHeader);
sys_http.AddFunc(0xed993147, cellHttpRequestAddHeader); REG_FUNC(sys_http, cellHttpRequestAddHeader);
sys_http.AddFunc(0x16214411, cellHttpRequestDeleteHeader); REG_FUNC(sys_http, cellHttpRequestDeleteHeader);
sys_http.AddFunc(0x61c90691, cellHttpRecvResponse); REG_FUNC(sys_http, cellHttpRecvResponse);
sys_http.AddFunc(0xbea17389, cellHttpResponseGetAllHeaders); REG_FUNC(sys_http, cellHttpResponseGetAllHeaders);
sys_http.AddFunc(0x4f5d8d20, cellHttpResponseGetHeader); REG_FUNC(sys_http, cellHttpResponseGetHeader);
sys_http.AddFunc(0x464ff889, cellHttpResponseGetContentLength); REG_FUNC(sys_http, cellHttpResponseGetContentLength);
sys_http.AddFunc(0x10d0d7fc, cellHttpResponseGetStatusCode); REG_FUNC(sys_http, cellHttpResponseGetStatusCode);
sys_http.AddFunc(0x6a81b5e4, cellHttpResponseGetStatusLine); REG_FUNC(sys_http, cellHttpResponseGetStatusLine);
sys_http.AddFunc(0x895c604c, cellHttpTransactionGetSslCipherName); REG_FUNC(sys_http, cellHttpTransactionGetSslCipherName);
sys_http.AddFunc(0x34061e49, cellHttpTransactionGetSslCipherId); REG_FUNC(sys_http, cellHttpTransactionGetSslCipherId);
sys_http.AddFunc(0x93e938e5, cellHttpTransactionGetSslCipherVersion); REG_FUNC(sys_http, cellHttpTransactionGetSslCipherVersion);
sys_http.AddFunc(0x38954133, cellHttpTransactionGetSslCipherBits); REG_FUNC(sys_http, cellHttpTransactionGetSslCipherBits);
sys_http.AddFunc(0xe3c424b3, cellHttpTransactionGetSslCipherString); REG_FUNC(sys_http, cellHttpTransactionGetSslCipherString);
sys_http.AddFunc(0xad1c6f02, cellHttpTransactionGetSslVersion); REG_FUNC(sys_http, cellHttpTransactionGetSslVersion);
sys_http.AddFunc(0x2a78ff04, cellHttpTransactionGetSslId); REG_FUNC(sys_http, cellHttpTransactionGetSslId);
sys_http.AddFunc(0x65691795, cellHttpClientSetSslVersion); REG_FUNC(sys_http, cellHttpClientSetSslVersion);
sys_http.AddFunc(0xccf57336, cellHttpClientGetSslVersion); REG_FUNC(sys_http, cellHttpClientGetSslVersion);
sys_http.AddFunc(0x7313c78d, cellHttpClientSetSslIdDestroyCallback); REG_FUNC(sys_http, cellHttpClientSetSslIdDestroyCallback);
} }
#endif #endif

608
rpcs3/Emu/SysCalls/Modules/sys_net.cpp
View File

@ -85,320 +85,324 @@ s32 getLastError()
return errno; return errno;
#endif #endif
} }
#ifdef _WIN32 #ifdef _WIN32
using pck_len_t = s32; using pck_len_t = s32;
#else #else
using pck_len_t = u32; using pck_len_t = u32;
#endif #endif
// Functions namespace sys_net_func
int sys_net_accept(s32 s, vm::ptr<sys_net_sockaddr> addr, vm::ptr<pck_len_t> paddrlen)
{ {
sys_net.Warning("accept(s=%d, family_addr=0x%x, paddrlen=0x%x)", s, addr.addr(), paddrlen.addr()); // Functions
if (!addr) { s32 accept(s32 s, vm::ptr<sys_net_sockaddr> addr, vm::ptr<pck_len_t> paddrlen)
int ret = accept(s, nullptr, nullptr); {
sys_net.Warning("accept(s=%d, family_addr=0x%x, paddrlen=0x%x)", s, addr.addr(), paddrlen.addr());
if (!addr) {
int ret = ::accept(s, nullptr, nullptr);
*g_lastError = getLastError();
return ret;
}
else {
sockaddr _addr;
memcpy(&_addr, addr.get_ptr(), sizeof(sockaddr));
_addr.sa_family = addr->sa_family;
pck_len_t _paddrlen;
int ret = ::accept(s, &_addr, &_paddrlen);
*paddrlen = _paddrlen;
*g_lastError = getLastError();
return ret;
}
}
s32 bind(s32 s, vm::ptr<sys_net_sockaddr_in> addr, u32 addrlen)
{
sys_net.Warning("bind(s=%d, family_addr=0x%x, addrlen=%d)", s, addr.addr(), addrlen);
sockaddr_in saddr;
memcpy(&saddr, addr.get_ptr(), sizeof(sockaddr_in));
saddr.sin_family = addr->sin_family;
const char *ipaddr = inet_ntoa(saddr.sin_addr);
sys_net.Warning("binding on %s to port %d", ipaddr, ntohs(saddr.sin_port));
int ret = ::bind(s, (const sockaddr *)&saddr, addrlen);
*g_lastError = getLastError(); *g_lastError = getLastError();
return ret; return ret;
} }
else {
s32 connect(s32 s, vm::ptr<sys_net_sockaddr_in> addr, u32 addrlen)
{
sys_net.Warning("connect(s=%d, family_addr=0x%x, addrlen=%d)", s, addr.addr(), addrlen);
sockaddr_in saddr;
memcpy(&saddr, addr.get_ptr(), sizeof(sockaddr_in));
saddr.sin_family = addr->sin_family;
const char *ipaddr = inet_ntoa(saddr.sin_addr);
sys_net.Warning("connecting on %s to port %d", ipaddr, ntohs(saddr.sin_port));
int ret = ::connect(s, (const sockaddr *)&saddr, addrlen);
*g_lastError = getLastError();
return ret;
}
s32 gethostbyaddr()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 gethostbyname()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 getpeername()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 getsockname()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 getsockopt()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 inet_addr(vm::ptr<const char> cp)
{
sys_net.Warning("inet_addr(cp_addr=0x%x['%s'])", cp.addr(), cp.get_ptr());
return htonl(::inet_addr(cp.get_ptr())); // return a big-endian IP address (WTF? function should return LITTLE-ENDIAN value)
}
s32 inet_aton()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 inet_lnaof()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 inet_makeaddr()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 inet_netof()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 inet_network()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 inet_ntoa()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 inet_ntop()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 inet_pton(s32 af, vm::ptr<const char> src, vm::ptr<char> dst)
{
sys_net.Warning("inet_pton(af=%d, src_addr=0x%x, dst_addr=0x%x)", af, src.addr(), dst.addr());
return ::inet_pton(af, src.get_ptr(), dst.get_ptr());
}
s32 listen(s32 s, s32 backlog)
{
sys_net.Warning("listen(s=%d, backlog=%d)", s, backlog);
int ret = ::listen(s, backlog);
*g_lastError = getLastError();
return ret;
}
s32 recv(s32 s, vm::ptr<char> buf, u32 len, s32 flags)
{
sys_net.Warning("recv(s=%d, buf_addr=0x%x, len=%d, flags=0x%x)", s, buf.addr(), len, flags);
int ret = ::recv(s, buf.get_ptr(), len, flags);
*g_lastError = getLastError();
return ret;
}
s32 recvfrom(s32 s, vm::ptr<char> buf, u32 len, s32 flags, vm::ptr<sys_net_sockaddr> addr, vm::ptr<pck_len_t> paddrlen)
{
sys_net.Warning("recvfrom(s=%d, buf_addr=0x%x, len=%d, flags=0x%x, addr_addr=0x%x, paddrlen=0x%x)",
s, buf.addr(), len, flags, addr.addr(), paddrlen.addr());
sockaddr _addr; sockaddr _addr;
memcpy(&_addr, addr.get_ptr(), sizeof(sockaddr)); memcpy(&_addr, addr.get_ptr(), sizeof(sockaddr));
_addr.sa_family = addr->sa_family; _addr.sa_family = addr->sa_family;
pck_len_t _paddrlen; pck_len_t _paddrlen;
int ret = accept(s, &_addr, &_paddrlen); int ret = ::recvfrom(s, buf.get_ptr(), len, flags, &_addr, &_paddrlen);
*paddrlen = _paddrlen; *paddrlen = _paddrlen;
*g_lastError = getLastError(); *g_lastError = getLastError();
return ret; return ret;
} }
}
int sys_net_bind(s32 s, vm::ptr<sys_net_sockaddr_in> addr, u32 addrlen) s32 recvmsg()
{ {
sys_net.Warning("bind(s=%d, family_addr=0x%x, addrlen=%d)", s, addr.addr(), addrlen); UNIMPLEMENTED_FUNC(sys_net);
sockaddr_in saddr; return CELL_OK;
memcpy(&saddr, addr.get_ptr(), sizeof(sockaddr_in)); }
saddr.sin_family = addr->sin_family;
const char *ipaddr = inet_ntoa(saddr.sin_addr);
sys_net.Warning("binding on %s to port %d", ipaddr, ntohs(saddr.sin_port));
int ret = bind(s, (const sockaddr *)&saddr, addrlen);
*g_lastError = getLastError();
return ret;
}
int sys_net_connect(s32 s, vm::ptr<sys_net_sockaddr_in> addr, u32 addrlen) s32 send(s32 s, vm::ptr<const char> buf, u32 len, s32 flags)
{ {
sys_net.Warning("connect(s=%d, family_addr=0x%x, addrlen=%d)", s, addr.addr(), addrlen); sys_net.Warning("send(s=%d, buf_addr=0x%x, len=%d, flags=0x%x)", s, buf.addr(), len, flags);
sockaddr_in saddr;
memcpy(&saddr, addr.get_ptr(), sizeof(sockaddr_in));
saddr.sin_family = addr->sin_family;
const char *ipaddr = inet_ntoa(saddr.sin_addr);
sys_net.Warning("connecting on %s to port %d", ipaddr, ntohs(saddr.sin_port));
int ret = connect(s, (const sockaddr *) &saddr, addrlen);
*g_lastError = getLastError();
return ret;
}
int gethostbyaddr() int ret = ::send(s, buf.get_ptr(), len, flags);
{ *g_lastError = getLastError();
UNIMPLEMENTED_FUNC(sys_net); return ret;
return CELL_OK; }
}
int gethostbyname() s32 sendmsg()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int getpeername() s32 sendto(s32 s, vm::ptr<const char> buf, u32 len, s32 flags, vm::ptr<sys_net_sockaddr> addr, u32 addrlen)
{ {
UNIMPLEMENTED_FUNC(sys_net); sys_net.Warning("sendto(s=%d, buf_addr=0x%x, len=%d, flags=0x%x, addr=0x%x, addrlen=%d)",
return CELL_OK; s, buf.addr(), len, flags, addr.addr(), addrlen);
}
int getsockname() sockaddr _addr;
{ memcpy(&_addr, addr.get_ptr(), sizeof(sockaddr));
UNIMPLEMENTED_FUNC(sys_net); _addr.sa_family = addr->sa_family;
return CELL_OK; int ret = ::sendto(s, buf.get_ptr(), len, flags, &_addr, addrlen);
} *g_lastError = getLastError();
return ret;
}
int getsockopt() s32 setsockopt(s32 s, s32 level, s32 optname, vm::ptr<const char> optval, u32 optlen)
{ {
UNIMPLEMENTED_FUNC(sys_net); sys_net.Warning("socket(s=%d, level=%d, optname=%d, optval_addr=0x%x, optlen=%d)", s, level, optname, optval.addr(), optlen);
return CELL_OK;
}
int sys_net_inet_addr(vm::ptr<const char> cp) int ret = ::setsockopt(s, level, optname, optval.get_ptr(), optlen);
{ *g_lastError = getLastError();
sys_net.Warning("inet_addr(cp_addr=0x%x['%s'])", cp.addr(), cp.get_ptr()); return ret;
return htonl(inet_addr(cp.get_ptr())); // return a big-endian IP address }
}
int inet_aton() s32 shutdown(s32 s, s32 how)
{ {
UNIMPLEMENTED_FUNC(sys_net); sys_net.Warning("shutdown(s=%d, how=%d)", s, how);
return CELL_OK; int ret = ::shutdown(s, how);
} *g_lastError = getLastError();
return ret;
}
int inet_lnaof() s32 socket(s32 family, s32 type, s32 protocol)
{ {
UNIMPLEMENTED_FUNC(sys_net); sys_net.Warning("socket(family=%d, type=%d, protocol=%d)", family, type, protocol);
return CELL_OK; int ret = ::socket(family, type, protocol);
} *g_lastError = getLastError();
return ret;
}
int inet_makeaddr() s32 socketclose(s32 s)
{ {
UNIMPLEMENTED_FUNC(sys_net); sys_net.Warning("socket(s=%d)", s);
return CELL_OK;
}
int inet_netof()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int inet_network()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int inet_ntoa()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int inet_ntop()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_inet_pton(s32 af, vm::ptr<const char> src, vm::ptr<char> dst)
{
sys_net.Warning("inet_pton(af=%d, src_addr=0x%x, dst_addr=0x%x)", af, src.addr(), dst.addr());
return inet_pton(af, src.get_ptr(), dst.get_ptr());
}
int sys_net_listen(s32 s, s32 backlog)
{
sys_net.Warning("listen(s=%d, backlog=%d)", s, backlog);
int ret = listen(s, backlog);
*g_lastError = getLastError();
return ret;
}
int sys_net_recv(s32 s, vm::ptr<char> buf, u32 len, s32 flags)
{
sys_net.Warning("recv(s=%d, buf_addr=0x%x, len=%d, flags=0x%x)", s, buf.addr(), len, flags);
int ret = recv(s, buf.get_ptr(), len, flags);
*g_lastError = getLastError();
return ret;
}
int sys_net_recvfrom(s32 s, vm::ptr<char> buf, u32 len, s32 flags, vm::ptr<sys_net_sockaddr> addr, vm::ptr<pck_len_t> paddrlen)
{
sys_net.Warning("recvfrom(s=%d, buf_addr=0x%x, len=%d, flags=0x%x, addr_addr=0x%x, paddrlen=0x%x)",
s, buf.addr(), len, flags, addr.addr(), paddrlen.addr());
sockaddr _addr;
memcpy(&_addr, addr.get_ptr(), sizeof(sockaddr));
_addr.sa_family = addr->sa_family;
pck_len_t _paddrlen;
int ret = recvfrom(s, buf.get_ptr(), len, flags, &_addr, &_paddrlen);
*paddrlen = _paddrlen;
*g_lastError = getLastError();
return ret;
}
int recvmsg()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_send(s32 s, vm::ptr<const char> buf, u32 len, s32 flags)
{
sys_net.Warning("send(s=%d, buf_addr=0x%x, len=%d, flags=0x%x)", s, buf.addr(), len, flags);
int ret = send(s, buf.get_ptr(), len, flags);
*g_lastError = getLastError();
return ret;
}
int sendmsg()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_sendto(s32 s, vm::ptr<const char> buf, u32 len, s32 flags, vm::ptr<sys_net_sockaddr> addr, u32 addrlen)
{
sys_net.Warning("sendto(s=%d, buf_addr=0x%x, len=%d, flags=0x%x, addr=0x%x, addrlen=%d)",
s, buf.addr(), len, flags, addr.addr(), addrlen);
sockaddr _addr;
memcpy(&_addr, addr.get_ptr(), sizeof(sockaddr));
_addr.sa_family = addr->sa_family;
int ret = sendto(s, buf.get_ptr(), len, flags, &_addr, addrlen);
*g_lastError = getLastError();
return ret;
}
int sys_net_setsockopt(s32 s, s32 level, s32 optname, vm::ptr<const char> optval, u32 optlen)
{
sys_net.Warning("socket(s=%d, level=%d, optname=%d, optval_addr=0x%x, optlen=%d)", s, level, optname, optval.addr(), optlen);
int ret = setsockopt(s, level, optname, optval.get_ptr(), optlen);
*g_lastError = getLastError();
return ret;
}
int sys_net_shutdown(s32 s, s32 how)
{
sys_net.Warning("shutdown(s=%d, how=%d)", s, how);
int ret = shutdown(s, how);
*g_lastError = getLastError();
return ret;
}
int sys_net_socket(s32 family, s32 type, s32 protocol)
{
sys_net.Warning("socket(family=%d, type=%d, protocol=%d)", family, type, protocol);
int ret = socket(family, type, protocol);
*g_lastError = getLastError();
return ret;
}
int sys_net_socketclose(s32 s)
{
sys_net.Warning("socket(s=%d)", s);
#ifdef _WIN32 #ifdef _WIN32
int ret = closesocket(s); int ret = ::closesocket(s);
#else #else
int ret = close(s); int ret = ::close(s);
#endif #endif
*g_lastError = getLastError(); *g_lastError = getLastError();
return ret; return ret;
}
s32 socketpoll()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 socketselect()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
} }
int socketpoll() s32 sys_net_initialize_network_ex(vm::ptr<sys_net_initialize_parameter> param)
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int socketselect()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_initialize_network_ex(vm::ptr<sys_net_initialize_parameter> param)
{ {
sys_net.Warning("sys_net_initialize_network_ex(param_addr=0x%x)", param.addr()); sys_net.Warning("sys_net_initialize_network_ex(param_addr=0x%x)", param.addr());
g_lastError = vm::ptr<s32>::make((u32)Memory.Alloc(4, 1)); g_lastError = vm::ptr<s32>::make((u32)Memory.Alloc(4, 1));
#ifdef _WIN32 #ifdef _WIN32
WSADATA wsaData; WSADATA wsaData;
WORD wVersionRequested = MAKEWORD(1,1); WORD wVersionRequested = MAKEWORD(1, 1);
WSAStartup(wVersionRequested, &wsaData); WSAStartup(wVersionRequested, &wsaData);
#endif #endif
return CELL_OK; return CELL_OK;
} }
int sys_net_get_udpp2p_test_param() s32 sys_net_get_udpp2p_test_param()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_set_udpp2p_test_param() s32 sys_net_set_udpp2p_test_param()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_get_lib_name_server() s32 sys_net_get_lib_name_server()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_if_ctl() s32 sys_net_if_ctl()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_get_netemu_test_param() s32 sys_net_get_netemu_test_param()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_get_sockinfo() s32 sys_net_get_sockinfo()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_close_dump() s32 sys_net_close_dump()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_set_test_param() s32 sys_net_set_test_param()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_show_nameserver() s32 sys_net_show_nameserver()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
@ -410,67 +414,67 @@ u32 _sys_net_errno_loc()
return g_lastError.addr(); return g_lastError.addr();
} }
int sys_net_set_resolver_configurations() s32 sys_net_set_resolver_configurations()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_show_route() s32 sys_net_show_route()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_read_dump() s32 sys_net_read_dump()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_abort_resolver() s32 sys_net_abort_resolver()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_abort_socket() s32 sys_net_abort_socket()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_set_lib_name_server() s32 sys_net_set_lib_name_server()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_get_test_param() s32 sys_net_get_test_param()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_get_sockinfo_ex() s32 sys_net_get_sockinfo_ex()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_open_dump() s32 sys_net_open_dump()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_show_ifconfig() s32 sys_net_show_ifconfig()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_finalize_network() s32 sys_net_finalize_network()
{ {
sys_net.Warning("sys_net_initialize_network_ex()"); sys_net.Warning("sys_net_initialize_network_ex()");
Memory.Free(g_lastError.addr()); Memory.Free(g_lastError.addr());
@ -481,83 +485,83 @@ int sys_net_finalize_network()
return CELL_OK; return CELL_OK;
} }
int _sys_net_h_errno_loc() s32 _sys_net_h_errno_loc()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_set_netemu_test_param() s32 sys_net_set_netemu_test_param()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_free_thread_context() s32 sys_net_free_thread_context()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
// define additional macro for specific namespace
#define REG_FUNC_(name) add_ppu_func(ModuleFunc(get_function_id(#name), &sys_net, bind_func(sys_net_func::name)))
Module sys_net("sys_net", []() Module sys_net("sys_net", []()
{ {
// The names of the following functions are modified to avoid overloading problems REG_FUNC_(accept);
sys_net.AddFunc(0xc94f6939, sys_net_accept); REG_FUNC_(bind);
sys_net.AddFunc(0xb0a59804, sys_net_bind); REG_FUNC_(connect);
sys_net.AddFunc(0x64f66d35, sys_net_connect); REG_FUNC_(gethostbyaddr);
//sys_net.AddFunc(0xf7ac8941, sys_net_gethostbyaddr); REG_FUNC_(gethostbyname);
//sys_net.AddFunc(0x71f4c717, sys_net_gethostbyname); REG_FUNC_(getpeername);
//sys_net.AddFunc(0xf9ec2db6, sys_net_getpeername); REG_FUNC_(getsockname);
//sys_net.AddFunc(0x13efe7f5, sys_net_getsockname); REG_FUNC_(getsockopt);
//sys_net.AddFunc(0x5a045bd1, sys_net_getsockopt); REG_FUNC_(inet_addr);
sys_net.AddFunc(0xdabbc2c0, sys_net_inet_addr); REG_FUNC_(inet_aton);
//sys_net.AddFunc(0xa9a079e0, sys_net_inet_aton); REG_FUNC_(inet_lnaof);
//sys_net.AddFunc(0x566893ce, sys_net_inet_lnaof); REG_FUNC_(inet_makeaddr);
//sys_net.AddFunc(0xb4152c74, sys_net_inet_makeaddr); REG_FUNC_(inet_netof);
//sys_net.AddFunc(0xe39a62a7, sys_net_inet_netof); REG_FUNC_(inet_network);
//sys_net.AddFunc(0x506ad863, sys_net_inet_network); REG_FUNC_(inet_ntoa);
//sys_net.AddFunc(0x858a930b, sys_net_inet_ntoa); REG_FUNC_(inet_ntop);
//sys_net.AddFunc(0xc98a3146, sys_net_inet_ntop); REG_FUNC_(inet_pton);
sys_net.AddFunc(0x8af3825e, sys_net_inet_pton); REG_FUNC_(listen);
sys_net.AddFunc(0x28e208bb, sys_net_listen); REG_FUNC_(recv);
//sys_net.AddFunc(, sys_net_ntohl); REG_FUNC_(recvfrom);
//sys_net.AddFunc(, sys_net_ntohs); REG_FUNC_(recvmsg);
sys_net.AddFunc(0xfba04f37, sys_net_recv); REG_FUNC_(send);
sys_net.AddFunc(0x1f953b9f, sys_net_recvfrom); REG_FUNC_(sendmsg);
//sys_net.AddFunc(0xc9d09c34, sys_net_recvmsg); REG_FUNC_(sendto);
sys_net.AddFunc(0xdc751b40, sys_net_send); REG_FUNC_(setsockopt);
//sys_net.AddFunc(0xad09481b, sys_net_sendmsg); REG_FUNC_(shutdown);
sys_net.AddFunc(0x9647570b, sys_net_sendto); REG_FUNC_(socket);
sys_net.AddFunc(0x88f03575, sys_net_setsockopt); REG_FUNC_(socketclose);
sys_net.AddFunc(0xa50777c6, sys_net_shutdown); REG_FUNC_(socketpoll);
sys_net.AddFunc(0x9c056962, sys_net_socket); REG_FUNC_(socketselect);
sys_net.AddFunc(0x6db6e8cd, sys_net_socketclose);
//sys_net.AddFunc(0x051ee3ee, sys_net_socketpoll);
//sys_net.AddFunc(0x3f09e20a, sys_net_socketselect);
sys_net.AddFunc(0x139a9e9b, sys_net_initialize_network_ex); REG_FUNC(sys_net, sys_net_initialize_network_ex);
sys_net.AddFunc(0x05bd4438, sys_net_get_udpp2p_test_param); REG_FUNC(sys_net, sys_net_get_udpp2p_test_param);
sys_net.AddFunc(0x10b81ed6, sys_net_set_udpp2p_test_param); REG_FUNC(sys_net, sys_net_set_udpp2p_test_param);
sys_net.AddFunc(0x1d14d6e4, sys_net_get_lib_name_server); REG_FUNC(sys_net, sys_net_get_lib_name_server);
sys_net.AddFunc(0x27fb339d, sys_net_if_ctl); REG_FUNC(sys_net, sys_net_if_ctl);
sys_net.AddFunc(0x368823c0, sys_net_get_netemu_test_param); REG_FUNC(sys_net, sys_net_get_netemu_test_param);
sys_net.AddFunc(0x3b27c780, sys_net_get_sockinfo); REG_FUNC(sys_net, sys_net_get_sockinfo);
sys_net.AddFunc(0x44328aa2, sys_net_close_dump); REG_FUNC(sys_net, sys_net_close_dump);
sys_net.AddFunc(0x4ab0b9b9, sys_net_set_test_param); REG_FUNC(sys_net, sys_net_set_test_param);
sys_net.AddFunc(0x5420e419, sys_net_show_nameserver); REG_FUNC(sys_net, sys_net_show_nameserver);
sys_net.AddFunc(0x6005cde1, _sys_net_errno_loc); REG_FUNC(sys_net, _sys_net_errno_loc);
sys_net.AddFunc(0x7687d48c, sys_net_set_resolver_configurations); REG_FUNC(sys_net, sys_net_set_resolver_configurations);
sys_net.AddFunc(0x79b61646, sys_net_show_route); REG_FUNC(sys_net, sys_net_show_route);
sys_net.AddFunc(0x89c9917c, sys_net_read_dump); REG_FUNC(sys_net, sys_net_read_dump);
sys_net.AddFunc(0x8ccf05ed, sys_net_abort_resolver); REG_FUNC(sys_net, sys_net_abort_resolver);
sys_net.AddFunc(0x8d1b77fb, sys_net_abort_socket); REG_FUNC(sys_net, sys_net_abort_socket);
sys_net.AddFunc(0x9a318259, sys_net_set_lib_name_server); REG_FUNC(sys_net, sys_net_set_lib_name_server);
sys_net.AddFunc(0xa5a86557, sys_net_get_test_param); REG_FUNC(sys_net, sys_net_get_test_param);
sys_net.AddFunc(0xa765d029, sys_net_get_sockinfo_ex); REG_FUNC(sys_net, sys_net_get_sockinfo_ex);
sys_net.AddFunc(0xab447704, sys_net_open_dump); REG_FUNC(sys_net, sys_net_open_dump);
sys_net.AddFunc(0xb48636c4, sys_net_show_ifconfig); REG_FUNC(sys_net, sys_net_show_ifconfig);
sys_net.AddFunc(0xb68d5625, sys_net_finalize_network); REG_FUNC(sys_net, sys_net_finalize_network);
sys_net.AddFunc(0xc9157d30, _sys_net_h_errno_loc); REG_FUNC(sys_net, _sys_net_h_errno_loc);
sys_net.AddFunc(0xe2434507, sys_net_set_netemu_test_param); REG_FUNC(sys_net, sys_net_set_netemu_test_param);
sys_net.AddFunc(0xfdb8f926, sys_net_free_thread_context); REG_FUNC(sys_net, sys_net_free_thread_context);
}); });

86
rpcs3/Emu/SysCalls/SC_FUNC.h
View File

@ -1,12 +1,7 @@
#pragma once #pragma once
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"
class func_caller typedef void(*ppu_func_caller)(PPUThread&);
{
public:
virtual void operator()(PPUThread& CPU) = 0;
virtual ~func_caller(){};
};
namespace ppu_func_detail namespace ppu_func_detail
{ {
@ -164,87 +159,56 @@ namespace ppu_func_detail
}; };
template<typename RT, typename... T> template<typename RT, typename... T>
class func_binder; struct func_binder;
template<typename... T> template<typename... T>
class func_binder<void, T...> : public func_caller struct func_binder<void, PPUThread&, T...>
{
typedef void(*func_t)(T...);
const func_t m_call;
public:
func_binder(func_t call)
: func_caller()
, m_call(call)
{
}
virtual void operator()(PPUThread& CPU)
{
call<void>(m_call, iterate<0, 0, 0, T...>(CPU));
}
};
template<typename... T>
class func_binder<void, PPUThread&, T...> : public func_caller
{ {
typedef void(*func_t)(PPUThread&, T...); typedef void(*func_t)(PPUThread&, T...);
const func_t m_call;
public: static void do_call(PPUThread& CPU, func_t _func)
func_binder(func_t call)
: func_caller()
, m_call(call)
{ {
} call<void>(_func, std::tuple_cat(std::tuple<PPUThread&>(CPU), iterate<0, 0, 0, T...>(CPU)));
virtual void operator()(PPUThread& CPU)
{
call<void>(m_call, std::tuple_cat(std::tuple<PPUThread&>(CPU), iterate<0, 0, 0, T...>(CPU)));
} }
}; };
template<typename RT, typename... T> template<typename... T>
class func_binder : public func_caller struct func_binder<void, T...>
{ {
typedef RT(*func_t)(T...); typedef void(*func_t)(T...);
const func_t m_call;
public: static void do_call(PPUThread& CPU, func_t _func)
func_binder(func_t call)
: func_caller()
, m_call(call)
{ {
} call<void>(_func, iterate<0, 0, 0, T...>(CPU));
virtual void operator()(PPUThread& CPU)
{
bind_result<RT, result_type<RT>::value>::func(CPU, call<RT>(m_call, iterate<0, 0, 0, T...>(CPU)));
} }
}; };
template<typename RT, typename... T> template<typename RT, typename... T>
class func_binder<RT, PPUThread&, T...> : public func_caller struct func_binder<RT, PPUThread&, T...>
{ {
typedef RT(*func_t)(PPUThread&, T...); typedef RT(*func_t)(PPUThread&, T...);
const func_t m_call;
public: static void do_call(PPUThread& CPU, func_t _func)
func_binder(func_t call)
: func_caller()
, m_call(call)
{ {
bind_result<RT, result_type<RT>::value>::func(CPU, call<RT>(_func, std::tuple_cat(std::tuple<PPUThread&>(CPU), iterate<0, 0, 0, T...>(CPU))));
} }
};
virtual void operator()(PPUThread& CPU) template<typename RT, typename... T>
struct func_binder
{
typedef RT(*func_t)(T...);
static void do_call(PPUThread& CPU, func_t _func)
{ {
bind_result<RT, result_type<RT>::value>::func(CPU, call<RT>(m_call, std::tuple_cat(std::tuple<PPUThread&>(CPU), iterate<0, 0, 0, T...>(CPU)))); bind_result<RT, result_type<RT>::value>::func(CPU, call<RT>(_func, iterate<0, 0, 0, T...>(CPU)));
} }
}; };
} }
template<typename RT, typename... T> template<typename RT, typename... T> __forceinline void call_ppu_func(PPUThread& CPU, RT(*func)(T...))
func_caller* bind_func(RT(*call)(T...))
{ {
return new ppu_func_detail::func_binder<RT, T...>(call); ppu_func_detail::func_binder<RT, T...>::do_call(CPU, func);
} }
#define bind_func(func) [](PPUThread& CPU){ call_ppu_func(CPU, func); }

217
rpcs3/Emu/SysCalls/Static.cpp
View File

@ -1,217 +0,0 @@
#include "stdafx.h"
#include "rpcs3/Ini.h"
#include "Utilities/Log.h"
#include "Emu/SysCalls/Modules.h"
#include "Static.h"
void StaticFuncManager::StaticAnalyse(void* ptr, u32 size, u32 base)
{
u32* data = (u32*)ptr; size /= 4;
if(!Ini.HLEHookStFunc.GetValue())
return;
// TODO: optimize search
for (u32 i = 0; i < size; i++)
{
for (u32 j = 0; j < m_static_funcs_list.size(); j++)
{
if ((data[i] & m_static_funcs_list[j]->ops[0].mask) == m_static_funcs_list[j]->ops[0].crc)
{
bool found = true;
u32 can_skip = 0;
for (u32 k = i, x = 0; x + 1 <= m_static_funcs_list[j]->ops.size(); k++, x++)
{
if (k >= size)
{
found = false;
break;
}
// skip NOP
if (data[k] == se32(0x60000000))
{
x--;
continue;
}
const u32 mask = m_static_funcs_list[j]->ops[x].mask;
const u32 crc = m_static_funcs_list[j]->ops[x].crc;
if (!mask)
{
// TODO: define syntax
if (crc < 4) // skip various number of instructions that don't match next pattern entry
{
can_skip += crc;
k--; // process this position again
}
else if (data[k] != crc) // skippable pattern ("optional" instruction), no mask allowed
{
k--;
if (can_skip) // cannot define this behaviour properly
{
LOG_WARNING(LOADER, "StaticAnalyse(): can_skip = %d (unchanged)", can_skip);
}
}
else
{
if (can_skip) // cannot define this behaviour properly
{
LOG_WARNING(LOADER, "StaticAnalyse(): can_skip = %d (set to 0)", can_skip);
can_skip = 0;
}
}
}
else if ((data[k] & mask) != crc) // masked pattern
{
if (can_skip)
{
can_skip--;
}
else
{
found = false;
break;
}
}
else
{
can_skip = 0;
}
}
if (found)
{
LOG_NOTICE(LOADER, "Function '%s' hooked (addr=0x%x)", m_static_funcs_list[j]->name, i * 4 + base);
m_static_funcs_list[j]->found++;
data[i+0] = re32(0x39600000 | j); // li r11, j
data[i+1] = se32(0x44000042); // sc 2
data[i+2] = se32(0x4e800020); // blr
i += 2; // skip modified code
}
}
}
}
// check function groups
for (u32 i = 0; i < m_static_funcs_list.size(); i++)
{
if (m_static_funcs_list[i]->found) // start from some group
{
const u64 group = m_static_funcs_list[i]->group;
enum GroupSearchResult : u32
{
GSR_SUCCESS = 0, // every function from this group has been found once
GSR_MISSING = 1, // (error) some function not found
GSR_EXCESS = 2, // (error) some function found twice or more
};
u32 res = GSR_SUCCESS;
// analyse
for (u32 j = 0; j < m_static_funcs_list.size(); j++) if (m_static_funcs_list[j]->group == group)
{
u32 count = m_static_funcs_list[j]->found;
if (count == 0) // not found
{
// check if this function has been found with different pattern
for (u32 k = 0; k < m_static_funcs_list.size(); k++) if (m_static_funcs_list[k]->group == group)
{
if (k != j && m_static_funcs_list[k]->ptr == m_static_funcs_list[j]->ptr)
{
count += m_static_funcs_list[k]->found;
}
}
if (count == 0)
{
res |= GSR_MISSING;
LOG_ERROR(LOADER, "Function '%s' not found", m_static_funcs_list[j]->name);
}
else if (count > 1)
{
res |= GSR_EXCESS;
}
}
else if (count == 1) // found
{
// ensure that this function has NOT been found with different pattern
for (u32 k = 0; k < m_static_funcs_list.size(); k++) if (m_static_funcs_list[k]->group == group)
{
if (k != j && m_static_funcs_list[k]->ptr == m_static_funcs_list[j]->ptr)
{
if (m_static_funcs_list[k]->found)
{
res |= GSR_EXCESS;
LOG_ERROR(LOADER, "Function '%s' hooked twice", m_static_funcs_list[j]->name);
}
}
}
}
else
{
res |= GSR_EXCESS;
LOG_ERROR(LOADER, "Function '%s' hooked twice", m_static_funcs_list[j]->name);
}
}
// clear data
for (u32 j = 0; j < m_static_funcs_list.size(); j++)
{
if (m_static_funcs_list[j]->group == group) m_static_funcs_list[j]->found = 0;
}
char name[9] = "????????";
*(u64*)name = group;
if (res == GSR_SUCCESS)
{
LOG_SUCCESS(LOADER, "Function group [%s] successfully hooked", std::string(name, 9).c_str());
}
else
{
LOG_ERROR(LOADER, "Function group [%s] failed:%s%s", std::string(name, 9).c_str(),
(res & GSR_MISSING ? " missing;" : ""),
(res & GSR_EXCESS ? " excess;" : ""));
}
}
}
}
void StaticFuncManager::StaticExecute(PPUThread& CPU, u32 code)
{
if (code < m_static_funcs_list.size())
{
(*m_static_funcs_list[code]->func)(CPU);
}
else
{
LOG_ERROR(LOADER, "StaticExecute(%d): unknown function or illegal opcode", code);
}
}
void StaticFuncManager::StaticFinalize()
{
for (SFunc *s : m_static_funcs_list)
{
delete s;
}
m_static_funcs_list.clear();
}
void StaticFuncManager::push_back(SFunc *ele)
{
m_static_funcs_list.push_back(ele);
}
SFunc *StaticFuncManager::operator[](size_t i)
{
return m_static_funcs_list[i];
}
StaticFuncManager::~StaticFuncManager()
{
StaticFinalize();
}

17
rpcs3/Emu/SysCalls/Static.h
View File

@ -1,17 +0,0 @@
#pragma once
struct SFunc;
class PPUThread;
class StaticFuncManager
{
std::vector<SFunc *> m_static_funcs_list;
public:
void StaticAnalyse(void* ptr, u32 size, u32 base);
void StaticExecute(PPUThread& CPU, u32 code);
void StaticFinalize();
void push_back(SFunc *ele);
SFunc *operator[](size_t i);
~StaticFuncManager();
};

31
rpcs3/Emu/SysCalls/SysCalls.cpp
View File

@ -42,17 +42,16 @@ namespace detail
} }
} }
void default_syscall(PPUThread& CPU); void null_func(PPUThread& CPU);
static func_caller *null_func = bind_func(default_syscall);
static const int kSyscallTableLength = 1024; const int kSyscallTableLength = 1024;
// UNS = Unused // UNS = Unused
// ROOT = Root // ROOT = Root
// DBG = Debug // DBG = Debug
// PM = Product Mode // PM = Product Mode
// AuthID = Authentication ID // AuthID = Authentication ID
static func_caller* sc_table[kSyscallTableLength] = const ppu_func_caller sc_table[1024] =
{ {
null_func, null_func,
bind_func(sys_process_getpid), //1 (0x001) bind_func(sys_process_getpid), //1 (0x001)
@ -897,25 +896,7 @@ static func_caller* sc_table[kSyscallTableLength] =
null_func, null_func, null_func, bind_func(cellGcmCallback), //1023 UNS null_func, null_func, null_func, bind_func(cellGcmCallback), //1023 UNS
}; };
/** HACK: Used to delete func_caller objects that get allocated and stored in sc_table (above). void null_func(PPUThread& CPU)
* The destructor of this static object gets called when the program shuts down.
*/
struct SyscallTableCleaner_t
{
SyscallTableCleaner_t() {}
~SyscallTableCleaner_t()
{
for (int i = 0; i < kSyscallTableLength; ++i)
{
if (sc_table[i] != null_func)
delete sc_table[i];
}
delete null_func;
}
} SyscallTableCleaner_t;
void default_syscall(PPUThread& CPU)
{ {
u32 code = (u32)CPU.GPR[11]; u32 code = (u32)CPU.GPR[11];
//TODO: remove this //TODO: remove this
@ -952,7 +933,7 @@ void SysCalls::DoSyscall(PPUThread& CPU, u32 code)
if(code < 1024) if(code < 1024)
{ {
(*sc_table[code])(CPU); sc_table[code](CPU);
return; return;
} }
@ -967,4 +948,4 @@ IdManager& SysCallBase::GetIdManager() const
bool SysCallBase::RemoveId(u32 id) bool SysCallBase::RemoveId(u32 id)
{ {
return Emu.GetIdManager().RemoveID(id); return Emu.GetIdManager().RemoveID(id);
} }

82
rpcs3/Emu/SysCalls/lv2/cellFs.cpp
View File

@ -1035,45 +1035,45 @@ Module sys_fs("sys_fs", []()
g_FsAioReadCur = 0; g_FsAioReadCur = 0;
aio_init = false; aio_init = false;
sys_fs.AddFunc(0x718bf5f8, cellFsOpen); REG_FUNC(sys_fs, cellFsOpen);
sys_fs.AddFunc(0xb1840b53, cellFsSdataOpen); REG_FUNC(sys_fs, cellFsSdataOpen);
sys_fs.AddFunc(0x6d3bb15b, cellFsSdataOpenByFd); REG_FUNC(sys_fs, cellFsSdataOpenByFd);
sys_fs.AddFunc(0x4d5ff8e2, cellFsRead); REG_FUNC(sys_fs, cellFsRead);
sys_fs.AddFunc(0xecdcf2ab, cellFsWrite); REG_FUNC(sys_fs, cellFsWrite);
sys_fs.AddFunc(0x2cb51f0d, cellFsClose); REG_FUNC(sys_fs, cellFsClose);
sys_fs.AddFunc(0x3f61245c, cellFsOpendir); REG_FUNC(sys_fs, cellFsOpendir);
sys_fs.AddFunc(0x5c74903d, cellFsReaddir); REG_FUNC(sys_fs, cellFsReaddir);
sys_fs.AddFunc(0xff42dcc3, cellFsClosedir); REG_FUNC(sys_fs, cellFsClosedir);
sys_fs.AddFunc(0x7de6dced, cellFsStat); REG_FUNC(sys_fs, cellFsStat);
sys_fs.AddFunc(0xef3efa34, cellFsFstat); REG_FUNC(sys_fs, cellFsFstat);
sys_fs.AddFunc(0xba901fe6, cellFsMkdir); REG_FUNC(sys_fs, cellFsMkdir);
sys_fs.AddFunc(0xf12eecc8, cellFsRename); REG_FUNC(sys_fs, cellFsRename);
sys_fs.AddFunc(0x99406d0b, cellFsChmod); REG_FUNC(sys_fs, cellFsChmod);
sys_fs.AddFunc(0x967a162b, cellFsFsync); REG_FUNC(sys_fs, cellFsFsync);
sys_fs.AddFunc(0x2796fdf3, cellFsRmdir); REG_FUNC(sys_fs, cellFsRmdir);
sys_fs.AddFunc(0x7f4677a8, cellFsUnlink); REG_FUNC(sys_fs, cellFsUnlink);
sys_fs.AddFunc(0xa397d042, cellFsLseek); REG_FUNC(sys_fs, cellFsLseek);
sys_fs.AddFunc(0x0e2939e5, cellFsFtruncate); REG_FUNC(sys_fs, cellFsFtruncate);
sys_fs.AddFunc(0xc9dc3ac5, cellFsTruncate); REG_FUNC(sys_fs, cellFsTruncate);
sys_fs.AddFunc(0xcb588dba, cellFsFGetBlockSize); REG_FUNC(sys_fs, cellFsFGetBlockSize);
sys_fs.AddFunc(0xc1c507e7, cellFsAioRead); REG_FUNC(sys_fs, cellFsAioRead);
sys_fs.AddFunc(0x4cef342e, cellFsAioWrite); REG_FUNC(sys_fs, cellFsAioWrite);
sys_fs.AddFunc(0xdb869f20, cellFsAioInit); REG_FUNC(sys_fs, cellFsAioInit);
sys_fs.AddFunc(0x9f951810, cellFsAioFinish); REG_FUNC(sys_fs, cellFsAioFinish);
sys_fs.AddFunc(0x1a108ab7, cellFsGetBlockSize); REG_FUNC(sys_fs, cellFsGetBlockSize);
sys_fs.AddFunc(0xaa3b4bcd, cellFsGetFreeSize); REG_FUNC(sys_fs, cellFsGetFreeSize);
sys_fs.AddFunc(0x0d5b4a14, cellFsReadWithOffset); REG_FUNC(sys_fs, cellFsReadWithOffset);
sys_fs.AddFunc(0x9b882495, cellFsGetDirectoryEntries); REG_FUNC(sys_fs, cellFsGetDirectoryEntries);
sys_fs.AddFunc(0x2664c8ae, cellFsStReadInit); REG_FUNC(sys_fs, cellFsStReadInit);
sys_fs.AddFunc(0xd73938df, cellFsStReadFinish); REG_FUNC(sys_fs, cellFsStReadFinish);
sys_fs.AddFunc(0xb3afee8b, cellFsStReadGetRingBuf); REG_FUNC(sys_fs, cellFsStReadGetRingBuf);
sys_fs.AddFunc(0xcf34969c, cellFsStReadGetStatus); REG_FUNC(sys_fs, cellFsStReadGetStatus);
sys_fs.AddFunc(0xbd273a88, cellFsStReadGetRegid); REG_FUNC(sys_fs, cellFsStReadGetRegid);
sys_fs.AddFunc(0x8df28ff9, cellFsStReadStart); REG_FUNC(sys_fs, cellFsStReadStart);
sys_fs.AddFunc(0xf8e5d9a0, cellFsStReadStop); REG_FUNC(sys_fs, cellFsStReadStop);
sys_fs.AddFunc(0x27800c6b, cellFsStRead); REG_FUNC(sys_fs, cellFsStRead);
sys_fs.AddFunc(0x190912f6, cellFsStReadGetCurrentAddr); REG_FUNC(sys_fs, cellFsStReadGetCurrentAddr);
sys_fs.AddFunc(0x81f33783, cellFsStReadPutCurrentAddr); REG_FUNC(sys_fs, cellFsStReadPutCurrentAddr);
sys_fs.AddFunc(0x8f71c5b2, cellFsStReadWait); REG_FUNC(sys_fs, cellFsStReadWait);
sys_fs.AddFunc(0x866f6aec, cellFsStReadWaitCallback); REG_FUNC(sys_fs, cellFsStReadWaitCallback);
}); });

6
rpcs3/Emu/System.cpp
View File

@ -7,7 +7,6 @@
#include "Emu/GameInfo.h" #include "Emu/GameInfo.h"
#include "Emu/ARMv7/PSVFuncList.h" #include "Emu/ARMv7/PSVFuncList.h"
#include "Emu/ARMv7/PSVObjectList.h" #include "Emu/ARMv7/PSVObjectList.h"
#include "Emu/SysCalls/Static.h"
#include "Emu/SysCalls/ModuleManager.h" #include "Emu/SysCalls/ModuleManager.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"
#include "Emu/Cell/SPUThread.h" #include "Emu/Cell/SPUThread.h"
@ -57,7 +56,6 @@ Emulator::Emulator()
, m_audio_manager(new AudioManager()) , m_audio_manager(new AudioManager())
, m_callback_manager(new CallbackManager()) , m_callback_manager(new CallbackManager())
, m_event_manager(new EventManager()) , m_event_manager(new EventManager())
, m_sfunc_manager(new StaticFuncManager())
, m_module_manager(new ModuleManager()) , m_module_manager(new ModuleManager())
, m_sync_prim_manager(new SyncPrimManager()) , m_sync_prim_manager(new SyncPrimManager())
, m_vfs(new VFS()) , m_vfs(new VFS())
@ -77,7 +75,6 @@ Emulator::~Emulator()
delete m_audio_manager; delete m_audio_manager;
delete m_callback_manager; delete m_callback_manager;
delete m_event_manager; delete m_event_manager;
delete m_sfunc_manager;
delete m_module_manager; delete m_module_manager;
delete m_sync_prim_manager; delete m_sync_prim_manager;
delete m_vfs; delete m_vfs;
@ -379,8 +376,6 @@ void Emulator::Stop()
// TODO: check finalization order // TODO: check finalization order
clear_ps3_functions();
SavePoints(BreakPointsDBName); SavePoints(BreakPointsDBName);
m_break_points.clear(); m_break_points.clear();
m_marked_points.clear(); m_marked_points.clear();
@ -397,7 +392,6 @@ void Emulator::Stop()
GetMouseManager().Close(); GetMouseManager().Close();
GetCallbackManager().Clear(); GetCallbackManager().Clear();
GetModuleManager().Close(); GetModuleManager().Close();
GetSFuncManager().StaticFinalize();
GetSyncPrimManager().Close(); GetSyncPrimManager().Close();
CurGameInfo.Reset(); CurGameInfo.Reset();

3
rpcs3/Emu/System.h
View File

@ -21,7 +21,6 @@ class CallbackManager;
class CPUThread; class CPUThread;
class EventManager; class EventManager;
class ModuleManager; class ModuleManager;
class StaticFuncManager;
class SyncPrimManager; class SyncPrimManager;
struct VFS; struct VFS;
@ -100,7 +99,6 @@ class Emulator
AudioManager* m_audio_manager; AudioManager* m_audio_manager;
CallbackManager* m_callback_manager; CallbackManager* m_callback_manager;
EventManager* m_event_manager; EventManager* m_event_manager;
StaticFuncManager* m_sfunc_manager;
ModuleManager* m_module_manager; ModuleManager* m_module_manager;
SyncPrimManager* m_sync_prim_manager; SyncPrimManager* m_sync_prim_manager;
VFS* m_vfs; VFS* m_vfs;
@ -163,7 +161,6 @@ public:
std::vector<u64>& GetBreakPoints() { return m_break_points; } std::vector<u64>& GetBreakPoints() { return m_break_points; }
std::vector<u64>& GetMarkedPoints() { return m_marked_points; } std::vector<u64>& GetMarkedPoints() { return m_marked_points; }
EventManager& GetEventManager() { return *m_event_manager; } EventManager& GetEventManager() { return *m_event_manager; }
StaticFuncManager& GetSFuncManager() { return *m_sfunc_manager; }
ModuleManager& GetModuleManager() { return *m_module_manager; } ModuleManager& GetModuleManager() { return *m_module_manager; }
SyncPrimManager& GetSyncPrimManager() { return *m_sync_prim_manager; } SyncPrimManager& GetSyncPrimManager() { return *m_sync_prim_manager; }

7
rpcs3/Gui/MainFrame.cpp
View File

@ -542,13 +542,6 @@ void MainFrame::Config(wxCommandEvent& WXUNUSED(event))
cbox_hle_loglvl ->SetSelection(Ini.HLELogLvl.GetValue()); cbox_hle_loglvl ->SetSelection(Ini.HLELogLvl.GetValue());
cbox_sys_lang ->SetSelection(Ini.SysLanguage.GetValue()); cbox_sys_lang ->SetSelection(Ini.SysLanguage.GetValue());
// Enable/Disable parameters
chbox_audio_dump->Enable(Emu.IsStopped());
chbox_audio_conv->Enable(Emu.IsStopped());
chbox_hle_logging->Enable(Emu.IsStopped());
chbox_rsx_logging->Enable(Emu.IsStopped());
chbox_hle_hook_stfunc->Enable(Emu.IsStopped());
s_round_cpu_decoder->Add(cbox_cpu_decoder, wxSizerFlags().Border(wxALL, 5).Expand()); s_round_cpu_decoder->Add(cbox_cpu_decoder, wxSizerFlags().Border(wxALL, 5).Expand());
s_round_spu_decoder->Add(cbox_spu_decoder, wxSizerFlags().Border(wxALL, 5).Expand()); s_round_spu_decoder->Add(cbox_spu_decoder, wxSizerFlags().Border(wxALL, 5).Expand());

13
rpcs3/Loader/ELF64.cpp
View File

@ -7,7 +7,6 @@
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/SysCalls/SysCalls.h" #include "Emu/SysCalls/SysCalls.h"
#include "Emu/SysCalls/Static.h"
#include "Emu/SysCalls/ModuleManager.h" #include "Emu/SysCalls/ModuleManager.h"
#include "Emu/SysCalls/lv2/sys_prx.h" #include "Emu/SysCalls/lv2/sys_prx.h"
#include "Emu/Cell/PPUInstrTable.h" #include "Emu/Cell/PPUInstrTable.h"
@ -399,7 +398,7 @@ namespace loader
for (auto& f : m.second.exports) for (auto& f : m.second.exports)
{ {
add_ps3_func(ModuleFunc(f.first, module, nullptr, vm::ptr<void()>::make(f.second))); add_ppu_func(ModuleFunc(f.first, module, nullptr, vm::ptr<void()>::make(f.second)));
} }
for (auto& f : m.second.imports) for (auto& f : m.second.imports)
@ -409,13 +408,13 @@ namespace loader
u32 index; u32 index;
auto func = get_ps3_func_by_nid(nid, &index); auto func = get_ppu_func_by_nid(nid, &index);
if (!func) if (!func)
{ {
LOG_ERROR(LOADER, "Unimplemented function '%s' (0x%x)", SysCalls::GetHLEFuncName(nid), addr); LOG_ERROR(LOADER, "Unimplemented function '%s' (0x%x)", SysCalls::GetHLEFuncName(nid), addr);
index = add_ps3_func(ModuleFunc(nid, module, nullptr)); index = add_ppu_func(ModuleFunc(nid, module, nullptr));
} }
else else
{ {
@ -532,7 +531,7 @@ namespace loader
{ {
m_stream->Seek(handler::get_stream_offset() + phdr.p_offset); m_stream->Seek(handler::get_stream_offset() + phdr.p_offset);
m_stream->Read(phdr.p_vaddr.get_ptr(), phdr.p_filesz); m_stream->Read(phdr.p_vaddr.get_ptr(), phdr.p_filesz);
Emu.GetSFuncManager().StaticAnalyse(phdr.p_vaddr.get_ptr(), (u32)phdr.p_filesz, phdr.p_vaddr.addr()); hook_ppu_funcs((u32*)phdr.p_vaddr.get_ptr(), vm::cast(phdr.p_filesz));
} }
} }
break; break;
@ -630,13 +629,13 @@ namespace loader
u32 index; u32 index;
auto func = get_ps3_func_by_nid(nid, &index); auto func = get_ppu_func_by_nid(nid, &index);
if (!func) if (!func)
{ {
LOG_ERROR(LOADER, "Unimplemented function '%s' in '%s' module (0x%x)", SysCalls::GetHLEFuncName(nid), module_name, addr); LOG_ERROR(LOADER, "Unimplemented function '%s' in '%s' module (0x%x)", SysCalls::GetHLEFuncName(nid), module_name, addr);
index = add_ps3_func(ModuleFunc(nid, module, nullptr)); index = add_ppu_func(ModuleFunc(nid, module, nullptr));
} }
else else
{ {

2
rpcs3/emucore.vcxproj
View File

@ -278,7 +278,6 @@
<ClCompile Include="Emu\SysCalls\Modules\sys_http.cpp" /> <ClCompile Include="Emu\SysCalls\Modules\sys_http.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\sys_io.cpp" /> <ClCompile Include="Emu\SysCalls\Modules\sys_io.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\sys_net.cpp" /> <ClCompile Include="Emu\SysCalls\Modules\sys_net.cpp" />
<ClCompile Include="Emu\SysCalls\Static.cpp" />
<ClCompile Include="Emu\SysCalls\SyncPrimitivesManager.cpp" /> <ClCompile Include="Emu\SysCalls\SyncPrimitivesManager.cpp" />
<ClCompile Include="Emu\SysCalls\SysCalls.cpp" /> <ClCompile Include="Emu\SysCalls\SysCalls.cpp" />
<ClCompile Include="Emu\System.cpp" /> <ClCompile Include="Emu\System.cpp" />
@ -511,7 +510,6 @@
<ClInclude Include="Emu\SysCalls\Modules\sysPrxForUser.h" /> <ClInclude Include="Emu\SysCalls\Modules\sysPrxForUser.h" />
<ClInclude Include="Emu\SysCalls\Modules\sys_net.h" /> <ClInclude Include="Emu\SysCalls\Modules\sys_net.h" />
<ClInclude Include="Emu\SysCalls\SC_FUNC.h" /> <ClInclude Include="Emu\SysCalls\SC_FUNC.h" />
<ClInclude Include="Emu\SysCalls\Static.h" />
<ClInclude Include="Emu\SysCalls\SyncPrimitivesManager.h" /> <ClInclude Include="Emu\SysCalls\SyncPrimitivesManager.h" />
<ClInclude Include="Emu\SysCalls\SysCalls.h" /> <ClInclude Include="Emu\SysCalls\SysCalls.h" />
<ClInclude Include="Emu\System.h" /> <ClInclude Include="Emu\System.h" />

6
rpcs3/emucore.vcxproj.filters
View File

@ -131,9 +131,6 @@
<ClCompile Include="Emu\SysCalls\Modules.cpp"> <ClCompile Include="Emu\SysCalls\Modules.cpp">
<Filter>Emu\SysCalls</Filter> <Filter>Emu\SysCalls</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="Emu\SysCalls\Static.cpp">
<Filter>Emu\SysCalls</Filter>
</ClCompile>
<ClCompile Include="Emu\SysCalls\SysCalls.cpp"> <ClCompile Include="Emu\SysCalls\SysCalls.cpp">
<Filter>Emu\SysCalls</Filter> <Filter>Emu\SysCalls</Filter>
</ClCompile> </ClCompile>
@ -1228,9 +1225,6 @@
<ClInclude Include="Emu\SysCalls\ModuleManager.h"> <ClInclude Include="Emu\SysCalls\ModuleManager.h">
<Filter>Emu\SysCalls</Filter> <Filter>Emu\SysCalls</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="Emu\SysCalls\Static.h">
<Filter>Emu\SysCalls</Filter>
</ClInclude>
<ClInclude Include="..\Utilities\simpleini\ConvertUTF.h"> <ClInclude Include="..\Utilities\simpleini\ConvertUTF.h">
<Filter>Utilities\SimpleIni</Filter> <Filter>Utilities\SimpleIni</Filter>
</ClInclude> </ClInclude>