archive/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-07-07 15:31:26 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

- Fixed memory leaks in cellRtc module.

Browse source 
- Fixed CPUThread crash.
- Improved ARMv7 Interpreter.
This commit is contained in:
DH 2013-11-09 14:25:12 +02:00
parent 3b15f35432
commit 6ea2c7d6a8
6 changed files with 949 additions and 729 deletions
Download patch file Download diff file Expand all files Collapse all files

229
rpcs3/Emu/ARMv7/ARMv7Interpreter.h
View file

@ -10,6 +10,229 @@ public:
{ {
} }
enum SRType
{
SRType_None,
SRType_LSL,
SRType_LSR,
SRType_ASR,
SRType_ROR,
SRType_RRX,
};
template<typename T>
bool IsZero(T x)
{
return x == T(0);
}
template<typename T>
bool IsOnes(T x)
{
return x == ~T(0);
}
template<typename T>
u8 IsZeroBit(T x)
{
return IsZero(x) ? 1 : 0;
}
template<typename T>
bool IsOnesBit(T x, u8 len = sizeof(T) * 8)
{
return IsOnes(x) ? 1 : 0;
}
template<typename T>
u8 BitCount(T x, u8 len = sizeof(T) * 8)
{
u8 result = 0;
for(u8 mask=1 << (len - 1); mask; mask >>= 1)
{
if(x & mask) result++;
}
return result;
}
template<typename T>
s8 LowestSetBit(T x, u8 len = sizeof(T) * 8)
{
if(!x) return len;
u8 result = 0;
for(T mask=1, i=0; i<len && (x & mask) == 0; mask <<= 1, i++)
{
result++;
}
return result;
}
template<typename T>
s8 HighestSetBit(T x, u8 len = sizeof(T) * 8)
{
if(!x) return -1;
u8 result = len;
for(T mask=T(1) << (len - 1); (x & mask) == 0; mask >>= 1)
{
result--;
}
return result;
}
template<typename T>
s8 CountLeadingZeroBits(T x, u8 len = sizeof(T) * 8)
{
return len - 1 - HighestSetBit(x, len);
}
SRType DecodeImmShift(u8 type, u8 imm5, uint* shift_n)
{
SRType shift_t;
switch(type)
{
case 0: shift_t = SRType_LSL; if(shift_n) *shift_n = imm5; break;
case 1: shift_t = SRType_LSR; if(shift_n) *shift_n = imm5 == 0 ? 32 : imm5; break;
case 2: shift_t = SRType_ASR; if(shift_n) *shift_n = imm5 == 0 ? 32 : imm5; break;
case 3:
if(imm5 == 0)
{
shift_t = SRType_RRX; if(shift_n) *shift_n = 1;
}
else
{
shift_t = SRType_ROR; if(shift_n) *shift_n = imm5;
}
break;
}
return shift_t;
}
SRType DecodeRegShift(u8 type)
{
SRType shift_t;
switch(type)
{
case 0: shift_t = SRType_LSL; break;
case 1: shift_t = SRType_LSR; break;
case 2: shift_t = SRType_ASR; break;
case 3: shift_t = SRType_ROR; break;
}
return shift_t;
}
u32 LSL_C(u32 x, int shift, bool& carry_out)
{
u32 extended_x = x << shift;
carry_out = (extended_x >> 31) ? 1 : 0;
return extended_x & ~(1 << 31);
}
u32 LSL(u32 x, int shift)
{
if(!shift) return x;
bool carry_out;
return LSL_C(x, shift, carry_out);
}
u32 LSR_C(u32 x, int shift, bool& carry_out)
{
carry_out = (x >> (shift - 1)) & 0x1;
return x >> shift;
}
u32 LSR(u32 x, int shift)
{
if(!shift) return x;
bool carry_out;
return LSR_C(x, shift, carry_out);
}
s32 ASR_C(s32 x, int shift, bool& carry_out)
{
carry_out = (x >> (shift - 1)) & 0x1;
return x >> shift;
}
s32 ASR(s32 x, int shift)
{
if(!shift) return x;
bool carry_out;
return ASR_C(x, shift, carry_out);
}
u32 ROR_C(u32 x, int shift, bool& carry_out)
{
u32 result = LSR(x, shift) | LSL(x, 32 - shift);
carry_out = (result >> 30) & 0x1;
return result;
}
s32 ROR(s32 x, int shift)
{
if(!shift) return x;
bool carry_out;
return ROR_C(x, shift, carry_out);
}
template<typename T> T RRX_C(T x, bool carry_in, bool& carry_out)
{
carry_out = x & 0x1;
return ((u32)carry_in << 31) | (x & 0x7ffffffe);
}
s32 RRX(s32 x, int shift)
{
if(!shift) return x;
bool carry_out;
return RRX_C(x, shift, carry_out);
}
template<typename T> T Shift_C(T value, SRType type, uint amount, bool carry_in, bool& carry_out)
{
if(amount)
{
switch(type)
{
case SRType_LSL: return LSL_C(value, amount, carry_out);
case SRType_LSR: return LSR_C(value, amount, carry_out);
case SRType_ASR: return ASR_C(value, amount, carry_out);
case SRType_ROR: return ROR_C(value, amount, carry_out);
case SRType_RRX: return RRX_C(value, amount, carry_out);
}
}
carry_out = carry_in;
return value;
}
template<typename T> T Shift(T value, SRType type, uint amount, bool carry_in)
{
bool carry_out;
return Shift_C(value, type, amount, carry_in, carry_out);
}
template<typename T> T AddWithCarry(T x, T y, bool carry_in, bool& carry_out, bool& overflow)
{
uint unsigned_sum = (uint)x + (uint)y + (uint)carry_in;
int signed_sum = (int)x + (int)y + (int)carry_in;
T result = unsigned_sum & ~(T(1) << (sizeof(T) - 1));
carry_out = (uint)result != unsigned_sum;
overflow = (int)result != signed_sum;
return result;
}
bool ConditionPassed(u8 cond) bool ConditionPassed(u8 cond)
{ {
bool result; bool result;
@ -51,20 +274,20 @@ protected:
{ {
if(regs_list & mask) if(regs_list & mask)
{ {
CPU.SP -= 4;
Memory.Write32(CPU.SP, CPU.read_gpr(i)); Memory.Write32(CPU.SP, CPU.read_gpr(i));
CPU.SP += 4;
} }
} }
} }
void POP(u16 regs_list) void POP(u16 regs_list)
{ {
for(u16 mask=(0x1 << 15), i=15; mask; mask >>= 1, i++) for(u16 mask=(0x1 << 15), i=15; mask; mask >>= 1, i--)
{ {
if(regs_list & mask) if(regs_list & mask)
{ {
CPU.SP -= 4;
CPU.write_gpr(i, Memory.Read32(CPU.SP)); CPU.write_gpr(i, Memory.Read32(CPU.SP));
CPU.SP += 4;
} }
} }
} }

4
rpcs3/Emu/ARMv7/ARMv7Thread.cpp
View file

@ -24,12 +24,12 @@ void ARMv7Thread::InitStack()
m_stack_addr = Memory.Alloc(0x10000, 1); m_stack_addr = Memory.Alloc(0x10000, 1);
} }
m_stack_point = m_stack_addr; m_stack_point = m_stack_addr + m_stack_size;
} }
u64 ARMv7Thread::GetFreeStackSize() const u64 ARMv7Thread::GetFreeStackSize() const
{ {
return GetStackSize() - (SP - GetStackAddr()); return SP - GetStackAddr();
} }
void ARMv7Thread::SetArg(const uint pos, const u64 arg) void ARMv7Thread::SetArg(const uint pos, const u64 arg)

10
rpcs3/Emu/CPU/CPUThread.cpp
View file

@ -33,6 +33,11 @@ void CPUThread::Close()
{ {
m_free_data = true; m_free_data = true;
} }
else
{
delete m_dec;
m_dec = nullptr;
}
Stop(); Stop();
} }
@ -242,7 +247,6 @@ void CPUThread::Stop()
Reset(); Reset();
DoStop(); DoStop();
Emu.CheckStatus(); Emu.CheckStatus();
delete m_dec;
wxGetApp().SendDbgCommand(DID_STOPED_THREAD, this); wxGetApp().SendDbgCommand(DID_STOPED_THREAD, this);
} }
@ -326,5 +330,9 @@ void CPUThread::Task()
//ConLog.Write("%s leave", CPUThread::GetFName()); //ConLog.Write("%s leave", CPUThread::GetFName());
if(m_free_data) if(m_free_data)
{
delete m_dec;
m_dec = nullptr;
free(this); free(this);
}
} }

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

@ -29,7 +29,8 @@ struct CellRtcTick
u64 tick; u64 tick;
}; };
struct CellRtcDateTime { struct CellRtcDateTime
{
u16 year; u16 year;
u16 month; u16 month;
u16 day; u16 day;
@ -39,11 +40,13 @@ struct CellRtcDateTime {
u32 microsecond; u32 microsecond;
}; };
long convertToUNIXTime(u16 seconds, u16 minutes, u16 hours, u16 days, int years) { long convertToUNIXTime(u16 seconds, u16 minutes, u16 hours, u16 days, int years)
{
return (seconds + minutes*60 + hours*3600 + days*86400 + (years-70)*31536000 + ((years-69)/4)*86400 - ((years-1)/100)*86400 + ((years+299)/400)*86400); return (seconds + minutes*60 + hours*3600 + days*86400 + (years-70)*31536000 + ((years-69)/4)*86400 - ((years-1)/100)*86400 + ((years+299)/400)*86400);
} }
u64 convertToWin32FILETIME(u16 seconds, u16 minutes, u16 hours, u16 days, int years) { u64 convertToWin32FILETIME(u16 seconds, u16 minutes, u16 hours, u16 days, int years)
{
long unixtime = convertToUNIXTime(seconds, minutes, hours, days, years); long unixtime = convertToUNIXTime(seconds, minutes, hours, days, years);
LONGLONG win32time = Int32x32To64(unixtime, 10000000) + 116444736000000000; LONGLONG win32time = Int32x32To64(unixtime, 10000000) + 116444736000000000;
u64 win32filetime = (u64) win32time | win32time >> 32; u64 win32filetime = (u64) win32time | win32time >> 32;
@ -53,38 +56,27 @@ u64 convertToWin32FILETIME(u16 seconds, u16 minutes, u16 hours, u16 days, int ye
int cellRtcGetCurrentTick(mem64_t tick) int cellRtcGetCurrentTick(mem64_t tick)
{ {
cellRtc.Log("cellRtcGetCurrentTick(tick_addr=0x%x)", tick.GetAddr()); cellRtc.Log("cellRtcGetCurrentTick(tick_addr=0x%x)", tick.GetAddr());
CellRtcTick *current_tick = new CellRtcTick;
wxDateTime unow = wxDateTime::UNow(); wxDateTime unow = wxDateTime::UNow();
current_tick->tick = unow.GetTicks(); tick = unow.GetTicks();
tick = current_tick->tick;
return CELL_OK; return CELL_OK;
} }
int cellRtcGetCurrentClock(u32 clock_addr, int time_zone) int cellRtcGetCurrentClock(u32 clock_addr, int time_zone)
{ {
cellRtc.Log("cellRtcGetCurrentClock(clock_addr=0x%x, time_zone=%d)", clock_addr, time_zone); cellRtc.Log("cellRtcGetCurrentClock(clock_addr=0x%x, time_zone=%d)", clock_addr, time_zone);
CellRtcDateTime *current_clock = new CellRtcDateTime;
wxDateTime unow = wxDateTime::UNow(); wxDateTime unow = wxDateTime::UNow();
// Add time_zone as offset in minutes. // Add time_zone as offset in minutes.
wxTimeSpan tz = wxTimeSpan::wxTimeSpan(0, (long) time_zone, 0, 0); wxTimeSpan tz = wxTimeSpan::wxTimeSpan(0, (long) time_zone, 0, 0);
unow.Add(tz); unow.Add(tz);
current_clock->year = unow.GetYear(wxDateTime::TZ::UTC); Memory.Write16(clock_addr, unow.GetYear(wxDateTime::TZ::UTC));
current_clock->month = unow.GetMonth(wxDateTime::TZ::UTC); Memory.Write16(clock_addr + 2, unow.GetMonth(wxDateTime::TZ::UTC));
current_clock->day = unow.GetDay(wxDateTime::TZ::UTC); Memory.Write16(clock_addr + 4, unow.GetDay(wxDateTime::TZ::UTC));
current_clock->hour = unow.GetHour(wxDateTime::TZ::UTC); Memory.Write16(clock_addr + 6, unow.GetHour(wxDateTime::TZ::UTC));
current_clock->minute = unow.GetMinute(wxDateTime::TZ::UTC); Memory.Write16(clock_addr + 8, unow.GetMinute(wxDateTime::TZ::UTC));
current_clock->second = unow.GetSecond(wxDateTime::TZ::UTC); Memory.Write16(clock_addr + 10, unow.GetSecond(wxDateTime::TZ::UTC));
current_clock->microsecond = unow.GetMillisecond(wxDateTime::TZ::UTC) * 1000; Memory.Write32(clock_addr + 12, unow.GetMillisecond(wxDateTime::TZ::UTC) * 1000);
Memory.Write16(clock_addr, current_clock->year);
Memory.Write16(clock_addr + 2, current_clock->month);
Memory.Write16(clock_addr + 4, current_clock->day);
Memory.Write16(clock_addr + 6, current_clock->hour);
Memory.Write16(clock_addr + 8, current_clock->minute);
Memory.Write16(clock_addr + 10, current_clock->second);
Memory.Write32(clock_addr + 12, current_clock->microsecond);
return CELL_OK; return CELL_OK;
} }
@ -92,24 +84,15 @@ int cellRtcGetCurrentClock(u32 clock_addr, int time_zone)
int cellRtcGetCurrentClockLocalTime(u32 clock_addr) int cellRtcGetCurrentClockLocalTime(u32 clock_addr)
{ {
cellRtc.Log("cellRtcGetCurrentClockLocalTime(clock_addr=0x%x)", clock_addr); cellRtc.Log("cellRtcGetCurrentClockLocalTime(clock_addr=0x%x)", clock_addr);
CellRtcDateTime *current_clock = new CellRtcDateTime;
wxDateTime unow = wxDateTime::UNow(); wxDateTime unow = wxDateTime::UNow();
current_clock->year = unow.GetYear(wxDateTime::TZ::Local); Memory.Write16(clock_addr, unow.GetYear(wxDateTime::TZ::Local));
current_clock->month = unow.GetMonth(wxDateTime::TZ::Local); Memory.Write16(clock_addr + 2, unow.GetMonth(wxDateTime::TZ::Local));
current_clock->day = unow.GetDay(wxDateTime::TZ::Local); Memory.Write16(clock_addr + 4, unow.GetDay(wxDateTime::TZ::Local));
current_clock->hour = unow.GetHour(wxDateTime::TZ::Local); Memory.Write16(clock_addr + 6, unow.GetHour(wxDateTime::TZ::Local));
current_clock->minute = unow.GetMinute(wxDateTime::TZ::Local); Memory.Write16(clock_addr + 8, unow.GetMinute(wxDateTime::TZ::Local));
current_clock->second = unow.GetSecond(wxDateTime::TZ::Local); Memory.Write16(clock_addr + 10, unow.GetSecond(wxDateTime::TZ::Local));
current_clock->microsecond = unow.GetMillisecond(wxDateTime::TZ::Local) * 1000; Memory.Write32(clock_addr + 12, unow.GetMillisecond(wxDateTime::TZ::Local) * 1000);
Memory.Write16(clock_addr, current_clock->year);
Memory.Write16(clock_addr + 2, current_clock->month);
Memory.Write16(clock_addr + 4, current_clock->day);
Memory.Write16(clock_addr + 6, current_clock->hour);
Memory.Write16(clock_addr + 8, current_clock->minute);
Memory.Write16(clock_addr + 10, current_clock->second);
Memory.Write32(clock_addr + 12, current_clock->microsecond);
return CELL_OK; return CELL_OK;
} }
@ -117,14 +100,14 @@ int cellRtcGetCurrentClockLocalTime(u32 clock_addr)
int cellRtcFormatRfc2822(u32 rfc_addr, u32 tick_addr, int time_zone) int cellRtcFormatRfc2822(u32 rfc_addr, u32 tick_addr, int time_zone)
{ {
cellRtc.Log("cellRtcFormatRfc2822(rfc_addr=0x%x, tick_addr=0x%x, time_zone=%d)", rfc_addr, tick_addr, time_zone); cellRtc.Log("cellRtcFormatRfc2822(rfc_addr=0x%x, tick_addr=0x%x, time_zone=%d)", rfc_addr, tick_addr, time_zone);
CellRtcTick *current_tick = new CellRtcTick; CellRtcTick current_tick;
current_tick->tick = Memory.Read64(tick_addr); current_tick.tick = Memory.Read64(tick_addr);
// Add time_zone as offset in minutes. // Add time_zone as offset in minutes.
wxTimeSpan tz = wxTimeSpan::wxTimeSpan(0, (long) time_zone, 0, 0); wxTimeSpan tz = wxTimeSpan::wxTimeSpan(0, (long) time_zone, 0, 0);
// Get date from ticks + tz. // Get date from ticks + tz.
wxDateTime date = wxDateTime::wxDateTime((time_t)current_tick->tick); wxDateTime date = wxDateTime::wxDateTime((time_t)current_tick.tick);
date.Add(tz); date.Add(tz);
// Format date string in RFC2822 format (e.g.: Mon, 01 Jan 1990 12:00:00 +0000). // Format date string in RFC2822 format (e.g.: Mon, 01 Jan 1990 12:00:00 +0000).
@ -137,11 +120,11 @@ int cellRtcFormatRfc2822(u32 rfc_addr, u32 tick_addr, int time_zone)
int cellRtcFormatRfc2822LocalTime(u32 rfc_addr, u32 tick_addr) int cellRtcFormatRfc2822LocalTime(u32 rfc_addr, u32 tick_addr)
{ {
cellRtc.Log("cellRtcFormatRfc2822LocalTime(rfc_addr=0x%x, tick_addr=0x%x)", rfc_addr, tick_addr); cellRtc.Log("cellRtcFormatRfc2822LocalTime(rfc_addr=0x%x, tick_addr=0x%x)", rfc_addr, tick_addr);
CellRtcTick *current_tick = new CellRtcTick; CellRtcTick current_tick;
current_tick->tick = Memory.Read64(tick_addr); current_tick.tick = Memory.Read64(tick_addr);
// Get date from ticks. // Get date from ticks.
wxDateTime date = wxDateTime::wxDateTime((time_t)current_tick->tick); wxDateTime date = wxDateTime::wxDateTime((time_t)current_tick.tick);
// Format date string in RFC2822 format (e.g.: Mon, 01 Jan 1990 12:00:00 +0000). // Format date string in RFC2822 format (e.g.: Mon, 01 Jan 1990 12:00:00 +0000).
const wxString& str = date.Format("%a, %d %b %Y %T %z", wxDateTime::TZ::Local); const wxString& str = date.Format("%a, %d %b %Y %T %z", wxDateTime::TZ::Local);
@ -153,14 +136,14 @@ int cellRtcFormatRfc2822LocalTime(u32 rfc_addr, u32 tick_addr)
int cellRtcFormatRfc3339(u32 rfc_addr, u32 tick_addr, int time_zone) int cellRtcFormatRfc3339(u32 rfc_addr, u32 tick_addr, int time_zone)
{ {
cellRtc.Log("cellRtcFormatRfc3339(rfc_addr=0x%x, tick_addr=0x%x, time_zone=%d)", rfc_addr, tick_addr, time_zone); cellRtc.Log("cellRtcFormatRfc3339(rfc_addr=0x%x, tick_addr=0x%x, time_zone=%d)", rfc_addr, tick_addr, time_zone);
CellRtcTick *current_tick = new CellRtcTick; CellRtcTick current_tick;
current_tick->tick = Memory.Read64(tick_addr); current_tick.tick = Memory.Read64(tick_addr);
// Add time_zone as offset in minutes. // Add time_zone as offset in minutes.
wxTimeSpan tz = wxTimeSpan::wxTimeSpan(0, (long) time_zone, 0, 0); wxTimeSpan tz = wxTimeSpan::wxTimeSpan(0, (long) time_zone, 0, 0);
// Get date from ticks + tz. // Get date from ticks + tz.
wxDateTime date = wxDateTime::wxDateTime((time_t)current_tick->tick); wxDateTime date = wxDateTime::wxDateTime((time_t)current_tick.tick);
date.Add(tz); date.Add(tz);
// Format date string in RFC3339 format (e.g.: 1990-01-01T12:00:00.00Z). // Format date string in RFC3339 format (e.g.: 1990-01-01T12:00:00.00Z).
@ -173,11 +156,11 @@ int cellRtcFormatRfc3339(u32 rfc_addr, u32 tick_addr, int time_zone)
int cellRtcFormatRfc3339LocalTime(u32 rfc_addr, u32 tick_addr) int cellRtcFormatRfc3339LocalTime(u32 rfc_addr, u32 tick_addr)
{ {
cellRtc.Log("cellRtcFormatRfc3339LocalTime(rfc_addr=0x%x, tick_addr=0x%x)", rfc_addr, tick_addr); cellRtc.Log("cellRtcFormatRfc3339LocalTime(rfc_addr=0x%x, tick_addr=0x%x)", rfc_addr, tick_addr);
CellRtcTick *current_tick = new CellRtcTick; CellRtcTick current_tick;
current_tick->tick = Memory.Read64(tick_addr); current_tick.tick = Memory.Read64(tick_addr);
// Get date from ticks. // Get date from ticks.
wxDateTime date = wxDateTime::wxDateTime((time_t)current_tick->tick); wxDateTime date = wxDateTime::wxDateTime((time_t)current_tick.tick);
// Format date string in RFC3339 format (e.g.: 1990-01-01T12:00:00.00Z). // Format date string in RFC3339 format (e.g.: 1990-01-01T12:00:00.00Z).
const wxString& str = date.Format("%FT%T.%zZ", wxDateTime::TZ::Local); const wxString& str = date.Format("%FT%T.%zZ", wxDateTime::TZ::Local);
@ -220,16 +203,16 @@ int cellRtcGetTick(u32 clock_addr, mem64_t tick)
{ {
cellRtc.Log("cellRtcGetTick(clock_addr=0x%x, tick_addr=0x%x)", clock_addr, tick.GetAddr()); cellRtc.Log("cellRtcGetTick(clock_addr=0x%x, tick_addr=0x%x)", clock_addr, tick.GetAddr());
CellRtcDateTime *clock = new CellRtcDateTime; CellRtcDateTime clock;
clock->year = Memory.Read16(clock_addr); clock.year = Memory.Read16(clock_addr);
clock->month = Memory.Read16(clock_addr + 2); clock.month = Memory.Read16(clock_addr + 2);
clock->day = Memory.Read16(clock_addr + 4); clock.day = Memory.Read16(clock_addr + 4);
clock->hour = Memory.Read16(clock_addr + 6); clock.hour = Memory.Read16(clock_addr + 6);
clock->minute = Memory.Read16(clock_addr + 8); clock.minute = Memory.Read16(clock_addr + 8);
clock->second = Memory.Read16(clock_addr + 10); clock.second = Memory.Read16(clock_addr + 10);
clock->microsecond = Memory.Read32(clock_addr + 12); clock.microsecond = Memory.Read32(clock_addr + 12);
wxDateTime datetime = wxDateTime::wxDateTime(clock->day, (wxDateTime::Month)clock->month, clock->year, clock->hour, clock->minute, clock->second, (clock->microsecond / 1000)); wxDateTime datetime = wxDateTime::wxDateTime(clock.day, (wxDateTime::Month)clock.month, clock.year, clock.hour, clock.minute, clock.second, (clock.microsecond / 1000));
tick = datetime.GetTicks(); tick = datetime.GetTicks();
return CELL_OK; return CELL_OK;
@ -238,27 +221,27 @@ int cellRtcGetTick(u32 clock_addr, mem64_t tick)
int cellRtcSetTick(u32 clock_addr, u32 tick_addr) int cellRtcSetTick(u32 clock_addr, u32 tick_addr)
{ {
cellRtc.Log("cellRtcSetTick(clock_addr=0x%x, tick_addr=0x%x)", clock_addr, tick_addr); cellRtc.Log("cellRtcSetTick(clock_addr=0x%x, tick_addr=0x%x)", clock_addr, tick_addr);
CellRtcTick *current_tick = new CellRtcTick; CellRtcTick current_tick;
current_tick->tick = Memory.Read64(tick_addr); current_tick.tick = Memory.Read64(tick_addr);
wxDateTime date = wxDateTime::wxDateTime((time_t)current_tick->tick); wxDateTime date = wxDateTime::wxDateTime((time_t)current_tick.tick);
CellRtcDateTime *clock = new CellRtcDateTime; CellRtcDateTime clock;
clock->year = date.GetYear(wxDateTime::TZ::UTC); clock.year = date.GetYear(wxDateTime::TZ::UTC);
clock->month = date.GetMonth(wxDateTime::TZ::UTC); clock.month = date.GetMonth(wxDateTime::TZ::UTC);
clock->day = date.GetDay(wxDateTime::TZ::UTC); clock.day = date.GetDay(wxDateTime::TZ::UTC);
clock->hour = date.GetHour(wxDateTime::TZ::UTC); clock.hour = date.GetHour(wxDateTime::TZ::UTC);
clock->minute = date.GetMinute(wxDateTime::TZ::UTC); clock.minute = date.GetMinute(wxDateTime::TZ::UTC);
clock->second = date.GetSecond(wxDateTime::TZ::UTC); clock.second = date.GetSecond(wxDateTime::TZ::UTC);
clock->microsecond = date.GetMillisecond(wxDateTime::TZ::UTC) * 1000; clock.microsecond = date.GetMillisecond(wxDateTime::TZ::UTC) * 1000;
Memory.Write16(clock_addr, clock->year); Memory.Write16(clock_addr, clock.year);
Memory.Write16(clock_addr + 2, clock->month); Memory.Write16(clock_addr + 2, clock.month);
Memory.Write16(clock_addr + 4, clock->day); Memory.Write16(clock_addr + 4, clock.day);
Memory.Write16(clock_addr + 6, clock->hour); Memory.Write16(clock_addr + 6, clock.hour);
Memory.Write16(clock_addr + 8, clock->minute); Memory.Write16(clock_addr + 8, clock.minute);
Memory.Write16(clock_addr + 10, clock->second); Memory.Write16(clock_addr + 10, clock.second);
Memory.Write32(clock_addr + 12, clock->microsecond); Memory.Write32(clock_addr + 12, clock.microsecond);
return CELL_OK; return CELL_OK;
} }
@ -388,17 +371,17 @@ int cellRtcConvertLocalTimeToUtc(u32 tick_local_addr, mem64_t tick_utc)
int cellRtcGetDosTime(u32 datetime_addr, mem64_t dos_time) int cellRtcGetDosTime(u32 datetime_addr, mem64_t dos_time)
{ {
cellRtc.Log("cellRtcGetDosTime(datetime_addr=0x%x, dos_time_addr=0x%x)", datetime_addr, dos_time.GetAddr()); cellRtc.Log("cellRtcGetDosTime(datetime_addr=0x%x, dos_time_addr=0x%x)", datetime_addr, dos_time.GetAddr());
CellRtcDateTime *datetime = new CellRtcDateTime; CellRtcDateTime datetime;
datetime->year = Memory.Read16(datetime_addr); datetime.year = Memory.Read16(datetime_addr);
datetime->month = Memory.Read16(datetime_addr + 2); datetime.month = Memory.Read16(datetime_addr + 2);
datetime->day = Memory.Read16(datetime_addr + 4); datetime.day = Memory.Read16(datetime_addr + 4);
datetime->hour = Memory.Read16(datetime_addr + 6); datetime.hour = Memory.Read16(datetime_addr + 6);
datetime->minute = Memory.Read16(datetime_addr + 8); datetime.minute = Memory.Read16(datetime_addr + 8);
datetime->second = Memory.Read16(datetime_addr + 10); datetime.second = Memory.Read16(datetime_addr + 10);
datetime->microsecond = Memory.Read32(datetime_addr + 12); datetime.microsecond = Memory.Read32(datetime_addr + 12);
// Convert to DOS time. // Convert to DOS time.
wxDateTime date_time = wxDateTime::wxDateTime(datetime->day, (wxDateTime::Month)datetime->month, datetime->year, datetime->hour, datetime->minute, datetime->second, (datetime->microsecond / 1000)); wxDateTime date_time = wxDateTime::wxDateTime(datetime.day, (wxDateTime::Month)datetime.month, datetime.year, datetime.hour, datetime.minute, datetime.second, (datetime.microsecond / 1000));
dos_time = date_time.GetAsDOS(); dos_time = date_time.GetAsDOS();
return CELL_OK; return CELL_OK;
@ -407,17 +390,17 @@ int cellRtcGetDosTime(u32 datetime_addr, mem64_t dos_time)
int cellRtcGetTime_t(u32 datetime_addr, mem64_t posix_time) int cellRtcGetTime_t(u32 datetime_addr, mem64_t posix_time)
{ {
cellRtc.Log("cellRtcGetTime_t(datetime_addr=0x%x, posix_time_addr=0x%x)", datetime_addr, posix_time.GetAddr()); cellRtc.Log("cellRtcGetTime_t(datetime_addr=0x%x, posix_time_addr=0x%x)", datetime_addr, posix_time.GetAddr());
CellRtcDateTime *datetime = new CellRtcDateTime; CellRtcDateTime datetime;
datetime->year = Memory.Read16(datetime_addr); datetime.year = Memory.Read16(datetime_addr);
datetime->month = Memory.Read16(datetime_addr + 2); datetime.month = Memory.Read16(datetime_addr + 2);
datetime->day = Memory.Read16(datetime_addr + 4); datetime.day = Memory.Read16(datetime_addr + 4);
datetime->hour = Memory.Read16(datetime_addr + 6); datetime.hour = Memory.Read16(datetime_addr + 6);
datetime->minute = Memory.Read16(datetime_addr + 8); datetime.minute = Memory.Read16(datetime_addr + 8);
datetime->second = Memory.Read16(datetime_addr + 10); datetime.second = Memory.Read16(datetime_addr + 10);
datetime->microsecond = Memory.Read32(datetime_addr + 12); datetime.microsecond = Memory.Read32(datetime_addr + 12);
// Convert to POSIX time_t. // Convert to POSIX time_t.
wxDateTime date_time = wxDateTime::wxDateTime(datetime->day, (wxDateTime::Month)datetime->month, datetime->year, datetime->hour, datetime->minute, datetime->second, (datetime->microsecond / 1000)); wxDateTime date_time = wxDateTime::wxDateTime(datetime.day, (wxDateTime::Month)datetime.month, datetime.year, datetime.hour, datetime.minute, datetime.second, (datetime.microsecond / 1000));
posix_time = convertToUNIXTime(date_time.GetSecond(wxDateTime::TZ::UTC), date_time.GetMinute(wxDateTime::TZ::UTC), posix_time = convertToUNIXTime(date_time.GetSecond(wxDateTime::TZ::UTC), date_time.GetMinute(wxDateTime::TZ::UTC),
date_time.GetHour(wxDateTime::TZ::UTC), date_time.GetDay(wxDateTime::TZ::UTC), date_time.GetYear(wxDateTime::TZ::UTC)); date_time.GetHour(wxDateTime::TZ::UTC), date_time.GetDay(wxDateTime::TZ::UTC), date_time.GetYear(wxDateTime::TZ::UTC));
@ -427,17 +410,17 @@ int cellRtcGetTime_t(u32 datetime_addr, mem64_t posix_time)
int cellRtcGetWin32FileTime(u32 datetime_addr, mem64_t win32_time) int cellRtcGetWin32FileTime(u32 datetime_addr, mem64_t win32_time)
{ {
cellRtc.Log("cellRtcGetWin32FileTime(datetime_addr=0x%x, win32_time_addr=0x%x)", datetime_addr, win32_time.GetAddr()); cellRtc.Log("cellRtcGetWin32FileTime(datetime_addr=0x%x, win32_time_addr=0x%x)", datetime_addr, win32_time.GetAddr());
CellRtcDateTime *datetime = new CellRtcDateTime; CellRtcDateTime datetime;
datetime->year = Memory.Read16(datetime_addr); datetime.year = Memory.Read16(datetime_addr);
datetime->month = Memory.Read16(datetime_addr + 2); datetime.month = Memory.Read16(datetime_addr + 2);
datetime->day = Memory.Read16(datetime_addr + 4); datetime.day = Memory.Read16(datetime_addr + 4);
datetime->hour = Memory.Read16(datetime_addr + 6); datetime.hour = Memory.Read16(datetime_addr + 6);
datetime->minute = Memory.Read16(datetime_addr + 8); datetime.minute = Memory.Read16(datetime_addr + 8);
datetime->second = Memory.Read16(datetime_addr + 10); datetime.second = Memory.Read16(datetime_addr + 10);
datetime->microsecond = Memory.Read32(datetime_addr + 12); datetime.microsecond = Memory.Read32(datetime_addr + 12);
// Convert to WIN32 FILETIME. // Convert to WIN32 FILETIME.
wxDateTime date_time = wxDateTime::wxDateTime(datetime->day, (wxDateTime::Month)datetime->month, datetime->year, datetime->hour, datetime->minute, datetime->second, (datetime->microsecond / 1000)); wxDateTime date_time = wxDateTime::wxDateTime(datetime.day, (wxDateTime::Month)datetime.month, datetime.year, datetime.hour, datetime.minute, datetime.second, (datetime.microsecond / 1000));
win32_time = convertToWin32FILETIME(date_time.GetSecond(wxDateTime::TZ::UTC), date_time.GetMinute(wxDateTime::TZ::UTC), win32_time = convertToWin32FILETIME(date_time.GetSecond(wxDateTime::TZ::UTC), date_time.GetMinute(wxDateTime::TZ::UTC),
date_time.GetHour(wxDateTime::TZ::UTC), date_time.GetDay(wxDateTime::TZ::UTC), date_time.GetYear(wxDateTime::TZ::UTC)); date_time.GetHour(wxDateTime::TZ::UTC), date_time.GetDay(wxDateTime::TZ::UTC), date_time.GetYear(wxDateTime::TZ::UTC));
@ -451,22 +434,22 @@ int cellRtcSetDosTime(u32 datetime_addr, u32 dos_time_addr)
wxDateTime date_time; wxDateTime date_time;
wxDateTime dos_time = date_time.SetFromDOS(Memory.Read32(dos_time_addr)); wxDateTime dos_time = date_time.SetFromDOS(Memory.Read32(dos_time_addr));
CellRtcDateTime *datetime = new CellRtcDateTime; CellRtcDateTime datetime;
datetime->year = dos_time.GetYear(wxDateTime::TZ::UTC); datetime.year = dos_time.GetYear(wxDateTime::TZ::UTC);
datetime->month = dos_time.GetMonth(wxDateTime::TZ::UTC); datetime.month = dos_time.GetMonth(wxDateTime::TZ::UTC);
datetime->day = dos_time.GetDay(wxDateTime::TZ::UTC); datetime.day = dos_time.GetDay(wxDateTime::TZ::UTC);
datetime->hour = dos_time.GetHour(wxDateTime::TZ::UTC); datetime.hour = dos_time.GetHour(wxDateTime::TZ::UTC);
datetime->minute = dos_time.GetMinute(wxDateTime::TZ::UTC); datetime.minute = dos_time.GetMinute(wxDateTime::TZ::UTC);
datetime->second = dos_time.GetSecond(wxDateTime::TZ::UTC); datetime.second = dos_time.GetSecond(wxDateTime::TZ::UTC);
datetime->microsecond = dos_time.GetMillisecond(wxDateTime::TZ::UTC) * 1000; datetime.microsecond = dos_time.GetMillisecond(wxDateTime::TZ::UTC) * 1000;
Memory.Write16(datetime_addr, datetime->year); Memory.Write16(datetime_addr, datetime.year);
Memory.Write16(datetime_addr + 2, datetime->month); Memory.Write16(datetime_addr + 2, datetime.month);
Memory.Write16(datetime_addr + 4, datetime->day); Memory.Write16(datetime_addr + 4, datetime.day);
Memory.Write16(datetime_addr + 6, datetime->hour); Memory.Write16(datetime_addr + 6, datetime.hour);
Memory.Write16(datetime_addr + 8, datetime->minute); Memory.Write16(datetime_addr + 8, datetime.minute);
Memory.Write16(datetime_addr + 10, datetime->second); Memory.Write16(datetime_addr + 10, datetime.second);
Memory.Write32(datetime_addr + 12, datetime->microsecond); Memory.Write32(datetime_addr + 12, datetime.microsecond);
return CELL_OK; return CELL_OK;
} }
@ -477,22 +460,22 @@ int cellRtcSetTime_t(u32 datetime_addr, u32 posix_time_addr)
wxDateTime date_time = wxDateTime::wxDateTime((time_t)Memory.Read64(posix_time_addr)); wxDateTime date_time = wxDateTime::wxDateTime((time_t)Memory.Read64(posix_time_addr));
CellRtcDateTime *datetime = new CellRtcDateTime; CellRtcDateTime datetime;
datetime->year = date_time.GetYear(wxDateTime::TZ::UTC); datetime.year = date_time.GetYear(wxDateTime::TZ::UTC);
datetime->month = date_time.GetMonth(wxDateTime::TZ::UTC); datetime.month = date_time.GetMonth(wxDateTime::TZ::UTC);
datetime->day = date_time.GetDay(wxDateTime::TZ::UTC); datetime.day = date_time.GetDay(wxDateTime::TZ::UTC);
datetime->hour = date_time.GetHour(wxDateTime::TZ::UTC); datetime.hour = date_time.GetHour(wxDateTime::TZ::UTC);
datetime->minute = date_time.GetMinute(wxDateTime::TZ::UTC); datetime.minute = date_time.GetMinute(wxDateTime::TZ::UTC);
datetime->second = date_time.GetSecond(wxDateTime::TZ::UTC); datetime.second = date_time.GetSecond(wxDateTime::TZ::UTC);
datetime->microsecond = date_time.GetMillisecond(wxDateTime::TZ::UTC) * 1000; datetime.microsecond = date_time.GetMillisecond(wxDateTime::TZ::UTC) * 1000;
Memory.Write16(datetime_addr, datetime->year); Memory.Write16(datetime_addr, datetime.year);
Memory.Write16(datetime_addr + 2, datetime->month); Memory.Write16(datetime_addr + 2, datetime.month);
Memory.Write16(datetime_addr + 4, datetime->day); Memory.Write16(datetime_addr + 4, datetime.day);
Memory.Write16(datetime_addr + 6, datetime->hour); Memory.Write16(datetime_addr + 6, datetime.hour);
Memory.Write16(datetime_addr + 8, datetime->minute); Memory.Write16(datetime_addr + 8, datetime.minute);
Memory.Write16(datetime_addr + 10, datetime->second); Memory.Write16(datetime_addr + 10, datetime.second);
Memory.Write32(datetime_addr + 12, datetime->microsecond); Memory.Write32(datetime_addr + 12, datetime.microsecond);
return CELL_OK; return CELL_OK;
} }
@ -503,22 +486,22 @@ int cellRtcSetWin32FileTime(u32 datetime_addr, u32 win32_time_addr)
wxDateTime date_time = wxDateTime::wxDateTime((time_t)Memory.Read64(win32_time_addr)); wxDateTime date_time = wxDateTime::wxDateTime((time_t)Memory.Read64(win32_time_addr));
CellRtcDateTime *datetime = new CellRtcDateTime; CellRtcDateTime datetime;
datetime->year = date_time.GetYear(wxDateTime::TZ::UTC); datetime.year = date_time.GetYear(wxDateTime::TZ::UTC);
datetime->month = date_time.GetMonth(wxDateTime::TZ::UTC); datetime.month = date_time.GetMonth(wxDateTime::TZ::UTC);
datetime->day = date_time.GetDay(wxDateTime::TZ::UTC); datetime.day = date_time.GetDay(wxDateTime::TZ::UTC);
datetime->hour = date_time.GetHour(wxDateTime::TZ::UTC); datetime.hour = date_time.GetHour(wxDateTime::TZ::UTC);
datetime->minute = date_time.GetMinute(wxDateTime::TZ::UTC); datetime.minute = date_time.GetMinute(wxDateTime::TZ::UTC);
datetime->second = date_time.GetSecond(wxDateTime::TZ::UTC); datetime.second = date_time.GetSecond(wxDateTime::TZ::UTC);
datetime->microsecond = date_time.GetMillisecond(wxDateTime::TZ::UTC) * 1000; datetime.microsecond = date_time.GetMillisecond(wxDateTime::TZ::UTC) * 1000;
Memory.Write16(datetime_addr, datetime->year); Memory.Write16(datetime_addr, datetime.year);
Memory.Write16(datetime_addr + 2, datetime->month); Memory.Write16(datetime_addr + 2, datetime.month);
Memory.Write16(datetime_addr + 4, datetime->day); Memory.Write16(datetime_addr + 4, datetime.day);
Memory.Write16(datetime_addr + 6, datetime->hour); Memory.Write16(datetime_addr + 6, datetime.hour);
Memory.Write16(datetime_addr + 8, datetime->minute); Memory.Write16(datetime_addr + 8, datetime.minute);
Memory.Write16(datetime_addr + 10, datetime->second); Memory.Write16(datetime_addr + 10, datetime.second);
Memory.Write32(datetime_addr + 12, datetime->microsecond); Memory.Write32(datetime_addr + 12, datetime.microsecond);
return CELL_OK; return CELL_OK;
} }
@ -551,30 +534,30 @@ int cellRtcGetDayOfWeek(int year, int month, int day)
int cellRtcCheckValid(u32 datetime_addr) int cellRtcCheckValid(u32 datetime_addr)
{ {
cellRtc.Log("cellRtcCheckValid(datetime_addr=0x%x)", datetime_addr); cellRtc.Log("cellRtcCheckValid(datetime_addr=0x%x)", datetime_addr);
CellRtcDateTime *datetime = new CellRtcDateTime; CellRtcDateTime datetime;
datetime->year = Memory.Read16(datetime_addr); datetime.year = Memory.Read16(datetime_addr);
datetime->month = Memory.Read16(datetime_addr + 2); datetime.month = Memory.Read16(datetime_addr + 2);
datetime->day = Memory.Read16(datetime_addr + 4); datetime.day = Memory.Read16(datetime_addr + 4);
datetime->hour = Memory.Read16(datetime_addr + 6); datetime.hour = Memory.Read16(datetime_addr + 6);
datetime->minute = Memory.Read16(datetime_addr + 8); datetime.minute = Memory.Read16(datetime_addr + 8);
datetime->second = Memory.Read16(datetime_addr + 10); datetime.second = Memory.Read16(datetime_addr + 10);
datetime->microsecond = Memory.Read32(datetime_addr + 12); datetime.microsecond = Memory.Read32(datetime_addr + 12);
if((datetime->year < 1) || (datetime->year > 9999)) return CELL_RTC_ERROR_INVALID_YEAR; if((datetime.year < 1) || (datetime.year > 9999)) return CELL_RTC_ERROR_INVALID_YEAR;
else if((datetime->month < 1) || (datetime->month > 12)) return CELL_RTC_ERROR_INVALID_MONTH; else if((datetime.month < 1) || (datetime.month > 12)) return CELL_RTC_ERROR_INVALID_MONTH;
else if((datetime->day < 1) || (datetime->day > 31)) return CELL_RTC_ERROR_INVALID_DAY; else if((datetime.day < 1) || (datetime.day > 31)) return CELL_RTC_ERROR_INVALID_DAY;
else if((datetime->hour < 0) || (datetime->hour > 23)) return CELL_RTC_ERROR_INVALID_HOUR; else if((datetime.hour < 0) || (datetime.hour > 23)) return CELL_RTC_ERROR_INVALID_HOUR;
else if((datetime->minute < 0) || (datetime->minute > 59)) return CELL_RTC_ERROR_INVALID_MINUTE; else if((datetime.minute < 0) || (datetime.minute > 59)) return CELL_RTC_ERROR_INVALID_MINUTE;
else if((datetime->second < 0) || (datetime->second > 59)) return CELL_RTC_ERROR_INVALID_SECOND; else if((datetime.second < 0) || (datetime.second > 59)) return CELL_RTC_ERROR_INVALID_SECOND;
else if((datetime->microsecond < 0) || (datetime->microsecond > 999999)) return CELL_RTC_ERROR_INVALID_MICROSECOND; else if((datetime.microsecond < 0) || (datetime.microsecond > 999999)) return CELL_RTC_ERROR_INVALID_MICROSECOND;
else return CELL_OK; else return CELL_OK;
} }
int cellRtcCompareTick(u32 tick_addr_1, u32 tick_addr_2) int cellRtcCompareTick(u32 tick_addr_1, u32 tick_addr_2)
{ {
cellRtc.Log("cellRtcCompareTick(tick_addr_1=0x%x, tick_addr_2=0x%x)", tick_addr_1, tick_addr_2); cellRtc.Log("cellRtcCompareTick(tick_addr_1=0x%x, tick_addr_2=0x%x)", tick_addr_1, tick_addr_2);
long tick1 = Memory.Read64(tick_addr_1); u64 tick1 = Memory.Read64(tick_addr_1);
long tick2 = Memory.Read64(tick_addr_2); u64 tick2 = Memory.Read64(tick_addr_2);
if(tick1 < tick2) return -1; if(tick1 < tick2) return -1;
else if(tick1 > tick2) return 1; else if(tick1 > tick2) return 1;

214
rpcs3/Emu/SysCalls/Modules/cellSysmodule.cpp
View file

@ -16,11 +16,11 @@ enum
}; };
const char *getModuleName(int id) { const char *getModuleName(int id) {
struct Entry { struct
{
const char *name; const char *name;
int id; int id;
}; } static const entries[] = {
static const Entry entries[] = {
{"CELL_SYSMODULE_INVALID", 0x0000ffff}, {"CELL_SYSMODULE_INVALID", 0x0000ffff},
{"CELL_SYSMODULE_NET", 0x00000000}, {"CELL_SYSMODULE_NET", 0x00000000},
{"CELL_SYSMODULE_HTTP", 0x00000001}, {"CELL_SYSMODULE_HTTP", 0x00000001},
@ -28,109 +28,113 @@ const char *getModuleName(int id) {
{"CELL_SYSMODULE_SSL", 0x00000003}, {"CELL_SYSMODULE_SSL", 0x00000003},
{"CELL_SYSMODULE_HTTPS", 0x00000004}, {"CELL_SYSMODULE_HTTPS", 0x00000004},
{"CELL_SYSMODULE_VDEC", 0x00000005}, {"CELL_SYSMODULE_VDEC", 0x00000005},
{"CELL_SYSMODULE_ADEC", 0x00000006}, {"CELL_SYSMODULE_ADEC", 0x00000006},
{"CELL_SYSMODULE_DMUX", 0x00000007}, {"CELL_SYSMODULE_DMUX", 0x00000007},
{"CELL_SYSMODULE_VPOST", 0x00000008}, {"CELL_SYSMODULE_VPOST", 0x00000008},
{"CELL_SYSMODULE_RTC", 0x00000009}, {"CELL_SYSMODULE_RTC", 0x00000009},
{"CELL_SYSMODULE_SPURS", 0x0000000a}, {"CELL_SYSMODULE_SPURS", 0x0000000a},
{"CELL_SYSMODULE_OVIS", 0x0000000b}, {"CELL_SYSMODULE_OVIS", 0x0000000b},
{"CELL_SYSMODULE_SHEAP", 0x0000000c}, {"CELL_SYSMODULE_SHEAP", 0x0000000c},
{"CELL_SYSMODULE_SYNC", 0x0000000d}, {"CELL_SYSMODULE_SYNC", 0x0000000d},
{"CELL_SYSMODULE_FS", 0x0000000e}, {"CELL_SYSMODULE_FS", 0x0000000e},
{"CELL_SYSMODULE_JPGDEC", 0x0000000f}, {"CELL_SYSMODULE_JPGDEC", 0x0000000f},
{"CELL_SYSMODULE_GCM_SYS", 0x00000010}, {"CELL_SYSMODULE_GCM_SYS", 0x00000010},
{"CELL_SYSMODULE_GCM", 0x00000010}, {"CELL_SYSMODULE_GCM", 0x00000010},
{"CELL_SYSMODULE_AUDIO", 0x00000011}, {"CELL_SYSMODULE_AUDIO", 0x00000011},
{"CELL_SYSMODULE_PAMF", 0x00000012}, {"CELL_SYSMODULE_PAMF", 0x00000012},
{"CELL_SYSMODULE_ATRAC3PLUS", 0x00000013}, {"CELL_SYSMODULE_ATRAC3PLUS", 0x00000013},
{"CELL_SYSMODULE_NETCTL", 0x00000014}, {"CELL_SYSMODULE_NETCTL", 0x00000014},
{"CELL_SYSMODULE_SYSUTIL", 0x00000015}, {"CELL_SYSMODULE_SYSUTIL", 0x00000015},
{"CELL_SYSMODULE_SYSUTIL_NP", 0x00000016}, {"CELL_SYSMODULE_SYSUTIL_NP", 0x00000016},
{"CELL_SYSMODULE_IO", 0x00000017}, {"CELL_SYSMODULE_IO", 0x00000017},
{"CELL_SYSMODULE_PNGDEC", 0x00000018}, {"CELL_SYSMODULE_PNGDEC", 0x00000018},
{"CELL_SYSMODULE_FONT", 0x00000019}, {"CELL_SYSMODULE_FONT", 0x00000019},
{"CELL_SYSMODULE_FONTFT", 0x0000001a}, {"CELL_SYSMODULE_FONTFT", 0x0000001a},
{"CELL_SYSMODULE_FREETYPE", 0x0000001b}, {"CELL_SYSMODULE_FREETYPE", 0x0000001b},
{"CELL_SYSMODULE_USBD", 0x0000001c}, {"CELL_SYSMODULE_USBD", 0x0000001c},
{"CELL_SYSMODULE_SAIL", 0x0000001d}, {"CELL_SYSMODULE_SAIL", 0x0000001d},
{"CELL_SYSMODULE_L10N", 0x0000001e}, {"CELL_SYSMODULE_L10N", 0x0000001e},
{"CELL_SYSMODULE_RESC", 0x0000001f}, {"CELL_SYSMODULE_RESC", 0x0000001f},
{"CELL_SYSMODULE_DAISY", 0x00000020}, {"CELL_SYSMODULE_DAISY", 0x00000020},
{"CELL_SYSMODULE_KEY2CHAR", 0x00000021}, {"CELL_SYSMODULE_KEY2CHAR", 0x00000021},
{"CELL_SYSMODULE_MIC", 0x00000022}, {"CELL_SYSMODULE_MIC", 0x00000022},
{"CELL_SYSMODULE_CAMERA", 0x00000023}, {"CELL_SYSMODULE_CAMERA", 0x00000023},
{"CELL_SYSMODULE_VDEC_MPEG2", 0x00000024}, {"CELL_SYSMODULE_VDEC_MPEG2", 0x00000024},
{"CELL_SYSMODULE_VDEC_AVC", 0x00000025}, {"CELL_SYSMODULE_VDEC_AVC", 0x00000025},
{"CELL_SYSMODULE_ADEC_LPCM", 0x00000026}, {"CELL_SYSMODULE_ADEC_LPCM", 0x00000026},
{"CELL_SYSMODULE_ADEC_AC3", 0x00000027}, {"CELL_SYSMODULE_ADEC_AC3", 0x00000027},
{"CELL_SYSMODULE_ADEC_ATX", 0x00000028}, {"CELL_SYSMODULE_ADEC_ATX", 0x00000028},
{"CELL_SYSMODULE_ADEC_AT3", 0x00000029}, {"CELL_SYSMODULE_ADEC_AT3", 0x00000029},
{"CELL_SYSMODULE_DMUX_PAMF", 0x0000002a}, {"CELL_SYSMODULE_DMUX_PAMF", 0x0000002a},
{"CELL_SYSMODULE_VDEC_AL", 0x0000002b}, {"CELL_SYSMODULE_VDEC_AL", 0x0000002b},
{"CELL_SYSMODULE_ADEC_AL", 0x0000002c}, {"CELL_SYSMODULE_ADEC_AL", 0x0000002c},
{"CELL_SYSMODULE_DMUX_AL", 0x0000002d}, {"CELL_SYSMODULE_DMUX_AL", 0x0000002d},
{"CELL_SYSMODULE_LV2DBG", 0x0000002e}, {"CELL_SYSMODULE_LV2DBG", 0x0000002e},
{"CELL_SYSMODULE_USBPSPCM", 0x00000030}, {"CELL_SYSMODULE_USBPSPCM", 0x00000030},
{"CELL_SYSMODULE_AVCONF_EXT", 0x00000031}, {"CELL_SYSMODULE_AVCONF_EXT", 0x00000031},
{"CELL_SYSMODULE_SYSUTIL_USERINFO", 0x00000032}, {"CELL_SYSMODULE_SYSUTIL_USERINFO", 0x00000032},
{"CELL_SYSMODULE_SYSUTIL_SAVEDATA", 0x00000033}, {"CELL_SYSMODULE_SYSUTIL_SAVEDATA", 0x00000033},
{"CELL_SYSMODULE_SUBDISPLAY", 0x00000034}, {"CELL_SYSMODULE_SUBDISPLAY", 0x00000034},
{"CELL_SYSMODULE_SYSUTIL_REC", 0x00000035}, {"CELL_SYSMODULE_SYSUTIL_REC", 0x00000035},
{"CELL_SYSMODULE_VIDEO_EXPORT", 0x00000036}, {"CELL_SYSMODULE_VIDEO_EXPORT", 0x00000036},
{"CELL_SYSMODULE_SYSUTIL_GAME_EXEC", 0x00000037}, {"CELL_SYSMODULE_SYSUTIL_GAME_EXEC", 0x00000037},
{"CELL_SYSMODULE_SYSUTIL_NP2", 0x00000038}, {"CELL_SYSMODULE_SYSUTIL_NP2", 0x00000038},
{"CELL_SYSMODULE_SYSUTIL_AP", 0x00000039}, {"CELL_SYSMODULE_SYSUTIL_AP", 0x00000039},
{"CELL_SYSMODULE_SYSUTIL_NP_CLANS", 0x0000003a}, {"CELL_SYSMODULE_SYSUTIL_NP_CLANS", 0x0000003a},
{"CELL_SYSMODULE_SYSUTIL_OSK_EXT", 0x0000003b}, {"CELL_SYSMODULE_SYSUTIL_OSK_EXT", 0x0000003b},
{"CELL_SYSMODULE_VDEC_DIVX", 0x0000003c}, {"CELL_SYSMODULE_VDEC_DIVX", 0x0000003c},
{"CELL_SYSMODULE_JPGENC", 0x0000003d}, {"CELL_SYSMODULE_JPGENC", 0x0000003d},
{"CELL_SYSMODULE_SYSUTIL_GAME", 0x0000003e}, {"CELL_SYSMODULE_SYSUTIL_GAME", 0x0000003e},
{"CELL_SYSMODULE_BGDL", 0x0000003f}, {"CELL_SYSMODULE_BGDL", 0x0000003f},
{"CELL_SYSMODULE_FREETYPE_TT", 0x00000040}, {"CELL_SYSMODULE_FREETYPE_TT", 0x00000040},
{"CELL_SYSMODULE_SYSUTIL_VIDEO_UPLOAD", 0x00000041}, {"CELL_SYSMODULE_SYSUTIL_VIDEO_UPLOAD", 0x00000041},
{"CELL_SYSMODULE_SYSUTIL_SYSCONF_EXT", 0x00000042}, {"CELL_SYSMODULE_SYSUTIL_SYSCONF_EXT", 0x00000042},
{"CELL_SYSMODULE_FIBER", 0x00000043}, {"CELL_SYSMODULE_FIBER", 0x00000043},
{"CELL_SYSMODULE_SYSUTIL_NP_COMMERCE2", 0x00000044}, {"CELL_SYSMODULE_SYSUTIL_NP_COMMERCE2", 0x00000044},
{"CELL_SYSMODULE_SYSUTIL_NP_TUS", 0x00000045}, {"CELL_SYSMODULE_SYSUTIL_NP_TUS", 0x00000045},
{"CELL_SYSMODULE_VOICE", 0x00000046}, {"CELL_SYSMODULE_VOICE", 0x00000046},
{"CELL_SYSMODULE_ADEC_CELP8", 0x00000047}, {"CELL_SYSMODULE_ADEC_CELP8", 0x00000047},
{"CELL_SYSMODULE_CELP8ENC", 0x00000048}, {"CELL_SYSMODULE_CELP8ENC", 0x00000048},
{"CELL_SYSMODULE_SYSUTIL_LICENSEAREA", 0x00000049}, {"CELL_SYSMODULE_SYSUTIL_LICENSEAREA", 0x00000049},
{"CELL_SYSMODULE_SYSUTIL_MUSIC2", 0x0000004a}, {"CELL_SYSMODULE_SYSUTIL_MUSIC2", 0x0000004a},
{"CELL_SYSMODULE_SYSUTIL_SCREENSHOT", 0x0000004e}, {"CELL_SYSMODULE_SYSUTIL_SCREENSHOT", 0x0000004e},
{"CELL_SYSMODULE_SYSUTIL_MUSIC_DECODE", 0x0000004f}, {"CELL_SYSMODULE_SYSUTIL_MUSIC_DECODE", 0x0000004f},
{"CELL_SYSMODULE_SPURS_JQ", 0x00000050}, {"CELL_SYSMODULE_SPURS_JQ", 0x00000050},
{"CELL_SYSMODULE_PNGENC", 0x00000052}, {"CELL_SYSMODULE_PNGENC", 0x00000052},
{"CELL_SYSMODULE_SYSUTIL_MUSIC_DECODE2", 0x00000053}, {"CELL_SYSMODULE_SYSUTIL_MUSIC_DECODE2", 0x00000053},
{"CELL_SYSMODULE_SYNC2", 0x00000055}, {"CELL_SYSMODULE_SYNC2", 0x00000055},
{"CELL_SYSMODULE_SYSUTIL_NP_UTIL", 0x00000056}, {"CELL_SYSMODULE_SYSUTIL_NP_UTIL", 0x00000056},
{"CELL_SYSMODULE_RUDP", 0x00000057}, {"CELL_SYSMODULE_RUDP", 0x00000057},
{"CELL_SYSMODULE_SYSUTIL_NP_SNS", 0x00000059}, {"CELL_SYSMODULE_SYSUTIL_NP_SNS", 0x00000059},
{"CELL_SYSMODULE_GEM", 0x0000005a}, {"CELL_SYSMODULE_GEM", 0x0000005a},
{"CELL_SYSMODULE_CELPENC", 0x0000f00a}, {"CELL_SYSMODULE_CELPENC", 0x0000f00a},
{"CELL_SYSMODULE_GIFDEC", 0x0000f010}, {"CELL_SYSMODULE_GIFDEC", 0x0000f010},
{"CELL_SYSMODULE_ADEC_CELP", 0x0000f019}, {"CELL_SYSMODULE_ADEC_CELP", 0x0000f019},
{"CELL_SYSMODULE_ADEC_M2BC", 0x0000f01b}, {"CELL_SYSMODULE_ADEC_M2BC", 0x0000f01b},
{"CELL_SYSMODULE_ADEC_M4AAC", 0x0000f01d}, {"CELL_SYSMODULE_ADEC_M4AAC", 0x0000f01d},
{"CELL_SYSMODULE_ADEC_MP3", 0x0000f01e}, {"CELL_SYSMODULE_ADEC_MP3", 0x0000f01e},
{"CELL_SYSMODULE_IMEJP", 0x0000f023}, {"CELL_SYSMODULE_IMEJP", 0x0000f023},
{"CELL_SYSMODULE_SYSUTIL_MUSIC", 0x0000f028}, {"CELL_SYSMODULE_SYSUTIL_MUSIC", 0x0000f028},
{"CELL_SYSMODULE_PHOTO_EXPORT", 0x0000f029}, {"CELL_SYSMODULE_PHOTO_EXPORT", 0x0000f029},
{"CELL_SYSMODULE_PRINT", 0x0000f02a}, {"CELL_SYSMODULE_PRINT", 0x0000f02a},
{"CELL_SYSMODULE_PHOTO_IMPORT", 0x0000f02b}, {"CELL_SYSMODULE_PHOTO_IMPORT", 0x0000f02b},
{"CELL_SYSMODULE_MUSIC_EXPORT", 0x0000f02c}, {"CELL_SYSMODULE_MUSIC_EXPORT", 0x0000f02c},
{"CELL_SYSMODULE_PHOTO_DECODE", 0x0000f02e}, {"CELL_SYSMODULE_PHOTO_DECODE", 0x0000f02e},
{"CELL_SYSMODULE_SYSUTIL_SEARCH", 0x0000f02f}, {"CELL_SYSMODULE_SYSUTIL_SEARCH", 0x0000f02f},
{"CELL_SYSMODULE_SYSUTIL_AVCHAT2", 0x0000f030}, {"CELL_SYSMODULE_SYSUTIL_AVCHAT2", 0x0000f030},
{"CELL_SYSMODULE_SAIL_REC", 0x0000f034}, {"CELL_SYSMODULE_SAIL_REC", 0x0000f034},
{"CELL_SYSMODULE_SYSUTIL_NP_TROPHY", 0x0000f035}, {"CELL_SYSMODULE_SYSUTIL_NP_TROPHY", 0x0000f035},
{"CELL_SYSMODULE_LIBATRAC3MULTI", 0x0000f054}, {"CELL_SYSMODULE_LIBATRAC3MULTI", 0x0000f054},
}; };
for (int i = 0; i < 103; ++i) {
if (entries[i].id == id) { for (int i = 0; i < sizeof(entries) / sizeof(entries[0]); ++i)
return entries[i].name; {
} if (entries[i].id == id)
} {
return entries[i].name;
}
}
return 0; return 0;
} }

6
rpcs3/Loader/ELF32.cpp
View file

@ -59,7 +59,7 @@ bool ELF32Loader::LoadEhdrInfo()
return false; return false;
} }
entry = ehdr.GetEntry() & ~0x3; entry = ehdr.GetEntry();
if(entry == 0) if(entry == 0)
{ {
ConLog.Error("elf32 error: entry is null!"); ConLog.Error("elf32 error: entry is null!");
@ -86,10 +86,12 @@ bool ELF32Loader::LoadPhdrInfo()
phdr_arr.Move(phdr); phdr_arr.Move(phdr);
} }
if(!Memory.IsGoodAddr(entry)) if(/*!Memory.IsGoodAddr(entry)*/ entry & 0x1)
{ {
//entry is physical, convert to virtual //entry is physical, convert to virtual
entry &= ~0x1;
for(size_t i=0; i<phdr_arr.GetCount(); ++i) for(size_t i=0; i<phdr_arr.GetCount(); ++i)
{ {
if(phdr_arr[i].p_paddr >= entry && entry < phdr_arr[i].p_paddr + phdr_arr[i].p_memsz) if(phdr_arr[i].p_paddr >= entry && entry < phdr_arr[i].p_paddr + phdr_arr[i].p_memsz)