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

use only one set of logging macros instead of two and don't use free() as a function name

Browse source
This commit is contained in:
Peter Tissen 2014-06-27 15:26:46 +02:00
parent afad6daa7d
commit 95f1a0e645
74 changed files with 800 additions and 793 deletions
Download patch file Download diff file Expand all files Collapse all files

33
Utilities/Log.h
View file

@ -11,21 +11,12 @@
//#define BUFFERED_LOGGING 1 //#define BUFFERED_LOGGING 1
//another msvc bug makes these not work, uncomment these and replace it with the one at the bottom when it's fixed
//#define LOG_MESSAGE(logType, severity, text) Log::LogManager::getInstance().log({logType, severity, text})
//first parameter is of type Log::LogType and text is of type std::string //first parameter is of type Log::LogType and text is of type std::string
#define LOG_MESSAGE(logType, severity, text) do{Log::LogMessage msg{logType, severity, text}; Log::LogManager::getInstance().log(msg);}while(0)
#define LOG_SUCCESS(logType, text) LOG_MESSAGE(logType, Log::Success, text) #define LOG_SUCCESS(logType, text, ...) log_message(logType, Log::Success, text, ##__VA_ARGS__)
#define LOG_NOTICE(logType, text) LOG_MESSAGE(logType, Log::Notice, text) #define LOG_NOTICE(logType, text, ...) log_message(logType, Log::Notice, text, ##__VA_ARGS__)
#define LOG_WARNING(logType, text) LOG_MESSAGE(logType, Log::Warning, text) #define LOG_WARNING(logType, text, ...) log_message(logType, Log::Warning, text, ##__VA_ARGS__)
#define LOG_ERROR(logType, text) LOG_MESSAGE(logType, Log::Error, text) #define LOG_ERROR(logType, text, ...) log_message(logType, Log::Error, text, ##__VA_ARGS__)
#define LOGF_SUCCESS(logType, fmtstring, ...) LOG_SUCCESS(logType, fmt::Format(fmtstring, ##__VA_ARGS__ ))
#define LOGF_NOTICE(logType, fmtstring, ...) LOG_NOTICE(logType, fmt::Format(fmtstring, ##__VA_ARGS__ ))
#define LOGF_WARNING(logType, fmtstring, ...) LOG_WARNING(logType, fmt::Format(fmtstring, ##__VA_ARGS__ ))
#define LOGF_ERROR(logType, fmtstring, ...) LOG_ERROR(logType, fmt::Format(fmtstring, ##__VA_ARGS__ ))
namespace Log namespace Log
{ {
@ -139,3 +130,19 @@ static struct { inline operator Log::LogType() { return Log::LogType::HLE; } } H
static struct { inline operator Log::LogType() { return Log::LogType::PPU; } } PPU; static struct { inline operator Log::LogType() { return Log::LogType::PPU; } } PPU;
static struct { inline operator Log::LogType() { return Log::LogType::SPU; } } SPU; static struct { inline operator Log::LogType() { return Log::LogType::SPU; } } SPU;
static struct { inline operator Log::LogType() { return Log::LogType::TTY; } } TTY; static struct { inline operator Log::LogType() { return Log::LogType::TTY; } } TTY;
inline void log_message(Log::LogType type, Log::LogSeverity sev, std::string text)
{
//another msvc bug makes this not work, uncomment this and delete everything else in this function when it's fixed
//Log::LogManager::getInstance().log({logType, severity, text})
Log::LogMessage msg{type, sev, text};
Log::LogManager::getInstance().log(msg);
}
template<typename T, typename ...Ts>
inline void log_message(Log::LogType type, Log::LogSeverity sev, std::string text, T arg, Ts... args)
{
Log::LogMessage msg{type, sev, fmt::Format(text,arg,args...)};
Log::LogManager::getInstance().log(msg);
}

12
Utilities/MTRingbuffer.h
View file

@ -25,8 +25,8 @@ class MTRingbuffer{
public: public:
MTRingbuffer() : mGet(0), mPut(0){} MTRingbuffer() : mGet(0), mPut(0){}
//blocks until there's something to get, so check "free()" if you want to avoid blocking //blocks until there's something to get, so check "spaceLeft()" if you want to avoid blocking
//also lock the get mutex around the free() check and the pop if you want to avoid racing //also lock the get mutex around the spaceLeft() check and the pop if you want to avoid racing
T pop() T pop()
{ {
std::lock_guard<std::recursive_mutex> lock(mMutGet); std::lock_guard<std::recursive_mutex> lock(mMutGet);
@ -63,7 +63,7 @@ public:
//returns the amount of free places, this is the amount of actual free spaces-1 //returns the amount of free places, this is the amount of actual free spaces-1
//since mGet==mPut signals an empty buffer we can't actually use the last free //since mGet==mPut signals an empty buffer we can't actually use the last free
//space, so we shouldn't report it as free. //space, so we shouldn't report it as free.
size_t free() size_t spaceLeft() //apparently free() is a macro definition in msvc in some conditions
{ {
if (mGet < mPut) if (mGet < mPut)
{ {
@ -81,8 +81,8 @@ public:
size_t size() size_t size()
{ {
//the magic -1 is the same magic 1 that is explained in the free() function //the magic -1 is the same magic 1 that is explained in the spaceLeft() function
return mBuffer.size() - free() - 1; return mBuffer.size() - spaceLeft() - 1;
} }
//takes random access iterator to T //takes random access iterator to T
@ -94,7 +94,7 @@ public:
//if whatever we're trying to store is greater than the entire buffer the following loop will be infinite //if whatever we're trying to store is greater than the entire buffer the following loop will be infinite
assert(mBuffer.size() > length); assert(mBuffer.size() > length);
while (free() < length) while (spaceLeft() < length)
{ {
//if this is reached a lot it's time to increase the buffer size //if this is reached a lot it's time to increase the buffer size
//or implement dynamic re-sizing //or implement dynamic re-sizing

20
rpcs3/Crypto/unedat.cpp
View file

@ -275,8 +275,8 @@ int decrypt_data(rFile *in, rFile *out, EDAT_SDAT_HEADER *edat, NPD_HEADER *npd,
if (verbose) if (verbose)
{ {
LOGF_NOTICE(LOADER, "EDAT: Compressed block size: %d\n", pad_length); LOG_NOTICE(LOADER, "EDAT: Compressed block size: %d\n", pad_length);
LOGF_NOTICE(LOADER, "EDAT: Decompressed block size: %d\n", res); LOG_NOTICE(LOADER, "EDAT: Decompressed block size: %d\n", res);
} }
edat->file_size -= res; edat->file_size -= res;
@ -337,7 +337,7 @@ static bool check_flags(EDAT_SDAT_HEADER *edat, NPD_HEADER *npd)
} }
else if (npd->version > 4) else if (npd->version > 4)
{ {
LOGF_ERROR(LOADER, "EDAT: Unknown version - %d\n", npd->version); LOG_ERROR(LOADER, "EDAT: Unknown version - %d\n", npd->version);
return false; return false;
} }
@ -418,7 +418,7 @@ int check_data(unsigned char *key, EDAT_SDAT_HEADER *edat, NPD_HEADER *npd, rFil
if (!crypto(hash_mode, crypto_mode, (npd->version == 4), data, tmp, block_size, header_key, header_iv, key, hash_result)) if (!crypto(hash_mode, crypto_mode, (npd->version == 4), data, tmp, block_size, header_key, header_iv, key, hash_result))
{ {
if (verbose) if (verbose)
LOGF_WARNING(LOADER, "EDAT: Metadata hash from block 0x%08x is invalid!\n", metadata_offset + bytes_read); LOG_WARNING(LOADER, "EDAT: Metadata hash from block 0x%08x is invalid!\n", metadata_offset + bytes_read);
} }
// Adjust sizes. // Adjust sizes.
@ -535,14 +535,14 @@ bool extract_data(rFile *input, rFile *output, const char* input_file_name, unsi
if (verbose) if (verbose)
{ {
LOG_NOTICE(LOADER, "NPD HEADER\n"); LOG_NOTICE(LOADER, "NPD HEADER\n");
LOGF_NOTICE(LOADER, "NPD version: %d\n", NPD->version); LOG_NOTICE(LOADER, "NPD version: %d\n", NPD->version);
LOGF_NOTICE(LOADER, "NPD license: %d\n", NPD->license); LOG_NOTICE(LOADER, "NPD license: %d\n", NPD->license);
LOGF_NOTICE(LOADER, "NPD type: %d\n", NPD->type); LOG_NOTICE(LOADER, "NPD type: %d\n", NPD->type);
LOG_NOTICE(LOADER, "\n"); LOG_NOTICE(LOADER, "\n");
LOG_NOTICE(LOADER, "EDAT HEADER\n"); LOG_NOTICE(LOADER, "EDAT HEADER\n");
LOGF_NOTICE(LOADER, "EDAT flags: 0x%08X\n", EDAT->flags); LOG_NOTICE(LOADER, "EDAT flags: 0x%08X\n", EDAT->flags);
LOGF_NOTICE(LOADER, "EDAT block size: 0x%08X\n", EDAT->block_size); LOG_NOTICE(LOADER, "EDAT block size: 0x%08X\n", EDAT->block_size);
LOGF_NOTICE(LOADER, "EDAT file size: 0x%08X\n", EDAT->file_size); LOG_NOTICE(LOADER, "EDAT file size: 0x%08X\n", EDAT->file_size);
LOG_NOTICE(LOADER, "\n"); LOG_NOTICE(LOADER, "\n");
} }

96
rpcs3/Crypto/unself.cpp
View file

@ -17,7 +17,7 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
// Check SCE magic. // Check SCE magic.
if (!sce_hdr.CheckMagic()) if (!sce_hdr.CheckMagic())
{ {
LOGF_ERROR(LOADER, "SELF: Not a SELF file!"); LOG_ERROR(LOADER, "SELF: Not a SELF file!");
return false; return false;
} }
@ -41,7 +41,7 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
phdr32_arr.clear(); phdr32_arr.clear();
if(elf32_hdr.e_phoff == 0 && elf32_hdr.e_phnum) if(elf32_hdr.e_phoff == 0 && elf32_hdr.e_phnum)
{ {
LOGF_ERROR(LOADER, "SELF: ELF program header offset is null!"); LOG_ERROR(LOADER, "SELF: ELF program header offset is null!");
return false; return false;
} }
self_f.Seek(self_hdr.se_phdroff); self_f.Seek(self_hdr.se_phdroff);
@ -56,7 +56,7 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
phdr64_arr.clear(); phdr64_arr.clear();
if(elf64_hdr.e_phoff == 0 && elf64_hdr.e_phnum) if(elf64_hdr.e_phoff == 0 && elf64_hdr.e_phnum)
{ {
LOGF_ERROR(LOADER, "SELF: ELF program header offset is null!"); LOG_ERROR(LOADER, "SELF: ELF program header offset is null!");
return false; return false;
} }
self_f.Seek(self_hdr.se_phdroff); self_f.Seek(self_hdr.se_phdroff);
@ -101,7 +101,7 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
shdr32_arr.clear(); shdr32_arr.clear();
if(elf32_hdr.e_shoff == 0 && elf32_hdr.e_shnum) if(elf32_hdr.e_shoff == 0 && elf32_hdr.e_shnum)
{ {
LOGF_WARNING(LOADER, "SELF: ELF section header offset is null!"); LOG_WARNING(LOADER, "SELF: ELF section header offset is null!");
return true; return true;
} }
self_f.Seek(self_hdr.se_shdroff); self_f.Seek(self_hdr.se_shdroff);
@ -116,7 +116,7 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
shdr64_arr.clear(); shdr64_arr.clear();
if(elf64_hdr.e_shoff == 0 && elf64_hdr.e_shnum) if(elf64_hdr.e_shoff == 0 && elf64_hdr.e_shnum)
{ {
LOGF_WARNING(LOADER, "SELF: ELF section header offset is null!"); LOG_WARNING(LOADER, "SELF: ELF section header offset is null!");
return true; return true;
} }
self_f.Seek(self_hdr.se_shdroff); self_f.Seek(self_hdr.se_shdroff);
@ -132,46 +132,46 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
void SELFDecrypter::ShowHeaders(bool isElf32) void SELFDecrypter::ShowHeaders(bool isElf32)
{ {
LOGF_NOTICE(LOADER, "SCE header"); LOG_NOTICE(LOADER, "SCE header");
LOGF_NOTICE(LOADER, "----------------------------------------------------"); LOG_NOTICE(LOADER, "----------------------------------------------------");
sce_hdr.Show(); sce_hdr.Show();
LOGF_NOTICE(LOADER, "----------------------------------------------------"); LOG_NOTICE(LOADER, "----------------------------------------------------");
LOGF_NOTICE(LOADER, "SELF header"); LOG_NOTICE(LOADER, "SELF header");
LOGF_NOTICE(LOADER, "----------------------------------------------------"); LOG_NOTICE(LOADER, "----------------------------------------------------");
self_hdr.Show(); self_hdr.Show();
LOGF_NOTICE(LOADER, "----------------------------------------------------"); LOG_NOTICE(LOADER, "----------------------------------------------------");
LOGF_NOTICE(LOADER, "APP INFO"); LOG_NOTICE(LOADER, "APP INFO");
LOGF_NOTICE(LOADER, "----------------------------------------------------"); LOG_NOTICE(LOADER, "----------------------------------------------------");
app_info.Show(); app_info.Show();
LOGF_NOTICE(LOADER, "----------------------------------------------------"); LOG_NOTICE(LOADER, "----------------------------------------------------");
LOGF_NOTICE(LOADER, "ELF header"); LOG_NOTICE(LOADER, "ELF header");
LOGF_NOTICE(LOADER, "----------------------------------------------------"); LOG_NOTICE(LOADER, "----------------------------------------------------");
isElf32 ? elf32_hdr.Show() : elf64_hdr.Show(); isElf32 ? elf32_hdr.Show() : elf64_hdr.Show();
LOGF_NOTICE(LOADER, "----------------------------------------------------"); LOG_NOTICE(LOADER, "----------------------------------------------------");
LOGF_NOTICE(LOADER, "ELF program headers"); LOG_NOTICE(LOADER, "ELF program headers");
LOGF_NOTICE(LOADER, "----------------------------------------------------"); LOG_NOTICE(LOADER, "----------------------------------------------------");
for(unsigned int i = 0; i < ((isElf32) ? phdr32_arr.size() : phdr64_arr.size()); i++) for(unsigned int i = 0; i < ((isElf32) ? phdr32_arr.size() : phdr64_arr.size()); i++)
isElf32 ? phdr32_arr[i].Show() : phdr64_arr[i].Show(); isElf32 ? phdr32_arr[i].Show() : phdr64_arr[i].Show();
LOGF_NOTICE(LOADER, "----------------------------------------------------"); LOG_NOTICE(LOADER, "----------------------------------------------------");
LOGF_NOTICE(LOADER, "Section info"); LOG_NOTICE(LOADER, "Section info");
LOGF_NOTICE(LOADER, "----------------------------------------------------"); LOG_NOTICE(LOADER, "----------------------------------------------------");
for(unsigned int i = 0; i < secinfo_arr.size(); i++) for(unsigned int i = 0; i < secinfo_arr.size(); i++)
secinfo_arr[i].Show(); secinfo_arr[i].Show();
LOGF_NOTICE(LOADER, "----------------------------------------------------"); LOG_NOTICE(LOADER, "----------------------------------------------------");
LOGF_NOTICE(LOADER, "SCE version info"); LOG_NOTICE(LOADER, "SCE version info");
LOGF_NOTICE(LOADER, "----------------------------------------------------"); LOG_NOTICE(LOADER, "----------------------------------------------------");
scev_info.Show(); scev_info.Show();
LOGF_NOTICE(LOADER, "----------------------------------------------------"); LOG_NOTICE(LOADER, "----------------------------------------------------");
LOGF_NOTICE(LOADER, "Control info"); LOG_NOTICE(LOADER, "Control info");
LOGF_NOTICE(LOADER, "----------------------------------------------------"); LOG_NOTICE(LOADER, "----------------------------------------------------");
for(unsigned int i = 0; i < ctrlinfo_arr.size(); i++) for(unsigned int i = 0; i < ctrlinfo_arr.size(); i++)
ctrlinfo_arr[i].Show(); ctrlinfo_arr[i].Show();
LOGF_NOTICE(LOADER, "----------------------------------------------------"); LOG_NOTICE(LOADER, "----------------------------------------------------");
LOGF_NOTICE(LOADER, "ELF section headers"); LOG_NOTICE(LOADER, "ELF section headers");
LOGF_NOTICE(LOADER, "----------------------------------------------------"); LOG_NOTICE(LOADER, "----------------------------------------------------");
for(unsigned int i = 0; i < ((isElf32) ? shdr32_arr.size() : shdr64_arr.size()); i++) for(unsigned int i = 0; i < ((isElf32) ? shdr32_arr.size() : shdr64_arr.size()); i++)
isElf32 ? shdr32_arr[i].Show() : shdr64_arr[i].Show(); isElf32 ? shdr32_arr[i].Show() : shdr64_arr[i].Show();
LOGF_NOTICE(LOADER, "----------------------------------------------------"); LOG_NOTICE(LOADER, "----------------------------------------------------");
} }
bool SELFDecrypter::DecryptNPDRM(u8 *metadata, u32 metadata_size) bool SELFDecrypter::DecryptNPDRM(u8 *metadata, u32 metadata_size)
@ -195,7 +195,7 @@ bool SELFDecrypter::DecryptNPDRM(u8 *metadata, u32 metadata_size)
// If not, the data has no NPDRM layer. // If not, the data has no NPDRM layer.
if (!ctrl) if (!ctrl)
{ {
LOGF_WARNING(LOADER, "SELF: No NPDRM control info found!"); LOG_WARNING(LOADER, "SELF: No NPDRM control info found!");
return true; return true;
} }
@ -208,7 +208,7 @@ bool SELFDecrypter::DecryptNPDRM(u8 *metadata, u32 metadata_size)
if (ctrl->npdrm.license == 1) // Network license. if (ctrl->npdrm.license == 1) // Network license.
{ {
LOGF_ERROR(LOADER, "SELF: Can't decrypt network NPDRM!"); LOG_ERROR(LOADER, "SELF: Can't decrypt network NPDRM!");
return false; return false;
} }
else if (ctrl->npdrm.license == 2) // Local license. else if (ctrl->npdrm.license == 2) // Local license.
@ -216,7 +216,7 @@ bool SELFDecrypter::DecryptNPDRM(u8 *metadata, u32 metadata_size)
// Try to find a RAP file to get the key. // Try to find a RAP file to get the key.
if (!GetKeyFromRap(ctrl->npdrm.content_id, npdrm_key)) if (!GetKeyFromRap(ctrl->npdrm.content_id, npdrm_key))
{ {
LOGF_ERROR(LOADER, "SELF: Can't find RAP file for NPDRM decryption!"); LOG_ERROR(LOADER, "SELF: Can't find RAP file for NPDRM decryption!");
return false; return false;
} }
} }
@ -227,7 +227,7 @@ bool SELFDecrypter::DecryptNPDRM(u8 *metadata, u32 metadata_size)
} }
else else
{ {
LOGF_ERROR(LOADER, "SELF: Invalid NPDRM license type!"); LOG_ERROR(LOADER, "SELF: Invalid NPDRM license type!");
return false; return false;
} }
@ -290,7 +290,7 @@ bool SELFDecrypter::LoadMetadata()
if ((meta_info.key_pad[0] != 0x00) || if ((meta_info.key_pad[0] != 0x00) ||
(meta_info.iv_pad[0] != 0x00)) (meta_info.iv_pad[0] != 0x00))
{ {
LOGF_ERROR(LOADER, "SELF: Failed to decrypt metadata info!"); LOG_ERROR(LOADER, "SELF: Failed to decrypt metadata info!");
return false; return false;
} }
@ -392,7 +392,7 @@ bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32)
rFile e(elf.c_str(), rFile::write); rFile e(elf.c_str(), rFile::write);
if(!e.IsOpened()) if(!e.IsOpened())
{ {
LOGF_ERROR(LOADER, "Could not create ELF file! (%s)", elf.c_str()); LOG_ERROR(LOADER, "Could not create ELF file! (%s)", elf.c_str());
return false; return false;
} }
@ -510,7 +510,7 @@ bool SELFDecrypter::GetKeyFromRap(u8 *content_id, u8 *npdrm_key)
// Check if we have a valid RAP file. // Check if we have a valid RAP file.
if (!rFile::Exists(rap_path)) if (!rFile::Exists(rap_path))
{ {
LOGF_ERROR(LOADER, "This application requires a valid RAP file for decryption!"); LOG_ERROR(LOADER, "This application requires a valid RAP file for decryption!");
return false; return false;
} }
@ -519,11 +519,11 @@ bool SELFDecrypter::GetKeyFromRap(u8 *content_id, u8 *npdrm_key)
if (!rap_file.IsOpened()) if (!rap_file.IsOpened())
{ {
LOGF_ERROR(LOADER, "Failed to load RAP file!"); LOG_ERROR(LOADER, "Failed to load RAP file!");
return false; return false;
} }
LOGF_NOTICE(LOADER, "Loading RAP file %s", (ci_str + ".rap").c_str()); LOG_NOTICE(LOADER, "Loading RAP file %s", (ci_str + ".rap").c_str());
rap_file.Read(rap_key, 0x10); rap_file.Read(rap_key, 0x10);
rap_file.Close(); rap_file.Close();
@ -573,7 +573,7 @@ bool CheckDebugSelf(const std::string& self, const std::string& elf)
if(!s.IsOpened()) if(!s.IsOpened())
{ {
LOGF_ERROR(LOADER, "Could not open SELF file! (%s)", self.c_str()); LOG_ERROR(LOADER, "Could not open SELF file! (%s)", self.c_str());
return false; return false;
} }
@ -585,7 +585,7 @@ bool CheckDebugSelf(const std::string& self, const std::string& elf)
// Check for DEBUG version. // Check for DEBUG version.
if(swap16(key_version) == 0x8000) if(swap16(key_version) == 0x8000)
{ {
LOGF_WARNING(LOADER, "Debug SELF detected! Removing fake header..."); LOG_WARNING(LOADER, "Debug SELF detected! Removing fake header...");
// Get the real elf offset. // Get the real elf offset.
s.Seek(0x10); s.Seek(0x10);
@ -600,7 +600,7 @@ bool CheckDebugSelf(const std::string& self, const std::string& elf)
rFile e(elf, rFile::write); rFile e(elf, rFile::write);
if(!e.IsOpened()) if(!e.IsOpened())
{ {
LOGF_ERROR(LOADER, "Could not create ELF file! (%s)", elf.c_str()); LOG_ERROR(LOADER, "Could not create ELF file! (%s)", elf.c_str());
return false; return false;
} }
@ -640,28 +640,28 @@ bool DecryptSelf(const std::string& elf, const std::string& self)
// Load the SELF file headers. // Load the SELF file headers.
if (!self_dec.LoadHeaders(isElf32)) if (!self_dec.LoadHeaders(isElf32))
{ {
LOGF_ERROR(LOADER, "SELF: Failed to load SELF file headers!"); LOG_ERROR(LOADER, "SELF: Failed to load SELF file headers!");
return false; return false;
} }
// Load and decrypt the SELF file metadata. // Load and decrypt the SELF file metadata.
if (!self_dec.LoadMetadata()) if (!self_dec.LoadMetadata())
{ {
LOGF_ERROR(LOADER, "SELF: Failed to load SELF file metadata!"); LOG_ERROR(LOADER, "SELF: Failed to load SELF file metadata!");
return false; return false;
} }
// Decrypt the SELF file data. // Decrypt the SELF file data.
if (!self_dec.DecryptData()) if (!self_dec.DecryptData())
{ {
LOGF_ERROR(LOADER, "SELF: Failed to decrypt SELF file data!"); LOG_ERROR(LOADER, "SELF: Failed to decrypt SELF file data!");
return false; return false;
} }
// Make a new ELF file from this SELF. // Make a new ELF file from this SELF.
if (!self_dec.MakeElf(elf, isElf32)) if (!self_dec.MakeElf(elf, isElf32))
{ {
LOGF_ERROR(LOADER, "SELF: Failed to make ELF file from SELF!"); LOG_ERROR(LOADER, "SELF: Failed to make ELF file from SELF!");
return false; return false;
} }
} }

122
rpcs3/Crypto/unself.h
View file

@ -25,10 +25,10 @@ struct AppInfo
void Show() void Show()
{ {
LOGF_NOTICE(LOADER, "AuthID: 0x%llx", authid); LOG_NOTICE(LOADER, "AuthID: 0x%llx", authid);
LOGF_NOTICE(LOADER, "VendorID: 0x%08x", vendor_id); LOG_NOTICE(LOADER, "VendorID: 0x%08x", vendor_id);
LOGF_NOTICE(LOADER, "SELF type: 0x%08x", self_type); LOG_NOTICE(LOADER, "SELF type: 0x%08x", self_type);
LOGF_NOTICE(LOADER, "Version: 0x%llx", version); LOG_NOTICE(LOADER, "Version: 0x%llx", version);
} }
}; };
@ -53,12 +53,12 @@ struct SectionInfo
void Show() void Show()
{ {
LOGF_NOTICE(LOADER, "Offset: 0x%llx", offset); LOG_NOTICE(LOADER, "Offset: 0x%llx", offset);
LOGF_NOTICE(LOADER, "Size: 0x%llx", size); LOG_NOTICE(LOADER, "Size: 0x%llx", size);
LOGF_NOTICE(LOADER, "Compressed: 0x%08x", compressed); LOG_NOTICE(LOADER, "Compressed: 0x%08x", compressed);
LOGF_NOTICE(LOADER, "Unknown1: 0x%08x", unknown1); LOG_NOTICE(LOADER, "Unknown1: 0x%08x", unknown1);
LOGF_NOTICE(LOADER, "Unknown2: 0x%08x", unknown2); LOG_NOTICE(LOADER, "Unknown2: 0x%08x", unknown2);
LOGF_NOTICE(LOADER, "Encrypted: 0x%08x", encrypted); LOG_NOTICE(LOADER, "Encrypted: 0x%08x", encrypted);
} }
}; };
@ -79,10 +79,10 @@ struct SCEVersionInfo
void Show() void Show()
{ {
LOGF_NOTICE(LOADER, "Sub-header type: 0x%08x", subheader_type); LOG_NOTICE(LOADER, "Sub-header type: 0x%08x", subheader_type);
LOGF_NOTICE(LOADER, "Present: 0x%08x", present); LOG_NOTICE(LOADER, "Present: 0x%08x", present);
LOGF_NOTICE(LOADER, "Size: 0x%08x", size); LOG_NOTICE(LOADER, "Size: 0x%08x", size);
LOGF_NOTICE(LOADER, "Unknown: 0x%08x", unknown); LOG_NOTICE(LOADER, "Unknown: 0x%08x", unknown);
} }
}; };
@ -181,20 +181,20 @@ struct ControlInfo
void Show() void Show()
{ {
LOGF_NOTICE(LOADER, "Type: 0x%08x", type); LOG_NOTICE(LOADER, "Type: 0x%08x", type);
LOGF_NOTICE(LOADER, "Size: 0x%08x", size); LOG_NOTICE(LOADER, "Size: 0x%08x", size);
LOGF_NOTICE(LOADER, "Next: 0x%llx", next); LOG_NOTICE(LOADER, "Next: 0x%llx", next);
if (type == 1) if (type == 1)
{ {
LOGF_NOTICE(LOADER, "Control flag 1: 0x%08x", control_flags.ctrl_flag1); LOG_NOTICE(LOADER, "Control flag 1: 0x%08x", control_flags.ctrl_flag1);
LOGF_NOTICE(LOADER, "Unknown1: 0x%08x", control_flags.unknown1); LOG_NOTICE(LOADER, "Unknown1: 0x%08x", control_flags.unknown1);
LOGF_NOTICE(LOADER, "Unknown2: 0x%08x", control_flags.unknown2); LOG_NOTICE(LOADER, "Unknown2: 0x%08x", control_flags.unknown2);
LOGF_NOTICE(LOADER, "Unknown3: 0x%08x", control_flags.unknown3); LOG_NOTICE(LOADER, "Unknown3: 0x%08x", control_flags.unknown3);
LOGF_NOTICE(LOADER, "Unknown4: 0x%08x", control_flags.unknown4); LOG_NOTICE(LOADER, "Unknown4: 0x%08x", control_flags.unknown4);
LOGF_NOTICE(LOADER, "Unknown5: 0x%08x", control_flags.unknown5); LOG_NOTICE(LOADER, "Unknown5: 0x%08x", control_flags.unknown5);
LOGF_NOTICE(LOADER, "Unknown6: 0x%08x", control_flags.unknown6); LOG_NOTICE(LOADER, "Unknown6: 0x%08x", control_flags.unknown6);
LOGF_NOTICE(LOADER, "Unknown7: 0x%08x", control_flags.unknown7); LOG_NOTICE(LOADER, "Unknown7: 0x%08x", control_flags.unknown7);
} }
else if (type == 2) else if (type == 2)
{ {
@ -204,8 +204,8 @@ struct ControlInfo
for (int i = 0; i < 20; i++) for (int i = 0; i < 20; i++)
digest_str += fmt::Format("%02x", file_digest_30.digest[i]); digest_str += fmt::Format("%02x", file_digest_30.digest[i]);
LOGF_NOTICE(LOADER, "Digest: %s", digest_str.c_str()); LOG_NOTICE(LOADER, "Digest: %s", digest_str.c_str());
LOGF_NOTICE(LOADER, "Unknown: 0x%llx", file_digest_30.unknown); LOG_NOTICE(LOADER, "Unknown: 0x%llx", file_digest_30.unknown);
} }
else if (size == 0x40) else if (size == 0x40)
{ {
@ -217,9 +217,9 @@ struct ControlInfo
digest_str2 += fmt::Format("%02x", file_digest_40.digest2[i]); digest_str2 += fmt::Format("%02x", file_digest_40.digest2[i]);
} }
LOGF_NOTICE(LOADER, "Digest1: %s", digest_str1.c_str()); LOG_NOTICE(LOADER, "Digest1: %s", digest_str1.c_str());
LOGF_NOTICE(LOADER, "Digest2: %s", digest_str2.c_str()); LOG_NOTICE(LOADER, "Digest2: %s", digest_str2.c_str());
LOGF_NOTICE(LOADER, "Unknown: 0x%llx", file_digest_40.unknown); LOG_NOTICE(LOADER, "Unknown: 0x%llx", file_digest_40.unknown);
} }
} }
else if (type == 3) else if (type == 3)
@ -237,16 +237,16 @@ struct ControlInfo
xordigest_str += fmt::Format("%02x", npdrm.xordigest[i]); xordigest_str += fmt::Format("%02x", npdrm.xordigest[i]);
} }
LOGF_NOTICE(LOADER, "Magic: 0x%08x", npdrm.magic); LOG_NOTICE(LOADER, "Magic: 0x%08x", npdrm.magic);
LOGF_NOTICE(LOADER, "Unknown1: 0x%08x", npdrm.unknown1); LOG_NOTICE(LOADER, "Unknown1: 0x%08x", npdrm.unknown1);
LOGF_NOTICE(LOADER, "License: 0x%08x", npdrm.license); LOG_NOTICE(LOADER, "License: 0x%08x", npdrm.license);
LOGF_NOTICE(LOADER, "Type: 0x%08x", npdrm.type); LOG_NOTICE(LOADER, "Type: 0x%08x", npdrm.type);
LOGF_NOTICE(LOADER, "ContentID: %s", contentid_str.c_str()); LOG_NOTICE(LOADER, "ContentID: %s", contentid_str.c_str());
LOGF_NOTICE(LOADER, "Digest: %s", digest_str.c_str()); LOG_NOTICE(LOADER, "Digest: %s", digest_str.c_str());
LOGF_NOTICE(LOADER, "Inverse digest: %s", invdigest_str.c_str()); LOG_NOTICE(LOADER, "Inverse digest: %s", invdigest_str.c_str());
LOGF_NOTICE(LOADER, "XOR digest: %s", xordigest_str.c_str()); LOG_NOTICE(LOADER, "XOR digest: %s", xordigest_str.c_str());
LOGF_NOTICE(LOADER, "Unknown2: 0x%llx", npdrm.unknown2); LOG_NOTICE(LOADER, "Unknown2: 0x%llx", npdrm.unknown2);
LOGF_NOTICE(LOADER, "Unknown3: 0x%llx", npdrm.unknown3); LOG_NOTICE(LOADER, "Unknown3: 0x%llx", npdrm.unknown3);
} }
} }
}; };
@ -281,10 +281,10 @@ struct MetadataInfo
iv_pad_str += fmt::Format("%02x", iv_pad[i]); iv_pad_str += fmt::Format("%02x", iv_pad[i]);
} }
LOGF_NOTICE(LOADER, "Key: %s", key_str.c_str()); LOG_NOTICE(LOADER, "Key: %s", key_str.c_str());
LOGF_NOTICE(LOADER, "Key pad: %s", key_pad_str.c_str()); LOG_NOTICE(LOADER, "Key pad: %s", key_pad_str.c_str());
LOGF_NOTICE(LOADER, "IV: %s", iv_str.c_str()); LOG_NOTICE(LOADER, "IV: %s", iv_str.c_str());
LOGF_NOTICE(LOADER, "IV pad: %s", iv_pad_str.c_str()); LOG_NOTICE(LOADER, "IV pad: %s", iv_pad_str.c_str());
} }
}; };
@ -320,13 +320,13 @@ struct MetadataHeader
void Show() void Show()
{ {
LOGF_NOTICE(LOADER, "Signature input length: 0x%llx", signature_input_length); LOG_NOTICE(LOADER, "Signature input length: 0x%llx", signature_input_length);
LOGF_NOTICE(LOADER, "Unknown1: 0x%08x", unknown1); LOG_NOTICE(LOADER, "Unknown1: 0x%08x", unknown1);
LOGF_NOTICE(LOADER, "Section count: 0x%08x", section_count); LOG_NOTICE(LOADER, "Section count: 0x%08x", section_count);
LOGF_NOTICE(LOADER, "Key count: 0x%08x", key_count); LOG_NOTICE(LOADER, "Key count: 0x%08x", key_count);
LOGF_NOTICE(LOADER, "Optional header size: 0x%08x", opt_header_size); LOG_NOTICE(LOADER, "Optional header size: 0x%08x", opt_header_size);
LOGF_NOTICE(LOADER, "Unknown2: 0x%08x", unknown2); LOG_NOTICE(LOADER, "Unknown2: 0x%08x", unknown2);
LOGF_NOTICE(LOADER, "Unknown3: 0x%08x", unknown3); LOG_NOTICE(LOADER, "Unknown3: 0x%08x", unknown3);
} }
}; };
@ -371,16 +371,16 @@ struct MetadataSectionHeader
void Show() void Show()
{ {
LOGF_NOTICE(LOADER, "Data offset: 0x%llx", data_offset); LOG_NOTICE(LOADER, "Data offset: 0x%llx", data_offset);
LOGF_NOTICE(LOADER, "Data size: 0x%llx", data_size); LOG_NOTICE(LOADER, "Data size: 0x%llx", data_size);
LOGF_NOTICE(LOADER, "Type: 0x%08x", type); LOG_NOTICE(LOADER, "Type: 0x%08x", type);
LOGF_NOTICE(LOADER, "Program index: 0x%08x", program_idx); LOG_NOTICE(LOADER, "Program index: 0x%08x", program_idx);
LOGF_NOTICE(LOADER, "Hashed: 0x%08x", hashed); LOG_NOTICE(LOADER, "Hashed: 0x%08x", hashed);
LOGF_NOTICE(LOADER, "SHA1 index: 0x%08x", sha1_idx); LOG_NOTICE(LOADER, "SHA1 index: 0x%08x", sha1_idx);
LOGF_NOTICE(LOADER, "Encrypted: 0x%08x", encrypted); LOG_NOTICE(LOADER, "Encrypted: 0x%08x", encrypted);
LOGF_NOTICE(LOADER, "Key index: 0x%08x", key_idx); LOG_NOTICE(LOADER, "Key index: 0x%08x", key_idx);
LOGF_NOTICE(LOADER, "IV index: 0x%08x", iv_idx); LOG_NOTICE(LOADER, "IV index: 0x%08x", iv_idx);
LOGF_NOTICE(LOADER, "Compressed: 0x%08x", compressed); LOG_NOTICE(LOADER, "Compressed: 0x%08x", compressed);
} }
}; };

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

@ -316,7 +316,7 @@ protected:
void UNK(const u16 code0, const u16 code1) void UNK(const u16 code0, const u16 code1)
{ {
LOGF_ERROR(HLE, "Unknown/Illegal opcode! (0x%04x : 0x%04x)", code0, code1); LOG_ERROR(HLE, "Unknown/Illegal opcode! (0x%04x : 0x%04x)", code0, code1);
Emu.Pause(); Emu.Pause();
} }
}; };

6
rpcs3/Emu/Audio/AL/OpenALThread.cpp
View file

@ -18,7 +18,7 @@ void printAlError(ALenum err, const char* situation)
{ {
if(err != AL_NO_ERROR) if(err != AL_NO_ERROR)
{ {
LOGF_ERROR(HLE, "%s: OpenAL error 0x%04x", situation, err); LOG_ERROR(HLE, "%s: OpenAL error 0x%04x", situation, err);
Emu.Pause(); Emu.Pause();
} }
} }
@ -27,7 +27,7 @@ void printAlcError(ALCenum err, const char* situation)
{ {
if(err != ALC_NO_ERROR) if(err != ALC_NO_ERROR)
{ {
LOGF_ERROR(HLE, "%s: OpenALC error 0x%04x", situation, err); LOG_ERROR(HLE, "%s: OpenALC error 0x%04x", situation, err);
Emu.Pause(); Emu.Pause();
} }
} }
@ -137,7 +137,7 @@ void OpenALThread::AddData(const void* src, ALsizei size)
int bsize = size < m_buffer_size ? size : m_buffer_size; int bsize = size < m_buffer_size ? size : m_buffer_size;
if (!AddBlock(buffer, bsize, bsrc)) if (!AddBlock(buffer, bsize, bsrc))
LOGF_ERROR(HLE, "OpenALThread::AddBlock: invalid block size: %d", bsize); LOG_ERROR(HLE, "OpenALThread::AddBlock: invalid block size: %d", bsize);
alSourceQueueBuffers(m_source, 1, &buffer); alSourceQueueBuffers(m_source, 1, &buffer);
checkForAlError("alSourceQueueBuffers"); checkForAlError("alSourceQueueBuffers");

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

@ -149,7 +149,7 @@ void CPUThread::SetBranch(const u64 pc, bool record_branch)
{ {
if(!Memory.IsGoodAddr(m_offset + pc)) if(!Memory.IsGoodAddr(m_offset + pc))
{ {
LOGF_ERROR(PPU, "%s branch error: bad address 0x%llx #pc: 0x%llx", GetFName().c_str(), m_offset + pc, m_offset + PC); LOG_ERROR(PPU, "%s branch error: bad address 0x%llx #pc: 0x%llx", GetFName().c_str(), m_offset + pc, m_offset + PC);
Emu.Pause(); Emu.Pause();
} }
@ -282,7 +282,7 @@ void CPUThread::ExecOnce()
void CPUThread::Task() void CPUThread::Task()
{ {
if (Ini.HLELogging.GetValue()) LOGF_NOTICE(PPU, "%s enter", CPUThread::GetFName().c_str()); if (Ini.HLELogging.GetValue()) LOG_NOTICE(PPU, "%s enter", CPUThread::GetFName().c_str());
const std::vector<u64>& bp = Emu.GetBreakPoints(); const std::vector<u64>& bp = Emu.GetBreakPoints();
@ -333,18 +333,18 @@ void CPUThread::Task()
} }
catch(const std::string& e) catch(const std::string& e)
{ {
LOGF_ERROR(PPU, "Exception: %s", e.c_str()); LOG_ERROR(PPU, "Exception: %s", e.c_str());
} }
catch(const char* e) catch(const char* e)
{ {
LOGF_ERROR(PPU, "Exception: %s", e); LOG_ERROR(PPU, "Exception: %s", e);
} }
catch(int exitcode) catch(int exitcode)
{ {
LOGF_SUCCESS(PPU, "Exit Code: %d", exitcode); LOG_SUCCESS(PPU, "Exit Code: %d", exitcode);
} }
if (Ini.HLELogging.GetValue()) LOGF_NOTICE(PPU, "%s leave", CPUThread::GetFName().c_str()); if (Ini.HLELogging.GetValue()) LOG_NOTICE(PPU, "%s leave", CPUThread::GetFName().c_str());
} }
s64 CPUThread::ExecAsCallback(u64 pc, bool wait, u64 a1, u64 a2, u64 a3, u64 a4) // not multithread-safe s64 CPUThread::ExecAsCallback(u64 pc, bool wait, u64 a1, u64 a2, u64 a3, u64 a4) // not multithread-safe
@ -353,7 +353,7 @@ s64 CPUThread::ExecAsCallback(u64 pc, bool wait, u64 a1, u64 a2, u64 a3, u64 a4)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(PPU, "ExecAsCallback() aborted"); LOG_WARNING(PPU, "ExecAsCallback() aborted");
return CELL_ECANCELED; // doesn't mean anything return CELL_ECANCELED; // doesn't mean anything
} }
Sleep(1); Sleep(1);
@ -379,7 +379,7 @@ s64 CPUThread::ExecAsCallback(u64 pc, bool wait, u64 a1, u64 a2, u64 a3, u64 a4)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(PPU, "ExecAsCallback(wait=%s) aborted", wait ? "true" : "false"); LOG_WARNING(PPU, "ExecAsCallback(wait=%s) aborted", wait ? "true" : "false");
return CELL_EABORT; // doesn't mean anything return CELL_EABORT; // doesn't mean anything
} }
Sleep(1); Sleep(1);

14
rpcs3/Emu/Cell/MFC.h
View file

@ -183,7 +183,7 @@ struct DMAC
return true; return true;
default: default:
LOGF_ERROR(HLE, "DMAC::ProcessCmd(): Unknown DMA cmd."); LOG_ERROR(HLE, "DMAC::ProcessCmd(): Unknown DMA cmd.");
return true; return true;
} }
} }
@ -268,11 +268,11 @@ struct DMAC
u16 tag = (u16)size_tag; u16 tag = (u16)size_tag;
u16 size = size_tag >> 16; u16 size = size_tag >> 16;
LOGF_WARNING(HLE, "RawSPU DMA %s:", op == MFC_PUT_CMD ? "PUT" : "GET"); LOG_WARNING(HLE, "RawSPU DMA %s:", op == MFC_PUT_CMD ? "PUT" : "GET");
LOGF_WARNING(HLE, "*** lsa = 0x%x", lsa); LOG_WARNING(HLE, "*** lsa = 0x%x", lsa);
LOGF_WARNING(HLE, "*** ea = 0x%llx", ea); LOG_WARNING(HLE, "*** ea = 0x%llx", ea);
LOGF_WARNING(HLE, "*** tag = 0x%x", tag); LOG_WARNING(HLE, "*** tag = 0x%x", tag);
LOGF_WARNING(HLE, "*** size = 0x%x", size); LOG_WARNING(HLE, "*** size = 0x%x", size);
LOG_WARNING(HLE, " "); LOG_WARNING(HLE, " ");
MFC_CMDStatus.SetValue(dmac.Cmd(cmd, tag, lsa, ea, size)); MFC_CMDStatus.SetValue(dmac.Cmd(cmd, tag, lsa, ea, size));
@ -280,7 +280,7 @@ struct DMAC
break; break;
default: default:
LOGF_ERROR(HLE, "Unknown MFC cmd. (opcode=0x%x, cmd=0x%x)", op, cmd); LOG_ERROR(HLE, "Unknown MFC cmd. (opcode=0x%x, cmd=0x%x)", op, cmd);
break; break;
} }
} }

26
rpcs3/Emu/Cell/PPUInterpreter.h
View file

@ -70,16 +70,16 @@ private:
if(Ini.HLELogging.GetValue()) if(Ini.HLELogging.GetValue())
{ {
LOGF_WARNING(PPU, "SysCall[0x%llx ('%s')] done with code [0x%llx]! #pc: 0x%llx", CPU.GPR[11], SysCalls::GetHLEFuncName(CPU.GPR[11]).c_str(), CPU.GPR[3], CPU.PC); LOG_WARNING(PPU, "SysCall[0x%llx ('%s')] done with code [0x%llx]! #pc: 0x%llx", CPU.GPR[11], SysCalls::GetHLEFuncName(CPU.GPR[11]).c_str(), CPU.GPR[3], CPU.PC);
} }
/*else if ((s64)CPU.GPR[3] < 0) // probably, error code /*else if ((s64)CPU.GPR[3] < 0) // probably, error code
{ {
LOGF_ERROR(PPU, "SysCall[0x%llx] done with code [0x%llx]! #pc: 0x%llx", CPU.GPR[11], CPU.GPR[3], CPU.PC); LOG_ERROR(PPU, "SysCall[0x%llx] done with code [0x%llx]! #pc: 0x%llx", CPU.GPR[11], CPU.GPR[3], CPU.PC);
if(CPU.GPR[11] > 1024) if(CPU.GPR[11] > 1024)
SysCalls::DoFunc(CPU.GPR[11]); SysCalls::DoFunc(CPU.GPR[11]);
}*/ }*/
#ifdef HLE_CALL_DEBUG #ifdef HLE_CALL_DEBUG
LOGF_NOTICE(PPU, "SysCall[%lld] done with code [0x%llx]! #pc: 0x%llx", CPU.GPR[11], CPU.GPR[3], CPU.PC); LOG_NOTICE(PPU, "SysCall[%lld] done with code [0x%llx]! #pc: 0x%llx", CPU.GPR[11], CPU.GPR[3], CPU.PC);
#endif #endif
} }
@ -2097,7 +2097,7 @@ private:
Emu.GetSFuncManager().StaticExecute(CPU.GPR[11]); Emu.GetSFuncManager().StaticExecute(CPU.GPR[11]);
if (Ini.HLELogging.GetValue()) if (Ini.HLELogging.GetValue())
{ {
LOGF_NOTICE(PPU, "'%s' done with code[0x%llx]! #pc: 0x%llx", LOG_NOTICE(PPU, "'%s' done with code[0x%llx]! #pc: 0x%llx",
Emu.GetSFuncManager()[CPU.GPR[11]]->name, CPU.GPR[3], CPU.PC); Emu.GetSFuncManager()[CPU.GPR[11]]->name, CPU.GPR[3], CPU.PC);
} }
break; break;
@ -3995,20 +3995,20 @@ private:
void UNK(const std::string& err, bool pause = true) void UNK(const std::string& err, bool pause = true)
{ {
LOGF_ERROR(PPU, err + fmt::Format(" #pc: 0x%llx", CPU.PC)); LOG_ERROR(PPU, err + fmt::Format(" #pc: 0x%llx", CPU.PC));
if(!pause) return; if(!pause) return;
Emu.Pause(); Emu.Pause();
for(uint i=0; i<32; ++i) LOGF_NOTICE(PPU, "r%d = 0x%llx", i, CPU.GPR[i]); for(uint i=0; i<32; ++i) LOG_NOTICE(PPU, "r%d = 0x%llx", i, CPU.GPR[i]);
for(uint i=0; i<32; ++i) LOGF_NOTICE(PPU, "f%d = %llf", i, CPU.FPR[i]); for(uint i=0; i<32; ++i) LOG_NOTICE(PPU, "f%d = %llf", i, CPU.FPR[i]);
for(uint i=0; i<32; ++i) LOGF_NOTICE(PPU, "v%d = 0x%s [%s]", i, CPU.VPR[i].ToString(true).c_str(), CPU.VPR[i].ToString().c_str()); for(uint i=0; i<32; ++i) LOG_NOTICE(PPU, "v%d = 0x%s [%s]", i, CPU.VPR[i].ToString(true).c_str(), CPU.VPR[i].ToString().c_str());
LOGF_NOTICE(PPU, "CR = 0x%08x", CPU.CR); LOG_NOTICE(PPU, "CR = 0x%08x", CPU.CR);
LOGF_NOTICE(PPU, "LR = 0x%llx", CPU.LR); LOG_NOTICE(PPU, "LR = 0x%llx", CPU.LR);
LOGF_NOTICE(PPU, "CTR = 0x%llx", CPU.CTR); LOG_NOTICE(PPU, "CTR = 0x%llx", CPU.CTR);
LOGF_NOTICE(PPU, "XER = 0x%llx [CA=%lld | OV=%lld | SO=%lld]", CPU.XER, fmt::by_value(CPU.XER.CA), fmt::by_value(CPU.XER.OV), fmt::by_value(CPU.XER.SO)); LOG_NOTICE(PPU, "XER = 0x%llx [CA=%lld | OV=%lld | SO=%lld]", CPU.XER, fmt::by_value(CPU.XER.CA), fmt::by_value(CPU.XER.OV), fmt::by_value(CPU.XER.SO));
LOGF_NOTICE(PPU, "FPSCR = 0x%x " LOG_NOTICE(PPU, "FPSCR = 0x%x "
"[RN=%d | NI=%d | XE=%d | ZE=%d | UE=%d | OE=%d | VE=%d | " "[RN=%d | NI=%d | XE=%d | ZE=%d | UE=%d | OE=%d | VE=%d | "
"VXCVI=%d | VXSQRT=%d | VXSOFT=%d | FPRF=%d | " "VXCVI=%d | VXSQRT=%d | VXSOFT=%d | FPRF=%d | "
"FI=%d | FR=%d | VXVC=%d | VXIMZ=%d | " "FI=%d | FR=%d | VXVC=%d | VXIMZ=%d | "

2
rpcs3/Emu/Cell/PPUThread.cpp
View file

@ -163,7 +163,7 @@ void PPUThread::DoRun()
break; break;
default: default:
LOGF_ERROR(PPU, "Invalid CPU decoder mode: %d", Ini.CPUDecoderMode.GetValue()); LOG_ERROR(PPU, "Invalid CPU decoder mode: %d", Ini.CPUDecoderMode.GetValue());
Emu.Pause(); Emu.Pause();
} }
} }

92
rpcs3/Emu/Cell/RawSPUThread.cpp
View file

@ -38,7 +38,7 @@ bool RawSPUThread::Read8(const u64 addr, u8* value)
} }
u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET; u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET;
LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Read8(0x%x)", m_index, offset); LOG_ERROR(Log::SPU, "RawSPUThread[%d]: Read8(0x%x)", m_index, offset);
Emu.Pause(); Emu.Pause();
return false; return false;
} }
@ -51,7 +51,7 @@ bool RawSPUThread::Read16(const u64 addr, u16* value)
} }
u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET; u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET;
LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Read16(0x%x)", m_index, offset); LOG_ERROR(Log::SPU, "RawSPUThread[%d]: Read16(0x%x)", m_index, offset);
Emu.Pause(); Emu.Pause();
return false; return false;
} }
@ -66,39 +66,39 @@ bool RawSPUThread::Read32(const u64 addr, u32* value)
u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET; u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET;
switch(offset) switch(offset)
{ {
case MFC_LSA_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(MFC_LSA)", m_index); *value = MFC2.LSA.GetValue(); break; case MFC_LSA_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(MFC_LSA)", m_index); *value = MFC2.LSA.GetValue(); break;
case MFC_EAH_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(MFC_EAH)", m_index); *value = MFC2.EAH.GetValue(); break; case MFC_EAH_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(MFC_EAH)", m_index); *value = MFC2.EAH.GetValue(); break;
case MFC_EAL_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(MFC_EAL)", m_index); *value = MFC2.EAL.GetValue(); break; case MFC_EAL_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(MFC_EAL)", m_index); *value = MFC2.EAL.GetValue(); break;
case MFC_Size_Tag_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(MFC_Size_Tag)", m_index); *value = MFC2.Size_Tag.GetValue(); break; case MFC_Size_Tag_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(MFC_Size_Tag)", m_index); *value = MFC2.Size_Tag.GetValue(); break;
case MFC_CMDStatus_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(MFC_CMDStatus)", m_index); *value = MFC2.CMDStatus.GetValue(); break; case MFC_CMDStatus_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(MFC_CMDStatus)", m_index); *value = MFC2.CMDStatus.GetValue(); break;
case MFC_QStatus_offs: case MFC_QStatus_offs:
LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(MFC_QStatus)", m_index); LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(MFC_QStatus)", m_index);
*value = MFC2.QStatus.GetValue(); *value = MFC2.QStatus.GetValue();
break; break;
case Prxy_QueryType_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(Prxy_QueryType)", m_index); *value = Prxy.QueryType.GetValue(); break; case Prxy_QueryType_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(Prxy_QueryType)", m_index); *value = Prxy.QueryType.GetValue(); break;
case Prxy_QueryMask_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(Prxy_QueryMask)", m_index); *value = Prxy.QueryMask.GetValue(); break; case Prxy_QueryMask_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(Prxy_QueryMask)", m_index); *value = Prxy.QueryMask.GetValue(); break;
case Prxy_TagStatus_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(Prxy_TagStatus)", m_index); *value = Prxy.TagStatus.GetValue(); break; case Prxy_TagStatus_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(Prxy_TagStatus)", m_index); *value = Prxy.TagStatus.GetValue(); break;
case SPU_Out_MBox_offs: case SPU_Out_MBox_offs:
//LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_Out_MBox)", m_index); //LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_Out_MBox)", m_index);
SPU.Out_MBox.PopUncond(*value); //if Out_MBox is empty yet, the result will be undefined SPU.Out_MBox.PopUncond(*value); //if Out_MBox is empty yet, the result will be undefined
break; break;
case SPU_In_MBox_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_In_MBox)", m_index); while(!SPU.In_MBox.Pop(*value) && !Emu.IsStopped()) Sleep(1); break; case SPU_In_MBox_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_In_MBox)", m_index); while(!SPU.In_MBox.Pop(*value) && !Emu.IsStopped()) Sleep(1); break;
case SPU_MBox_Status_offs: //LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_MBox_Status)", m_index); case SPU_MBox_Status_offs: //LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_MBox_Status)", m_index);
//SPU.MBox_Status.SetValue(SPU.Out_MBox.GetCount() ? SPU.MBox_Status.GetValue() | 1 : SPU.MBox_Status.GetValue() & ~1); //SPU.MBox_Status.SetValue(SPU.Out_MBox.GetCount() ? SPU.MBox_Status.GetValue() | 1 : SPU.MBox_Status.GetValue() & ~1);
SPU.MBox_Status.SetValue((SPU.Out_MBox.GetCount() & 0xff) | (SPU.In_MBox.GetFreeCount() << 8)); SPU.MBox_Status.SetValue((SPU.Out_MBox.GetCount() & 0xff) | (SPU.In_MBox.GetFreeCount() << 8));
*value = SPU.MBox_Status.GetValue(); *value = SPU.MBox_Status.GetValue();
break; break;
case SPU_RunCntl_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_RunCntl)", m_index); *value = SPU.RunCntl.GetValue(); break; case SPU_RunCntl_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_RunCntl)", m_index); *value = SPU.RunCntl.GetValue(); break;
case SPU_Status_offs: case SPU_Status_offs:
//LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_Status)", m_index); //LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_Status)", m_index);
*value = SPU.Status.GetValue(); *value = SPU.Status.GetValue();
break; break;
case SPU_NPC_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_NPC)", m_index); *value = SPU.NPC.GetValue(); break; case SPU_NPC_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_NPC)", m_index); *value = SPU.NPC.GetValue(); break;
case SPU_RdSigNotify1_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_RdSigNotify1)", m_index); *value = SPU.SNR[0].GetValue(); break; case SPU_RdSigNotify1_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_RdSigNotify1)", m_index); *value = SPU.SNR[0].GetValue(); break;
case SPU_RdSigNotify2_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_RdSigNotify2)", m_index); *value = SPU.SNR[1].GetValue(); break; case SPU_RdSigNotify2_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_RdSigNotify2)", m_index); *value = SPU.SNR[1].GetValue(); break;
default: default:
LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Read32(0x%x)", m_index, offset); LOG_ERROR(Log::SPU, "RawSPUThread[%d]: Read32(0x%x)", m_index, offset);
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -114,7 +114,7 @@ bool RawSPUThread::Read64(const u64 addr, u64* value)
} }
u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET; u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET;
LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Read64(0x%x)", m_index, offset); LOG_ERROR(Log::SPU, "RawSPUThread[%d]: Read64(0x%x)", m_index, offset);
Emu.Pause(); Emu.Pause();
return false; return false;
} }
@ -127,7 +127,7 @@ bool RawSPUThread::Read128(const u64 addr, u128* value)
} }
u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET; u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET;
LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Read128(0x%x)", m_index, offset); LOG_ERROR(Log::SPU, "RawSPUThread[%d]: Read128(0x%x)", m_index, offset);
Emu.Pause(); Emu.Pause();
return false; return false;
} }
@ -140,7 +140,7 @@ bool RawSPUThread::Write8(const u64 addr, const u8 value)
} }
u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET; u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET;
LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Write8(0x%x, 0x%x)", m_index, offset, value); LOG_ERROR(Log::SPU, "RawSPUThread[%d]: Write8(0x%x, 0x%x)", m_index, offset, value);
Emu.Pause(); Emu.Pause();
return false; return false;
} }
@ -153,7 +153,7 @@ bool RawSPUThread::Write16(const u64 addr, const u16 value)
} }
u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET; u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET;
LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Write16(0x%x, 0x%x)", m_index, offset, value); LOG_ERROR(Log::SPU, "RawSPUThread[%d]: Write16(0x%x, 0x%x)", m_index, offset, value);
Emu.Pause(); Emu.Pause();
return false; return false;
} }
@ -177,20 +177,20 @@ bool RawSPUThread::Write32(const u64 addr, const u32 value)
MFC2.CMDStatus.SetValue(value); MFC2.CMDStatus.SetValue(value);
EnqMfcCmd(MFC2); EnqMfcCmd(MFC2);
break; break;
case MFC_QStatus_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(MFC_QStatus, 0x%x)", m_index, value); MFC2.QStatus.SetValue(value); break; case MFC_QStatus_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(MFC_QStatus, 0x%x)", m_index, value); MFC2.QStatus.SetValue(value); break;
case Prxy_QueryType_offs: case Prxy_QueryType_offs:
{ {
LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(Prxy_QueryType, 0x%x)", m_index, value); LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(Prxy_QueryType, 0x%x)", m_index, value);
Prxy.QueryType.SetValue(value); Prxy.QueryType.SetValue(value);
switch(value) switch(value)
{ {
case 2: case 2:
LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Prxy Query Immediate.", m_index); LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Prxy Query Immediate.", m_index);
break; break;
default: default:
LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Unknown Prxy Query Type. (prxy_query=0x%x)", m_index, value); LOG_ERROR(Log::SPU, "RawSPUThread[%d]: Unknown Prxy Query Type. (prxy_query=0x%x)", m_index, value);
break; break;
} }
@ -198,22 +198,22 @@ bool RawSPUThread::Write32(const u64 addr, const u32 value)
MFC2.QStatus.SetValue(Prxy.QueryMask.GetValue()); MFC2.QStatus.SetValue(Prxy.QueryMask.GetValue());
} }
break; break;
case Prxy_QueryMask_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(Prxy_QueryMask, 0x%x)", m_index, value); Prxy.QueryMask.SetValue(value); break; case Prxy_QueryMask_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(Prxy_QueryMask, 0x%x)", m_index, value); Prxy.QueryMask.SetValue(value); break;
case Prxy_TagStatus_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(Prxy_TagStatus, 0x%x)", m_index, value); Prxy.TagStatus.SetValue(value); break; case Prxy_TagStatus_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(Prxy_TagStatus, 0x%x)", m_index, value); Prxy.TagStatus.SetValue(value); break;
case SPU_Out_MBox_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_Out_MBox, 0x%x)", m_index, value); while(!SPU.Out_MBox.Push(value) && !Emu.IsStopped()) Sleep(1); break; case SPU_Out_MBox_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_Out_MBox, 0x%x)", m_index, value); while(!SPU.Out_MBox.Push(value) && !Emu.IsStopped()) Sleep(1); break;
case SPU_In_MBox_offs: case SPU_In_MBox_offs:
//LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_In_MBox, 0x%x)", m_index, value); //LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_In_MBox, 0x%x)", m_index, value);
SPU.In_MBox.PushUncond(value); //if In_MBox is already full, the last message will be overwritten SPU.In_MBox.PushUncond(value); //if In_MBox is already full, the last message will be overwritten
break; break;
case SPU_MBox_Status_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_MBox_Status, 0x%x)", m_index, value); SPU.MBox_Status.SetValue(value); break; case SPU_MBox_Status_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_MBox_Status, 0x%x)", m_index, value); SPU.MBox_Status.SetValue(value); break;
case SPU_RunCntl_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_RunCntl, 0x%x)", m_index, value); SPU.RunCntl.SetValue(value); break; case SPU_RunCntl_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_RunCntl, 0x%x)", m_index, value); SPU.RunCntl.SetValue(value); break;
case SPU_Status_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_Status, 0x%x)", m_index, value); SPU.Status.SetValue(value); break; case SPU_Status_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_Status, 0x%x)", m_index, value); SPU.Status.SetValue(value); break;
case SPU_NPC_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_NPC, 0x%x)", m_index, value); SPU.NPC.SetValue(value); break; case SPU_NPC_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_NPC, 0x%x)", m_index, value); SPU.NPC.SetValue(value); break;
case SPU_RdSigNotify1_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_RdSigNotify1, 0x%x)", m_index, value); SPU.SNR[0].SetValue(value); break; case SPU_RdSigNotify1_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_RdSigNotify1, 0x%x)", m_index, value); SPU.SNR[0].SetValue(value); break;
case SPU_RdSigNotify2_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_RdSigNotify2, 0x%x)", m_index, value); SPU.SNR[1].SetValue(value); break; case SPU_RdSigNotify2_offs: LOG_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_RdSigNotify2, 0x%x)", m_index, value); SPU.SNR[1].SetValue(value); break;
default: default:
LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Write32(0x%x, 0x%x)", m_index, offset, value); LOG_ERROR(Log::SPU, "RawSPUThread[%d]: Write32(0x%x, 0x%x)", m_index, offset, value);
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -229,7 +229,7 @@ bool RawSPUThread::Write64(const u64 addr, const u64 value)
} }
u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET; u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET;
LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Write64(0x%x, 0x%llx)", m_index, offset, value); LOG_ERROR(Log::SPU, "RawSPUThread[%d]: Write64(0x%x, 0x%llx)", m_index, offset, value);
Emu.Pause(); Emu.Pause();
return false; return false;
} }
@ -242,7 +242,7 @@ bool RawSPUThread::Write128(const u64 addr, const u128 value)
} }
u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET; u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET;
LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Write128(0x%x, 0x%llx_%llx)", m_index, offset, value._u64[1], value._u64[0]); LOG_ERROR(Log::SPU, "RawSPUThread[%d]: Write128(0x%x, 0x%llx_%llx)", m_index, offset, value._u64[1], value._u64[0]);
Emu.Pause(); Emu.Pause();
return false; return false;
} }
@ -260,7 +260,7 @@ u32 RawSPUThread::GetIndex() const
void RawSPUThread::Task() void RawSPUThread::Task()
{ {
if (Ini.HLELogging.GetValue()) LOGF_NOTICE(Log::SPU, "%s enter", PPCThread::GetFName().c_str()); if (Ini.HLELogging.GetValue()) LOG_NOTICE(Log::SPU, "%s enter", PPCThread::GetFName().c_str());
const std::vector<u64>& bp = Emu.GetBreakPoints(); const std::vector<u64>& bp = Emu.GetBreakPoints();
@ -312,7 +312,7 @@ void RawSPUThread::Task()
is_last_paused = false; is_last_paused = false;
PC = SPU.NPC.GetValue(); PC = SPU.NPC.GetValue();
SPU.Status.SetValue(SPU_STATUS_RUNNING); SPU.Status.SetValue(SPU_STATUS_RUNNING);
LOGF_WARNING(Log::SPU, "Starting RawSPU..."); LOG_WARNING(Log::SPU, "Starting RawSPU...");
} }
Step(); Step();
@ -336,12 +336,12 @@ void RawSPUThread::Task()
} }
catch(const std::string& e) catch(const std::string& e)
{ {
LOGF_ERROR(Log::SPU, "Exception: %s", e.c_str()); LOG_ERROR(Log::SPU, "Exception: %s", e.c_str());
} }
catch(const char* e) catch(const char* e)
{ {
LOGF_ERROR(Log::SPU, "Exception: %s", e); LOG_ERROR(Log::SPU, "Exception: %s", e);
} }
if (Ini.HLELogging.GetValue()) LOGF_NOTICE(Log::SPU, "%s leave", PPCThread::GetFName().c_str()); if (Ini.HLELogging.GetValue()) LOG_NOTICE(Log::SPU, "%s leave", PPCThread::GetFName().c_str());
} }

26
rpcs3/Emu/Cell/SPUInterpreter.h
View file

@ -18,9 +18,9 @@
#define MEM_AND_REG_HASH() \ #define MEM_AND_REG_HASH() \
unsigned char mem_h[20]; sha1(&Memory[CPU.dmac.ls_offset], 256*1024, mem_h); \ unsigned char mem_h[20]; sha1(&Memory[CPU.dmac.ls_offset], 256*1024, mem_h); \
unsigned char reg_h[20]; sha1((const unsigned char*)CPU.GPR, sizeof(CPU.GPR), reg_h); \ unsigned char reg_h[20]; sha1((const unsigned char*)CPU.GPR, sizeof(CPU.GPR), reg_h); \
LOGF_NOTICE(Log::SPU, "Mem hash: 0x%llx, reg hash: 0x%llx", *(u64*)mem_h, *(u64*)reg_h); LOG_NOTICE(Log::SPU, "Mem hash: 0x%llx, reg hash: 0x%llx", *(u64*)mem_h, *(u64*)reg_h);
#define LOG2_OPCODE(...) //MEM_AND_REG_HASH(); LOGF_NOTICE(Log::SPU, __FUNCTION__ "(): " __VA_ARGS__) #define LOG2_OPCODE(...) //MEM_AND_REG_HASH(); LOG_NOTICE(Log::SPU, __FUNCTION__ "(): " __VA_ARGS__)
#define LOG5_OPCODE(...) /// #define LOG5_OPCODE(...) ///
@ -339,7 +339,7 @@ private:
u32 lsa = (CPU.GPR[ra]._u32[3] + CPU.GPR[rb]._u32[3]) & 0x3fff0; u32 lsa = (CPU.GPR[ra]._u32[3] + CPU.GPR[rb]._u32[3]) & 0x3fff0;
if(!CPU.IsGoodLSA(lsa)) if(!CPU.IsGoodLSA(lsa))
{ {
LOGF_ERROR(Log::SPU, "STQX: bad lsa (0x%x)", lsa); LOG_ERROR(Log::SPU, "STQX: bad lsa (0x%x)", lsa);
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -438,7 +438,7 @@ private:
if(!CPU.IsGoodLSA(lsa)) if(!CPU.IsGoodLSA(lsa))
{ {
LOGF_ERROR(Log::SPU, "LQX: bad lsa (0x%x)", lsa); LOG_ERROR(Log::SPU, "LQX: bad lsa (0x%x)", lsa);
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -1126,7 +1126,7 @@ private:
u32 lsa = (i16 << 2) & 0x3fff0; u32 lsa = (i16 << 2) & 0x3fff0;
if(!CPU.IsGoodLSA(lsa)) if(!CPU.IsGoodLSA(lsa))
{ {
LOGF_ERROR(Log::SPU, "STQA: bad lsa (0x%x)", lsa); LOG_ERROR(Log::SPU, "STQA: bad lsa (0x%x)", lsa);
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -1177,7 +1177,7 @@ private:
u32 lsa = branchTarget(CPU.PC, i16) & 0x3fff0; u32 lsa = branchTarget(CPU.PC, i16) & 0x3fff0;
if(!CPU.IsGoodLSA(lsa)) if(!CPU.IsGoodLSA(lsa))
{ {
LOGF_ERROR(Log::SPU, "STQR: bad lsa (0x%x)", lsa); LOG_ERROR(Log::SPU, "STQR: bad lsa (0x%x)", lsa);
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -1195,7 +1195,7 @@ private:
u32 lsa = (i16 << 2) & 0x3fff0; u32 lsa = (i16 << 2) & 0x3fff0;
if(!CPU.IsGoodLSA(lsa)) if(!CPU.IsGoodLSA(lsa))
{ {
LOGF_ERROR(Log::SPU, "LQA: bad lsa (0x%x)", lsa); LOG_ERROR(Log::SPU, "LQA: bad lsa (0x%x)", lsa);
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -1245,7 +1245,7 @@ private:
u32 lsa = branchTarget(CPU.PC, i16) & 0x3fff0; u32 lsa = branchTarget(CPU.PC, i16) & 0x3fff0;
if(!CPU.IsGoodLSA(lsa)) if(!CPU.IsGoodLSA(lsa))
{ {
LOGF_ERROR(Log::SPU, "LQR: bad lsa (0x%x)", lsa); LOG_ERROR(Log::SPU, "LQR: bad lsa (0x%x)", lsa);
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -1334,11 +1334,11 @@ private:
const u32 lsa = (CPU.GPR[ra]._i32[3] + i10) & 0x3fff0; const u32 lsa = (CPU.GPR[ra]._i32[3] + i10) & 0x3fff0;
if(!CPU.IsGoodLSA(lsa)) if(!CPU.IsGoodLSA(lsa))
{ {
LOGF_ERROR(Log::SPU, "STQD: bad lsa (0x%x)", lsa); LOG_ERROR(Log::SPU, "STQD: bad lsa (0x%x)", lsa);
Emu.Pause(); Emu.Pause();
return; return;
} }
//LOGF_NOTICE(Log::SPU, "STQD(lsa=0x%x): GPR[%d] (0x%llx%llx)", lsa, rt, CPU.GPR[rt]._u64[1], CPU.GPR[rt]._u64[0]); //LOG_NOTICE(Log::SPU, "STQD(lsa=0x%x): GPR[%d] (0x%llx%llx)", lsa, rt, CPU.GPR[rt]._u64[1], CPU.GPR[rt]._u64[0]);
CPU.WriteLS128(lsa, CPU.GPR[rt]._u128); CPU.WriteLS128(lsa, CPU.GPR[rt]._u128);
} }
void LQD(u32 rt, s32 i10, u32 ra) //i10 is shifted left by 4 while decoding void LQD(u32 rt, s32 i10, u32 ra) //i10 is shifted left by 4 while decoding
@ -1346,7 +1346,7 @@ private:
const u32 lsa = (CPU.GPR[ra]._i32[3] + i10) & 0x3fff0; const u32 lsa = (CPU.GPR[ra]._i32[3] + i10) & 0x3fff0;
if(!CPU.IsGoodLSA(lsa)) if(!CPU.IsGoodLSA(lsa))
{ {
LOGF_ERROR(Log::SPU, "LQD: bad lsa (0x%x)", lsa); LOG_ERROR(Log::SPU, "LQD: bad lsa (0x%x)", lsa);
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -1540,8 +1540,8 @@ private:
void UNK(const std::string& err) void UNK(const std::string& err)
{ {
LOGF_ERROR(Log::SPU, err + fmt::Format(" #pc: 0x%x", CPU.PC)); LOG_ERROR(Log::SPU, err + fmt::Format(" #pc: 0x%x", CPU.PC));
Emu.Pause(); Emu.Pause();
for(uint i=0; i<128; ++i) LOGF_NOTICE(Log::SPU, "r%d = 0x%s", i, CPU.GPR[i].ToString().c_str()); for(uint i=0; i<128; ++i) LOG_NOTICE(Log::SPU, "r%d = 0x%s", i, CPU.GPR[i].ToString().c_str());
} }
}; };

2
rpcs3/Emu/Cell/SPURecompiler.h
View file

@ -3845,7 +3845,7 @@ private:
void UNK(const std::string& err) void UNK(const std::string& err)
{ {
LOGF_ERROR(Log::SPU, err + fmt::Format(" #pc: 0x%x", CPU.PC)); LOG_ERROR(Log::SPU, err + fmt::Format(" #pc: 0x%x", CPU.PC));
c.mov(cpu_qword(PC), (u32)CPU.PC); c.mov(cpu_qword(PC), (u32)CPU.PC);
do_finalize = true; do_finalize = true;
Emu.Pause(); Emu.Pause();

12
rpcs3/Emu/Cell/SPURecompilerCore.cpp
View file

@ -164,7 +164,7 @@ u8 SPURecompilerCore::DecodeMemory(const u64 address)
if (!pos) if (!pos)
{ {
LOGF_ERROR(Log::SPU, "SPURecompilerCore::DecodeMemory(): ls_addr = 0"); LOG_ERROR(Log::SPU, "SPURecompilerCore::DecodeMemory(): ls_addr = 0");
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -185,7 +185,7 @@ u8 SPURecompilerCore::DecodeMemory(const u64 address)
if (!is_valid) if (!is_valid)
{ {
// TODO // TODO
LOGF_ERROR(Log::SPU, "SPURecompilerCore::DecodeMemory(ls_addr=0x%x): code has changed", pos * sizeof(u32)); LOG_ERROR(Log::SPU, "SPURecompilerCore::DecodeMemory(ls_addr=0x%x): code has changed", pos * sizeof(u32));
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -198,7 +198,7 @@ u8 SPURecompilerCore::DecodeMemory(const u64 address)
did_compile = true; did_compile = true;
if (entry[pos].valid == 0) if (entry[pos].valid == 0)
{ {
LOGF_ERROR(Log::SPU, "SPURecompilerCore::Compile(ls_addr=0x%x): branch to 0x0 opcode", pos * sizeof(u32)); LOG_ERROR(Log::SPU, "SPURecompilerCore::Compile(ls_addr=0x%x): branch to 0x0 opcode", pos * sizeof(u32));
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -206,7 +206,7 @@ u8 SPURecompilerCore::DecodeMemory(const u64 address)
if (!entry[pos].pointer) if (!entry[pos].pointer)
{ {
LOGF_ERROR(Log::SPU, "SPURecompilerCore::DecodeMemory(ls_addr=0x%x): compilation failed", pos * sizeof(u32)); LOG_ERROR(Log::SPU, "SPURecompilerCore::DecodeMemory(ls_addr=0x%x): compilation failed", pos * sizeof(u32));
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -223,7 +223,7 @@ u8 SPURecompilerCore::DecodeMemory(const u64 address)
//if (pos == 0x19c >> 2) //if (pos == 0x19c >> 2)
{ {
//Emu.Pause(); //Emu.Pause();
//for (uint i = 0; i < 128; ++i) LOGF_NOTICE(Log::SPU, "r%d = 0x%s", i, CPU.GPR[i].ToString().c_str()); //for (uint i = 0; i < 128; ++i) LOG_NOTICE(Log::SPU, "r%d = 0x%s", i, CPU.GPR[i].ToString().c_str());
} }
} }
@ -243,7 +243,7 @@ u8 SPURecompilerCore::DecodeMemory(const u64 address)
//if (pos == 0x340 >> 2) //if (pos == 0x340 >> 2)
{ {
//Emu.Pause(); //Emu.Pause();
//for (uint i = 0; i < 128; ++i) LOGF_NOTICE(Log::SPU, "r%d = 0x%s", i, CPU.GPR[i].ToString().c_str()); //for (uint i = 0; i < 128; ++i) LOG_NOTICE(Log::SPU, "r%d = 0x%s", i, CPU.GPR[i].ToString().c_str());
} }
} }

2
rpcs3/Emu/Cell/SPUThread.cpp
View file

@ -86,7 +86,7 @@ void SPUThread::DoRun()
break; break;
default: default:
LOGF_ERROR(Log::SPU, "Invalid SPU decoder mode: %d", Ini.SPUDecoderMode.GetValue()); LOG_ERROR(Log::SPU, "Invalid SPU decoder mode: %d", Ini.SPUDecoderMode.GetValue());
Emu.Pause(); Emu.Pause();
} }
} }

82
rpcs3/Emu/Cell/SPUThread.h
View file

@ -211,7 +211,7 @@ public:
return this->low >> 22 & 0x3; return this->low >> 22 & 0x3;
default: default:
LOGF_ERROR(SPU, "Unexpected slice value in FPSCR::checkSliceRounding(): %d", slice); LOG_ERROR(SPU, "Unexpected slice value in FPSCR::checkSliceRounding(): %d", slice);
return 0; return 0;
} }
} }
@ -599,7 +599,7 @@ public:
u32 num = (ea & SYS_SPU_THREAD_BASE_MASK) / SYS_SPU_THREAD_OFFSET; // thread number in group u32 num = (ea & SYS_SPU_THREAD_BASE_MASK) / SYS_SPU_THREAD_OFFSET; // thread number in group
if (num >= group->list.size() || !group->list[num]) if (num >= group->list.size() || !group->list[num])
{ {
LOGF_ERROR(Log::SPU, "DMAC::ProcessCmd(): SPU Thread Group MMIO Access (ea=0x%llx): invalid thread", ea); LOG_ERROR(Log::SPU, "DMAC::ProcessCmd(): SPU Thread Group MMIO Access (ea=0x%llx): invalid thread", ea);
return false; return false;
} }
@ -618,13 +618,13 @@ public:
} }
else else
{ {
LOGF_ERROR(Log::SPU, "DMAC::ProcessCmd(): SPU Thread Group MMIO Access (ea=0x%llx, size=%d, cmd=0x%x): invalid command", ea, size, cmd); LOG_ERROR(Log::SPU, "DMAC::ProcessCmd(): SPU Thread Group MMIO Access (ea=0x%llx, size=%d, cmd=0x%x): invalid command", ea, size, cmd);
return false; return false;
} }
} }
else else
{ {
LOGF_ERROR(Log::SPU, "DMAC::ProcessCmd(): SPU Thread Group MMIO Access (ea=0x%llx): group not set", ea); LOG_ERROR(Log::SPU, "DMAC::ProcessCmd(): SPU Thread Group MMIO Access (ea=0x%llx): group not set", ea);
return false; return false;
} }
} }
@ -664,7 +664,7 @@ public:
} }
else else
{ {
LOGF_ERROR(Log::SPU, "DMAC::ProcessCmd(): PUT* cmd failed (ea=0x%llx, lsa=0x%x, size=%d)", ea, lsa, size); LOG_ERROR(Log::SPU, "DMAC::ProcessCmd(): PUT* cmd failed (ea=0x%llx, lsa=0x%x, size=%d)", ea, lsa, size);
return false; // TODO: page fault (?) return false; // TODO: page fault (?)
} }
} }
@ -677,7 +677,7 @@ public:
} }
else else
{ {
LOGF_ERROR(Log::SPU, "DMAC::ProcessCmd(): GET* cmd failed (ea=0x%llx, lsa=0x%x, size=%d)", ea, lsa, size); LOG_ERROR(Log::SPU, "DMAC::ProcessCmd(): GET* cmd failed (ea=0x%llx, lsa=0x%x, size=%d)", ea, lsa, size);
return false; // TODO: page fault (?) return false; // TODO: page fault (?)
} }
} }
@ -725,7 +725,7 @@ public:
u32 size = rec->ts; u32 size = rec->ts;
if (size < 16 && size != 1 && size != 2 && size != 4 && size != 8) if (size < 16 && size != 1 && size != 2 && size != 4 && size != 8)
{ {
LOGF_ERROR(Log::SPU, "DMA List: invalid transfer size(%d)", size); LOG_ERROR(Log::SPU, "DMA List: invalid transfer size(%d)", size);
return; return;
} }
@ -737,7 +737,7 @@ public:
} }
if (Ini.HLELogging.GetValue() || rec->s) if (Ini.HLELogging.GetValue() || rec->s)
LOGF_NOTICE(Log::SPU, "*** list element(%d/%d): s = 0x%x, ts = 0x%x, low ea = 0x%x (lsa = 0x%x)", LOG_NOTICE(Log::SPU, "*** list element(%d/%d): s = 0x%x, ts = 0x%x, low ea = 0x%x (lsa = 0x%x)",
i, list_size, (u16)rec->s, (u16)rec->ts, (u32)rec->ea, lsa | (addr & 0xf)); i, list_size, (u16)rec->s, (u16)rec->ts, (u32)rec->ea, lsa | (addr & 0xf));
lsa += std::max(size, (u32)16); lsa += std::max(size, (u32)16);
@ -748,7 +748,7 @@ public:
if (StallList[tag].MFCArgs) if (StallList[tag].MFCArgs)
{ {
LOGF_ERROR(Log::SPU, "DMA List: existing stalled list found (tag=%d)", tag); LOG_ERROR(Log::SPU, "DMA List: existing stalled list found (tag=%d)", tag);
} }
StallList[tag].MFCArgs = &MFCArgs; StallList[tag].MFCArgs = &MFCArgs;
StallList[tag].cmd = cmd; StallList[tag].cmd = cmd;
@ -780,7 +780,7 @@ public:
case MFC_PUTR_CMD: // ??? case MFC_PUTR_CMD: // ???
case MFC_GET_CMD: case MFC_GET_CMD:
{ {
if (Ini.HLELogging.GetValue()) LOGF_NOTICE(Log::SPU, "DMA %s%s%s%s: lsa = 0x%x, ea = 0x%llx, tag = 0x%x, size = 0x%x, cmd = 0x%x", if (Ini.HLELogging.GetValue()) LOG_NOTICE(Log::SPU, "DMA %s%s%s%s: lsa = 0x%x, ea = 0x%llx, tag = 0x%x, size = 0x%x, cmd = 0x%x",
(op & MFC_PUT_CMD ? "PUT" : "GET"), (op & MFC_PUT_CMD ? "PUT" : "GET"),
(op & MFC_RESULT_MASK ? "R" : ""), (op & MFC_RESULT_MASK ? "R" : ""),
(op & MFC_BARRIER_MASK ? "B" : ""), (op & MFC_BARRIER_MASK ? "B" : ""),
@ -795,7 +795,7 @@ public:
case MFC_PUTRL_CMD: // ??? case MFC_PUTRL_CMD: // ???
case MFC_GETL_CMD: case MFC_GETL_CMD:
{ {
if (Ini.HLELogging.GetValue()) LOGF_NOTICE(Log::SPU, "DMA %s%s%s%s: lsa = 0x%x, list = 0x%llx, tag = 0x%x, size = 0x%x, cmd = 0x%x", if (Ini.HLELogging.GetValue()) LOG_NOTICE(Log::SPU, "DMA %s%s%s%s: lsa = 0x%x, list = 0x%llx, tag = 0x%x, size = 0x%x, cmd = 0x%x",
(op & MFC_PUT_CMD ? "PUT" : "GET"), (op & MFC_PUT_CMD ? "PUT" : "GET"),
(op & MFC_RESULT_MASK ? "RL" : "L"), (op & MFC_RESULT_MASK ? "RL" : "L"),
(op & MFC_BARRIER_MASK ? "B" : ""), (op & MFC_BARRIER_MASK ? "B" : ""),
@ -811,7 +811,7 @@ public:
case MFC_PUTLLUC_CMD: case MFC_PUTLLUC_CMD:
case MFC_PUTQLLUC_CMD: case MFC_PUTQLLUC_CMD:
{ {
if (Ini.HLELogging.GetValue() || size != 128) LOGF_NOTICE(Log::SPU, "DMA %s: lsa=0x%x, ea = 0x%llx, (tag) = 0x%x, (size) = 0x%x, cmd = 0x%x", if (Ini.HLELogging.GetValue() || size != 128) LOG_NOTICE(Log::SPU, "DMA %s: lsa=0x%x, ea = 0x%llx, (tag) = 0x%x, (size) = 0x%x, cmd = 0x%x",
(op == MFC_GETLLAR_CMD ? "GETLLAR" : (op == MFC_GETLLAR_CMD ? "GETLLAR" :
op == MFC_PUTLLC_CMD ? "PUTLLC" : op == MFC_PUTLLC_CMD ? "PUTLLC" :
op == MFC_PUTLLUC_CMD ? "PUTLLUC" : "PUTQLLUC"), op == MFC_PUTLLUC_CMD ? "PUTLLUC" : "PUTQLLUC"),
@ -885,7 +885,7 @@ public:
} }
else // full 64 bit else // full 64 bit
{ {
LOGF_ERROR(Log::SPU, "MFC_PUTLLC_CMD: TODO: 64bit compare and swap"); LOG_ERROR(Log::SPU, "MFC_PUTLLC_CMD: TODO: 64bit compare and swap");
Emu.Pause(); Emu.Pause();
Prxy.AtomicStat.PushUncond(MFC_PUTLLC_SUCCESS); Prxy.AtomicStat.PushUncond(MFC_PUTLLC_SUCCESS);
}*/ }*/
@ -894,7 +894,7 @@ public:
else else
{ {
ProcessCmd(MFC_PUT_CMD, tag, lsa, ea, 128); ProcessCmd(MFC_PUT_CMD, tag, lsa, ea, 128);
LOGF_ERROR(Log::SPU, "MFC_PUTLLC_CMD: Reservation Error: impossibru (~ 16x%d (mask=0x%x)) (opcode=0x%x, cmd=0x%x, lsa = 0x%x, ea = 0x%llx, tag = 0x%x, size = 0x%x)", LOG_ERROR(Log::SPU, "MFC_PUTLLC_CMD: Reservation Error: impossibru (~ 16x%d (mask=0x%x)) (opcode=0x%x, cmd=0x%x, lsa = 0x%x, ea = 0x%llx, tag = 0x%x, size = 0x%x)",
changed, mask, op, cmd, lsa, ea, tag, size); changed, mask, op, cmd, lsa, ea, tag, size);
Emu.Pause(); Emu.Pause();
Prxy.AtomicStat.PushUncond(MFC_PUTLLC_SUCCESS); Prxy.AtomicStat.PushUncond(MFC_PUTLLC_SUCCESS);
@ -929,7 +929,7 @@ public:
break; break;
default: default:
LOGF_ERROR( Log::SPU, "Unknown MFC cmd. (opcode=0x%x, cmd=0x%x, lsa = 0x%x, ea = 0x%llx, tag = 0x%x, size = 0x%x)", LOG_ERROR( Log::SPU, "Unknown MFC cmd. (opcode=0x%x, cmd=0x%x, lsa = 0x%x, ea = 0x%llx, tag = 0x%x, size = 0x%x)",
op, cmd, lsa, ea, tag, size); op, cmd, lsa, ea, tag, size);
break; break;
} }
@ -949,7 +949,7 @@ public:
return count; return count;
case SPU_WrOutIntrMbox: case SPU_WrOutIntrMbox:
LOGF_WARNING(Log::SPU, "GetChannelCount(%s) = 0", spu_ch_name[ch]); LOG_WARNING(Log::SPU, "GetChannelCount(%s) = 0", spu_ch_name[ch]);
return 0; return 0;
case MFC_RdTagStat: case MFC_RdTagStat:
@ -971,7 +971,7 @@ public:
return Prxy.AtomicStat.GetCount(); return Prxy.AtomicStat.GetCount();
default: default:
LOGF_ERROR(Log::SPU, "%s error: unknown/illegal channel (%d [%s]).", LOG_ERROR(Log::SPU, "%s error: unknown/illegal channel (%d [%s]).",
__FUNCTION__, ch, spu_ch_name[ch]); __FUNCTION__, ch, spu_ch_name[ch]);
break; break;
} }
@ -988,7 +988,7 @@ public:
case SPU_WrOutIntrMbox: case SPU_WrOutIntrMbox:
if (!group) // if RawSPU if (!group) // if RawSPU
{ {
if (Ini.HLELogging.GetValue()) LOGF_NOTICE(Log::SPU, "SPU_WrOutIntrMbox: interrupt(v=0x%x)", v); if (Ini.HLELogging.GetValue()) LOG_NOTICE(Log::SPU, "SPU_WrOutIntrMbox: interrupt(v=0x%x)", v);
SPU.Out_IntrMBox.PushUncond(v); SPU.Out_IntrMBox.PushUncond(v);
m_intrtag[2].stat |= 1; m_intrtag[2].stat |= 1;
if (CPUThread* t = Emu.GetCPU().GetThread(m_intrtag[2].thread)) if (CPUThread* t = Emu.GetCPU().GetThread(m_intrtag[2].thread))
@ -998,7 +998,7 @@ public:
Sleep(1); Sleep(1);
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(Log::SPU, "%s(%s) aborted", __FUNCTION__, spu_ch_name[ch]); LOG_WARNING(Log::SPU, "%s(%s) aborted", __FUNCTION__, spu_ch_name[ch]);
return; return;
} }
} }
@ -1019,20 +1019,20 @@ public:
u32 data; u32 data;
if (!SPU.Out_MBox.Pop(data)) if (!SPU.Out_MBox.Pop(data))
{ {
LOGF_ERROR(Log::SPU, "sys_spu_thread_send_event(v=0x%x, spup=%d): Out_MBox is empty", v, spup); LOG_ERROR(Log::SPU, "sys_spu_thread_send_event(v=0x%x, spup=%d): Out_MBox is empty", v, spup);
return; return;
} }
if (SPU.In_MBox.GetCount()) if (SPU.In_MBox.GetCount())
{ {
LOGF_ERROR(Log::SPU, "sys_spu_thread_send_event(v=0x%x, spup=%d): In_MBox is not empty", v, spup); LOG_ERROR(Log::SPU, "sys_spu_thread_send_event(v=0x%x, spup=%d): In_MBox is not empty", v, spup);
SPU.In_MBox.PushUncond(CELL_EBUSY); // ??? SPU.In_MBox.PushUncond(CELL_EBUSY); // ???
return; return;
} }
if (Ini.HLELogging.GetValue()) if (Ini.HLELogging.GetValue())
{ {
LOGF_NOTICE(Log::SPU, "sys_spu_thread_send_event(spup=%d, data0=0x%x, data1=0x%x)", spup, v & 0x00ffffff, data); LOG_NOTICE(Log::SPU, "sys_spu_thread_send_event(spup=%d, data0=0x%x, data1=0x%x)", spup, v & 0x00ffffff, data);
} }
EventPort& port = SPUPs[spup]; EventPort& port = SPUPs[spup];
@ -1042,7 +1042,7 @@ public:
if (!port.eq) if (!port.eq)
{ {
// spu_printf fails there // spu_printf fails there
LOGF_WARNING(Log::SPU, "sys_spu_thread_send_event(spup=%d, data0=0x%x, data1=0x%x): event queue not connected", spup, (v & 0x00ffffff), data); LOG_WARNING(Log::SPU, "sys_spu_thread_send_event(spup=%d, data0=0x%x, data1=0x%x): event queue not connected", spup, (v & 0x00ffffff), data);
SPU.In_MBox.PushUncond(CELL_ENOTCONN); // TODO: check error passing SPU.In_MBox.PushUncond(CELL_ENOTCONN); // TODO: check error passing
return; return;
} }
@ -1064,25 +1064,25 @@ public:
u32 data; u32 data;
if (!SPU.Out_MBox.Pop(data)) if (!SPU.Out_MBox.Pop(data))
{ {
LOGF_ERROR(Log::SPU, "sys_event_flag_set_bit(v=0x%x (flag=%d)): Out_MBox is empty", v, flag); LOG_ERROR(Log::SPU, "sys_event_flag_set_bit(v=0x%x (flag=%d)): Out_MBox is empty", v, flag);
return; return;
} }
if (flag > 63) if (flag > 63)
{ {
LOGF_ERROR(Log::SPU, "sys_event_flag_set_bit(id=%d, v=0x%x): flag > 63", data, v, flag); LOG_ERROR(Log::SPU, "sys_event_flag_set_bit(id=%d, v=0x%x): flag > 63", data, v, flag);
return; return;
} }
//if (Ini.HLELogging.GetValue()) //if (Ini.HLELogging.GetValue())
{ {
LOGF_WARNING(Log::SPU, "sys_event_flag_set_bit(id=%d, v=0x%x (flag=%d))", data, v, flag); LOG_WARNING(Log::SPU, "sys_event_flag_set_bit(id=%d, v=0x%x (flag=%d))", data, v, flag);
} }
EventFlag* ef; EventFlag* ef;
if (!Emu.GetIdManager().GetIDData(data, ef)) if (!Emu.GetIdManager().GetIDData(data, ef))
{ {
LOGF_ERROR(Log::SPU, "sys_event_flag_set_bit(id=%d, v=0x%x (flag=%d)): EventFlag not found", data, v, flag); LOG_ERROR(Log::SPU, "sys_event_flag_set_bit(id=%d, v=0x%x (flag=%d)): EventFlag not found", data, v, flag);
SPU.In_MBox.PushUncond(CELL_ESRCH); SPU.In_MBox.PushUncond(CELL_ESRCH);
return; return;
} }
@ -1110,11 +1110,11 @@ public:
u32 data; u32 data;
if (SPU.Out_MBox.Pop(data)) if (SPU.Out_MBox.Pop(data))
{ {
LOGF_ERROR(Log::SPU, "SPU_WrOutIntrMbox: unknown data (v=0x%x); Out_MBox = 0x%x", v, data); LOG_ERROR(Log::SPU, "SPU_WrOutIntrMbox: unknown data (v=0x%x); Out_MBox = 0x%x", v, data);
} }
else else
{ {
LOGF_ERROR(Log::SPU, "SPU_WrOutIntrMbox: unknown data (v=0x%x)", v); LOG_ERROR(Log::SPU, "SPU_WrOutIntrMbox: unknown data (v=0x%x)", v);
} }
SPU.In_MBox.PushUncond(CELL_EINVAL); // ??? SPU.In_MBox.PushUncond(CELL_EINVAL); // ???
return; return;
@ -1166,13 +1166,13 @@ public:
{ {
if (v >= 32) if (v >= 32)
{ {
LOGF_ERROR(Log::SPU, "MFC_WrListStallAck error: invalid tag(%d)", v); LOG_ERROR(Log::SPU, "MFC_WrListStallAck error: invalid tag(%d)", v);
return; return;
} }
StalledList temp = StallList[v]; StalledList temp = StallList[v];
if (!temp.MFCArgs) if (!temp.MFCArgs)
{ {
LOGF_ERROR(Log::SPU, "MFC_WrListStallAck error: empty tag(%d)", v); LOG_ERROR(Log::SPU, "MFC_WrListStallAck error: empty tag(%d)", v);
return; return;
} }
StallList[v].MFCArgs = nullptr; StallList[v].MFCArgs = nullptr;
@ -1181,11 +1181,11 @@ public:
break; break;
default: default:
LOGF_ERROR(Log::SPU, "%s error: unknown/illegal channel (%d [%s]).", __FUNCTION__, ch, spu_ch_name[ch]); LOG_ERROR(Log::SPU, "%s error: unknown/illegal channel (%d [%s]).", __FUNCTION__, ch, spu_ch_name[ch]);
break; break;
} }
if (Emu.IsStopped()) LOGF_WARNING(Log::SPU, "%s(%s) aborted", __FUNCTION__, spu_ch_name[ch]); if (Emu.IsStopped()) LOG_WARNING(Log::SPU, "%s(%s) aborted", __FUNCTION__, spu_ch_name[ch]);
} }
void ReadChannel(SPU_GPR_hdr& r, u32 ch) void ReadChannel(SPU_GPR_hdr& r, u32 ch)
@ -1224,11 +1224,11 @@ public:
break; break;
default: default:
LOGF_ERROR(Log::SPU, "%s error: unknown/illegal channel (%d [%s]).", __FUNCTION__, ch, spu_ch_name[ch]); LOG_ERROR(Log::SPU, "%s error: unknown/illegal channel (%d [%s]).", __FUNCTION__, ch, spu_ch_name[ch]);
break; break;
} }
if (Emu.IsStopped()) LOGF_WARNING(Log::SPU, "%s(%s) aborted", __FUNCTION__, spu_ch_name[ch]); if (Emu.IsStopped()) LOG_WARNING(Log::SPU, "%s(%s) aborted", __FUNCTION__, spu_ch_name[ch]);
} }
void DoStop(u32 code) void DoStop(u32 code)
@ -1249,14 +1249,14 @@ public:
if (SPU.In_MBox.GetCount()) if (SPU.In_MBox.GetCount())
{ {
LOGF_ERROR(Log::SPU, "sys_spu_thread_receive_event(spuq=0x%x): In_MBox is not empty", spuq); LOG_ERROR(Log::SPU, "sys_spu_thread_receive_event(spuq=0x%x): In_MBox is not empty", spuq);
SPU.In_MBox.PushUncond(CELL_EBUSY); // ??? SPU.In_MBox.PushUncond(CELL_EBUSY); // ???
return; return;
} }
if (Ini.HLELogging.GetValue()) if (Ini.HLELogging.GetValue())
{ {
LOGF_NOTICE(Log::SPU, "sys_spu_thread_receive_event(spuq=0x%x)", spuq); LOG_NOTICE(Log::SPU, "sys_spu_thread_receive_event(spuq=0x%x)", spuq);
} }
EventQueue* eq; EventQueue* eq;
@ -1307,7 +1307,7 @@ public:
Sleep(1); Sleep(1);
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(Log::SPU, "sys_spu_thread_receive_event(spuq=0x%x) aborted", spuq); LOG_WARNING(Log::SPU, "sys_spu_thread_receive_event(spuq=0x%x) aborted", spuq);
eq->sq.invalidate(tid); eq->sq.invalidate(tid);
return; return;
} }
@ -1322,7 +1322,7 @@ public:
else if (Ini.HLELogging.GetValue()) else if (Ini.HLELogging.GetValue())
{ {
// the real exit status // the real exit status
LOGF_NOTICE(Log::SPU, "sys_spu_thread_exit (status=0x%x)", SPU.Out_MBox.GetValue()); LOG_NOTICE(Log::SPU, "sys_spu_thread_exit (status=0x%x)", SPU.Out_MBox.GetValue());
} }
SPU.Status.SetValue(SPU_STATUS_STOPPED_BY_STOP); SPU.Status.SetValue(SPU_STATUS_STOPPED_BY_STOP);
Stop(); Stop();
@ -1330,11 +1330,11 @@ public:
default: default:
if (!SPU.Out_MBox.GetCount()) if (!SPU.Out_MBox.GetCount())
{ {
LOGF_ERROR(Log::SPU, "Unknown STOP code: 0x%x (no message)", code); LOG_ERROR(Log::SPU, "Unknown STOP code: 0x%x (no message)", code);
} }
else else
{ {
LOGF_ERROR(Log::SPU, "Unknown STOP code: 0x%x (message=0x%x)", code, SPU.Out_MBox.GetValue()); LOG_ERROR(Log::SPU, "Unknown STOP code: 0x%x (message=0x%x)", code, SPU.Out_MBox.GetValue());
} }
SPU.Status.SetValue(SPU_STATUS_STOPPED_BY_STOP); SPU.Status.SetValue(SPU_STATUS_STOPPED_BY_STOP);
Stop(); Stop();

4
rpcs3/Emu/FS/vfsLocalFile.cpp
View file

@ -53,7 +53,7 @@ bool vfsLocalFile::Open(const std::string& path, vfsOpenMode mode)
bool vfsLocalFile::Create(const std::string& path) bool vfsLocalFile::Create(const std::string& path)
{ {
LOGF_WARNING(HLE, "vfsLocalFile::Create('%s')", path.c_str()); LOG_WARNING(HLE, "vfsLocalFile::Create('%s')", path.c_str());
for(uint p=1; p < path.length() && path[p] != '\0' ; p++) for(uint p=1; p < path.length() && path[p] != '\0' ; p++)
{ {
for(; p < path.length() && path[p] != '\0'; p++) for(; p < path.length() && path[p] != '\0'; p++)
@ -65,7 +65,7 @@ bool vfsLocalFile::Create(const std::string& path)
const std::string& dir = path.substr(0, p); const std::string& dir = path.substr(0, p);
if(!rDirExists(dir)) if(!rDirExists(dir))
{ {
LOGF_NOTICE(HLE, "create dir: %s", dir.c_str()); LOG_NOTICE(HLE, "create dir: %s", dir.c_str());
rMkdir(dir); rMkdir(dir);
} }
} }

12
rpcs3/Emu/GS/GL/GLFragmentProgram.cpp
View file

@ -19,7 +19,7 @@ void GLFragmentDecompilerThread::SetDst(std::string code, bool append_mask)
case 7: code = "(" + code + " / 8.0)"; break; case 7: code = "(" + code + " / 8.0)"; break;
default: default:
LOGF_ERROR(RSX, "Bad scale: %d", fmt::by_value(src1.scale)); LOG_ERROR(RSX, "Bad scale: %d", fmt::by_value(src1.scale));
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -210,7 +210,7 @@ template<typename T> std::string GLFragmentDecompilerThread::GetSRC(T src)
} }
else else
{ {
LOGF_ERROR(RSX, "Bad src reg num: %d", fmt::by_value(dst.src_attr_reg_num)); LOG_ERROR(RSX, "Bad src reg num: %d", fmt::by_value(dst.src_attr_reg_num));
ret += m_parr.AddParam(PARAM_IN, "vec4", "unk"); ret += m_parr.AddParam(PARAM_IN, "vec4", "unk");
Emu.Pause(); Emu.Pause();
} }
@ -224,7 +224,7 @@ template<typename T> std::string GLFragmentDecompilerThread::GetSRC(T src)
break; break;
default: default:
LOGF_ERROR(RSX, "Bad src type %d", fmt::by_value(src.reg_type)); LOG_ERROR(RSX, "Bad src type %d", fmt::by_value(src.reg_type));
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -416,7 +416,7 @@ void GLFragmentDecompilerThread::Task()
//case 0x45: SetDst("return"); break; //RET //case 0x45: SetDst("return"); break; //RET
default: default:
LOGF_ERROR(RSX, "Unknown fp opcode 0x%x (inst %d)", opcode, m_size / (4 * 4)); LOG_ERROR(RSX, "Unknown fp opcode 0x%x (inst %d)", opcode, m_size / (4 * 4));
//Emu.Pause(); //Emu.Pause();
break; break;
} }
@ -515,7 +515,7 @@ void GLShaderProgram::Compile()
char* buf = new char[infoLength]; // Buffer to store infoLog char* buf = new char[infoLength]; // Buffer to store infoLog
glGetShaderInfoLog(m_id, infoLength, &len, buf); // Retrieve the shader info log into our buffer glGetShaderInfoLog(m_id, infoLength, &len, buf); // Retrieve the shader info log into our buffer
LOGF_ERROR(RSX, "Failed to compile shader: %s", buf); // Write log to the console LOG_ERROR(RSX, "Failed to compile shader: %s", buf); // Write log to the console
delete[] buf; delete[] buf;
} }
@ -540,7 +540,7 @@ void GLShaderProgram::Delete()
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(RSX, "GLShaderProgram::Delete(): glDeleteShader(%d) avoided", m_id); LOG_WARNING(RSX, "GLShaderProgram::Delete(): glDeleteShader(%d) avoided", m_id);
} }
else else
{ {

38
rpcs3/Emu/GS/GL/GLGSRender.cpp
View file

@ -9,7 +9,7 @@
#define DUMP_VERTEX_DATA 0 #define DUMP_VERTEX_DATA 0
#if CMD_DEBUG #if CMD_DEBUG
#define CMD_LOG(...) LOGF_NOTICE(RSX, __VA_ARGS__) #define CMD_LOG(...) LOG_NOTICE(RSX, __VA_ARGS__)
#else #else
#define CMD_LOG(...) #define CMD_LOG(...)
#endif #endif
@ -27,7 +27,7 @@ void printGlError(GLenum err, const char* situation)
{ {
if(err != GL_NO_ERROR) if(err != GL_NO_ERROR)
{ {
LOGF_ERROR(RSX, "%s: opengl error 0x%04x", situation, err); LOG_ERROR(RSX, "%s: opengl error 0x%04x", situation, err);
Emu.Pause(); Emu.Pause();
} }
} }
@ -180,7 +180,7 @@ void GLGSRender::EnableVertexData(bool indexed_draw)
break; break;
default: default:
LOGF_ERROR(HLE, "Bad cv type! %d", m_vertex_data[i].type); LOG_ERROR(HLE, "Bad cv type! %d", m_vertex_data[i].type);
return; return;
} }
@ -309,7 +309,7 @@ void GLGSRender::InitFragmentData()
{ {
if(!m_cur_shader_prog) if(!m_cur_shader_prog)
{ {
LOGF_ERROR(RSX, "InitFragmentData: m_cur_shader_prog == NULL"); LOG_ERROR(RSX, "InitFragmentData: m_cur_shader_prog == NULL");
return; return;
} }
@ -337,13 +337,13 @@ bool GLGSRender::LoadProgram()
{ {
if(!m_cur_shader_prog) if(!m_cur_shader_prog)
{ {
LOGF_WARNING(RSX, "LoadProgram: m_cur_shader_prog == NULL"); LOG_WARNING(RSX, "LoadProgram: m_cur_shader_prog == NULL");
return false; return false;
} }
if(!m_cur_vertex_prog) if(!m_cur_vertex_prog)
{ {
LOGF_WARNING(RSX, "LoadProgram: m_cur_vertex_prog == NULL"); LOG_WARNING(RSX, "LoadProgram: m_cur_vertex_prog == NULL");
return false; return false;
} }
@ -354,7 +354,7 @@ bool GLGSRender::LoadProgram()
if(m_fp_buf_num == -1) if(m_fp_buf_num == -1)
{ {
LOGF_WARNING(RSX, "FP not found in buffer!"); LOG_WARNING(RSX, "FP not found in buffer!");
m_shader_prog.DecompileAsync(*m_cur_shader_prog); m_shader_prog.DecompileAsync(*m_cur_shader_prog);
m_shader_prog.Wait(); m_shader_prog.Wait();
m_shader_prog.Compile(); m_shader_prog.Compile();
@ -366,7 +366,7 @@ bool GLGSRender::LoadProgram()
if(m_vp_buf_num == -1) if(m_vp_buf_num == -1)
{ {
LOGF_WARNING(RSX, "VP not found in buffer!"); LOG_WARNING(RSX, "VP not found in buffer!");
m_vertex_prog.DecompileAsync(*m_cur_vertex_prog); m_vertex_prog.DecompileAsync(*m_cur_vertex_prog);
m_vertex_prog.Wait(); m_vertex_prog.Wait();
m_vertex_prog.Compile(); m_vertex_prog.Compile();
@ -450,7 +450,7 @@ void GLGSRender::WriteDepthBuffer()
u32 address = GetAddress(m_surface_offset_z, m_context_dma_z - 0xfeed0000); u32 address = GetAddress(m_surface_offset_z, m_context_dma_z - 0xfeed0000);
if (!Memory.IsGoodAddr(address)) if (!Memory.IsGoodAddr(address))
{ {
LOGF_WARNING(RSX, "Bad depth address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_z, m_context_dma_z); LOG_WARNING(RSX, "Bad depth address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_z, m_context_dma_z);
return; return;
} }
@ -484,7 +484,7 @@ void GLGSRender::WriteColourBufferA()
u32 address = GetAddress(m_surface_offset_a, m_context_dma_color_a - 0xfeed0000); u32 address = GetAddress(m_surface_offset_a, m_context_dma_color_a - 0xfeed0000);
if (!Memory.IsGoodAddr(address)) if (!Memory.IsGoodAddr(address))
{ {
LOGF_WARNING(RSX, "Bad colour buffer a address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_a, m_context_dma_color_a); LOG_WARNING(RSX, "Bad colour buffer a address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_a, m_context_dma_color_a);
return; return;
} }
@ -513,7 +513,7 @@ void GLGSRender::WriteColourBufferB()
u32 address = GetAddress(m_surface_offset_b, m_context_dma_color_b - 0xfeed0000); u32 address = GetAddress(m_surface_offset_b, m_context_dma_color_b - 0xfeed0000);
if (!Memory.IsGoodAddr(address)) if (!Memory.IsGoodAddr(address))
{ {
LOGF_WARNING(RSX, "Bad colour buffer b address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_b, m_context_dma_color_b); LOG_WARNING(RSX, "Bad colour buffer b address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_b, m_context_dma_color_b);
return; return;
} }
@ -543,7 +543,7 @@ void GLGSRender::WriteColourBufferC()
u32 address = GetAddress(m_surface_offset_c, m_context_dma_color_c - 0xfeed0000); u32 address = GetAddress(m_surface_offset_c, m_context_dma_color_c - 0xfeed0000);
if (!Memory.IsGoodAddr(address)) if (!Memory.IsGoodAddr(address))
{ {
LOGF_WARNING(RSX, "Bad colour buffer c address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_c, m_context_dma_color_c); LOG_WARNING(RSX, "Bad colour buffer c address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_c, m_context_dma_color_c);
return; return;
} }
@ -572,7 +572,7 @@ void GLGSRender::WriteColourBufferD()
u32 address = GetAddress(m_surface_offset_d, m_context_dma_color_d - 0xfeed0000); u32 address = GetAddress(m_surface_offset_d, m_context_dma_color_d - 0xfeed0000);
if (!Memory.IsGoodAddr(address)) if (!Memory.IsGoodAddr(address))
{ {
LOGF_WARNING(RSX, "Bad colour buffer d address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_d, m_context_dma_color_d); LOG_WARNING(RSX, "Bad colour buffer d address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_d, m_context_dma_color_d);
return; return;
} }
@ -703,14 +703,14 @@ void GLGSRender::ExecCMD()
//return; //return;
if(!LoadProgram()) if(!LoadProgram())
{ {
LOGF_ERROR(RSX, "LoadProgram failed."); LOG_ERROR(RSX, "LoadProgram failed.");
Emu.Pause(); Emu.Pause();
return; return;
} }
if(!m_fbo.IsCreated() || RSXThread::m_width != last_width || RSXThread::m_height != last_height || last_depth_format != m_surface_depth_format) if(!m_fbo.IsCreated() || RSXThread::m_width != last_width || RSXThread::m_height != last_height || last_depth_format != m_surface_depth_format)
{ {
LOGF_WARNING(RSX, "New FBO (%dx%d)", RSXThread::m_width, RSXThread::m_height); LOG_WARNING(RSX, "New FBO (%dx%d)", RSXThread::m_width, RSXThread::m_height);
last_width = RSXThread::m_width; last_width = RSXThread::m_width;
last_height = RSXThread::m_height; last_height = RSXThread::m_height;
last_depth_format = m_surface_depth_format; last_depth_format = m_surface_depth_format;
@ -753,7 +753,7 @@ void GLGSRender::ExecCMD()
break; break;
default: default:
LOGF_ERROR(RSX, "Bad depth format! (%d)", m_surface_depth_format); LOG_ERROR(RSX, "Bad depth format! (%d)", m_surface_depth_format);
assert(0); assert(0);
break; break;
} }
@ -821,7 +821,7 @@ void GLGSRender::ExecCMD()
break; break;
default: default:
LOGF_ERROR(RSX, "Bad surface colour target: %d", m_surface_colour_target); LOG_ERROR(RSX, "Bad surface colour target: %d", m_surface_colour_target);
break; break;
} }
@ -1099,7 +1099,7 @@ void GLGSRender::ExecCMD()
if(m_indexed_array.m_count && m_draw_array_count) if(m_indexed_array.m_count && m_draw_array_count)
{ {
LOGF_WARNING(RSX, "m_indexed_array.m_count && draw_array_count"); LOG_WARNING(RSX, "m_indexed_array.m_count && draw_array_count");
} }
for(u32 i=0; i<m_textures_count; ++i) for(u32 i=0; i<m_textures_count; ++i)
@ -1142,7 +1142,7 @@ void GLGSRender::ExecCMD()
break; break;
default: default:
LOGF_ERROR(RSX, "Bad indexed array type (%d)", m_indexed_array.m_type); LOG_ERROR(RSX, "Bad indexed array type (%d)", m_indexed_array.m_type);
break; break;
} }

6
rpcs3/Emu/GS/GL/GLGSRender.h
View file

@ -57,7 +57,7 @@ public:
case 8: return GL_MIRROR_CLAMP_EXT; case 8: return GL_MIRROR_CLAMP_EXT;
} }
LOGF_ERROR(RSX, "Texture wrap error: bad wrap (%d).", wrap); LOG_ERROR(RSX, "Texture wrap error: bad wrap (%d).", wrap);
return GL_REPEAT; return GL_REPEAT;
} }
@ -89,7 +89,7 @@ public:
const u64 texaddr = GetAddress(tex.GetOffset(), tex.GetLocation()); const u64 texaddr = GetAddress(tex.GetOffset(), tex.GetLocation());
if (!Memory.IsGoodAddr(texaddr)) if (!Memory.IsGoodAddr(texaddr))
{ {
LOGF_ERROR(RSX, "Bad texture address=0x%x", texaddr); LOG_ERROR(RSX, "Bad texture address=0x%x", texaddr);
return; return;
} }
//ConLog.Warning("texture addr = 0x%x, width = %d, height = %d, max_aniso=%d, mipmap=%d, remap=0x%x, zfunc=0x%x, wraps=0x%x, wrapt=0x%x, wrapr=0x%x, minlod=0x%x, maxlod=0x%x", //ConLog.Warning("texture addr = 0x%x, width = %d, height = %d, max_aniso=%d, mipmap=%d, remap=0x%x, zfunc=0x%x, wraps=0x%x, wrapt=0x%x, wrapr=0x%x, minlod=0x%x, maxlod=0x%x",
@ -420,7 +420,7 @@ public:
} }
break; break;
default: LOGF_ERROR(RSX, "Init tex error: Bad tex format (0x%x | %s | 0x%x)", format, default: LOG_ERROR(RSX, "Init tex error: Bad tex format (0x%x | %s | 0x%x)", format,
(is_swizzled ? "swizzled" : "linear"), tex.GetFormat() & 0x40); break; (is_swizzled ? "swizzled" : "linear"), tex.GetFormat() & 0x40); break;
} }

6
rpcs3/Emu/GS/GL/GLProgram.cpp
View file

@ -54,13 +54,13 @@ void GLProgram::Create(const u32 vp, const u32 fp)
char* buf = new char[bufLength+1]; char* buf = new char[bufLength+1];
memset(buf, 0, bufLength+1); memset(buf, 0, bufLength+1);
glGetProgramInfoLog(id, bufLength, NULL, buf); glGetProgramInfoLog(id, bufLength, NULL, buf);
LOGF_ERROR(RSX, "Could not link program: %s", buf); LOG_ERROR(RSX, "Could not link program: %s", buf);
delete[] buf; delete[] buf;
return; return;
} }
} }
//else LOGF_NOTICE(HLE, "program linked!"); //else LOG_NOTICE(HLE, "program linked!");
glGetProgramiv(id, GL_VALIDATE_STATUS, &linkStatus); glGetProgramiv(id, GL_VALIDATE_STATUS, &linkStatus);
if(linkStatus != GL_TRUE) if(linkStatus != GL_TRUE)
@ -73,7 +73,7 @@ void GLProgram::Create(const u32 vp, const u32 fp)
char* buf = new char[bufLength]; char* buf = new char[bufLength];
memset(buf, 0, bufLength); memset(buf, 0, bufLength);
glGetProgramInfoLog(id, bufLength, NULL, buf); glGetProgramInfoLog(id, bufLength, NULL, buf);
LOGF_ERROR(RSX, "Could not link program: %s", buf); LOG_ERROR(RSX, "Could not link program: %s", buf);
delete[] buf; delete[] buf;
return; return;

40
rpcs3/Emu/GS/GL/GLProgramBuffer.cpp
View file

@ -52,13 +52,13 @@ u32 GLProgramBuffer::GetProg(u32 fp, u32 vp) const
if(fp == vp) if(fp == vp)
{ {
/* /*
LOGF_NOTICE(RSX, "Get program (%d):", fp); LOG_NOTICE(RSX, "Get program (%d):", fp);
LOGF_NOTICE(RSX, "*** prog id = %d", m_buf[fp].prog_id); LOG_NOTICE(RSX, "*** prog id = %d", m_buf[fp].prog_id);
LOGF_NOTICE(RSX, "*** vp id = %d", m_buf[fp].vp_id); LOG_NOTICE(RSX, "*** vp id = %d", m_buf[fp].vp_id);
LOGF_NOTICE(RSX, "*** fp id = %d", m_buf[fp].fp_id); LOG_NOTICE(RSX, "*** fp id = %d", m_buf[fp].fp_id);
LOGF_NOTICE(RSX, "*** vp shader = \n%s", m_buf[fp].vp_shader.wx_str()); LOG_NOTICE(RSX, "*** vp shader = \n%s", m_buf[fp].vp_shader.wx_str());
LOGF_NOTICE(RSX, "*** fp shader = \n%s", m_buf[fp].fp_shader.wx_str()); LOG_NOTICE(RSX, "*** fp shader = \n%s", m_buf[fp].fp_shader.wx_str());
*/ */
return m_buf[fp].prog_id; return m_buf[fp].prog_id;
} }
@ -70,13 +70,13 @@ u32 GLProgramBuffer::GetProg(u32 fp, u32 vp) const
if(CmpVP(vp, i) && CmpFP(fp, i)) if(CmpVP(vp, i) && CmpFP(fp, i))
{ {
/* /*
LOGF_NOTICE(RSX, "Get program (%d):", i); LOG_NOTICE(RSX, "Get program (%d):", i);
LOGF_NOTICE(RSX, "*** prog id = %d", m_buf[i].prog_id); LOG_NOTICE(RSX, "*** prog id = %d", m_buf[i].prog_id);
LOGF_NOTICE(RSX, "*** vp id = %d", m_buf[i].vp_id); LOG_NOTICE(RSX, "*** vp id = %d", m_buf[i].vp_id);
LOGF_NOTICE(RSX, "*** fp id = %d", m_buf[i].fp_id); LOG_NOTICE(RSX, "*** fp id = %d", m_buf[i].fp_id);
LOGF_NOTICE(RSX, "*** vp shader = \n%s", m_buf[i].vp_shader.wx_str()); LOG_NOTICE(RSX, "*** vp shader = \n%s", m_buf[i].vp_shader.wx_str());
LOGF_NOTICE(RSX, "*** fp shader = \n%s", m_buf[i].fp_shader.wx_str()); LOG_NOTICE(RSX, "*** fp shader = \n%s", m_buf[i].fp_shader.wx_str());
*/ */
return m_buf[i].prog_id; return m_buf[i].prog_id;
} }
@ -89,15 +89,15 @@ void GLProgramBuffer::Add(GLProgram& prog, GLShaderProgram& gl_fp, RSXShaderProg
{ {
GLBufferInfo new_buf; GLBufferInfo new_buf;
LOGF_NOTICE(RSX, "Add program (%d):", m_buf.size()); LOG_NOTICE(RSX, "Add program (%d):", m_buf.size());
LOGF_NOTICE(RSX, "*** prog id = %d", prog.id); LOG_NOTICE(RSX, "*** prog id = %d", prog.id);
LOGF_NOTICE(RSX, "*** vp id = %d", gl_vp.id); LOG_NOTICE(RSX, "*** vp id = %d", gl_vp.id);
LOGF_NOTICE(RSX, "*** fp id = %d", gl_fp.GetId()); LOG_NOTICE(RSX, "*** fp id = %d", gl_fp.GetId());
LOGF_NOTICE(RSX, "*** vp data size = %d", rsx_vp.data.size() * 4); LOG_NOTICE(RSX, "*** vp data size = %d", rsx_vp.data.size() * 4);
LOGF_NOTICE(RSX, "*** fp data size = %d", rsx_fp.size); LOG_NOTICE(RSX, "*** fp data size = %d", rsx_fp.size);
LOGF_NOTICE(RSX, "*** vp shader = \n%s", gl_vp.shader.c_str()); LOG_NOTICE(RSX, "*** vp shader = \n%s", gl_vp.shader.c_str());
LOGF_NOTICE(RSX, "*** fp shader = \n%s", gl_fp.GetShaderText().c_str()); LOG_NOTICE(RSX, "*** fp shader = \n%s", gl_fp.GetShaderText().c_str());
new_buf.prog_id = prog.id; new_buf.prog_id = prog.id;

16
rpcs3/Emu/GS/GL/GLVertexProgram.cpp
View file

@ -49,7 +49,7 @@ std::string GLVertexDecompilerThread::GetDST(bool isSca)
default: default:
if (d3.dst > 15) if (d3.dst > 15)
LOGF_ERROR(RSX, "dst index out of range: %u", d3.dst); LOG_ERROR(RSX, "dst index out of range: %u", d3.dst);
ret += m_parr.AddParam(PARAM_NONE, "vec4", std::string("dst_reg") + std::to_string(d3.dst), d3.dst == 0 ? "vec4(0.0f, 0.0f, 0.0f, 1.0f)" : "vec4(0.0)"); ret += m_parr.AddParam(PARAM_NONE, "vec4", std::string("dst_reg") + std::to_string(d3.dst), d3.dst == 0 ? "vec4(0.0f, 0.0f, 0.0f, 1.0f)" : "vec4(0.0)");
break; break;
} }
@ -83,7 +83,7 @@ std::string GLVertexDecompilerThread::GetSRC(const u32 n)
} }
else else
{ {
LOGF_ERROR(RSX, "Bad input src num: %d", fmt::by_value(d1.input_src)); LOG_ERROR(RSX, "Bad input src num: %d", fmt::by_value(d1.input_src));
ret += m_parr.AddParam(PARAM_IN, "vec4", "in_unk", d1.input_src); ret += m_parr.AddParam(PARAM_IN, "vec4", "in_unk", d1.input_src);
} }
break; break;
@ -93,7 +93,7 @@ std::string GLVertexDecompilerThread::GetSRC(const u32 n)
break; break;
default: default:
LOGF_ERROR(RSX, "Bad src%u reg type: %d", n, fmt::by_value(src[n].reg_type)); LOG_ERROR(RSX, "Bad src%u reg type: %d", n, fmt::by_value(src[n].reg_type));
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -510,7 +510,7 @@ void GLVertexDecompilerThread::Task()
default: default:
m_body.push_back(fmt::Format("//Unknown vp sca_opcode 0x%x", fmt::by_value(d1.sca_opcode))); m_body.push_back(fmt::Format("//Unknown vp sca_opcode 0x%x", fmt::by_value(d1.sca_opcode)));
LOGF_ERROR(RSX, "Unknown vp sca_opcode 0x%x", fmt::by_value(d1.sca_opcode)); LOG_ERROR(RSX, "Unknown vp sca_opcode 0x%x", fmt::by_value(d1.sca_opcode));
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -543,7 +543,7 @@ void GLVertexDecompilerThread::Task()
default: default:
m_body.push_back(fmt::Format("//Unknown vp opcode 0x%x", fmt::by_value(d1.vec_opcode))); m_body.push_back(fmt::Format("//Unknown vp opcode 0x%x", fmt::by_value(d1.vec_opcode)));
LOGF_ERROR(RSX, "Unknown vp opcode 0x%x", fmt::by_value(d1.vec_opcode)); LOG_ERROR(RSX, "Unknown vp opcode 0x%x", fmt::by_value(d1.vec_opcode));
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -647,14 +647,14 @@ void GLVertexProgram::Compile()
GLsizei len; GLsizei len;
memset(buf, 0, r+1); memset(buf, 0, r+1);
glGetShaderInfoLog(id, r, &len, buf); glGetShaderInfoLog(id, r, &len, buf);
LOGF_ERROR(RSX, "Failed to compile vertex shader: %s", buf); LOG_ERROR(RSX, "Failed to compile vertex shader: %s", buf);
delete[] buf; delete[] buf;
} }
LOG_NOTICE(RSX, shader); LOG_NOTICE(RSX, shader);
Emu.Pause(); Emu.Pause();
} }
//else LOGF_WARNING(RSX, "Vertex shader compiled successfully!"); //else LOG_WARNING(RSX, "Vertex shader compiled successfully!");
} }
@ -667,7 +667,7 @@ void GLVertexProgram::Delete()
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(RSX, "GLVertexProgram::Delete(): glDeleteShader(%d) avoided", id); LOG_WARNING(RSX, "GLVertexProgram::Delete(): glDeleteShader(%d) avoided", id);
} }
else else
{ {

120
rpcs3/Emu/GS/RSXThread.cpp
View file

@ -20,7 +20,7 @@ u32 GetAddress(u32 offset, u8 location)
return realAddr; return realAddr;
} }
LOGF_ERROR(RSX, "GetAddress(offset=0x%x, location=0x%x)", location); LOG_ERROR(RSX, "GetAddress(offset=0x%x, location=0x%x)", location);
assert(0); assert(0);
return 0; return 0;
} }
@ -97,7 +97,7 @@ u32 RSXVertexData::GetTypeSize()
case 7: return 1; case 7: return 1;
} }
LOGF_ERROR(RSX, "Bad vertex data type! %d", type); LOG_ERROR(RSX, "Bad vertex data type! %d", type);
return 1; return 1;
} }
@ -115,7 +115,7 @@ u32 RSXThread::OutOfArgsCount(const uint x, const u32 cmd, const u32 count)
debug += "("; debug += "(";
for(u32 i=0; i<count; ++i) debug += (i ? ", " : "") + fmt::Format("0x%x", ARGS(i)); for(u32 i=0; i<count; ++i) debug += (i ? ", " : "") + fmt::Format("0x%x", ARGS(i));
debug += ")"; debug += ")";
LOGF_NOTICE(RSX, "OutOfArgsCount(x=%u, count=%u): " + debug, x, count); LOG_NOTICE(RSX, "OutOfArgsCount(x=%u, count=%u): " + debug, x, count);
return 0; return 0;
} }
@ -214,7 +214,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_NO_OPERATION: case NV4097_NO_OPERATION:
{ {
LOGF_WARNING(RSX, "NV4097_NO_OPERATION"); LOG_WARNING(RSX, "NV4097_NO_OPERATION");
} }
break; break;
@ -274,7 +274,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case_16(NV4097_SET_TEX_COORD_CONTROL, 4) : case_16(NV4097_SET_TEX_COORD_CONTROL, 4) :
{ {
LOGF_WARNING(RSX, "NV4097_SET_TEX_COORD_CONTROL"); LOG_WARNING(RSX, "NV4097_SET_TEX_COORD_CONTROL");
} }
break; break;
@ -304,7 +304,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
m_vertex_data[index].data.push_back(v1); m_vertex_data[index].data.push_back(v1);
m_vertex_data[index].data.push_back(v2); m_vertex_data[index].data.push_back(v2);
m_vertex_data[index].data.push_back(v3); m_vertex_data[index].data.push_back(v3);
//LOGF_WARNING(RSX, "index = %d, v0 = 0x%x, v1 = 0x%x, v2 = 0x%x, v3 = 0x%x", index, v0, v1, v2, v3); //LOG_WARNING(RSX, "index = %d, v0 = 0x%x, v1 = 0x%x, v2 = 0x%x, v3 = 0x%x", index, v0, v1, v2, v3);
} }
break; break;
@ -323,7 +323,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
(float&)m_vertex_data[index].data[sizeof(float)*0] = v0; (float&)m_vertex_data[index].data[sizeof(float)*0] = v0;
(float&)m_vertex_data[index].data[sizeof(float)*1] = v1; (float&)m_vertex_data[index].data[sizeof(float)*1] = v1;
//LOGF_WARNING(RSX, "index = %d, v0 = %f, v1 = %f", index, v0, v1); //LOG_WARNING(RSX, "index = %d, v0 = %f, v1 = %f", index, v0, v1);
} }
break; break;
@ -348,7 +348,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
(float&)m_vertex_data[index].data[sizeof(float)*2] = v2; (float&)m_vertex_data[index].data[sizeof(float)*2] = v2;
(float&)m_vertex_data[index].data[sizeof(float)*3] = v3; (float&)m_vertex_data[index].data[sizeof(float)*3] = v3;
//LOGF_WARNING(RSX, "index = %d, v0 = %f, v1 = %f, v2 = %f, v3 = %f", index, v0, v1, v2, v3); //LOG_WARNING(RSX, "index = %d, v0 = %f, v1 = %f, v2 = %f, v3 = %f", index, v0, v1, v2, v3);
} }
break; break;
@ -383,7 +383,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_VERTEX_ATTRIB_INPUT_MASK: case NV4097_SET_VERTEX_ATTRIB_INPUT_MASK:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_SET_VERTEX_ATTRIB_INPUT_MASK: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_SET_VERTEX_ATTRIB_INPUT_MASK: %x", ARGS(0));
//VertexData[0].prog.attributeInputMask = ARGS(0); //VertexData[0].prog.attributeInputMask = ARGS(0);
} }
@ -392,7 +392,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_VERTEX_ATTRIB_OUTPUT_MASK: case NV4097_SET_VERTEX_ATTRIB_OUTPUT_MASK:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_SET_VERTEX_ATTRIB_OUTPUT_MASK: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_SET_VERTEX_ATTRIB_OUTPUT_MASK: %x", ARGS(0));
//VertexData[0].prog.attributeOutputMask = ARGS(0); //VertexData[0].prog.attributeOutputMask = ARGS(0);
//FragmentData.prog.attributeInputMask = ARGS(0)/* & ~0x20*/; //FragmentData.prog.attributeInputMask = ARGS(0)/* & ~0x20*/;
@ -415,7 +415,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_COLOR_MASK_MRT: case NV4097_SET_COLOR_MASK_MRT:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_SET_COLOR_MASK_MRT: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_SET_COLOR_MASK_MRT: %x", ARGS(0));
} }
break; break;
@ -479,7 +479,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_BLEND_ENABLE_MRT: case NV4097_SET_BLEND_ENABLE_MRT:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_SET_BLEND_ENABLE_MRT: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_SET_BLEND_ENABLE_MRT: %x", ARGS(0));
} }
break; break;
@ -519,7 +519,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_BLEND_COLOR2: case NV4097_SET_BLEND_COLOR2:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_SET_BLEND_COLOR2: 0x % x", ARGS(0)); LOG_WARNING(RSX, "NV4097_SET_BLEND_COLOR2: 0x % x", ARGS(0));
} }
break; break;
@ -534,7 +534,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_REDUCE_DST_COLOR: case NV4097_SET_REDUCE_DST_COLOR:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_SET_REDUCE_DST_COLOR: 0x % x", ARGS(0)); LOG_WARNING(RSX, "NV4097_SET_REDUCE_DST_COLOR: 0x % x", ARGS(0));
} }
break; break;
@ -608,7 +608,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_CLIP_MAX: case NV4097_SET_CLIP_MAX:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_SET_CLIP_MAX: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_SET_CLIP_MAX: %x", ARGS(0));
} }
break; break;
@ -734,14 +734,14 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_CLEAR_RECT_HORIZONTAL: case NV4097_SET_CLEAR_RECT_HORIZONTAL:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_SET_CLEAR_RECT_HORIZONTAL: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_SET_CLEAR_RECT_HORIZONTAL: %x", ARGS(0));
} }
break; break;
case NV4097_SET_CLEAR_RECT_VERTICAL: case NV4097_SET_CLEAR_RECT_VERTICAL:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_SET_CLEAR_RECT_VERTICAL: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_SET_CLEAR_RECT_VERTICAL: %x", ARGS(0));
} }
break; break;
@ -754,7 +754,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
const u32 first = ac & 0xffffff; const u32 first = ac & 0xffffff;
const u32 _count = (ac >> 24) + 1; const u32 _count = (ac >> 24) + 1;
//LOGF_WARNING(RSX, "NV4097_DRAW_ARRAYS: %d - %d", first, _count); //LOG_WARNING(RSX, "NV4097_DRAW_ARRAYS: %d - %d", first, _count);
LoadVertexData(first, _count); LoadVertexData(first, _count);
@ -791,7 +791,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
m_indexed_array.m_data.resize(m_indexed_array.m_data.size() + 4); m_indexed_array.m_data.resize(m_indexed_array.m_data.size() + 4);
index = Memory.Read32(m_indexed_array.m_addr + i * 4); index = Memory.Read32(m_indexed_array.m_addr + i * 4);
*(u32*)&m_indexed_array.m_data[pos] = index; *(u32*)&m_indexed_array.m_data[pos] = index;
//LOGF_WARNING(RSX, "index 4: %d", *(u32*)&m_indexed_array.m_data[pos]); //LOG_WARNING(RSX, "index 4: %d", *(u32*)&m_indexed_array.m_data[pos]);
} }
break; break;
@ -800,7 +800,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
int pos = m_indexed_array.m_data.size(); int pos = m_indexed_array.m_data.size();
m_indexed_array.m_data.resize(m_indexed_array.m_data.size() + 2); m_indexed_array.m_data.resize(m_indexed_array.m_data.size() + 2);
index = Memory.Read16(m_indexed_array.m_addr + i * 2); index = Memory.Read16(m_indexed_array.m_addr + i * 2);
//LOGF_WARNING(RSX, "index 2: %d", index); //LOG_WARNING(RSX, "index 2: %d", index);
*(u16*)&m_indexed_array.m_data[pos] = index; *(u16*)&m_indexed_array.m_data[pos] = index;
} }
break; break;
@ -819,7 +819,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
{ {
const u32 a0 = ARGS(0); const u32 a0 = ARGS(0);
//LOGF_WARNING(RSX, "NV4097_SET_BEGIN_END: %x", a0); //LOG_WARNING(RSX, "NV4097_SET_BEGIN_END: %x", a0);
m_read_buffer = false; m_read_buffer = false;
@ -850,7 +850,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
{ {
if(!m_cur_shader_prog) if(!m_cur_shader_prog)
{ {
LOGF_ERROR(RSX, "NV4097_SET_SHADER_CONTROL: m_cur_shader_prog == NULL"); LOG_ERROR(RSX, "NV4097_SET_SHADER_CONTROL: m_cur_shader_prog == NULL");
break; break;
} }
@ -877,7 +877,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
// Transform // Transform
case NV4097_SET_TRANSFORM_PROGRAM_LOAD: case NV4097_SET_TRANSFORM_PROGRAM_LOAD:
{ {
//LOGF_WARNING(RSX, "NV4097_SET_TRANSFORM_PROGRAM_LOAD: prog = %d", ARGS(0)); //LOG_WARNING(RSX, "NV4097_SET_TRANSFORM_PROGRAM_LOAD: prog = %d", ARGS(0));
m_cur_vertex_prog = &m_vertex_progs[ARGS(0)]; m_cur_vertex_prog = &m_vertex_progs[ARGS(0)];
m_cur_vertex_prog->data.clear(); m_cur_vertex_prog->data.clear();
@ -886,7 +886,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
{ {
const u32 start = ARGS(1); const u32 start = ARGS(1);
if(start) if(start)
LOGF_WARNING(RSX, "NV4097_SET_TRANSFORM_PROGRAM_LOAD: start = %d", start); LOG_WARNING(RSX, "NV4097_SET_TRANSFORM_PROGRAM_LOAD: start = %d", start);
} }
} }
break; break;
@ -894,17 +894,17 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_TRANSFORM_PROGRAM_START: case NV4097_SET_TRANSFORM_PROGRAM_START:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_SET_TRANSFORM_PROGRAM_START: 0x%x", ARGS(0)); LOG_WARNING(RSX, "NV4097_SET_TRANSFORM_PROGRAM_START: 0x%x", ARGS(0));
} }
break; break;
case_32(NV4097_SET_TRANSFORM_PROGRAM, 4): case_32(NV4097_SET_TRANSFORM_PROGRAM, 4):
{ {
//LOGF_WARNING(RSX, "NV4097_SET_TRANSFORM_PROGRAM[%d](%d)", index, count); //LOG_WARNING(RSX, "NV4097_SET_TRANSFORM_PROGRAM[%d](%d)", index, count);
if(!m_cur_vertex_prog) if(!m_cur_vertex_prog)
{ {
LOGF_WARNING(RSX, "NV4097_SET_TRANSFORM_PROGRAM: m_cur_vertex_prog == NULL"); LOG_WARNING(RSX, "NV4097_SET_TRANSFORM_PROGRAM: m_cur_vertex_prog == NULL");
break; break;
} }
@ -916,7 +916,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
if(!m_cur_vertex_prog) if(!m_cur_vertex_prog)
{ {
LOGF_WARNING(RSX, "NV4097_SET_TRANSFORM_TIMEOUT: m_cur_vertex_prog == NULL"); LOG_WARNING(RSX, "NV4097_SET_TRANSFORM_TIMEOUT: m_cur_vertex_prog == NULL");
break; break;
} }
@ -950,28 +950,28 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_INVALIDATE_L2: case NV4097_INVALIDATE_L2:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_INVALIDATE_L2: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_INVALIDATE_L2: %x", ARGS(0));
} }
break; break;
case NV4097_INVALIDATE_VERTEX_CACHE_FILE: case NV4097_INVALIDATE_VERTEX_CACHE_FILE:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_INVALIDATE_VERTEX_CACHE_FILE: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_INVALIDATE_VERTEX_CACHE_FILE: %x", ARGS(0));
} }
break; break;
case NV4097_INVALIDATE_VERTEX_FILE: case NV4097_INVALIDATE_VERTEX_FILE:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_INVALIDATE_VERTEX_FILE: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_INVALIDATE_VERTEX_FILE: %x", ARGS(0));
} }
break; break;
case NV4097_INVALIDATE_ZCULL: case NV4097_INVALIDATE_ZCULL:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_INVALIDATE_ZCULL: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_INVALIDATE_ZCULL: %x", ARGS(0));
} }
break; break;
@ -1235,7 +1235,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV406E_SEMAPHORE_ACQUIRE: case NV406E_SEMAPHORE_ACQUIRE:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV406E_SEMAPHORE_ACQUIRE: %x", ARGS(0)); LOG_WARNING(RSX, "NV406E_SEMAPHORE_ACQUIRE: %x", ARGS(0));
} }
break; break;
@ -1347,7 +1347,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
{ {
if (count != 4) if (count != 4)
{ {
LOGF_WARNING(RSX, "NV4097_SET_SURFACE_PITCH_C: Bad count (%d)", count); LOG_WARNING(RSX, "NV4097_SET_SURFACE_PITCH_C: Bad count (%d)", count);
break; break;
} }
@ -1361,7 +1361,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_SURFACE_PITCH_D: case NV4097_SET_SURFACE_PITCH_D:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_SET_SURFACE_PITCH_D: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_SET_SURFACE_PITCH_D: %x", ARGS(0));
} }
break; break;
@ -1401,7 +1401,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_CONTEXT_DMA_COLOR_D: case NV4097_SET_CONTEXT_DMA_COLOR_D:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_SET_CONTEXT_DMA_COLOR_D: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_SET_CONTEXT_DMA_COLOR_D: %x", ARGS(0));
} }
break; break;
@ -1443,7 +1443,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_ANTI_ALIASING_CONTROL: case NV4097_SET_ANTI_ALIASING_CONTROL:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_SET_ANTI_ALIASING_CONTROL: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_SET_ANTI_ALIASING_CONTROL: %x", ARGS(0));
} }
break; break;
@ -1498,7 +1498,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_ZCULL_CONTROL0: case NV4097_SET_ZCULL_CONTROL0:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_SET_ZCULL_CONTROL0: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_SET_ZCULL_CONTROL0: %x", ARGS(0));
//m_set_depth_func = true; //m_set_depth_func = true;
//m_depth_func = ARGS(0) >> 4; //m_depth_func = ARGS(0) >> 4;
@ -1508,7 +1508,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_ZCULL_CONTROL1: case NV4097_SET_ZCULL_CONTROL1:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_SET_ZCULL_CONTROL1: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_SET_ZCULL_CONTROL1: %x", ARGS(0));
//m_set_depth_func = true; //m_set_depth_func = true;
//m_depth_func = ARGS(0) >> 4; //m_depth_func = ARGS(0) >> 4;
@ -1531,12 +1531,12 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case CELL_GCM_ZCULL_STATS2: case CELL_GCM_ZCULL_STATS2:
case CELL_GCM_ZCULL_STATS3: case CELL_GCM_ZCULL_STATS3:
value = 0; value = 0;
LOGF_WARNING(RSX, "NV4097_GET_REPORT: Unimplemented type %d", type); LOG_WARNING(RSX, "NV4097_GET_REPORT: Unimplemented type %d", type);
break; break;
default: default:
value = 0; value = 0;
LOGF_WARNING(RSX, "NV4097_GET_REPORT: Bad type %d", type); LOG_WARNING(RSX, "NV4097_GET_REPORT: Bad type %d", type);
break; break;
} }
@ -1586,7 +1586,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_ZMIN_MAX_CONTROL: case NV4097_SET_ZMIN_MAX_CONTROL:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_SET_ZMIN_MAX_CONTROL: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_SET_ZMIN_MAX_CONTROL: %x", ARGS(0));
} }
break; break;
@ -1594,28 +1594,28 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_WINDOW_OFFSET: case NV4097_SET_WINDOW_OFFSET:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_SET_WINDOW_OFFSET: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_SET_WINDOW_OFFSET: %x", ARGS(0));
} }
break; break;
case NV4097_SET_WINDOW_CLIP_TYPE: case NV4097_SET_WINDOW_CLIP_TYPE:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_SET_WINDOW_CLIP_TYPE: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_SET_WINDOW_CLIP_TYPE: %x", ARGS(0));
} }
break; break;
case NV4097_SET_WINDOW_CLIP_HORIZONTAL: case NV4097_SET_WINDOW_CLIP_HORIZONTAL:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_SET_WINDOW_CLIP_HORIZONTAL: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_SET_WINDOW_CLIP_HORIZONTAL: %x", ARGS(0));
} }
break; break;
case NV4097_SET_WINDOW_CLIP_VERTICAL: case NV4097_SET_WINDOW_CLIP_VERTICAL:
{ {
if (ARGS(0)) if (ARGS(0))
LOGF_WARNING(RSX, "NV4097_SET_WINDOW_CLIP_VERTICAL: %x", ARGS(0)); LOG_WARNING(RSX, "NV4097_SET_WINDOW_CLIP_VERTICAL: %x", ARGS(0));
} }
break; break;
@ -1638,7 +1638,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
} }
else else
{ {
LOGF_WARNING(RSX, "NV0039_SET_CONTEXT_DMA_BUFFER_IN: TODO: srcContext=0x%x, dstContext=0x%x", srcContext, dstContext); LOG_WARNING(RSX, "NV0039_SET_CONTEXT_DMA_BUFFER_IN: TODO: srcContext=0x%x, dstContext=0x%x", srcContext, dstContext);
} }
} }
break; break;
@ -1662,7 +1662,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
} }
else else
{ {
LOGF_WARNING(RSX, "NV0039_OFFSET_IN: TODO: offset(in=0x%x, out=0x%x), pitch(in=0x%x, out=0x%x), line(len=0x%x, cnt=0x%x), fmt(in=0x%x, out=0x%x), notify=0x%x", LOG_WARNING(RSX, "NV0039_OFFSET_IN: TODO: offset(in=0x%x, out=0x%x), pitch(in=0x%x, out=0x%x), line(len=0x%x, cnt=0x%x), fmt(in=0x%x, out=0x%x), notify=0x%x",
inOffset, outOffset, inPitch, outPitch, lineLength, lineCount, inFormat, outFormat, notify); inOffset, outOffset, inPitch, outPitch, lineLength, lineCount, inFormat, outFormat, notify);
} }
} }
@ -1677,7 +1677,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
} }
else else
{ {
LOGF_WARNING(RSX, "NV0039_OFFSET_OUT: TODO: offset=0x%x", offset); LOG_WARNING(RSX, "NV0039_OFFSET_OUT: TODO: offset=0x%x", offset);
} }
} }
break; break;
@ -1723,10 +1723,10 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
if(count >= 5) if(count >= 5)
{ {
LOGF_WARNING(RSX, "NV308A_COLOR: count = %d", count); LOG_WARNING(RSX, "NV308A_COLOR: count = %d", count);
} }
//LOGF_WARNING(RSX, "NV308A_COLOR: [%d]: %f, %f, %f, %f", c.id, c.x, c.y, c.z, c.w); //LOG_WARNING(RSX, "NV308A_COLOR: [%d]: %f, %f, %f, %f", c.id, c.x, c.y, c.z, c.w);
m_fragment_constants.push_back(c); m_fragment_constants.push_back(c);
} }
break; break;
@ -1810,7 +1810,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
{ {
if (ARGS(0) != CELL_GCM_CONTEXT_SURFACE2D) if (ARGS(0) != CELL_GCM_CONTEXT_SURFACE2D)
{ {
LOGF_WARNING(RSX, "NV3089_SET_CONTEXT_SURFACE: Unsupported surface (0x%x)", ARGS(0)); LOG_WARNING(RSX, "NV3089_SET_CONTEXT_SURFACE: Unsupported surface (0x%x)", ARGS(0));
} }
} }
break; break;
@ -1866,7 +1866,7 @@ void RSXThread::End()
void RSXThread::Task() void RSXThread::Task()
{ {
u8 inc; u8 inc;
LOGF_NOTICE(RSX, "RSX thread started"); LOG_NOTICE(RSX, "RSX thread started");
OnInitThread(); OnInitThread();
@ -1874,7 +1874,7 @@ void RSXThread::Task()
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(RSX, "RSX thread aborted"); LOG_WARNING(RSX, "RSX thread aborted");
return; return;
} }
std::lock_guard<std::mutex> lock(m_cs_main); std::lock_guard<std::mutex> lock(m_cs_main);
@ -1912,7 +1912,7 @@ void RSXThread::Task()
if(cmd & CELL_GCM_METHOD_FLAG_JUMP) if(cmd & CELL_GCM_METHOD_FLAG_JUMP)
{ {
u32 addr = cmd & ~(CELL_GCM_METHOD_FLAG_JUMP | CELL_GCM_METHOD_FLAG_NON_INCREMENT); u32 addr = cmd & ~(CELL_GCM_METHOD_FLAG_JUMP | CELL_GCM_METHOD_FLAG_NON_INCREMENT);
//LOGF_WARNING(RSX, "rsx jump(0x%x) #addr=0x%x, cmd=0x%x, get=0x%x, put=0x%x", addr, m_ioAddress + get, cmd, get, put); //LOG_WARNING(RSX, "rsx jump(0x%x) #addr=0x%x, cmd=0x%x, get=0x%x, put=0x%x", addr, m_ioAddress + get, cmd, get, put);
m_ctrl->get = addr; m_ctrl->get = addr;
continue; continue;
} }
@ -1921,22 +1921,22 @@ void RSXThread::Task()
m_call_stack.push(get + 4); m_call_stack.push(get + 4);
u32 offs = cmd & ~CELL_GCM_METHOD_FLAG_CALL; u32 offs = cmd & ~CELL_GCM_METHOD_FLAG_CALL;
u32 addr = Memory.RSXIOMem.GetStartAddr() + offs; u32 addr = Memory.RSXIOMem.GetStartAddr() + offs;
//LOGF_WARNING(RSX, "rsx call(0x%x) #0x%x - 0x%x - 0x%x", offs, addr, cmd, get); //LOG_WARNING(RSX, "rsx call(0x%x) #0x%x - 0x%x - 0x%x", offs, addr, cmd, get);
m_ctrl->get = offs; m_ctrl->get = offs;
continue; continue;
} }
if(cmd == CELL_GCM_METHOD_FLAG_RETURN) if(cmd == CELL_GCM_METHOD_FLAG_RETURN)
{ {
//LOGF_WARNING(RSX, "rsx return!"); //LOG_WARNING(RSX, "rsx return!");
u32 get = m_call_stack.top(); u32 get = m_call_stack.top();
m_call_stack.pop(); m_call_stack.pop();
//LOGF_WARNING(RSX, "rsx return(0x%x)", get); //LOG_WARNING(RSX, "rsx return(0x%x)", get);
m_ctrl->get = get; m_ctrl->get = get;
continue; continue;
} }
if(cmd & CELL_GCM_METHOD_FLAG_NON_INCREMENT) if(cmd & CELL_GCM_METHOD_FLAG_NON_INCREMENT)
{ {
//LOGF_WARNING(RSX, "non increment cmd! 0x%x", cmd); //LOG_WARNING(RSX, "non increment cmd! 0x%x", cmd);
inc=0; inc=0;
} }
@ -1961,7 +1961,7 @@ void RSXThread::Task()
//memset(Memory.GetMemFromAddr(p.m_ioAddress + get), 0, (count + 1) * 4); //memset(Memory.GetMemFromAddr(p.m_ioAddress + get), 0, (count + 1) * 4);
} }
LOGF_NOTICE(RSX, "RSX thread ended"); LOG_NOTICE(RSX, "RSX thread ended");
OnExitThread(); OnExitThread();
} }

8
rpcs3/Emu/HDD/HDD.h
View file

@ -486,7 +486,7 @@ public:
int OpenDir(const std::string& name) int OpenDir(const std::string& name)
{ {
LOGF_WARNING(HLE, "OpenDir(%s)", name.c_str()); LOG_WARNING(HLE, "OpenDir(%s)", name.c_str());
u64 entry_block; u64 entry_block;
if(!SearchEntry(name, entry_block)) if(!SearchEntry(name, entry_block))
return -1; return -1;
@ -594,7 +594,7 @@ public:
return false; return false;
} }
LOGF_NOTICE(HLE, "CREATING ENTRY AT 0x%llx", new_block); LOG_NOTICE(HLE, "CREATING ENTRY AT 0x%llx", new_block);
WriteBlock(new_block, g_used_block); WriteBlock(new_block, g_used_block);
{ {
@ -744,7 +744,7 @@ public:
return false; return false;
} }
LOGF_NOTICE(HLE, "ENTRY FOUND AT 0x%llx", file_block); LOG_NOTICE(HLE, "ENTRY FOUND AT 0x%llx", file_block);
m_file.Open(file_block); m_file.Open(file_block);
return vfsFileBase::Open(path, mode); return vfsFileBase::Open(path, mode);
@ -774,7 +774,7 @@ public:
if(entry.type == vfsHDD_Entry_Dir && name != "." && name != "..") if(entry.type == vfsHDD_Entry_Dir && name != "." && name != "..")
{ {
LOGF_WARNING(HLE, "Removing sub folder '%s'", name.c_str()); LOG_WARNING(HLE, "Removing sub folder '%s'", name.c_str());
RemoveBlocksDir(entry.data_block); RemoveBlocksDir(entry.data_block);
} }
else if(entry.type == vfsHDD_Entry_File) else if(entry.type == vfsHDD_Entry_File)

2
rpcs3/Emu/Io/XInput/XInputPadHandler.cpp
View file

@ -113,7 +113,7 @@ void XInputPadHandler::Close()
{ {
active = false; active = false;
if (WaitForSingleObject(thread, THREAD_TIMEOUT) != WAIT_OBJECT_0) if (WaitForSingleObject(thread, THREAD_TIMEOUT) != WAIT_OBJECT_0)
LOGF_ERROR(HLE, "XInput thread could not stop within %d milliseconds", THREAD_TIMEOUT); LOG_ERROR(HLE, "XInput thread could not stop within %d milliseconds", THREAD_TIMEOUT);
thread = nullptr; thread = nullptr;
} }

6
rpcs3/Emu/Memory/DynamicMemoryBlockBase.h
View file

@ -212,10 +212,10 @@ bool DynamicMemoryBlockBase<PT>::Free(u64 addr)
} }
} }
LOGF_ERROR(MEMORY, "DynamicMemoryBlock::Free(addr=0x%llx): failed", addr); LOG_ERROR(MEMORY, "DynamicMemoryBlock::Free(addr=0x%llx): failed", addr);
for (u32 i = 0; i < m_allocated.size(); i++) for (u32 i = 0; i < m_allocated.size(); i++)
{ {
LOGF_NOTICE(MEMORY, "*** Memory Block: addr = 0x%llx, size = 0x%x", m_allocated[i].addr, m_allocated[i].size); LOG_NOTICE(MEMORY, "*** Memory Block: addr = 0x%llx, size = 0x%x", m_allocated[i].addr, m_allocated[i].size);
} }
return false; return false;
} }
@ -233,7 +233,7 @@ u8* DynamicMemoryBlockBase<PT>::GetMem(u64 addr) const // lock-free, addr is fix
} }
} }
LOGF_ERROR(MEMORY, "GetMem(%llx) from not allocated address.", addr); LOG_ERROR(MEMORY, "GetMem(%llx) from not allocated address.", addr);
assert(0); assert(0);
return nullptr; return nullptr;
} }

20
rpcs3/Emu/Memory/Memory.cpp
View file

@ -331,7 +331,7 @@ bool MemoryBlockLE::Write128(const u64 addr, const u128 value)
//NullMemoryBlock //NullMemoryBlock
bool NullMemoryBlock::Read8(const u64 addr, u8* ) bool NullMemoryBlock::Read8(const u64 addr, u8* )
{ {
LOGF_ERROR(MEMORY, "Read8 from null block: [%08llx]", addr); LOG_ERROR(MEMORY, "Read8 from null block: [%08llx]", addr);
if (!Ini.CPUIgnoreRWErrors.GetValue()) if (!Ini.CPUIgnoreRWErrors.GetValue())
Emu.Pause(); Emu.Pause();
return false; return false;
@ -339,7 +339,7 @@ bool NullMemoryBlock::Read8(const u64 addr, u8* )
bool NullMemoryBlock::Read16(const u64 addr, u16* ) bool NullMemoryBlock::Read16(const u64 addr, u16* )
{ {
LOGF_ERROR(MEMORY, "Read16 from null block: [%08llx]", addr); LOG_ERROR(MEMORY, "Read16 from null block: [%08llx]", addr);
if (!Ini.CPUIgnoreRWErrors.GetValue()) if (!Ini.CPUIgnoreRWErrors.GetValue())
Emu.Pause(); Emu.Pause();
return false; return false;
@ -347,7 +347,7 @@ bool NullMemoryBlock::Read16(const u64 addr, u16* )
bool NullMemoryBlock::Read32(const u64 addr, u32* ) bool NullMemoryBlock::Read32(const u64 addr, u32* )
{ {
LOGF_ERROR(MEMORY, "Read32 from null block: [%08llx]", addr); LOG_ERROR(MEMORY, "Read32 from null block: [%08llx]", addr);
if (!Ini.CPUIgnoreRWErrors.GetValue()) if (!Ini.CPUIgnoreRWErrors.GetValue())
Emu.Pause(); Emu.Pause();
return false; return false;
@ -355,7 +355,7 @@ bool NullMemoryBlock::Read32(const u64 addr, u32* )
bool NullMemoryBlock::Read64(const u64 addr, u64* ) bool NullMemoryBlock::Read64(const u64 addr, u64* )
{ {
LOGF_ERROR(MEMORY, "Read64 from null block: [%08llx]", addr); LOG_ERROR(MEMORY, "Read64 from null block: [%08llx]", addr);
if (!Ini.CPUIgnoreRWErrors.GetValue()) if (!Ini.CPUIgnoreRWErrors.GetValue())
Emu.Pause(); Emu.Pause();
return false; return false;
@ -363,7 +363,7 @@ bool NullMemoryBlock::Read64(const u64 addr, u64* )
bool NullMemoryBlock::Read128(const u64 addr, u128* ) bool NullMemoryBlock::Read128(const u64 addr, u128* )
{ {
LOGF_ERROR(MEMORY, "Read128 from null block: [%08llx]", addr); LOG_ERROR(MEMORY, "Read128 from null block: [%08llx]", addr);
if (!Ini.CPUIgnoreRWErrors.GetValue()) if (!Ini.CPUIgnoreRWErrors.GetValue())
Emu.Pause(); Emu.Pause();
return false; return false;
@ -371,7 +371,7 @@ bool NullMemoryBlock::Read128(const u64 addr, u128* )
bool NullMemoryBlock::Write8(const u64 addr, const u8 value) bool NullMemoryBlock::Write8(const u64 addr, const u8 value)
{ {
LOGF_ERROR(MEMORY, "Write8 to null block: [%08llx]: %x", addr, value); LOG_ERROR(MEMORY, "Write8 to null block: [%08llx]: %x", addr, value);
if (!Ini.CPUIgnoreRWErrors.GetValue()) if (!Ini.CPUIgnoreRWErrors.GetValue())
Emu.Pause(); Emu.Pause();
return false; return false;
@ -379,7 +379,7 @@ bool NullMemoryBlock::Write8(const u64 addr, const u8 value)
bool NullMemoryBlock::Write16(const u64 addr, const u16 value) bool NullMemoryBlock::Write16(const u64 addr, const u16 value)
{ {
LOGF_ERROR(MEMORY, "Write16 to null block: [%08llx]: %x", addr, value); LOG_ERROR(MEMORY, "Write16 to null block: [%08llx]: %x", addr, value);
if (!Ini.CPUIgnoreRWErrors.GetValue()) if (!Ini.CPUIgnoreRWErrors.GetValue())
Emu.Pause(); Emu.Pause();
return false; return false;
@ -387,7 +387,7 @@ bool NullMemoryBlock::Write16(const u64 addr, const u16 value)
bool NullMemoryBlock::Write32(const u64 addr, const u32 value) bool NullMemoryBlock::Write32(const u64 addr, const u32 value)
{ {
LOGF_ERROR(MEMORY, "Write32 to null block: [%08llx]: %x", addr, value); LOG_ERROR(MEMORY, "Write32 to null block: [%08llx]: %x", addr, value);
if (!Ini.CPUIgnoreRWErrors.GetValue()) if (!Ini.CPUIgnoreRWErrors.GetValue())
Emu.Pause(); Emu.Pause();
return false; return false;
@ -395,7 +395,7 @@ bool NullMemoryBlock::Write32(const u64 addr, const u32 value)
bool NullMemoryBlock::Write64(const u64 addr, const u64 value) bool NullMemoryBlock::Write64(const u64 addr, const u64 value)
{ {
LOGF_ERROR(MEMORY, "Write64 to null block: [%08llx]: %llx", addr, value); LOG_ERROR(MEMORY, "Write64 to null block: [%08llx]: %llx", addr, value);
if (!Ini.CPUIgnoreRWErrors.GetValue()) if (!Ini.CPUIgnoreRWErrors.GetValue())
Emu.Pause(); Emu.Pause();
return false; return false;
@ -403,7 +403,7 @@ bool NullMemoryBlock::Write64(const u64 addr, const u64 value)
bool NullMemoryBlock::Write128(const u64 addr, const u128 value) bool NullMemoryBlock::Write128(const u64 addr, const u128 value)
{ {
LOGF_ERROR(MEMORY, "Write128 to null block: [%08llx]: %llx_%llx", addr, value.hi, value.lo); LOG_ERROR(MEMORY, "Write128 to null block: [%08llx]: %llx_%llx", addr, value.hi, value.lo);
if (!Ini.CPUIgnoreRWErrors.GetValue()) if (!Ini.CPUIgnoreRWErrors.GetValue())
Emu.Pause(); Emu.Pause();
return false; return false;

12
rpcs3/Emu/Memory/Memory.h
View file

@ -405,7 +405,7 @@ public:
if(mem.IsNULL()) if(mem.IsNULL())
{ {
LOGF_ERROR(MEMORY, "ReadLeft[%d] from null block (0x%llx)", size, addr); LOG_ERROR(MEMORY, "ReadLeft[%d] from null block (0x%llx)", size, addr);
return; return;
} }
@ -418,7 +418,7 @@ public:
if(mem.IsNULL()) if(mem.IsNULL())
{ {
LOGF_ERROR(MEMORY, "WriteLeft[%d] to null block (0x%llx)", size, addr); LOG_ERROR(MEMORY, "WriteLeft[%d] to null block (0x%llx)", size, addr);
return; return;
} }
@ -431,7 +431,7 @@ public:
if(mem.IsNULL()) if(mem.IsNULL())
{ {
LOGF_ERROR(MEMORY, "ReadRight[%d] from null block (0x%llx)", size, addr); LOG_ERROR(MEMORY, "ReadRight[%d] from null block (0x%llx)", size, addr);
return; return;
} }
@ -444,7 +444,7 @@ public:
if(mem.IsNULL()) if(mem.IsNULL())
{ {
LOGF_ERROR(MEMORY, "WriteRight[%d] to null block (0x%llx)", size, addr); LOG_ERROR(MEMORY, "WriteRight[%d] to null block (0x%llx)", size, addr);
return; return;
} }
@ -477,7 +477,7 @@ public:
{ {
if(!IsGoodAddr(addr, str.length())) if(!IsGoodAddr(addr, str.length()))
{ {
LOGF_ERROR(MEMORY,"Memory::WriteString error: bad address (0x%llx)", addr); LOG_ERROR(MEMORY,"Memory::WriteString error: bad address (0x%llx)", addr);
return; return;
} }
@ -527,7 +527,7 @@ public:
} }
MemoryBlocks.push_back((new MemoryMirror())->SetRange(GetMemFromAddr(src_addr), dst_addr, size)); MemoryBlocks.push_back((new MemoryMirror())->SetRange(GetMemFromAddr(src_addr), dst_addr, size));
LOGF_WARNING(MEMORY, "memory mapped 0x%llx to 0x%llx size=0x%x", src_addr, dst_addr, size); LOG_WARNING(MEMORY, "memory mapped 0x%llx to 0x%llx size=0x%x", src_addr, dst_addr, size);
return true; return true;
} }

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

@ -53,7 +53,7 @@ next:
{ {
if (!Memory.CopyToReal(buf, adec.reader.addr, adec.reader.size)) if (!Memory.CopyToReal(buf, adec.reader.addr, adec.reader.size))
{ {
LOGF_ERROR(HLE, "adecRawRead(): data reading failed (reader.size=0x%x)", adec.reader.size); LOG_ERROR(HLE, "adecRawRead(): data reading failed (reader.size=0x%x)", adec.reader.size);
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -68,11 +68,11 @@ next:
adec.reader.addr = adec.task.au.addr; adec.reader.addr = adec.task.au.addr;
adec.reader.size = adec.task.au.size; adec.reader.size = adec.task.au.size;
//LOGF_NOTICE(HLE, "Audio AU: size = 0x%x, pts = 0x%llx", adec.task.au.size, adec.task.au.pts); //LOG_NOTICE(HLE, "Audio AU: size = 0x%x, pts = 0x%llx", adec.task.au.size, adec.task.au.pts);
} }
break; break;
default: default:
LOGF_ERROR(HLE, "adecRawRead(): sequence error (task %d)", adec.job.Peek().type); LOG_ERROR(HLE, "adecRawRead(): sequence error (task %d)", adec.job.Peek().type);
return -1; return -1;
} }
@ -89,7 +89,7 @@ next:
} }
else if (!Memory.CopyToReal(buf, adec.reader.addr, buf_size)) else if (!Memory.CopyToReal(buf, adec.reader.addr, buf_size))
{ {
LOGF_ERROR(HLE, "adecRawRead(): data reading failed (buf_size=0x%x)", buf_size); LOG_ERROR(HLE, "adecRawRead(): data reading failed (buf_size=0x%x)", buf_size);
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -111,7 +111,7 @@ int adecRead(void* opaque, u8* buf, int buf_size)
{ {
if (buf_size < (int)adec.reader.rem_size) if (buf_size < (int)adec.reader.rem_size)
{ {
LOGF_ERROR(HLE, "adecRead(): too small buf_size (rem_size = %d, buf_size = %d)", adec.reader.rem_size, buf_size); LOG_ERROR(HLE, "adecRead(): too small buf_size (rem_size = %d, buf_size = %d)", adec.reader.rem_size, buf_size);
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -131,7 +131,7 @@ int adecRead(void* opaque, u8* buf, int buf_size)
if (adecRawRead(opaque, header, 8) < 8) break; if (adecRawRead(opaque, header, 8) < 8) break;
if (header[0] != 0x0f || header[1] != 0xd0) if (header[0] != 0x0f || header[1] != 0xd0)
{ {
LOGF_ERROR(HLE, "adecRead(): 0x0FD0 header not found"); LOG_ERROR(HLE, "adecRead(): 0x0FD0 header not found");
Emu.Pause(); Emu.Pause();
return -1; return -1;
} }
@ -141,7 +141,7 @@ int adecRead(void* opaque, u8* buf, int buf_size)
OMAHeader oma(1 /* atrac3p id */, header[2], header[3]); OMAHeader oma(1 /* atrac3p id */, header[2], header[3]);
if (buf_size < sizeof(oma) + 8) if (buf_size < sizeof(oma) + 8)
{ {
LOGF_ERROR(HLE, "adecRead(): OMAHeader writing failed"); LOG_ERROR(HLE, "adecRead(): OMAHeader writing failed");
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -159,7 +159,7 @@ int adecRead(void* opaque, u8* buf, int buf_size)
u32 size = (((header[2] & 0x3) << 8) | header[3]) * 8 + 8; // data to be read before next header u32 size = (((header[2] & 0x3) << 8) | header[3]) * 8 + 8; // data to be read before next header
//LOGF_NOTICE(HLE, "*** audio block read: size = 0x%x", size); //LOG_NOTICE(HLE, "*** audio block read: size = 0x%x", size);
if (buf_size < (int)size) if (buf_size < (int)size)
{ {
@ -198,7 +198,7 @@ u32 adecOpen(AudioDecoder* data)
thread t("Audio Decoder[" + std::to_string(adec_id) + "] Thread", [&]() thread t("Audio Decoder[" + std::to_string(adec_id) + "] Thread", [&]()
{ {
LOGF_NOTICE(HLE, "Audio Decoder thread started"); LOG_NOTICE(HLE, "Audio Decoder thread started");
AdecTask& task = adec.task; AdecTask& task = adec.task;
@ -231,7 +231,7 @@ u32 adecOpen(AudioDecoder* data)
case adecStartSeq: case adecStartSeq:
{ {
// TODO: reset data // TODO: reset data
LOGF_WARNING(HLE, "adecStartSeq:"); LOG_WARNING(HLE, "adecStartSeq:");
adec.reader.addr = 0; adec.reader.addr = 0;
adec.reader.size = 0; adec.reader.size = 0;
@ -247,7 +247,7 @@ u32 adecOpen(AudioDecoder* data)
case adecEndSeq: case adecEndSeq:
{ {
// TODO: finalize // TODO: finalize
LOGF_WARNING(HLE, "adecEndSeq:"); LOG_WARNING(HLE, "adecEndSeq:");
/*Callback cb; /*Callback cb;
cb.SetAddr(adec.cbFunc); cb.SetAddr(adec.cbFunc);
@ -268,7 +268,7 @@ u32 adecOpen(AudioDecoder* data)
adec.reader.addr = task.au.addr; adec.reader.addr = task.au.addr;
adec.reader.size = task.au.size; adec.reader.size = task.au.size;
//LOGF_NOTICE(HLE, "Audio AU: size = 0x%x, pts = 0x%llx", task.au.size, task.au.pts); //LOG_NOTICE(HLE, "Audio AU: size = 0x%x, pts = 0x%llx", task.au.size, task.au.pts);
if (adec.just_started) if (adec.just_started)
{ {
@ -317,33 +317,33 @@ u32 adecOpen(AudioDecoder* data)
err = avformat_open_input(&adec.fmt, NULL, av_find_input_format("oma"), NULL); err = avformat_open_input(&adec.fmt, NULL, av_find_input_format("oma"), NULL);
if (err) if (err)
{ {
LOGF_ERROR(HLE, "adecDecodeAu: avformat_open_input() failed"); LOG_ERROR(HLE, "adecDecodeAu: avformat_open_input() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
AVCodec* codec = avcodec_find_decoder(AV_CODEC_ID_ATRAC3P); // ??? AVCodec* codec = avcodec_find_decoder(AV_CODEC_ID_ATRAC3P); // ???
if (!codec) if (!codec)
{ {
LOGF_ERROR(HLE, "adecDecodeAu: avcodec_find_decoder() failed"); LOG_ERROR(HLE, "adecDecodeAu: avcodec_find_decoder() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
/*err = avformat_find_stream_info(adec.fmt, NULL); /*err = avformat_find_stream_info(adec.fmt, NULL);
if (err) if (err)
{ {
LOGF_ERROR(HLE, "adecDecodeAu: avformat_find_stream_info() failed"); LOG_ERROR(HLE, "adecDecodeAu: avformat_find_stream_info() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
if (!adec.fmt->nb_streams) if (!adec.fmt->nb_streams)
{ {
LOGF_ERROR(HLE, "adecDecodeAu: no stream found"); LOG_ERROR(HLE, "adecDecodeAu: no stream found");
Emu.Pause(); Emu.Pause();
break; break;
}*/ }*/
if (!avformat_new_stream(adec.fmt, codec)) if (!avformat_new_stream(adec.fmt, codec))
{ {
LOGF_ERROR(HLE, "adecDecodeAu: avformat_new_stream() failed"); LOG_ERROR(HLE, "adecDecodeAu: avformat_new_stream() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -358,7 +358,7 @@ u32 adecOpen(AudioDecoder* data)
} }
if (err) if (err)
{ {
LOGF_ERROR(HLE, "adecDecodeAu: avcodec_open2() failed"); LOG_ERROR(HLE, "adecDecodeAu: avcodec_open2() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -371,7 +371,7 @@ u32 adecOpen(AudioDecoder* data)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "adecDecodeAu: aborted"); LOG_WARNING(HLE, "adecDecodeAu: aborted");
return; return;
} }
@ -420,7 +420,7 @@ u32 adecOpen(AudioDecoder* data)
if (!frame.data) if (!frame.data)
{ {
LOGF_ERROR(HLE, "adecDecodeAu: av_frame_alloc() failed"); LOG_ERROR(HLE, "adecDecodeAu: av_frame_alloc() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -433,7 +433,7 @@ u32 adecOpen(AudioDecoder* data)
{ {
if (!last_frame && decode < 0) if (!last_frame && decode < 0)
{ {
LOGF_ERROR(HLE, "adecDecodeAu: AU decoding error(0x%x)", decode); LOG_ERROR(HLE, "adecDecodeAu: AU decoding error(0x%x)", decode);
} }
if (!got_frame && adec.reader.size == 0) break; if (!got_frame && adec.reader.size == 0) break;
} }
@ -460,18 +460,18 @@ u32 adecOpen(AudioDecoder* data)
if (frame.data->format != AV_SAMPLE_FMT_FLTP) if (frame.data->format != AV_SAMPLE_FMT_FLTP)
{ {
LOGF_ERROR(HLE, "adecDecodeaAu: unsupported frame format(%d)", frame.data->format); LOG_ERROR(HLE, "adecDecodeaAu: unsupported frame format(%d)", frame.data->format);
Emu.Pause(); Emu.Pause();
break; break;
} }
if (frame.data->channels != 2) if (frame.data->channels != 2)
{ {
LOGF_ERROR(HLE, "adecDecodeAu: unsupported channel count (%d)", frame.data->channels); LOG_ERROR(HLE, "adecDecodeAu: unsupported channel count (%d)", frame.data->channels);
Emu.Pause(); Emu.Pause();
break; break;
} }
//LOGF_NOTICE(HLE, "got audio frame (pts=0x%llx, nb_samples=%d, ch=%d, sample_rate=%d, nbps=%d)", //LOG_NOTICE(HLE, "got audio frame (pts=0x%llx, nb_samples=%d, ch=%d, sample_rate=%d, nbps=%d)",
//frame.pts, frame.data->nb_samples, frame.data->channels, frame.data->sample_rate, //frame.pts, frame.data->nb_samples, frame.data->channels, frame.data->sample_rate,
//av_get_bytes_per_sample((AVSampleFormat)frame.data->format)); //av_get_bytes_per_sample((AVSampleFormat)frame.data->format));
@ -497,16 +497,16 @@ u32 adecOpen(AudioDecoder* data)
case adecClose: case adecClose:
{ {
adec.is_finished = true; adec.is_finished = true;
LOGF_NOTICE(HLE, "Audio Decoder thread ended"); LOG_NOTICE(HLE, "Audio Decoder thread ended");
return; return;
} }
default: default:
LOGF_ERROR(HLE, "Audio Decoder thread error: unknown task(%d)", task.type); LOG_ERROR(HLE, "Audio Decoder thread error: unknown task(%d)", task.type);
} }
} }
adec.is_finished = true; adec.is_finished = true;
LOGF_WARNING(HLE, "Audio Decoder thread aborted"); LOG_WARNING(HLE, "Audio Decoder thread aborted");
}); });
t.detach(); t.detach();
@ -518,8 +518,8 @@ bool adecCheckType(AudioCodecType type)
{ {
switch (type) switch (type)
{ {
case CELL_ADEC_TYPE_ATRACX: LOGF_NOTICE(HLE, "*** (?) type: ATRAC3plus"); break; case CELL_ADEC_TYPE_ATRACX: LOG_NOTICE(HLE, "*** (?) type: ATRAC3plus"); break;
case CELL_ADEC_TYPE_ATRACX_2CH: LOGF_NOTICE(HLE, "*** type: ATRAC3plus 2ch"); break; case CELL_ADEC_TYPE_ATRACX_2CH: LOG_NOTICE(HLE, "*** type: ATRAC3plus 2ch"); break;
case CELL_ADEC_TYPE_ATRACX_6CH: case CELL_ADEC_TYPE_ATRACX_6CH:
case CELL_ADEC_TYPE_ATRACX_8CH: case CELL_ADEC_TYPE_ATRACX_8CH:
@ -609,7 +609,7 @@ int cellAdecClose(u32 handle)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "cellAdecClose(%d) aborted", handle); LOG_WARNING(HLE, "cellAdecClose(%d) aborted", handle);
break; break;
} }
Sleep(1); Sleep(1);
@ -732,7 +732,7 @@ int cellAdecGetPcm(u32 handle, u32 outBuffer_addr)
if (!swr) if (!swr)
{ {
LOGF_ERROR(HLE, "cellAdecGetPcm(%d): swr_alloc_set_opts() failed", handle); LOG_ERROR(HLE, "cellAdecGetPcm(%d): swr_alloc_set_opts() failed", handle);
Emu.Pause(); Emu.Pause();
free(out); free(out);
if (af.data) if (af.data)
@ -759,7 +759,7 @@ int cellAdecGetPcm(u32 handle, u32 outBuffer_addr)
if (!Memory.CopyFromReal(outBuffer_addr, out, af.size)) if (!Memory.CopyFromReal(outBuffer_addr, out, af.size))
{ {
LOGF_ERROR(HLE, "cellAdecGetPcm(%d): data copying failed (addr=0x%x)", handle, outBuffer_addr); LOG_ERROR(HLE, "cellAdecGetPcm(%d): data copying failed (addr=0x%x)", handle, outBuffer_addr);
Emu.Pause(); Emu.Pause();
} }

6
rpcs3/Emu/SysCalls/Modules/cellAdec.h
View file

@ -1133,14 +1133,14 @@ public:
AVCodec* codec = avcodec_find_decoder(AV_CODEC_ID_ATRAC3P); AVCodec* codec = avcodec_find_decoder(AV_CODEC_ID_ATRAC3P);
if (!codec) if (!codec)
{ {
LOGF_ERROR(HLE, "AudioDecoder(): avcodec_find_decoder(ATRAC3P) failed"); LOG_ERROR(HLE, "AudioDecoder(): avcodec_find_decoder(ATRAC3P) failed");
Emu.Pause(); Emu.Pause();
return; return;
} }
fmt = avformat_alloc_context(); fmt = avformat_alloc_context();
if (!fmt) if (!fmt)
{ {
LOGF_ERROR(HLE, "AudioDecoder(): avformat_alloc_context failed"); LOG_ERROR(HLE, "AudioDecoder(): avformat_alloc_context failed");
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -1148,7 +1148,7 @@ public:
fmt->pb = avio_alloc_context(io_buf, 4096, 0, this, adecRead, NULL, NULL); fmt->pb = avio_alloc_context(io_buf, 4096, 0, this, adecRead, NULL, NULL);
if (!fmt->pb) if (!fmt->pb)
{ {
LOGF_ERROR(HLE, "AudioDecoder(): avio_alloc_context failed"); LOG_ERROR(HLE, "AudioDecoder(): avio_alloc_context failed");
Emu.Pause(); Emu.Pause();
return; return;
} }

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

@ -50,11 +50,11 @@ int cellAudioInit()
if (do_dump && !m_dump.Init()) if (do_dump && !m_dump.Init())
{ {
LOGF_ERROR(HLE, "cellAudioInit(): AudioDumper::Init() failed"); LOG_ERROR(HLE, "cellAudioInit(): AudioDumper::Init() failed");
return; return;
} }
LOGF_NOTICE(HLE, "Audio thread started"); LOG_NOTICE(HLE, "Audio thread started");
if (Ini.AudioDumpToFile.GetValue()) if (Ini.AudioDumpToFile.GetValue())
m_dump.WriteHeader(); m_dump.WriteHeader();
@ -146,7 +146,7 @@ int cellAudioInit()
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "Audio thread aborted"); LOG_WARNING(HLE, "Audio thread aborted");
goto abort; goto abort;
} }
@ -426,7 +426,7 @@ int cellAudioInit()
{ {
if (m_dump.WriteData(&buf8ch, sizeof(buf8ch)) != sizeof(buf8ch)) // write file data if (m_dump.WriteData(&buf8ch, sizeof(buf8ch)) != sizeof(buf8ch)) // write file data
{ {
LOGF_ERROR(HLE, "cellAudioInit(): AudioDumper::WriteData() failed"); LOG_ERROR(HLE, "cellAudioInit(): AudioDumper::WriteData() failed");
goto abort; goto abort;
} }
} }
@ -434,21 +434,21 @@ int cellAudioInit()
{ {
if (m_dump.WriteData(&buf2ch, sizeof(buf2ch)) != sizeof(buf2ch)) // write file data if (m_dump.WriteData(&buf2ch, sizeof(buf2ch)) != sizeof(buf2ch)) // write file data
{ {
LOGF_ERROR(HLE, "cellAudioInit(): AudioDumper::WriteData() failed"); LOG_ERROR(HLE, "cellAudioInit(): AudioDumper::WriteData() failed");
goto abort; goto abort;
} }
} }
else else
{ {
LOGF_ERROR(HLE, "cellAudioInit(): unknown AudioDumper::GetCh() value (%d)", m_dump.GetCh()); LOG_ERROR(HLE, "cellAudioInit(): unknown AudioDumper::GetCh() value (%d)", m_dump.GetCh());
goto abort; goto abort;
} }
} }
//LOGF_NOTICE(HLE, "Audio perf: start=%d (access=%d, AddData=%d, events=%d, dump=%d)", //LOG_NOTICE(HLE, "Audio perf: start=%d (access=%d, AddData=%d, events=%d, dump=%d)",
//stamp0 - m_config.start_time, stamp1 - stamp0, stamp2 - stamp1, stamp3 - stamp2, get_system_time() - stamp3); //stamp0 - m_config.start_time, stamp1 - stamp0, stamp2 - stamp1, stamp3 - stamp2, get_system_time() - stamp3);
} }
LOGF_NOTICE(HLE, "Audio thread ended"); LOG_NOTICE(HLE, "Audio thread ended");
abort: abort:
queue.Push(nullptr); queue.Push(nullptr);
queue_float.Push(nullptr); queue_float.Push(nullptr);
@ -480,7 +480,7 @@ abort:
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "cellAudioInit() aborted"); LOG_WARNING(HLE, "cellAudioInit() aborted");
return CELL_OK; return CELL_OK;
} }
Sleep(1); Sleep(1);
@ -505,7 +505,7 @@ int cellAudioQuit()
Sleep(1); Sleep(1);
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "cellAudioQuit(): aborted"); LOG_WARNING(HLE, "cellAudioQuit(): aborted");
return CELL_OK; return CELL_OK;
} }
} }

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

@ -47,7 +47,7 @@ u32 dmuxOpen(Demuxer* data)
thread t("Demuxer[" + std::to_string(dmux_id) + "] Thread", [&]() thread t("Demuxer[" + std::to_string(dmux_id) + "] Thread", [&]()
{ {
LOGF_NOTICE(HLE, "Demuxer thread started (mem=0x%x, size=0x%x, cb=0x%x, arg=0x%x)", dmux.memAddr, dmux.memSize, dmux.cbFunc, dmux.cbArg); LOG_NOTICE(HLE, "Demuxer thread started (mem=0x%x, size=0x%x, cb=0x%x, arg=0x%x)", dmux.memAddr, dmux.memSize, dmux.cbFunc, dmux.cbArg);
DemuxerTask task; DemuxerTask task;
DemuxerStream stream; DemuxerStream stream;
@ -134,7 +134,7 @@ u32 dmuxOpen(Demuxer* data)
if (!pes.new_au) // temporarily if (!pes.new_au) // temporarily
{ {
LOGF_ERROR(HLE, "No pts info found"); LOG_ERROR(HLE, "No pts info found");
} }
// read additional header: // read additional header:
@ -149,7 +149,7 @@ u32 dmuxOpen(Demuxer* data)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "esATX[%d] was full, waiting aborted", ch); LOG_WARNING(HLE, "esATX[%d] was full, waiting aborted", ch);
return; return;
} }
Sleep(1); Sleep(1);
@ -166,7 +166,7 @@ u32 dmuxOpen(Demuxer* data)
es.push(stream, len - pes.size - 3, pes); es.push(stream, len - pes.size - 3, pes);
es.finish(stream); es.finish(stream);
//LOGF_NOTICE(HLE, "*** AT3+ AU sent (len=0x%x, pts=0x%llx)", len - pes.size - 3, pes.pts); //LOG_NOTICE(HLE, "*** AT3+ AU sent (len=0x%x, pts=0x%llx)", len - pes.size - 3, pes.pts);
mem_ptr_t<CellDmuxEsMsg> esMsg(a128(dmux.memAddr) + (cb_add ^= 16)); mem_ptr_t<CellDmuxEsMsg> esMsg(a128(dmux.memAddr) + (cb_add ^= 16));
esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_AU_FOUND; esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_AU_FOUND;
@ -198,7 +198,7 @@ u32 dmuxOpen(Demuxer* data)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "esAVC[%d] was full, waiting aborted", ch); LOG_WARNING(HLE, "esAVC[%d] was full, waiting aborted", ch);
return; return;
} }
Sleep(1); Sleep(1);
@ -236,7 +236,7 @@ u32 dmuxOpen(Demuxer* data)
if (pes.new_au) if (pes.new_au)
{ {
//LOGF_NOTICE(HLE, "*** AVC AU detected (pts=0x%llx, dts=0x%llx)", pes.pts, pes.dts); //LOG_NOTICE(HLE, "*** AVC AU detected (pts=0x%llx, dts=0x%llx)", pes.pts, pes.dts);
} }
if (es.isfull()) if (es.isfull())
@ -268,7 +268,7 @@ u32 dmuxOpen(Demuxer* data)
case 0x1dc: case 0x1dd: case 0x1de: case 0x1df: case 0x1dc: case 0x1dd: case 0x1de: case 0x1df:
{ {
// unknown // unknown
LOGF_WARNING(HLE, "Unknown MPEG stream found"); LOG_WARNING(HLE, "Unknown MPEG stream found");
stream.skip(4); stream.skip(4);
stream.get(len); stream.get(len);
stream.skip(len); stream.skip(len);
@ -277,7 +277,7 @@ u32 dmuxOpen(Demuxer* data)
case USER_DATA_START_CODE: case USER_DATA_START_CODE:
{ {
LOGF_ERROR(HLE, "USER_DATA_START_CODE found"); LOG_ERROR(HLE, "USER_DATA_START_CODE found");
return; return;
} }
@ -304,7 +304,7 @@ u32 dmuxOpen(Demuxer* data)
{ {
if (task.stream.discontinuity) if (task.stream.discontinuity)
{ {
LOGF_WARNING(HLE, "dmuxSetStream (beginning)"); LOG_WARNING(HLE, "dmuxSetStream (beginning)");
for (u32 i = 0; i < 192; i++) for (u32 i = 0; i < 192; i++)
{ {
if (esALL[i]) if (esALL[i])
@ -318,13 +318,13 @@ u32 dmuxOpen(Demuxer* data)
if (updates_count != updates_signaled) if (updates_count != updates_signaled)
{ {
LOGF_ERROR(HLE, "dmuxSetStream: stream update inconsistency (input=%d, signaled=%d)", updates_count, updates_signaled); LOG_ERROR(HLE, "dmuxSetStream: stream update inconsistency (input=%d, signaled=%d)", updates_count, updates_signaled);
return; return;
} }
updates_count++; updates_count++;
stream = task.stream; stream = task.stream;
//LOGF_NOTICE(HLE, "*** stream updated(addr=0x%x, size=0x%x, discont=%d, userdata=0x%llx)", //LOG_NOTICE(HLE, "*** stream updated(addr=0x%x, size=0x%x, discont=%d, userdata=0x%llx)",
//stream.addr, stream.size, stream.discontinuity, stream.userdata); //stream.addr, stream.size, stream.discontinuity, stream.userdata);
dmux.is_running = true; dmux.is_running = true;
@ -357,7 +357,7 @@ u32 dmuxOpen(Demuxer* data)
case dmuxClose: case dmuxClose:
{ {
dmux.is_finished = true; dmux.is_finished = true;
LOGF_NOTICE(HLE, "Demuxer thread ended"); LOG_NOTICE(HLE, "Demuxer thread ended");
return; return;
} }
@ -381,7 +381,7 @@ u32 dmuxOpen(Demuxer* data)
} }
else else
{ {
LOGF_WARNING(HLE, "dmuxEnableEs: (TODO) unsupported filter (0x%x, 0x%x, 0x%x, 0x%x)", es.fidMajor, es.fidMinor, es.sup1, es.sup2); LOG_WARNING(HLE, "dmuxEnableEs: (TODO) unsupported filter (0x%x, 0x%x, 0x%x, 0x%x)", es.fidMajor, es.fidMinor, es.sup1, es.sup2);
} }
es.dmux = &dmux; es.dmux = &dmux;
} }
@ -392,7 +392,7 @@ u32 dmuxOpen(Demuxer* data)
ElementaryStream& es = *task.es.es_ptr; ElementaryStream& es = *task.es.es_ptr;
if (es.dmux != &dmux) if (es.dmux != &dmux)
{ {
LOGF_WARNING(HLE, "dmuxDisableEs: invalid elementary stream"); LOG_WARNING(HLE, "dmuxDisableEs: invalid elementary stream");
break; break;
} }
for (u32 i = 0; i < 192; i++) for (u32 i = 0; i < 192; i++)
@ -450,11 +450,11 @@ u32 dmuxOpen(Demuxer* data)
break; break;
default: default:
LOGF_ERROR(HLE, "Demuxer thread error: unknown task(%d)", task.type); LOG_ERROR(HLE, "Demuxer thread error: unknown task(%d)", task.type);
return; return;
} }
} }
LOGF_WARNING(HLE, "Demuxer thread aborted"); LOG_WARNING(HLE, "Demuxer thread aborted");
}); });
t.detach(); t.detach();
@ -598,7 +598,7 @@ int cellDmuxClose(u32 demuxerHandle)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "cellDmuxClose(%d) aborted", demuxerHandle); LOG_WARNING(HLE, "cellDmuxClose(%d) aborted", demuxerHandle);
return CELL_OK; return CELL_OK;
} }
@ -630,7 +630,7 @@ int cellDmuxSetStream(u32 demuxerHandle, const u32 streamAddress, u32 streamSize
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "cellDmuxSetStream(%d) aborted (waiting)", demuxerHandle); LOG_WARNING(HLE, "cellDmuxSetStream(%d) aborted (waiting)", demuxerHandle);
return CELL_OK; return CELL_OK;
} }
Sleep(1); Sleep(1);
@ -649,12 +649,12 @@ int cellDmuxSetStream(u32 demuxerHandle, const u32 streamAddress, u32 streamSize
u32 addr; u32 addr;
if (!dmux->fbSetStream.Pop(addr)) if (!dmux->fbSetStream.Pop(addr))
{ {
LOGF_WARNING(HLE, "cellDmuxSetStream(%d) aborted (fbSetStream.Pop())", demuxerHandle); LOG_WARNING(HLE, "cellDmuxSetStream(%d) aborted (fbSetStream.Pop())", demuxerHandle);
return CELL_OK; return CELL_OK;
} }
if (addr != info.addr) if (addr != info.addr)
{ {
LOGF_ERROR(HLE, "cellDmuxSetStream(%d): wrong stream queued (right=0x%x, queued=0x%x)", demuxerHandle, info.addr, addr); LOG_ERROR(HLE, "cellDmuxSetStream(%d): wrong stream queued (right=0x%x, queued=0x%x)", demuxerHandle, info.addr, addr);
Emu.Pause(); Emu.Pause();
} }
return CELL_OK; return CELL_OK;
@ -690,12 +690,12 @@ int cellDmuxResetStreamAndWaitDone(u32 demuxerHandle)
u32 addr; u32 addr;
if (!dmux->fbSetStream.Pop(addr)) if (!dmux->fbSetStream.Pop(addr))
{ {
LOGF_WARNING(HLE, "cellDmuxResetStreamAndWaitDone(%d) aborted (fbSetStream.Pop())", demuxerHandle); LOG_WARNING(HLE, "cellDmuxResetStreamAndWaitDone(%d) aborted (fbSetStream.Pop())", demuxerHandle);
return CELL_OK; return CELL_OK;
} }
if (addr != 0) if (addr != 0)
{ {
LOGF_ERROR(HLE, "cellDmuxResetStreamAndWaitDone(%d): wrong stream queued (0x%x)", demuxerHandle, addr); LOG_ERROR(HLE, "cellDmuxResetStreamAndWaitDone(%d): wrong stream queued (0x%x)", demuxerHandle, addr);
Emu.Pause(); Emu.Pause();
} }
return CELL_OK; return CELL_OK;

38
rpcs3/Emu/SysCalls/Modules/cellDmux.h
View file

@ -394,14 +394,14 @@ struct PesHeader
new_au = true; new_au = true;
if ((v & 0xF0) != 0x30 || (size - empty) < 10) if ((v & 0xF0) != 0x30 || (size - empty) < 10)
{ {
LOGF_ERROR(HLE, "PesHeader(): pts not found"); LOG_ERROR(HLE, "PesHeader(): pts not found");
Emu.Pause(); Emu.Pause();
} }
pts = stream.get_ts(v); pts = stream.get_ts(v);
stream.get(v); stream.get(v);
if ((v & 0xF0) != 0x10) if ((v & 0xF0) != 0x10)
{ {
LOGF_ERROR(HLE, "PesHeader(): dts not found"); LOG_ERROR(HLE, "PesHeader(): dts not found");
Emu.Pause(); Emu.Pause();
} }
dts = stream.get_ts(v); dts = stream.get_ts(v);
@ -557,7 +557,7 @@ public:
{ {
if (size > GetMaxAU()) if (size > GetMaxAU())
{ {
LOGF_ERROR(HLE, "es::freespace(): last_size too big (size=0x%x, max_au=0x%x)", size, GetMaxAU()); LOG_ERROR(HLE, "es::freespace(): last_size too big (size=0x%x, max_au=0x%x)", size, GetMaxAU());
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -587,7 +587,7 @@ public:
u32 addr; u32 addr;
{ {
std::lock_guard<std::mutex> lock(m_mutex); std::lock_guard<std::mutex> lock(m_mutex);
//if (fidMajor != 0xbd) LOGF_NOTICE(HLE, ">>> es::finish(): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", peek, first, put, size); //if (fidMajor != 0xbd) LOG_NOTICE(HLE, ">>> es::finish(): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", peek, first, put, size);
addr = put; addr = put;
/*if (!first) /*if (!first)
@ -600,7 +600,7 @@ public:
}*/ }*/
mem_ptr_t<CellDmuxAuInfo> info(put); mem_ptr_t<CellDmuxAuInfo> info(put);
//if (fidMajor != 0xbd) LOGF_WARNING(HLE, "es::finish(): (%s) size = 0x%x, info_addr=0x%x, pts = 0x%x", //if (fidMajor != 0xbd) LOG_WARNING(HLE, "es::finish(): (%s) size = 0x%x, info_addr=0x%x, pts = 0x%x",
//wxString(fidMajor == 0xbd ? "ATRAC3P Audio" : "Video AVC").wx_str(), //wxString(fidMajor == 0xbd ? "ATRAC3P Audio" : "Video AVC").wx_str(),
//(u32)info->auSize, put, (u32)info->ptsLower); //(u32)info->auSize, put, (u32)info->ptsLower);
@ -611,11 +611,11 @@ public:
size = 0; size = 0;
put_count++; put_count++;
//if (fidMajor != 0xbd) LOGF_NOTICE(HLE, "<<< es::finish(): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", peek, first, put, size); //if (fidMajor != 0xbd) LOG_NOTICE(HLE, "<<< es::finish(): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", peek, first, put, size);
} }
if (!entries.Push(addr)) if (!entries.Push(addr))
{ {
LOGF_ERROR(HLE, "es::finish() aborted (no space)"); LOG_ERROR(HLE, "es::finish() aborted (no space)");
} }
} }
@ -625,7 +625,7 @@ public:
if (is_full()) if (is_full())
{ {
LOGF_ERROR(HLE, "es::push(): buffer is full"); LOG_ERROR(HLE, "es::push(): buffer is full");
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -634,7 +634,7 @@ public:
size += sz; size += sz;
if (!Memory.Copy(data_addr, stream.addr, sz)) if (!Memory.Copy(data_addr, stream.addr, sz))
{ {
LOGF_ERROR(HLE, "es::push(): data copying failed"); LOG_ERROR(HLE, "es::push(): data copying failed");
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -674,22 +674,22 @@ public:
bool release() bool release()
{ {
std::lock_guard<std::mutex> lock(m_mutex); std::lock_guard<std::mutex> lock(m_mutex);
//if (fidMajor != 0xbd) LOGF_NOTICE(HLE, ">>> es::release(): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", peek, first, put, size); //if (fidMajor != 0xbd) LOG_NOTICE(HLE, ">>> es::release(): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", peek, first, put, size);
if (released >= put_count) if (released >= put_count)
{ {
LOGF_ERROR(HLE, "es::release(): buffer is empty"); LOG_ERROR(HLE, "es::release(): buffer is empty");
return false; return false;
} }
u32 addr = entries.Peek(); u32 addr = entries.Peek();
mem_ptr_t<CellDmuxAuInfo> info(addr); mem_ptr_t<CellDmuxAuInfo> info(addr);
//if (fidMajor != 0xbd) LOGF_WARNING(HLE, "es::release(): (%s) size = 0x%x, info = 0x%x, pts = 0x%x", //if (fidMajor != 0xbd) LOG_WARNING(HLE, "es::release(): (%s) size = 0x%x, info = 0x%x, pts = 0x%x",
//wxString(fidMajor == 0xbd ? "ATRAC3P Audio" : "Video AVC").wx_str(), (u32)info->auSize, first, (u32)info->ptsLower); //wxString(fidMajor == 0xbd ? "ATRAC3P Audio" : "Video AVC").wx_str(), (u32)info->auSize, first, (u32)info->ptsLower);
if (released >= peek_count) if (released >= peek_count)
{ {
LOGF_ERROR(HLE, "es::release(): buffer has not been seen yet"); LOG_ERROR(HLE, "es::release(): buffer has not been seen yet");
return false; return false;
} }
@ -711,30 +711,30 @@ public:
released++; released++;
if (!entries.Pop(addr)) if (!entries.Pop(addr))
{ {
LOGF_ERROR(HLE, "es::release(): entries.Pop() aborted (no entries found)"); LOG_ERROR(HLE, "es::release(): entries.Pop() aborted (no entries found)");
return false; return false;
} }
//if (fidMajor != 0xbd) LOGF_NOTICE(HLE, "<<< es::release(): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", peek, first, put, size); //if (fidMajor != 0xbd) LOG_NOTICE(HLE, "<<< es::release(): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", peek, first, put, size);
return true; return true;
} }
bool peek(u32& out_data, bool no_ex, u32& out_spec, bool update_index) bool peek(u32& out_data, bool no_ex, u32& out_spec, bool update_index)
{ {
std::lock_guard<std::mutex> lock(m_mutex); std::lock_guard<std::mutex> lock(m_mutex);
//if (fidMajor != 0xbd) LOGF_NOTICE(HLE, ">>> es::peek(%sAu%s): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", wxString(update_index ? "Get" : "Peek").wx_str(), //if (fidMajor != 0xbd) LOG_NOTICE(HLE, ">>> es::peek(%sAu%s): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", wxString(update_index ? "Get" : "Peek").wx_str(),
//wxString(no_ex ? "" : "Ex").wx_str(), peek, first, put, size); //wxString(no_ex ? "" : "Ex").wx_str(), peek, first, put, size);
if (peek_count >= put_count) return false; if (peek_count >= put_count) return false;
if (peek_count < released) if (peek_count < released)
{ {
LOGF_ERROR(HLE, "es::peek(): sequence error: peek_count < released (peek_count=%d, released=%d)", peek_count, released); LOG_ERROR(HLE, "es::peek(): sequence error: peek_count < released (peek_count=%d, released=%d)", peek_count, released);
Emu.Pause(); Emu.Pause();
return false; return false;
} }
u32 addr = entries.Peek(peek_count - released); u32 addr = entries.Peek(peek_count - released);
mem_ptr_t<CellDmuxAuInfo> info(addr); mem_ptr_t<CellDmuxAuInfo> info(addr);
//if (fidMajor != 0xbd) LOGF_WARNING(HLE, "es::peek(%sAu(Ex)): (%s) size = 0x%x, info = 0x%x, pts = 0x%x", //if (fidMajor != 0xbd) LOG_WARNING(HLE, "es::peek(%sAu(Ex)): (%s) size = 0x%x, info = 0x%x, pts = 0x%x",
//wxString(update_index ? "Get" : "Peek").wx_str(), //wxString(update_index ? "Get" : "Peek").wx_str(),
//wxString(fidMajor == 0xbd ? "ATRAC3P Audio" : "Video AVC").wx_str(), (u32)info->auSize, peek, (u32)info->ptsLower); //wxString(fidMajor == 0xbd ? "ATRAC3P Audio" : "Video AVC").wx_str(), (u32)info->auSize, peek, (u32)info->ptsLower);
@ -760,7 +760,7 @@ public:
peek_count++; peek_count++;
} }
//if (fidMajor != 0xbd) LOGF_NOTICE(HLE, "<<< es::peek(%sAu%s): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", wxString(update_index ? "Get" : "Peek").wx_str(), //if (fidMajor != 0xbd) LOG_NOTICE(HLE, "<<< es::peek(%sAu%s): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", wxString(update_index ? "Get" : "Peek").wx_str(),
//wxString(no_ex ? "" : "Ex").wx_str(), peek, first, put, size); //wxString(no_ex ? "" : "Ex").wx_str(), peek, first, put, size);
return true; return true;
} }

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

@ -93,7 +93,7 @@ int cellSyncMutexLock(mem_ptr_t<CellSyncMutex> mutex)
Sleep(1); Sleep(1);
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "cellSyncMutexLock(mutex=0x%x) aborted", mutex.GetAddr()); LOG_WARNING(HLE, "cellSyncMutexLock(mutex=0x%x) aborted", mutex.GetAddr());
break; break;
} }
} }

34
rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
View file

@ -230,7 +230,7 @@ s32 modifySaveDataFiles(mem_func_ptr_t<CellSaveDataFileCallback>& funcFile, mem_
{ {
funcFile(result.GetAddr(), fileGet.GetAddr(), fileSet.GetAddr()); funcFile(result.GetAddr(), fileGet.GetAddr(), fileSet.GetAddr());
if (result->result < 0) { if (result->result < 0) {
LOGF_ERROR(HLE, "modifySaveDataFiles: CellSaveDataFileCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOG_ERROR(HLE, "modifySaveDataFiles: CellSaveDataFileCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
if (result->result == CELL_SAVEDATA_CBRESULT_OK_LAST) { if (result->result == CELL_SAVEDATA_CBRESULT_OK_LAST) {
@ -251,7 +251,7 @@ s32 modifySaveDataFiles(mem_func_ptr_t<CellSaveDataFileCallback>& funcFile, mem_
case CELL_SAVEDATA_FILETYPE_CONTENT_SND0: filepath += "SND0.AT3"; break; case CELL_SAVEDATA_FILETYPE_CONTENT_SND0: filepath += "SND0.AT3"; break;
default: default:
LOGF_ERROR(HLE, "modifySaveDataFiles: Unknown fileType! Aborting..."); LOG_ERROR(HLE, "modifySaveDataFiles: Unknown fileType! Aborting...");
return CELL_SAVEDATA_ERROR_PARAM; return CELL_SAVEDATA_ERROR_PARAM;
} }
@ -274,11 +274,11 @@ s32 modifySaveDataFiles(mem_func_ptr_t<CellSaveDataFileCallback>& funcFile, mem_
break; break;
case CELL_SAVEDATA_FILEOP_WRITE_NOTRUNC: case CELL_SAVEDATA_FILEOP_WRITE_NOTRUNC:
LOGF_WARNING(HLE, "modifySaveDataFiles: File operation CELL_SAVEDATA_FILEOP_WRITE_NOTRUNC not yet implemented"); LOG_WARNING(HLE, "modifySaveDataFiles: File operation CELL_SAVEDATA_FILEOP_WRITE_NOTRUNC not yet implemented");
break; break;
default: default:
LOGF_ERROR(HLE, "modifySaveDataFiles: Unknown fileOperation! Aborting..."); LOG_ERROR(HLE, "modifySaveDataFiles: Unknown fileOperation! Aborting...");
return CELL_SAVEDATA_ERROR_PARAM; return CELL_SAVEDATA_ERROR_PARAM;
} }
@ -339,7 +339,7 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
funcList(result.GetAddr(), listGet.GetAddr(), listSet.GetAddr()); funcList(result.GetAddr(), listGet.GetAddr(), listSet.GetAddr());
if (result->result < 0) { if (result->result < 0) {
LOGF_ERROR(HLE, "cellSaveDataListSave2: CellSaveDataListCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOG_ERROR(HLE, "cellSaveDataListSave2: CellSaveDataListCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
if (!listSet->fixedList.IsGood()) if (!listSet->fixedList.IsGood())
@ -349,7 +349,7 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
if (listSet->newData.IsGood()) if (listSet->newData.IsGood())
addNewSaveDataEntry(saveEntries, (u32)listSet->newData.GetAddr()); addNewSaveDataEntry(saveEntries, (u32)listSet->newData.GetAddr());
if (saveEntries.size() == 0) { if (saveEntries.size() == 0) {
LOGF_WARNING(HLE, "cellSaveDataListSave2: No save entries found!"); // TODO: Find a better way to handle this error LOG_WARNING(HLE, "cellSaveDataListSave2: No save entries found!"); // TODO: Find a better way to handle this error
return CELL_SAVEDATA_RET_OK; return CELL_SAVEDATA_RET_OK;
} }
@ -362,7 +362,7 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr()); funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr());
Memory.Free(statGet->fileList.GetAddr()); Memory.Free(statGet->fileList.GetAddr());
if (result->result < 0) { if (result->result < 0) {
LOGF_ERROR(HLE, "cellSaveDataListLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOG_ERROR(HLE, "cellSaveDataListLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
/*if (statSet->setParam.IsGood()) /*if (statSet->setParam.IsGood())
@ -424,7 +424,7 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
funcList(result.GetAddr(), listGet.GetAddr(), listSet.GetAddr()); funcList(result.GetAddr(), listGet.GetAddr(), listSet.GetAddr());
if (result->result < 0) { if (result->result < 0) {
LOGF_ERROR(HLE, "cellSaveDataListLoad2: CellSaveDataListCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOG_ERROR(HLE, "cellSaveDataListLoad2: CellSaveDataListCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
if (!listSet->fixedList.IsGood()) if (!listSet->fixedList.IsGood())
@ -434,7 +434,7 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
if (listSet->newData.IsGood()) if (listSet->newData.IsGood())
addNewSaveDataEntry(saveEntries, (u32)listSet->newData.GetAddr()); addNewSaveDataEntry(saveEntries, (u32)listSet->newData.GetAddr());
if (saveEntries.size() == 0) { if (saveEntries.size() == 0) {
LOGF_WARNING(HLE, "cellSaveDataListLoad2: No save entries found!"); // TODO: Find a better way to handle this error LOG_WARNING(HLE, "cellSaveDataListLoad2: No save entries found!"); // TODO: Find a better way to handle this error
return CELL_SAVEDATA_RET_OK; return CELL_SAVEDATA_RET_OK;
} }
@ -447,7 +447,7 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr()); funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr());
Memory.Free(statGet->fileList.GetAddr()); Memory.Free(statGet->fileList.GetAddr());
if (result->result < 0) { if (result->result < 0) {
LOGF_ERROR(HLE, "cellSaveDataListLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOG_ERROR(HLE, "cellSaveDataListLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
/*if (statSet->setParam.IsGood()) /*if (statSet->setParam.IsGood())
@ -508,7 +508,7 @@ int cellSaveDataFixedSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList,
} }
funcFixed(result.GetAddr(), listGet.GetAddr(), fixedSet.GetAddr()); funcFixed(result.GetAddr(), listGet.GetAddr(), fixedSet.GetAddr());
if (result->result < 0) { if (result->result < 0) {
LOGF_ERROR(HLE, "cellSaveDataFixedSave2: CellSaveDataFixedCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOG_ERROR(HLE, "cellSaveDataFixedSave2: CellSaveDataFixedCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
setSaveDataFixed(saveEntries, fixedSet.GetAddr()); setSaveDataFixed(saveEntries, fixedSet.GetAddr());
@ -519,7 +519,7 @@ int cellSaveDataFixedSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList,
funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr()); funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr());
Memory.Free(statGet->fileList.GetAddr()); Memory.Free(statGet->fileList.GetAddr());
if (result->result < 0) { if (result->result < 0) {
LOGF_ERROR(HLE, "cellSaveDataFixedSave2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOG_ERROR(HLE, "cellSaveDataFixedSave2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
/*if (statSet->setParam.IsGood()) /*if (statSet->setParam.IsGood())
@ -580,7 +580,7 @@ int cellSaveDataFixedLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList,
} }
funcFixed(result.GetAddr(), listGet.GetAddr(), fixedSet.GetAddr()); funcFixed(result.GetAddr(), listGet.GetAddr(), fixedSet.GetAddr());
if (result->result < 0) { if (result->result < 0) {
LOGF_ERROR(HLE, "cellSaveDataFixedLoad2: CellSaveDataFixedCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOG_ERROR(HLE, "cellSaveDataFixedLoad2: CellSaveDataFixedCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
setSaveDataFixed(saveEntries, fixedSet.GetAddr()); setSaveDataFixed(saveEntries, fixedSet.GetAddr());
@ -591,7 +591,7 @@ int cellSaveDataFixedLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList,
funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr()); funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr());
Memory.Free(statGet->fileList.GetAddr()); Memory.Free(statGet->fileList.GetAddr());
if (result->result < 0) { if (result->result < 0) {
LOGF_ERROR(HLE, "cellSaveDataFixedLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOG_ERROR(HLE, "cellSaveDataFixedLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
/*if (statSet->setParam.IsGood()) /*if (statSet->setParam.IsGood())
@ -647,7 +647,7 @@ int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
Memory.Free(statGet->fileList.GetAddr()); Memory.Free(statGet->fileList.GetAddr());
if (result->result < 0) { if (result->result < 0) {
LOGF_ERROR(HLE, "cellSaveDataAutoSave2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOG_ERROR(HLE, "cellSaveDataAutoSave2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
/*if (statSet->setParam.IsGood()) /*if (statSet->setParam.IsGood())
@ -690,7 +690,7 @@ int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
// The target entry does not exist // The target entry does not exist
if (saveEntries.size() == 0) { if (saveEntries.size() == 0) {
LOGF_WARNING(HLE, "cellSaveDataAutoLoad2: Couldn't find save entry (%s)", dirName.c_str()); LOG_WARNING(HLE, "cellSaveDataAutoLoad2: Couldn't find save entry (%s)", dirName.c_str());
return CELL_OK; // TODO: Can anyone check the actual behaviour of a PS3 when saves are not found? return CELL_OK; // TODO: Can anyone check the actual behaviour of a PS3 when saves are not found?
} }
@ -700,7 +700,7 @@ int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
Memory.Free(statGet->fileList.GetAddr()); Memory.Free(statGet->fileList.GetAddr());
if (result->result < 0) { if (result->result < 0) {
LOGF_ERROR(HLE, "cellSaveDataAutoLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOG_ERROR(HLE, "cellSaveDataAutoLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
/*if (statSet->setParam.IsGood()) /*if (statSet->setParam.IsGood())

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

@ -35,7 +35,7 @@ next:
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "vdecRead(): aborted"); LOG_WARNING(HLE, "vdecRead(): aborted");
return 0; return 0;
} }
Sleep(1); Sleep(1);
@ -52,7 +52,7 @@ next:
{ {
if (!Memory.CopyToReal(buf, vdec.reader.addr, vdec.reader.size)) if (!Memory.CopyToReal(buf, vdec.reader.addr, vdec.reader.size))
{ {
LOGF_ERROR(HLE, "vdecRead(): data reading failed (reader.size=0x%x)", vdec.reader.size); LOG_ERROR(HLE, "vdecRead(): data reading failed (reader.size=0x%x)", vdec.reader.size);
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -71,11 +71,11 @@ next:
vdec.reader.addr = vdec.task.addr; vdec.reader.addr = vdec.task.addr;
vdec.reader.size = vdec.task.size; vdec.reader.size = vdec.task.size;
//LOGF_NOTICE(HLE, "Video AU: size = 0x%x, pts = 0x%llx, dts = 0x%llx", vdec.task.size, vdec.task.pts, vdec.task.dts); //LOG_NOTICE(HLE, "Video AU: size = 0x%x, pts = 0x%llx, dts = 0x%llx", vdec.task.size, vdec.task.pts, vdec.task.dts);
} }
break; break;
default: default:
LOGF_ERROR(HLE, "vdecRead(): sequence error (task %d)", vdec.job.Peek().type); LOG_ERROR(HLE, "vdecRead(): sequence error (task %d)", vdec.job.Peek().type);
return 0; return 0;
} }
@ -92,7 +92,7 @@ next:
} }
else if (!Memory.CopyToReal(buf, vdec.reader.addr, buf_size)) else if (!Memory.CopyToReal(buf, vdec.reader.addr, buf_size))
{ {
LOGF_ERROR(HLE, "vdecRead(): data reading failed (buf_size=0x%x)", buf_size); LOG_ERROR(HLE, "vdecRead(): data reading failed (buf_size=0x%x)", buf_size);
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -136,7 +136,7 @@ u32 vdecOpen(VideoDecoder* data)
thread t("Video Decoder[" + std::to_string(vdec_id) + "] Thread", [&]() thread t("Video Decoder[" + std::to_string(vdec_id) + "] Thread", [&]()
{ {
LOGF_NOTICE(HLE, "Video Decoder thread started"); LOG_NOTICE(HLE, "Video Decoder thread started");
VdecTask& task = vdec.task; VdecTask& task = vdec.task;
@ -169,7 +169,7 @@ u32 vdecOpen(VideoDecoder* data)
case vdecStartSeq: case vdecStartSeq:
{ {
// TODO: reset data // TODO: reset data
LOGF_WARNING(HLE, "vdecStartSeq:"); LOG_WARNING(HLE, "vdecStartSeq:");
vdec.reader.addr = 0; vdec.reader.addr = 0;
vdec.reader.size = 0; vdec.reader.size = 0;
@ -181,7 +181,7 @@ u32 vdecOpen(VideoDecoder* data)
case vdecEndSeq: case vdecEndSeq:
{ {
// TODO: finalize // TODO: finalize
LOGF_WARNING(HLE, "vdecEndSeq:"); LOG_WARNING(HLE, "vdecEndSeq:");
vdec.vdecCb->ExecAsCallback(vdec.cbFunc, false, vdec.id, CELL_VDEC_MSG_TYPE_SEQDONE, CELL_OK, vdec.cbArg); vdec.vdecCb->ExecAsCallback(vdec.cbFunc, false, vdec.id, CELL_VDEC_MSG_TYPE_SEQDONE, CELL_OK, vdec.cbArg);
/*Callback cb; /*Callback cb;
@ -202,13 +202,13 @@ u32 vdecOpen(VideoDecoder* data)
if (task.mode != CELL_VDEC_DEC_MODE_NORMAL) if (task.mode != CELL_VDEC_DEC_MODE_NORMAL)
{ {
LOGF_ERROR(HLE, "vdecDecodeAu: unsupported decoding mode(%d)", task.mode); LOG_ERROR(HLE, "vdecDecodeAu: unsupported decoding mode(%d)", task.mode);
break; break;
} }
vdec.reader.addr = task.addr; vdec.reader.addr = task.addr;
vdec.reader.size = task.size; vdec.reader.size = task.size;
//LOGF_NOTICE(HLE, "Video AU: size = 0x%x, pts = 0x%llx, dts = 0x%llx", task.size, task.pts, task.dts); //LOG_NOTICE(HLE, "Video AU: size = 0x%x, pts = 0x%llx, dts = 0x%llx", task.size, task.pts, task.dts);
if (vdec.just_started) if (vdec.just_started)
{ {
@ -249,33 +249,33 @@ u32 vdecOpen(VideoDecoder* data)
err = avformat_open_input(&vdec.fmt, NULL, av_find_input_format("mpeg"), NULL); err = avformat_open_input(&vdec.fmt, NULL, av_find_input_format("mpeg"), NULL);
if (err) if (err)
{ {
LOGF_ERROR(HLE, "vdecDecodeAu: avformat_open_input() failed"); LOG_ERROR(HLE, "vdecDecodeAu: avformat_open_input() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
AVCodec* codec = avcodec_find_decoder(AV_CODEC_ID_H264); // ??? AVCodec* codec = avcodec_find_decoder(AV_CODEC_ID_H264); // ???
if (!codec) if (!codec)
{ {
LOGF_ERROR(HLE, "vdecDecodeAu: avcodec_find_decoder() failed"); LOG_ERROR(HLE, "vdecDecodeAu: avcodec_find_decoder() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
/*err = avformat_find_stream_info(vdec.fmt, NULL); /*err = avformat_find_stream_info(vdec.fmt, NULL);
if (err) if (err)
{ {
LOGF_ERROR(HLE, "vdecDecodeAu: avformat_find_stream_info() failed"); LOG_ERROR(HLE, "vdecDecodeAu: avformat_find_stream_info() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
if (!vdec.fmt->nb_streams) if (!vdec.fmt->nb_streams)
{ {
LOGF_ERROR(HLE, "vdecDecodeAu: no stream found"); LOG_ERROR(HLE, "vdecDecodeAu: no stream found");
Emu.Pause(); Emu.Pause();
break; break;
}*/ }*/
if (!avformat_new_stream(vdec.fmt, codec)) if (!avformat_new_stream(vdec.fmt, codec))
{ {
LOGF_ERROR(HLE, "vdecDecodeAu: avformat_new_stream() failed"); LOG_ERROR(HLE, "vdecDecodeAu: avformat_new_stream() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -290,7 +290,7 @@ u32 vdecOpen(VideoDecoder* data)
} }
if (err) if (err)
{ {
LOGF_ERROR(HLE, "vdecDecodeAu: avcodec_open2() failed"); LOG_ERROR(HLE, "vdecDecodeAu: avcodec_open2() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -305,7 +305,7 @@ u32 vdecOpen(VideoDecoder* data)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "vdecDecodeAu: aborted"); LOG_WARNING(HLE, "vdecDecodeAu: aborted");
return; return;
} }
@ -338,7 +338,7 @@ u32 vdecOpen(VideoDecoder* data)
if (!frame.data) if (!frame.data)
{ {
LOGF_ERROR(HLE, "vdecDecodeAu: av_frame_alloc() failed"); LOG_ERROR(HLE, "vdecDecodeAu: av_frame_alloc() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -351,7 +351,7 @@ u32 vdecOpen(VideoDecoder* data)
{ {
if (!last_frame && decode < 0) if (!last_frame && decode < 0)
{ {
LOGF_ERROR(HLE, "vdecDecodeAu: AU decoding error(0x%x)", decode); LOG_ERROR(HLE, "vdecDecodeAu: AU decoding error(0x%x)", decode);
} }
if (!got_picture && vdec.reader.size == 0) break; // video end? if (!got_picture && vdec.reader.size == 0) break; // video end?
} }
@ -374,7 +374,7 @@ u32 vdecOpen(VideoDecoder* data)
frame.dts = (frame.pts - vdec.first_pts) + vdec.first_dts; frame.dts = (frame.pts - vdec.first_pts) + vdec.first_dts;
frame.userdata = task.userData; frame.userdata = task.userData;
//LOGF_NOTICE(HLE, "got picture (pts=0x%llx, dts=0x%llx)", frame.pts, frame.dts); //LOG_NOTICE(HLE, "got picture (pts=0x%llx, dts=0x%llx)", frame.pts, frame.dts);
vdec.frames.Push(frame); // !!!!!!!! vdec.frames.Push(frame); // !!!!!!!!
frame.data = nullptr; // to prevent destruction frame.data = nullptr; // to prevent destruction
@ -398,23 +398,23 @@ u32 vdecOpen(VideoDecoder* data)
case vdecClose: case vdecClose:
{ {
vdec.is_finished = true; vdec.is_finished = true;
LOGF_NOTICE(HLE, "Video Decoder thread ended"); LOG_NOTICE(HLE, "Video Decoder thread ended");
return; return;
} }
case vdecSetFrameRate: case vdecSetFrameRate:
{ {
LOGF_ERROR(HLE, "TODO: vdecSetFrameRate(%d)", task.frc); LOG_ERROR(HLE, "TODO: vdecSetFrameRate(%d)", task.frc);
} }
break; break;
default: default:
LOGF_ERROR(HLE, "Video Decoder thread error: unknown task(%d)", task.type); LOG_ERROR(HLE, "Video Decoder thread error: unknown task(%d)", task.type);
} }
} }
vdec.is_finished = true; vdec.is_finished = true;
LOGF_WARNING(HLE, "Video Decoder thread aborted"); LOG_WARNING(HLE, "Video Decoder thread aborted");
}); });
t.detach(); t.detach();
@ -502,7 +502,7 @@ int cellVdecClose(u32 handle)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "cellVdecClose(%d) aborted", handle); LOG_WARNING(HLE, "cellVdecClose(%d) aborted", handle);
break; break;
} }
Sleep(1); Sleep(1);
@ -553,7 +553,7 @@ int cellVdecEndSeq(u32 handle)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "cellVdecEndSeq(%d) aborted", handle); LOG_WARNING(HLE, "cellVdecEndSeq(%d) aborted", handle);
return CELL_OK; return CELL_OK;
} }
Sleep(1); Sleep(1);
@ -751,13 +751,13 @@ int cellVdecGetPicItem(u32 handle, mem32_t picItem_ptr)
} }
else else
{ {
LOGF_ERROR(HLE, "cellVdecGetPicItem: unsupported time_base.den (%d)", vdec->ctx->time_base.den); LOG_ERROR(HLE, "cellVdecGetPicItem: unsupported time_base.den (%d)", vdec->ctx->time_base.den);
Emu.Pause(); Emu.Pause();
} }
} }
else else
{ {
LOGF_ERROR(HLE, "cellVdecGetPicItem: unsupported time_base.num (%d)", vdec->ctx->time_base.num); LOG_ERROR(HLE, "cellVdecGetPicItem: unsupported time_base.num (%d)", vdec->ctx->time_base.num);
Emu.Pause(); Emu.Pause();
} }
avc->fixed_frame_rate_flag = true; avc->fixed_frame_rate_flag = true;

6
rpcs3/Emu/SysCalls/Modules/cellVdec.h
View file

@ -741,14 +741,14 @@ public:
AVCodec* codec = avcodec_find_decoder(AV_CODEC_ID_H264); AVCodec* codec = avcodec_find_decoder(AV_CODEC_ID_H264);
if (!codec) if (!codec)
{ {
LOGF_ERROR(HLE, "VideoDecoder(): avcodec_find_decoder(H264) failed"); LOG_ERROR(HLE, "VideoDecoder(): avcodec_find_decoder(H264) failed");
Emu.Pause(); Emu.Pause();
return; return;
} }
fmt = avformat_alloc_context(); fmt = avformat_alloc_context();
if (!fmt) if (!fmt)
{ {
LOGF_ERROR(HLE, "VideoDecoder(): avformat_alloc_context failed"); LOG_ERROR(HLE, "VideoDecoder(): avformat_alloc_context failed");
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -756,7 +756,7 @@ public:
fmt->pb = avio_alloc_context(io_buf, 4096, 0, this, vdecRead, NULL, NULL); fmt->pb = avio_alloc_context(io_buf, 4096, 0, this, vdecRead, NULL, NULL);
if (!fmt->pb) if (!fmt->pb)
{ {
LOGF_ERROR(HLE, "VideoDecoder(): avio_alloc_context failed"); LOG_ERROR(HLE, "VideoDecoder(): avio_alloc_context failed");
Emu.Pause(); Emu.Pause();
return; return;
} }

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

@ -38,7 +38,7 @@ u32 vpostOpen(VpostInstance* data)
{ {
u32 id = cellVpost->GetNewId(data); u32 id = cellVpost->GetNewId(data);
LOGF_NOTICE(HLE, "*** Vpost instance created (to_rgba=%d): id = %d", data->to_rgba, id); LOG_NOTICE(HLE, "*** Vpost instance created (to_rgba=%d): id = %d", data->to_rgba, id);
return id; return id;
} }
@ -123,15 +123,15 @@ int cellVpostExec(u32 handle, const u32 inPicBuff_addr, const mem_ptr_t<CellVpos
} }
ctrlParam->inWindow; // ignored ctrlParam->inWindow; // ignored
if (ctrlParam->inWindow.x) LOGF_WARNING(HLE, "*** inWindow.x = %d", (u32)ctrlParam->inWindow.x); if (ctrlParam->inWindow.x) LOG_WARNING(HLE, "*** inWindow.x = %d", (u32)ctrlParam->inWindow.x);
if (ctrlParam->inWindow.y) LOGF_WARNING(HLE, "*** inWindow.y = %d", (u32)ctrlParam->inWindow.y); if (ctrlParam->inWindow.y) LOG_WARNING(HLE, "*** inWindow.y = %d", (u32)ctrlParam->inWindow.y);
if (ctrlParam->inWindow.width != w) LOGF_WARNING(HLE, "*** inWindow.width = %d", (u32)ctrlParam->inWindow.width); if (ctrlParam->inWindow.width != w) LOG_WARNING(HLE, "*** inWindow.width = %d", (u32)ctrlParam->inWindow.width);
if (ctrlParam->inWindow.height != h) LOGF_WARNING(HLE, "*** inWindow.height = %d", (u32)ctrlParam->inWindow.height); if (ctrlParam->inWindow.height != h) LOG_WARNING(HLE, "*** inWindow.height = %d", (u32)ctrlParam->inWindow.height);
ctrlParam->outWindow; // ignored ctrlParam->outWindow; // ignored
if (ctrlParam->outWindow.x) LOGF_WARNING(HLE, "*** outWindow.x = %d", (u32)ctrlParam->outWindow.x); if (ctrlParam->outWindow.x) LOG_WARNING(HLE, "*** outWindow.x = %d", (u32)ctrlParam->outWindow.x);
if (ctrlParam->outWindow.y) LOGF_WARNING(HLE, "*** outWindow.y = %d", (u32)ctrlParam->outWindow.y); if (ctrlParam->outWindow.y) LOG_WARNING(HLE, "*** outWindow.y = %d", (u32)ctrlParam->outWindow.y);
if (ctrlParam->outWindow.width != ow) LOGF_WARNING(HLE, "*** outWindow.width = %d", (u32)ctrlParam->outWindow.width); if (ctrlParam->outWindow.width != ow) LOG_WARNING(HLE, "*** outWindow.width = %d", (u32)ctrlParam->outWindow.width);
if (ctrlParam->outWindow.height != oh) LOGF_WARNING(HLE, "*** outWindow.height = %d", (u32)ctrlParam->outWindow.height); if (ctrlParam->outWindow.height != oh) LOG_WARNING(HLE, "*** outWindow.height = %d", (u32)ctrlParam->outWindow.height);
ctrlParam->execType; // ignored ctrlParam->execType; // ignored
ctrlParam->scalerType; // ignored ctrlParam->scalerType; // ignored
ctrlParam->ipcType; // ignored ctrlParam->ipcType; // ignored

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

@ -209,7 +209,7 @@ void fsAioRead(u32 fd, mem_ptr_t<CellFsAio> aio, int xid, mem_func_ptr_t<void (*
fin: fin:
file.Seek(old_pos); file.Seek(old_pos);
LOGF_WARNING(HLE, "*** fsAioRead(fd=%d, offset=0x%llx, buf_addr=0x%x, size=0x%x, error=0x%x, res=0x%x, xid=0x%x [%s])", LOG_WARNING(HLE, "*** fsAioRead(fd=%d, offset=0x%llx, buf_addr=0x%x, size=0x%x, error=0x%x, res=0x%x, xid=0x%x [%s])",
fd, (u64)aio->offset, buf_addr, (u64)aio->size, error, res, xid, orig_file->GetPath().c_str()); fd, (u64)aio->offset, buf_addr, (u64)aio->size, error, res, xid, orig_file->GetPath().c_str());
if (func) // start callback thread if (func) // start callback thread
@ -223,7 +223,7 @@ fin:
Sleep(1); Sleep(1);
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "fsAioRead() aborted"); LOG_WARNING(HLE, "fsAioRead() aborted");
break; break;
} }
}*/ }*/

18
rpcs3/Emu/SysCalls/Static.cpp
View file

@ -54,14 +54,14 @@ void StaticFuncManager::StaticAnalyse(void* ptr, u32 size, u32 base)
k--; k--;
if (can_skip) // cannot define this behaviour properly if (can_skip) // cannot define this behaviour properly
{ {
LOGF_WARNING(LOADER, "StaticAnalyse(): can_skip = %d (unchanged)", can_skip); LOG_WARNING(LOADER, "StaticAnalyse(): can_skip = %d (unchanged)", can_skip);
} }
} }
else else
{ {
if (can_skip) // cannot define this behaviour properly if (can_skip) // cannot define this behaviour properly
{ {
LOGF_WARNING(LOADER, "StaticAnalyse(): can_skip = %d (set to 0)", can_skip); LOG_WARNING(LOADER, "StaticAnalyse(): can_skip = %d (set to 0)", can_skip);
can_skip = 0; can_skip = 0;
} }
} }
@ -85,7 +85,7 @@ void StaticFuncManager::StaticAnalyse(void* ptr, u32 size, u32 base)
} }
if (found) if (found)
{ {
LOGF_NOTICE(LOADER, "Function '%s' hooked (addr=0x%x)", m_static_funcs_list[j]->name, i * 4 + base); LOG_NOTICE(LOADER, "Function '%s' hooked (addr=0x%x)", m_static_funcs_list[j]->name, i * 4 + base);
m_static_funcs_list[j]->found++; m_static_funcs_list[j]->found++;
data[i+0] = re32(0x39600000 | j); // li r11, j data[i+0] = re32(0x39600000 | j); // li r11, j
data[i+1] = se32(0x44000003); // sc 3 data[i+1] = se32(0x44000003); // sc 3
@ -129,7 +129,7 @@ void StaticFuncManager::StaticAnalyse(void* ptr, u32 size, u32 base)
if (count == 0) if (count == 0)
{ {
res |= GSR_MISSING; res |= GSR_MISSING;
LOGF_ERROR(LOADER, "Function '%s' not found", m_static_funcs_list[j]->name); LOG_ERROR(LOADER, "Function '%s' not found", m_static_funcs_list[j]->name);
} }
else if (count > 1) else if (count > 1)
{ {
@ -146,7 +146,7 @@ void StaticFuncManager::StaticAnalyse(void* ptr, u32 size, u32 base)
if (m_static_funcs_list[k]->found) if (m_static_funcs_list[k]->found)
{ {
res |= GSR_EXCESS; res |= GSR_EXCESS;
LOGF_ERROR(LOADER, "Function '%s' hooked twice", m_static_funcs_list[j]->name); LOG_ERROR(LOADER, "Function '%s' hooked twice", m_static_funcs_list[j]->name);
} }
} }
} }
@ -154,7 +154,7 @@ void StaticFuncManager::StaticAnalyse(void* ptr, u32 size, u32 base)
else else
{ {
res |= GSR_EXCESS; res |= GSR_EXCESS;
LOGF_ERROR(LOADER, "Function '%s' hooked twice", m_static_funcs_list[j]->name); LOG_ERROR(LOADER, "Function '%s' hooked twice", m_static_funcs_list[j]->name);
} }
} }
@ -170,11 +170,11 @@ void StaticFuncManager::StaticAnalyse(void* ptr, u32 size, u32 base)
if (res == GSR_SUCCESS) if (res == GSR_SUCCESS)
{ {
LOGF_SUCCESS(LOADER, "Function group [%s] successfully hooked", std::string(name, 9).c_str()); LOG_SUCCESS(LOADER, "Function group [%s] successfully hooked", std::string(name, 9).c_str());
} }
else else
{ {
LOGF_ERROR(LOADER, "Function group [%s] failed:%s%s", std::string(name, 9).c_str(), LOG_ERROR(LOADER, "Function group [%s] failed:%s%s", std::string(name, 9).c_str(),
(res & GSR_MISSING ? " missing;" : ""), (res & GSR_MISSING ? " missing;" : ""),
(res & GSR_EXCESS ? " excess;" : "")); (res & GSR_EXCESS ? " excess;" : ""));
} }
@ -190,7 +190,7 @@ void StaticFuncManager::StaticExecute(u32 code)
} }
else else
{ {
LOGF_ERROR(LOADER, "StaticExecute(%d): unknown function or illegal opcode", code); LOG_ERROR(LOADER, "StaticExecute(%d): unknown function or illegal opcode", code);
} }
} }

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

@ -553,7 +553,7 @@ void default_syscall()
{ {
//tty //tty
case 988: case 988:
LOGF_WARNING(HLE, "SysCall 988! r3: 0x%llx, r4: 0x%llx, pc: 0x%llx", LOG_WARNING(HLE, "SysCall 988! r3: 0x%llx, r4: 0x%llx, pc: 0x%llx",
CPU.GPR[3], CPU.GPR[4], CPU.PC); CPU.GPR[3], CPU.GPR[4], CPU.PC);
RESULT(0); RESULT(0);
return; return;
@ -561,16 +561,16 @@ void default_syscall()
case 999: case 999:
dump_enable = !dump_enable; dump_enable = !dump_enable;
Emu.Pause(); Emu.Pause();
LOGF_WARNING(HLE, "Dump %s", (dump_enable ? "enabled" : "disabled")); LOG_WARNING(HLE, "Dump %s", (dump_enable ? "enabled" : "disabled"));
return; return;
case 1000: case 1000:
Ini.HLELogging.SetValue(!Ini.HLELogging.GetValue()); Ini.HLELogging.SetValue(!Ini.HLELogging.GetValue());
LOGF_WARNING(HLE, "Log %s", (Ini.HLELogging.GetValue() ? "enabled" : "disabled")); LOG_WARNING(HLE, "Log %s", (Ini.HLELogging.GetValue() ? "enabled" : "disabled"));
return; return;
} }
LOGF_ERROR(HLE, "Unknown syscall: %d - %08x", code, code); LOG_ERROR(HLE, "Unknown syscall: %d - %08x", code, code);
RESULT(0); RESULT(0);
return; return;
} }
@ -589,7 +589,7 @@ void SysCalls::DoSyscall(u32 code)
} }
LOGF_ERROR(HLE, "TODO: %s", GetHLEFuncName(code).c_str()); LOG_ERROR(HLE, "TODO: %s", GetHLEFuncName(code).c_str());
declCPU(); declCPU();
RESULT(0); RESULT(0);
} }

8
rpcs3/Emu/SysCalls/lv2/SC_Condition.cpp
View file

@ -85,7 +85,7 @@ int sys_cond_signal(u32 cond_id)
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "sys_cond_signal(id=%d) aborted", cond_id); LOG_WARNING(HLE, "sys_cond_signal(id=%d) aborted", cond_id);
} }
} }
@ -113,7 +113,7 @@ int sys_cond_signal_all(u32 cond_id)
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "sys_cond_signal_all(id=%d) aborted", cond_id); LOG_WARNING(HLE, "sys_cond_signal_all(id=%d) aborted", cond_id);
break; break;
} }
} }
@ -153,7 +153,7 @@ int sys_cond_signal_to(u32 cond_id, u32 thread_id)
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "sys_cond_signal_to(id=%d, to=%d) aborted", cond_id, thread_id); LOG_WARNING(HLE, "sys_cond_signal_to(id=%d, to=%d) aborted", cond_id, thread_id);
} }
return CELL_OK; return CELL_OK;
@ -236,6 +236,6 @@ int sys_cond_wait(u32 cond_id, u64 timeout)
} }
abort: abort:
LOGF_WARNING(HLE, "sys_cond_wait(id=%d) aborted", cond_id); LOG_WARNING(HLE, "sys_cond_wait(id=%d) aborted", cond_id);
return CELL_OK; return CELL_OK;
} }

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

@ -95,7 +95,7 @@ int sys_event_queue_destroy(u32 equeue_id, int mode)
Sleep(1); Sleep(1);
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "sys_event_queue_destroy(equeue=%d) aborted", equeue_id); LOG_WARNING(HLE, "sys_event_queue_destroy(equeue=%d) aborted", equeue_id);
break; break;
} }
} }
@ -223,7 +223,7 @@ int sys_event_queue_receive(u32 equeue_id, mem_ptr_t<sys_event_data> event, u64
Sleep(1); Sleep(1);
if (counter++ > timeout || Emu.IsStopped()) if (counter++ > timeout || Emu.IsStopped())
{ {
if (Emu.IsStopped()) LOGF_WARNING(HLE, "sys_event_queue_receive(equeue=%d) aborted", equeue_id); if (Emu.IsStopped()) LOG_WARNING(HLE, "sys_event_queue_receive(equeue=%d) aborted", equeue_id);
eq->sq.invalidate(tid); eq->sq.invalidate(tid);
return CELL_ETIMEDOUT; return CELL_ETIMEDOUT;
} }

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

@ -197,7 +197,7 @@ int sys_event_flag_wait(u32 eflag_id, u64 bitptn, u32 mode, mem64_t result, u64
} }
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "sys_event_flag_wait(id=%d) aborted", eflag_id); LOG_WARNING(HLE, "sys_event_flag_wait(id=%d) aborted", eflag_id);
return CELL_OK; return CELL_OK;
} }
} }
@ -324,7 +324,7 @@ int sys_event_flag_cancel(u32 eflag_id, mem32_t num)
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "sys_event_flag_cancel(id=%d) aborted", eflag_id); LOG_WARNING(HLE, "sys_event_flag_cancel(id=%d) aborted", eflag_id);
return CELL_OK; return CELL_OK;
} }

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

@ -126,7 +126,7 @@ int cellFsOpen(u32 path_addr, int flags, mem32_t fd, mem32_t arg, u64 size)
} }
fd = sys_fs->GetNewId(stream, IDFlag_File); fd = sys_fs->GetNewId(stream, IDFlag_File);
LOGF_WARNING(HLE, "*** cellFsOpen(path=\"%s\"): fd = %d", path.c_str(), fd.GetValue()); LOG_WARNING(HLE, "*** cellFsOpen(path=\"%s\"): fd = %d", path.c_str(), fd.GetValue());
return CELL_OK; return CELL_OK;
} }

8
rpcs3/Emu/SysCalls/lv2/SC_Lwcond.cpp
View file

@ -95,7 +95,7 @@ int sys_lwcond_signal(mem_ptr_t<sys_lwcond_t> lwcond)
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "sys_lwcond_signal(id=%d) aborted", (u32)lwcond->lwcond_queue); LOG_WARNING(HLE, "sys_lwcond_signal(id=%d) aborted", (u32)lwcond->lwcond_queue);
return CELL_OK; return CELL_OK;
} }
} }
@ -126,7 +126,7 @@ int sys_lwcond_signal_all(mem_ptr_t<sys_lwcond_t> lwcond)
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "sys_lwcond_signal_all(id=%d) aborted", (u32)lwcond->lwcond_queue); LOG_WARNING(HLE, "sys_lwcond_signal_all(id=%d) aborted", (u32)lwcond->lwcond_queue);
return CELL_OK; return CELL_OK;
} }
} }
@ -165,7 +165,7 @@ int sys_lwcond_signal_to(mem_ptr_t<sys_lwcond_t> lwcond, u32 ppu_thread_id)
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "sys_lwcond_signal_to(id=%d, to=%d) aborted", (u32)lwcond->lwcond_queue, ppu_thread_id); LOG_WARNING(HLE, "sys_lwcond_signal_to(id=%d, to=%d) aborted", (u32)lwcond->lwcond_queue, ppu_thread_id);
return CELL_OK; return CELL_OK;
} }
} }
@ -260,6 +260,6 @@ int sys_lwcond_wait(mem_ptr_t<sys_lwcond_t> lwcond, u64 timeout)
} }
abort: abort:
LOGF_WARNING(HLE, "sys_lwcond_wait(id=%d) aborted", (u32)lwcond->lwcond_queue); LOG_WARNING(HLE, "sys_lwcond_wait(id=%d) aborted", (u32)lwcond->lwcond_queue);
return CELL_OK; return CELL_OK;
} }

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

@ -251,7 +251,7 @@ int sys_lwmutex_t::trylock(be_t<u32> tid)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "(hack) sys_lwmutex_t::(try)lock aborted (waiting for recursive attribute, attr=0x%x)", (u32)attribute); LOG_WARNING(HLE, "(hack) sys_lwmutex_t::(try)lock aborted (waiting for recursive attribute, attr=0x%x)", (u32)attribute);
return CELL_ESRCH; return CELL_ESRCH;
} }
Sleep(1); Sleep(1);
@ -340,7 +340,7 @@ int sys_lwmutex_t::lock(be_t<u32> tid, u64 timeout)
case SMR_TIMEOUT: case SMR_TIMEOUT:
sq->invalidate(tid); return CELL_ETIMEDOUT; sq->invalidate(tid); return CELL_ETIMEDOUT;
case SMR_ABORT: case SMR_ABORT:
if (Emu.IsStopped()) LOGF_WARNING(HLE, "sys_lwmutex_t::lock(sq=%d) aborted", (u32)sleep_queue); if (Emu.IsStopped()) LOG_WARNING(HLE, "sys_lwmutex_t::lock(sq=%d) aborted", (u32)sleep_queue);
default: default:
sq->invalidate(tid); return CELL_EINVAL; sq->invalidate(tid); return CELL_EINVAL;
} }

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

@ -39,14 +39,14 @@ struct Mutex
{ {
if (u32 owner = m_mutex.GetOwner()) if (u32 owner = m_mutex.GetOwner())
{ {
LOGF_NOTICE(HLE, "Mutex(%d) was owned by thread %d (recursive=%d)", id, owner, recursive); LOG_NOTICE(HLE, "Mutex(%d) was owned by thread %d (recursive=%d)", id, owner, recursive);
} }
if (!m_queue.m_mutex.try_lock()) return; if (!m_queue.m_mutex.try_lock()) return;
for (u32 i = 0; i < m_queue.list.size(); i++) for (u32 i = 0; i < m_queue.list.size(); i++)
{ {
if (u32 owner = m_queue.list[i]) LOGF_NOTICE(HLE, "Mutex(%d) was waited by thread %d", id, owner); if (u32 owner = m_queue.list[i]) LOG_NOTICE(HLE, "Mutex(%d) was waited by thread %d", id, owner);
} }
m_queue.m_mutex.unlock(); m_queue.m_mutex.unlock();

6
rpcs3/Emu/SysCalls/lv2/SC_PPU_Thread.cpp
View file

@ -32,7 +32,7 @@ void sys_ppu_thread_exit(u64 errorcode)
if (thr.owned_mutexes) if (thr.owned_mutexes)
{ {
LOGF_ERROR(PPU, "Owned mutexes found (%d)", thr.owned_mutexes); LOG_ERROR(PPU, "Owned mutexes found (%d)", thr.owned_mutexes);
thr.owned_mutexes = 0; thr.owned_mutexes = 0;
} }
@ -58,7 +58,7 @@ int sys_ppu_thread_join(u64 thread_id, mem64_t vptr)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(PPU, "sys_ppu_thread_join(%d) aborted", thread_id); LOG_WARNING(PPU, "sys_ppu_thread_join(%d) aborted", thread_id);
return CELL_OK; return CELL_OK;
} }
Sleep(1); Sleep(1);
@ -204,7 +204,7 @@ int sys_ppu_thread_create(mem64_t thread_id, u32 entry, u64 arg, int prio, u32 s
new_thread.m_is_interrupt = is_interrupt; new_thread.m_is_interrupt = is_interrupt;
new_thread.SetName(threadname); new_thread.SetName(threadname);
LOGF_NOTICE(PPU, "*** New PPU Thread [%s] (flags=0x%llx, entry=0x%x): id = %d", new_thread.GetName().c_str(), flags, entry, new_thread.GetId()); LOG_NOTICE(PPU, "*** New PPU Thread [%s] (flags=0x%llx, entry=0x%x): id = %d", new_thread.GetName().c_str(), flags, entry, new_thread.GetId());
if (!is_interrupt) if (!is_interrupt)
{ {

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

@ -69,7 +69,7 @@ int sys_rwlock_rlock(u32 rw_lock_id, u64 timeout)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "sys_rwlock_rlock(rw_lock_id=%d, ...) aborted", rw_lock_id); LOG_WARNING(HLE, "sys_rwlock_rlock(rw_lock_id=%d, ...) aborted", rw_lock_id);
return CELL_ETIMEDOUT; return CELL_ETIMEDOUT;
} }
Sleep(1); Sleep(1);
@ -132,7 +132,7 @@ int sys_rwlock_wlock(u32 rw_lock_id, u64 timeout)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "sys_rwlock_wlock(rw_lock_id=%d, ...) aborted", rw_lock_id); LOG_WARNING(HLE, "sys_rwlock_wlock(rw_lock_id=%d, ...) aborted", rw_lock_id);
return CELL_ETIMEDOUT; return CELL_ETIMEDOUT;
} }
Sleep(1); Sleep(1);

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

@ -346,7 +346,7 @@ int sys_spu_thread_group_join(u32 id, mem32_t cause, mem32_t status)
} }
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(Log::SPU, "sys_spu_thread_group_join(id=%d, ...) aborted", id); LOG_WARNING(Log::SPU, "sys_spu_thread_group_join(id=%d, ...) aborted", id);
return CELL_OK; return CELL_OK;
} }
Sleep(1); Sleep(1);

6
rpcs3/Emu/SysCalls/lv2/SC_Semaphore.cpp
View file

@ -39,7 +39,7 @@ int sys_semaphore_create(mem32_t sem, mem_ptr_t<sys_semaphore_attribute> attr, i
} }
sem = sys_sem.GetNewId(new Semaphore(initial_count, max_count, attr->protocol, attr->name_u64)); sem = sys_sem.GetNewId(new Semaphore(initial_count, max_count, attr->protocol, attr->name_u64));
LOGF_NOTICE(HLE, "*** semaphore created [%s] (protocol=0x%x): id = %d", LOG_NOTICE(HLE, "*** semaphore created [%s] (protocol=0x%x): id = %d",
std::string(attr->name, 8).c_str(), (u32)attr->protocol, sem.GetValue()); std::string(attr->name, 8).c_str(), (u32)attr->protocol, sem.GetValue());
return CELL_OK; return CELL_OK;
@ -91,7 +91,7 @@ int sys_semaphore_wait(u32 sem_id, u64 timeout)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "sys_semaphore_wait(%d) aborted", sem_id); LOG_WARNING(HLE, "sys_semaphore_wait(%d) aborted", sem_id);
return CELL_OK; return CELL_OK;
} }
@ -165,7 +165,7 @@ int sys_semaphore_post(u32 sem_id, int count)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
LOGF_WARNING(HLE, "sys_semaphore_post(%d) aborted", sem_id); LOG_WARNING(HLE, "sys_semaphore_post(%d) aborted", sem_id);
return CELL_OK; return CELL_OK;
} }

8
rpcs3/Emu/SysCalls/lv2/SC_Spinlock.cpp
View file

@ -22,8 +22,8 @@ void sys_spinlock_lock(mem_ptr_t<spinlock> lock)
be_t<u32> tid = GetCurrentPPUThread().GetId(); be_t<u32> tid = GetCurrentPPUThread().GetId();
switch (lock->mutex.lock(tid)) switch (lock->mutex.lock(tid))
{ {
case SMR_ABORT: LOGF_WARNING(HLE, "sys_spinlock_lock(0x%x) aborted", lock.GetAddr()); break; case SMR_ABORT: LOG_WARNING(HLE, "sys_spinlock_lock(0x%x) aborted", lock.GetAddr()); break;
case SMR_DEADLOCK: LOGF_ERROR(HLE, "sys_spinlock_lock(0x%x) reached deadlock", lock.GetAddr()); break; // ??? case SMR_DEADLOCK: LOG_ERROR(HLE, "sys_spinlock_lock(0x%x) reached deadlock", lock.GetAddr()); break; // ???
default: break; default: break;
} }
} }
@ -36,8 +36,8 @@ int sys_spinlock_trylock(mem_ptr_t<spinlock> lock)
switch (lock->mutex.trylock(tid)) switch (lock->mutex.trylock(tid))
{ {
case SMR_FAILED: return CELL_EBUSY; case SMR_FAILED: return CELL_EBUSY;
case SMR_ABORT: LOGF_WARNING(HLE, "sys_spinlock_trylock(0x%x) aborted", lock.GetAddr()); break; case SMR_ABORT: LOG_WARNING(HLE, "sys_spinlock_trylock(0x%x) aborted", lock.GetAddr()); break;
case SMR_DEADLOCK: LOGF_ERROR(HLE, "sys_spinlock_trylock(0x%x) reached deadlock", lock.GetAddr()); break; case SMR_DEADLOCK: LOG_ERROR(HLE, "sys_spinlock_trylock(0x%x) reached deadlock", lock.GetAddr()); break;
default: break; default: break;
} }

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

@ -7,7 +7,7 @@
int sys_tty_read(u32 ch, u64 buf_addr, u32 len, u64 preadlen_addr) int sys_tty_read(u32 ch, u64 buf_addr, u32 len, u64 preadlen_addr)
{ {
//we currently do not support reading from the Console //we currently do not support reading from the Console
LOGF_WARNING(HLE, "sys_tty_read: ch: %d, buf addr: %llx, len: %d", ch, buf_addr, len); LOG_WARNING(HLE, "sys_tty_read: ch: %d, buf addr: %llx, len: %d", ch, buf_addr, len);
Memory.Write32NN(preadlen_addr, len); Memory.Write32NN(preadlen_addr, len);
Emu.Pause(); Emu.Pause();

14
rpcs3/Emu/System.cpp
View file

@ -153,7 +153,7 @@ void Emulator::Load()
m_path = elf_path; m_path = elf_path;
} }
LOGF_NOTICE(LOADER, "Loading '%s'...", m_path.c_str()); LOG_NOTICE(LOADER, "Loading '%s'...", m_path.c_str());
GetInfo().Reset(); GetInfo().Reset();
m_vfs.Init(m_path); m_vfs.Init(m_path);
@ -161,7 +161,7 @@ void Emulator::Load()
LOG_NOTICE(LOADER, "Mount info:"); LOG_NOTICE(LOADER, "Mount info:");
for(uint i=0; i<m_vfs.m_devices.size(); ++i) for(uint i=0; i<m_vfs.m_devices.size(); ++i)
{ {
LOGF_NOTICE(LOADER, "%s -> %s", m_vfs.m_devices[i]->GetPs3Path().c_str(), m_vfs.m_devices[i]->GetLocalPath().c_str()); LOG_NOTICE(LOADER, "%s -> %s", m_vfs.m_devices[i]->GetPs3Path().c_str(), m_vfs.m_devices[i]->GetLocalPath().c_str());
} }
LOG_NOTICE(LOADER, " ");//used to be skip_line LOG_NOTICE(LOADER, " ");//used to be skip_line
@ -174,7 +174,7 @@ void Emulator::Load()
if(!f.IsOpened()) if(!f.IsOpened())
{ {
LOGF_ERROR(LOADER, "Elf not found! (%s - %s)", m_path.c_str(), m_elf_path.c_str()); LOG_ERROR(LOADER, "Elf not found! (%s - %s)", m_path.c_str(), m_elf_path.c_str());
return; return;
} }
@ -247,8 +247,8 @@ void Emulator::Load()
switch(l.GetMachine()) switch(l.GetMachine())
{ {
case MACHINE_SPU: case MACHINE_SPU:
LOGF_NOTICE(LOADER, "offset = 0x%llx", Memory.MainMem.GetStartAddr()); LOG_NOTICE(LOADER, "offset = 0x%llx", Memory.MainMem.GetStartAddr());
LOGF_NOTICE(LOADER, "max addr = 0x%x", l.GetMaxAddr()); LOG_NOTICE(LOADER, "max addr = 0x%x", l.GetMaxAddr());
thread.SetOffset(Memory.MainMem.GetStartAddr()); thread.SetOffset(Memory.MainMem.GetStartAddr());
Memory.MainMem.AllocFixed(Memory.MainMem.GetStartAddr() + l.GetMaxAddr(), 0xFFFFED - l.GetMaxAddr()); Memory.MainMem.AllocFixed(Memory.MainMem.GetStartAddr() + l.GetMaxAddr(), 0xFFFFED - l.GetMaxAddr());
thread.SetEntry(l.GetEntry() - Memory.MainMem.GetStartAddr()); thread.SetEntry(l.GetEntry() - Memory.MainMem.GetStartAddr());
@ -375,7 +375,7 @@ void Emulator::Stop()
Sleep(1); Sleep(1);
if (counter++ > 3000) if (counter++ > 3000)
{ {
LOGF_ERROR(HLE, "%d threads not stopped (timeout)", (u32)(g_thread_count - uncounted)); LOG_ERROR(HLE, "%d threads not stopped (timeout)", (u32)(g_thread_count - uncounted));
break; break;
} }
} }
@ -448,7 +448,7 @@ void Emulator::LoadPoints(const std::string& path)
if(version != bpdb_version || if(version != bpdb_version ||
(sizeof(u16) + break_count * sizeof(u64) + sizeof(u32) + marked_count * sizeof(u64) + sizeof(u32)) != length) (sizeof(u16) + break_count * sizeof(u64) + sizeof(u32) + marked_count * sizeof(u64) + sizeof(u32)) != length)
{ {
LOGF_ERROR(LOADER, "'%s' is broken", path.c_str()); LOG_ERROR(LOADER, "'%s' is broken", path.c_str());
return; return;
} }

16
rpcs3/Gui/DisAsmFrame.cpp
View file

@ -152,7 +152,7 @@ public:
virtual void Task() virtual void Task()
{ {
LOGF_NOTICE(HLE, "Start dump in thread %d!", (int)id); LOG_NOTICE(HLE, "Start dump in thread %d!", (int)id);
const u32 max_value = prog_dial->GetMaxValue(id); const u32 max_value = prog_dial->GetMaxValue(id);
const u32 shdr_count = ElfType64 ? shdr_arr_64->size() : shdr_arr_32->size(); const u32 shdr_count = ElfType64 ? shdr_arr_64->size() : shdr_arr_32->size();
@ -180,14 +180,14 @@ public:
} }
} }
LOGF_NOTICE(HLE, "Finish dump in thread %d!", (int)id); LOG_NOTICE(HLE, "Finish dump in thread %d!", (int)id);
*done = true; *done = true;
} }
void OnExit() void OnExit()
{ {
LOGF_NOTICE(HLE, "CleanUp dump thread (%d)!", (int)id); LOG_NOTICE(HLE, "CleanUp dump thread (%d)!", (int)id);
safe_delete(decoder); safe_delete(decoder);
} }
}; };
@ -223,7 +223,7 @@ struct WaitDumperThread : public ThreadBase
while(done[i] == false) Sleep(1); while(done[i] == false) Sleep(1);
} }
LOGF_NOTICE(HLE, "Saving dump is started!"); LOG_NOTICE(HLE, "Saving dump is started!");
const uint length_for_core = prog_dial.GetMaxValue(0); const uint length_for_core = prog_dial.GetMaxValue(0);
const uint length = length_for_core * cores; const uint length = length_for_core * cores;
prog_dial.Close(); prog_dial.Close();
@ -266,7 +266,7 @@ struct WaitDumperThread : public ThreadBase
fd.Write(wxString::Format("End of section header %d\n\n", sh)); fd.Write(wxString::Format("End of section header %d\n\n", sh));
} }
LOGF_NOTICE(HLE, "CleanUp dump saving!"); LOG_NOTICE(HLE, "CleanUp dump saving!");
for(uint c=0; c<cores; ++c) for(uint c=0; c<cores; ++c)
{ {
@ -298,13 +298,13 @@ void DisAsmFrame::Dump(wxCommandEvent& WXUNUSED(event))
vfsLocalFile& f_elf = *new vfsLocalFile(nullptr); vfsLocalFile& f_elf = *new vfsLocalFile(nullptr);
f_elf.Open(Emu.m_path); f_elf.Open(Emu.m_path);
LOGF_NOTICE(HLE, "path: %s", Emu.m_path.c_str()); LOG_NOTICE(HLE, "path: %s", Emu.m_path.c_str());
Elf_Ehdr ehdr; Elf_Ehdr ehdr;
ehdr.Load(f_elf); ehdr.Load(f_elf);
if(!ehdr.CheckMagic()) if(!ehdr.CheckMagic())
{ {
LOGF_ERROR(HLE, "Corrupted ELF!"); LOG_ERROR(HLE, "Corrupted ELF!");
return; return;
} }
std::vector<std::string> name_arr; std::vector<std::string> name_arr;
@ -338,7 +338,7 @@ void DisAsmFrame::Dump(wxCommandEvent& WXUNUSED(event))
if(l_elf32->shdr_arr.size() <= 0) return; if(l_elf32->shdr_arr.size() <= 0) return;
break; break;
default: LOGF_ERROR(HLE, "Corrupted ELF!"); return; default: LOG_ERROR(HLE, "Corrupted ELF!"); return;
} }
PPCDisAsm* disasm; PPCDisAsm* disasm;

2
rpcs3/Gui/FnIdGenerator.cpp
View file

@ -82,7 +82,7 @@ void FnIdGenerator::PrintId()
m_func_name.push_back(func_name); m_func_name.push_back(func_name);
m_func_id.push_back(result); m_func_id.push_back(result);
LOGF_NOTICE(HLE, "Function: %s, Id: 0x%08x ", func_name.c_str(), result); LOG_NOTICE(HLE, "Function: %s, Id: 0x%08x ", func_name.c_str(), result);
UpdateInformation(); UpdateInformation();
} }

6
rpcs3/Gui/GameViewer.cpp
View file

@ -39,7 +39,7 @@ public:
virtual wxDirTraverseResult OnFile(const wxString& filename) virtual wxDirTraverseResult OnFile(const wxString& filename)
{ {
if (!wxRemoveFile(filename)){ if (!wxRemoveFile(filename)){
LOGF_ERROR(HLE, "Couldn't delete File: %s", fmt::ToUTF8(filename).c_str()); LOG_ERROR(HLE, "Couldn't delete File: %s", fmt::ToUTF8(filename).c_str());
} }
return wxDIR_CONTINUE; return wxDIR_CONTINUE;
} }
@ -103,7 +103,7 @@ void GameViewer::OnColClick(wxListEvent& event)
void GameViewer::LoadGames() void GameViewer::LoadGames()
{ {
vfsDir dir(m_path); vfsDir dir(m_path);
LOGF_NOTICE(HLE, "path: %s", m_path.c_str()); LOG_NOTICE(HLE, "path: %s", m_path.c_str());
if(!dir.IsOpened()) return; if(!dir.IsOpened()) return;
m_games.clear(); m_games.clear();
@ -207,7 +207,7 @@ void GameViewer::DClick(wxListEvent& event)
std::string local_path; std::string local_path;
if(Emu.GetVFS().GetDevice(path, local_path) && !Emu.BootGame(local_path)) if(Emu.GetVFS().GetDevice(path, local_path) && !Emu.BootGame(local_path))
{ {
LOGF_ERROR(HLE, "Boot error: elf not found! [%s]", path.c_str()); LOG_ERROR(HLE, "Boot error: elf not found! [%s]", path.c_str());
return; return;
} }
Emu.Run(); Emu.Run();

6
rpcs3/Gui/GameViewer.h
View file

@ -134,7 +134,7 @@ public:
if(!col) if(!col)
{ {
LOGF_ERROR(HLE, "Columns loaded with error!"); LOG_ERROR(HLE, "Columns loaded with error!");
return; return;
} }
@ -191,7 +191,7 @@ public:
{ {
if(m_columns[c1].pos == m_columns[c2].pos) if(m_columns[c1].pos == m_columns[c2].pos)
{ {
LOGF_ERROR(HLE, "Columns loaded with error!"); LOG_ERROR(HLE, "Columns loaded with error!");
Init(); Init();
return; return;
} }
@ -210,7 +210,7 @@ public:
if(!ishas) if(!ishas)
{ {
LOGF_ERROR(HLE, "Columns loaded with error!"); LOG_ERROR(HLE, "Columns loaded with error!");
Init(); Init();
return; return;
} }

4
rpcs3/Gui/MainFrame.cpp
View file

@ -201,7 +201,7 @@ void MainFrame::BootGame(wxCommandEvent& WXUNUSED(event))
} }
else else
{ {
LOGF_ERROR(HLE, "PS3 executable not found in selected folder (%s)", ctrl.GetPath().wx_str()); LOG_ERROR(HLE, "PS3 executable not found in selected folder (%s)", ctrl.GetPath().wx_str());
} }
} }
@ -231,7 +231,7 @@ void MainFrame::BootGameAndRun(wxCommandEvent& WXUNUSED(event))
} }
else else
{ {
LOGF_ERROR(HLE, "PS3 executable not found in selected folder (%s)", ctrl.GetPath().wx_str()); LOG_ERROR(HLE, "PS3 executable not found in selected folder (%s)", ctrl.GetPath().wx_str());
} }
if (Emu.IsReady()) if (Emu.IsReady())

6
rpcs3/Gui/PADManager.cpp
View file

@ -289,7 +289,7 @@ void PADManager::OnKeyDown(wxKeyEvent &keyEvent)
case id_pad_rstick_up: Ini.PadHandlerRStickUp.SetValue(keyEvent.GetKeyCode()); break; case id_pad_rstick_up: Ini.PadHandlerRStickUp.SetValue(keyEvent.GetKeyCode()); break;
case 0: break; case 0: break;
default: LOGF_ERROR(HLE, "Unknown button ID: %d", m_button_id); break; default: LOG_ERROR(HLE, "Unknown button ID: %d", m_button_id); break;
} }
UpdateLabel(); UpdateLabel();
@ -323,7 +323,7 @@ void PADManager::OnButtonClicked(wxCommandEvent &event)
case wxID_OK: Ini.Save(); break; case wxID_OK: Ini.Save(); break;
case wxID_CANCEL: break; case wxID_CANCEL: break;
default: LOGF_ERROR(HLE, "Unknown button ID: %d", event.GetId()); break; default: LOG_ERROR(HLE, "Unknown button ID: %d", event.GetId()); break;
} }
} }
@ -509,7 +509,7 @@ void PADManager::UpdateTimerLabel(const u32 id)
case id_pad_rstick_right: b_right_rstick->SetLabel(static_cast<char>(m_seconds + 47)); break; case id_pad_rstick_right: b_right_rstick->SetLabel(static_cast<char>(m_seconds + 47)); break;
case id_pad_rstick_up: b_up_rstick->SetLabel(static_cast<char>(m_seconds + 47)); break; case id_pad_rstick_up: b_up_rstick->SetLabel(static_cast<char>(m_seconds + 47)); break;
default: LOGF_ERROR(HLE, "Unknown button ID: %d", id); break; default: LOG_ERROR(HLE, "Unknown button ID: %d", id); break;
} }
} }

2
rpcs3/Gui/Plugins.h
View file

@ -314,7 +314,7 @@ struct PluginsManager
for(u32 i=0; i<res.GetCount(); ++i) for(u32 i=0; i<res.GetCount(); ++i)
{ {
LOGF_NOTICE(HLE, "loading " + res[i] + "..."); LOG_NOTICE(HLE, "loading " + res[i] + "...");
Ps3EmuPlugin l(res[i]); Ps3EmuPlugin l(res[i]);
if(!l.Test()) continue; if(!l.Test()) continue;

4
rpcs3/Gui/VHDDManager.cpp
View file

@ -33,7 +33,7 @@ wxDragResult VHDDListDropTarget::OnData(wxCoord x, wxCoord y, wxDragResult def)
{ {
int flags = 0; int flags = 0;
int dst_indx = m_parent->HitTest(wxPoint(x, y), flags); int dst_indx = m_parent->HitTest(wxPoint(x, y), flags);
LOGF_NOTICE(HLE, "OnData(%d -> %d)", m_src_indx, dst_indx); LOG_NOTICE(HLE, "OnData(%d -> %d)", m_src_indx, dst_indx);
return def; return def;
} }
@ -189,7 +189,7 @@ void VHDDExplorer::OnDropFiles(wxDropFilesEvent& event)
for(int i=0; i<count; ++i) for(int i=0; i<count; ++i)
{ {
LOGF_NOTICE(HLE, "Importing '%s'", dropped[i].wx_str()); LOG_NOTICE(HLE, "Importing '%s'", dropped[i].wx_str());
Import(fmt::ToUTF8(dropped[i]), fmt::ToUTF8(wxFileName(dropped[i]).GetFullName())); Import(fmt::ToUTF8(dropped[i]), fmt::ToUTF8(wxFileName(dropped[i]).GetFullName()));
} }

22
rpcs3/Loader/ELF32.cpp
View file

@ -106,7 +106,7 @@ bool ELF32Loader::LoadEhdrInfo()
default: default:
machine = MACHINE_Unknown; machine = MACHINE_Unknown;
LOGF_ERROR(LOADER, "Unknown elf32 machine: 0x%x", ehdr.e_machine); LOG_ERROR(LOADER, "Unknown elf32 machine: 0x%x", ehdr.e_machine);
return false; return false;
} }
@ -149,7 +149,7 @@ bool ELF32Loader::LoadPhdrInfo()
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)
{ {
entry += phdr_arr[i].p_vaddr; entry += phdr_arr[i].p_vaddr;
LOGF_WARNING(LOADER, "virtual entry = 0x%x", entry); LOG_WARNING(LOADER, "virtual entry = 0x%x", entry);
break; break;
} }
} }
@ -226,7 +226,7 @@ bool ELF32Loader::LoadPhdrData(u64 _offset)
if(phdr_arr[i].p_vaddr != phdr_arr[i].p_paddr) if(phdr_arr[i].p_vaddr != phdr_arr[i].p_paddr)
{ {
LOGF_WARNING LOG_WARNING
( (
LOADER, LOADER,
"LoadPhdr32 different load addrs: paddr=0x%8.8x, vaddr=0x%8.8x", "LoadPhdr32 different load addrs: paddr=0x%8.8x, vaddr=0x%8.8x",
@ -256,19 +256,19 @@ bool ELF32Loader::LoadPhdrData(u64 _offset)
if(note.type != 1) if(note.type != 1)
{ {
LOGF_ERROR(LOADER, "ELF32: Bad NOTE type (%d)", note.type); LOG_ERROR(LOADER, "ELF32: Bad NOTE type (%d)", note.type);
break; break;
} }
if(note.namesz != sizeof(note.name)) if(note.namesz != sizeof(note.name))
{ {
LOGF_ERROR(LOADER, "ELF32: Bad NOTE namesz (%d)", note.namesz); LOG_ERROR(LOADER, "ELF32: Bad NOTE namesz (%d)", note.namesz);
break; break;
} }
if(note.descsz != sizeof(note.desc) && note.descsz != 32) if(note.descsz != sizeof(note.desc) && note.descsz != 32)
{ {
LOGF_ERROR(LOADER, "ELF32: Bad NOTE descsz (%d)", note.descsz); LOG_ERROR(LOADER, "ELF32: Bad NOTE descsz (%d)", note.descsz);
break; break;
} }
@ -280,13 +280,13 @@ bool ELF32Loader::LoadPhdrData(u64 _offset)
if(note.descsz == sizeof(note.desc)) if(note.descsz == sizeof(note.desc))
{ {
LOGF_WARNING(LOADER, "name = %s", std::string((const char *)note.name, 8).c_str()); LOG_WARNING(LOADER, "name = %s", std::string((const char *)note.name, 8).c_str());
LOGF_WARNING(LOADER, "ls_size = %d", note.desc.ls_size); LOG_WARNING(LOADER, "ls_size = %d", note.desc.ls_size);
LOGF_WARNING(LOADER, "stack_size = %d", note.desc.stack_size); LOG_WARNING(LOADER, "stack_size = %d", note.desc.stack_size);
} }
else else
{ {
LOGF_WARNING(LOADER, "desc = '%s'", std::string(note.desc_text, 32).c_str()); LOG_WARNING(LOADER, "desc = '%s'", std::string(note.desc_text, 32).c_str());
} }
} }
#ifdef LOADER_DEBUG #ifdef LOADER_DEBUG
@ -304,7 +304,7 @@ bool ELF32Loader::LoadShdrData(u64 offset)
Elf32_Shdr& shdr = shdr_arr[i]; Elf32_Shdr& shdr = shdr_arr[i];
#ifdef LOADER_DEBUG #ifdef LOADER_DEBUG
if(i < shdr_name_arr.size()) LOGF_NOTICE(LOADER, "Name: %s", shdr_name_arr[i].c_str()); if(i < shdr_name_arr.size()) LOG_NOTICE(LOADER, "Name: %s", shdr_name_arr[i].c_str());
shdr.Show(); shdr.Show();
LOG_NOTICE(LOADER, ""); LOG_NOTICE(LOADER, "");
#endif #endif

74
rpcs3/Loader/ELF32.h
View file

@ -26,25 +26,25 @@ struct Elf32_Ehdr
void Show() void Show()
{ {
#ifdef LOADER_DEBUG #ifdef LOADER_DEBUG
LOGF_NOTICE(LOADER, "Magic: %08x", e_magic); LOG_NOTICE(LOADER, "Magic: %08x", e_magic);
LOGF_NOTICE(LOADER, "Class: %s", "ELF32"); LOG_NOTICE(LOADER, "Class: %s", "ELF32");
LOGF_NOTICE(LOADER, "Data: %s", Ehdr_DataToString(e_data).c_str()); LOG_NOTICE(LOADER, "Data: %s", Ehdr_DataToString(e_data).c_str());
LOGF_NOTICE(LOADER, "Current Version: %d", e_curver); LOG_NOTICE(LOADER, "Current Version: %d", e_curver);
LOGF_NOTICE(LOADER, "OS/ABI: %s", Ehdr_OS_ABIToString(e_os_abi).c_str()); LOG_NOTICE(LOADER, "OS/ABI: %s", Ehdr_OS_ABIToString(e_os_abi).c_str());
LOGF_NOTICE(LOADER, "ABI version: %lld", e_abi_ver); LOG_NOTICE(LOADER, "ABI version: %lld", e_abi_ver);
LOGF_NOTICE(LOADER, "Type: %s", Ehdr_TypeToString(e_type).c_str()); LOG_NOTICE(LOADER, "Type: %s", Ehdr_TypeToString(e_type).c_str());
LOGF_NOTICE(LOADER, "Machine: %s", Ehdr_MachineToString(e_machine).c_str()); LOG_NOTICE(LOADER, "Machine: %s", Ehdr_MachineToString(e_machine).c_str());
LOGF_NOTICE(LOADER, "Version: %d", e_version); LOG_NOTICE(LOADER, "Version: %d", e_version);
LOGF_NOTICE(LOADER, "Entry point address: 0x%x", e_entry); LOG_NOTICE(LOADER, "Entry point address: 0x%x", e_entry);
LOGF_NOTICE(LOADER, "Program headers offset: 0x%08x", e_phoff); LOG_NOTICE(LOADER, "Program headers offset: 0x%08x", e_phoff);
LOGF_NOTICE(LOADER, "Section headers offset: 0x%08x", e_shoff); LOG_NOTICE(LOADER, "Section headers offset: 0x%08x", e_shoff);
LOGF_NOTICE(LOADER, "Flags: 0x%x", e_flags); LOG_NOTICE(LOADER, "Flags: 0x%x", e_flags);
LOGF_NOTICE(LOADER, "Size of this header: %d", e_ehsize); LOG_NOTICE(LOADER, "Size of this header: %d", e_ehsize);
LOGF_NOTICE(LOADER, "Size of program headers: %d", e_phentsize); LOG_NOTICE(LOADER, "Size of program headers: %d", e_phentsize);
LOGF_NOTICE(LOADER, "Number of program headers: %d", e_phnum); LOG_NOTICE(LOADER, "Number of program headers: %d", e_phnum);
LOGF_NOTICE(LOADER, "Size of section headers: %d", e_shentsize); LOG_NOTICE(LOADER, "Size of section headers: %d", e_shentsize);
LOGF_NOTICE(LOADER, "Number of section headers: %d", e_shnum); LOG_NOTICE(LOADER, "Number of section headers: %d", e_shnum);
LOGF_NOTICE(LOADER, "Section header string table index: %d", e_shstrndx); LOG_NOTICE(LOADER, "Section header string table index: %d", e_shstrndx);
#endif #endif
} }
@ -216,16 +216,16 @@ struct Elf32_Shdr
void Show() void Show()
{ {
#ifdef LOADER_DEBUG #ifdef LOADER_DEBUG
LOGF_NOTICE(LOADER, "Name offset: %x", sh_name); LOG_NOTICE(LOADER, "Name offset: %x", sh_name);
LOGF_NOTICE(LOADER, "Type: %d", sh_type); LOG_NOTICE(LOADER, "Type: %d", sh_type);
LOGF_NOTICE(LOADER, "Addr: %x", sh_addr); LOG_NOTICE(LOADER, "Addr: %x", sh_addr);
LOGF_NOTICE(LOADER, "Offset: %x", sh_offset); LOG_NOTICE(LOADER, "Offset: %x", sh_offset);
LOGF_NOTICE(LOADER, "Size: %x", sh_size); LOG_NOTICE(LOADER, "Size: %x", sh_size);
LOGF_NOTICE(LOADER, "EntSize: %d", sh_entsize); LOG_NOTICE(LOADER, "EntSize: %d", sh_entsize);
LOGF_NOTICE(LOADER, "Flags: %x", sh_flags); LOG_NOTICE(LOADER, "Flags: %x", sh_flags);
LOGF_NOTICE(LOADER, "Link: %x", sh_link); LOG_NOTICE(LOADER, "Link: %x", sh_link);
LOGF_NOTICE(LOADER, "Info: %d", sh_info); LOG_NOTICE(LOADER, "Info: %d", sh_info);
LOGF_NOTICE(LOADER, "Address align: %x", sh_addralign); LOG_NOTICE(LOADER, "Address align: %x", sh_addralign);
#endif #endif
} }
}; };
@ -268,14 +268,14 @@ struct Elf32_Phdr
void Show() void Show()
{ {
#ifdef LOADER_DEBUG #ifdef LOADER_DEBUG
LOGF_NOTICE(LOADER, "Type: %s", Phdr_TypeToString(p_type).c_str()); LOG_NOTICE(LOADER, "Type: %s", Phdr_TypeToString(p_type).c_str());
LOGF_NOTICE(LOADER, "Offset: 0x%08x", p_offset); LOG_NOTICE(LOADER, "Offset: 0x%08x", p_offset);
LOGF_NOTICE(LOADER, "Virtual address: 0x%08x", p_vaddr); LOG_NOTICE(LOADER, "Virtual address: 0x%08x", p_vaddr);
LOGF_NOTICE(LOADER, "Physical address: 0x%08x", p_paddr); LOG_NOTICE(LOADER, "Physical address: 0x%08x", p_paddr);
LOGF_NOTICE(LOADER, "File size: 0x%08x", p_filesz); LOG_NOTICE(LOADER, "File size: 0x%08x", p_filesz);
LOGF_NOTICE(LOADER, "Memory size: 0x%08x", p_memsz); LOG_NOTICE(LOADER, "Memory size: 0x%08x", p_memsz);
LOGF_NOTICE(LOADER, "Flags: %s", Phdr_FlagsToString(p_flags).c_str()); LOG_NOTICE(LOADER, "Flags: %s", Phdr_FlagsToString(p_flags).c_str());
LOGF_NOTICE(LOADER, "Align: 0x%x", p_align); LOG_NOTICE(LOADER, "Align: 0x%x", p_align);
#endif #endif
} }
}; };

74
rpcs3/Loader/ELF64.cpp
View file

@ -104,13 +104,13 @@ bool ELF64Loader::LoadEhdrInfo(s64 offset)
if(ehdr.e_phentsize != sizeof(Elf64_Phdr)) if(ehdr.e_phentsize != sizeof(Elf64_Phdr))
{ {
LOGF_ERROR(LOADER, "elf64 error: e_phentsize[0x%x] != sizeof(Elf64_Phdr)[0x%x]", ehdr.e_phentsize, sizeof(Elf64_Phdr)); LOG_ERROR(LOADER, "elf64 error: e_phentsize[0x%x] != sizeof(Elf64_Phdr)[0x%x]", ehdr.e_phentsize, sizeof(Elf64_Phdr));
return false; return false;
} }
if(ehdr.e_shentsize != sizeof(Elf64_Shdr)) if(ehdr.e_shentsize != sizeof(Elf64_Shdr))
{ {
LOGF_ERROR(LOADER, "elf64 error: e_shentsize[0x%x] != sizeof(Elf64_Shdr)[0x%x]", ehdr.e_shentsize, sizeof(Elf64_Shdr)); LOG_ERROR(LOADER, "elf64 error: e_shentsize[0x%x] != sizeof(Elf64_Shdr)[0x%x]", ehdr.e_shentsize, sizeof(Elf64_Shdr));
return false; return false;
} }
@ -123,7 +123,7 @@ bool ELF64Loader::LoadEhdrInfo(s64 offset)
default: default:
machine = MACHINE_Unknown; machine = MACHINE_Unknown;
LOGF_ERROR(LOADER, "Unknown elf64 type: 0x%x", ehdr.e_machine); LOG_ERROR(LOADER, "Unknown elf64 type: 0x%x", ehdr.e_machine);
return false; return false;
} }
@ -226,7 +226,7 @@ bool ELF64Loader::LoadPhdrData(u64 offset)
if(phdr_arr[i].p_vaddr != phdr_arr[i].p_paddr) if(phdr_arr[i].p_vaddr != phdr_arr[i].p_paddr)
{ {
LOGF_WARNING LOG_WARNING
( (
LOADER, LOADER,
"ElfProgram different load addrs: paddr=0x%8.8x, vaddr=0x%8.8x", "ElfProgram different load addrs: paddr=0x%8.8x, vaddr=0x%8.8x",
@ -271,12 +271,12 @@ bool ELF64Loader::LoadPhdrData(u64 offset)
if(re(proc_param.size) < sizeof(sys_process_param)) if(re(proc_param.size) < sizeof(sys_process_param))
{ {
LOGF_WARNING(LOADER, "Bad proc param size! [0x%x : 0x%x]", re(proc_param.size), sizeof(sys_process_param)); LOG_WARNING(LOADER, "Bad proc param size! [0x%x : 0x%x]", re(proc_param.size), sizeof(sys_process_param));
} }
if(re(proc_param.magic) != 0x13bcc5f6) if(re(proc_param.magic) != 0x13bcc5f6)
{ {
LOGF_ERROR(LOADER, "Bad magic! [0x%x]", Memory.Reverse32(proc_param.magic)); LOG_ERROR(LOADER, "Bad magic! [0x%x]", Memory.Reverse32(proc_param.magic));
} }
else else
{ {
@ -288,12 +288,12 @@ bool ELF64Loader::LoadPhdrData(u64 offset)
info.ppc_seg = re(proc_param.info.ppc_seg); info.ppc_seg = re(proc_param.info.ppc_seg);
//info.crash_dump_param_addr = re(proc_param.info.crash_dump_param_addr); //info.crash_dump_param_addr = re(proc_param.info.crash_dump_param_addr);
#ifdef LOADER_DEBUG #ifdef LOADER_DEBUG
LOGF_NOTICE(LOADER, "*** sdk version: 0x%x", info.sdk_version); LOG_NOTICE(LOADER, "*** sdk version: 0x%x", info.sdk_version);
LOGF_NOTICE(LOADER, "*** primary prio: %d", info.primary_prio); LOG_NOTICE(LOADER, "*** primary prio: %d", info.primary_prio);
LOGF_NOTICE(LOADER, "*** primary stacksize: 0x%x", info.primary_stacksize); LOG_NOTICE(LOADER, "*** primary stacksize: 0x%x", info.primary_stacksize);
LOGF_NOTICE(LOADER, "*** malloc pagesize: 0x%x", info.malloc_pagesize); LOG_NOTICE(LOADER, "*** malloc pagesize: 0x%x", info.malloc_pagesize);
LOGF_NOTICE(LOADER, "*** ppc seg: 0x%x", info.ppc_seg); LOG_NOTICE(LOADER, "*** ppc seg: 0x%x", info.ppc_seg);
//LOGF_NOTICE(LOADER, "*** crash dump param addr: 0x%x", info.crash_dump_param_addr); //LOG_NOTICE(LOADER, "*** crash dump param addr: 0x%x", info.crash_dump_param_addr);
#endif #endif
} }
} }
@ -315,19 +315,19 @@ bool ELF64Loader::LoadPhdrData(u64 offset)
proc_prx_param.ver = re(proc_prx_param.ver); proc_prx_param.ver = re(proc_prx_param.ver);
#ifdef LOADER_DEBUG #ifdef LOADER_DEBUG
LOGF_NOTICE(LOADER, "*** size: 0x%x", proc_prx_param.size); LOG_NOTICE(LOADER, "*** size: 0x%x", proc_prx_param.size);
LOGF_NOTICE(LOADER, "*** magic: 0x%x", proc_prx_param.magic); LOG_NOTICE(LOADER, "*** magic: 0x%x", proc_prx_param.magic);
LOGF_NOTICE(LOADER, "*** version: 0x%x", proc_prx_param.version); LOG_NOTICE(LOADER, "*** version: 0x%x", proc_prx_param.version);
LOGF_NOTICE(LOADER, "*** libentstart: 0x%x", proc_prx_param.libentstart); LOG_NOTICE(LOADER, "*** libentstart: 0x%x", proc_prx_param.libentstart);
LOGF_NOTICE(LOADER, "*** libentend: 0x%x", proc_prx_param.libentend); LOG_NOTICE(LOADER, "*** libentend: 0x%x", proc_prx_param.libentend);
LOGF_NOTICE(LOADER, "*** libstubstart: 0x%x", proc_prx_param.libstubstart); LOG_NOTICE(LOADER, "*** libstubstart: 0x%x", proc_prx_param.libstubstart);
LOGF_NOTICE(LOADER, "*** libstubend: 0x%x", proc_prx_param.libstubend); LOG_NOTICE(LOADER, "*** libstubend: 0x%x", proc_prx_param.libstubend);
LOGF_NOTICE(LOADER, "*** ver: 0x%x", proc_prx_param.ver); LOG_NOTICE(LOADER, "*** ver: 0x%x", proc_prx_param.ver);
#endif #endif
if(proc_prx_param.magic != 0x1b434cec) if(proc_prx_param.magic != 0x1b434cec)
{ {
LOGF_ERROR(LOADER, "Bad magic! (0x%x)", proc_prx_param.magic); LOG_ERROR(LOADER, "Bad magic! (0x%x)", proc_prx_param.magic);
} }
else else
{ {
@ -352,19 +352,19 @@ bool ELF64Loader::LoadPhdrData(u64 offset)
} }
else else
{ {
LOGF_WARNING(LOADER, "Unknown module '%s'", module_name.c_str()); LOG_WARNING(LOADER, "Unknown module '%s'", module_name.c_str());
} }
#ifdef LOADER_DEBUG #ifdef LOADER_DEBUG
LOG_NOTICE(LOADER, ""); LOG_NOTICE(LOADER, "");
LOGF_NOTICE(LOADER, "*** size: 0x%x", stub.s_size); LOG_NOTICE(LOADER, "*** size: 0x%x", stub.s_size);
LOGF_NOTICE(LOADER, "*** version: 0x%x", stub.s_version); LOG_NOTICE(LOADER, "*** version: 0x%x", stub.s_version);
LOGF_NOTICE(LOADER, "*** unk0: 0x%x", stub.s_unk0); LOG_NOTICE(LOADER, "*** unk0: 0x%x", stub.s_unk0);
LOGF_NOTICE(LOADER, "*** unk1: 0x%x", stub.s_unk1); LOG_NOTICE(LOADER, "*** unk1: 0x%x", stub.s_unk1);
LOGF_NOTICE(LOADER, "*** imports: %d", stub.s_imports); LOG_NOTICE(LOADER, "*** imports: %d", stub.s_imports);
LOGF_NOTICE(LOADER, "*** module name: %s [0x%x]", module_name.c_str(), stub.s_modulename); LOG_NOTICE(LOADER, "*** module name: %s [0x%x]", module_name.c_str(), stub.s_modulename);
LOGF_NOTICE(LOADER, "*** nid: 0x%x", stub.s_nid); LOG_NOTICE(LOADER, "*** nid: 0x%x", stub.s_nid);
LOGF_NOTICE(LOADER, "*** text: 0x%x", stub.s_text); LOG_NOTICE(LOADER, "*** text: 0x%x", stub.s_text);
#endif #endif
static const u32 section = 4 * 3; static const u32 section = 4 * 3;
u64 tbl = Memory.MainMem.AllocAlign(stub.s_imports * 4 * 2); u64 tbl = Memory.MainMem.AllocAlign(stub.s_imports * 4 * 2);
@ -379,13 +379,13 @@ bool ELF64Loader::LoadPhdrData(u64 offset)
{ {
if(!module->Load(nid)) if(!module->Load(nid))
{ {
LOGF_WARNING(LOADER, "Unimplemented function '%s' in '%s' module", SysCalls::GetHLEFuncName(nid).c_str(), module_name.c_str()); LOG_WARNING(LOADER, "Unimplemented function '%s' in '%s' module", SysCalls::GetHLEFuncName(nid).c_str(), module_name.c_str());
} }
} }
#ifdef LOADER_DEBUG #ifdef LOADER_DEBUG
LOGF_NOTICE(LOADER, "import %d:", i+1); LOG_NOTICE(LOADER, "import %d:", i+1);
LOGF_NOTICE(LOADER, "*** nid: 0x%x (0x%x)", nid, stub.s_nid + i*4); LOG_NOTICE(LOADER, "*** nid: 0x%x (0x%x)", nid, stub.s_nid + i*4);
LOGF_NOTICE(LOADER, "*** text: 0x%x (0x%x)", text, stub.s_text + i*4); LOG_NOTICE(LOADER, "*** text: 0x%x (0x%x)", text, stub.s_text + i*4);
#endif #endif
Memory.Write32(stub.s_text + i*4, tbl + i*8); Memory.Write32(stub.s_text + i*4, tbl + i*8);
@ -407,7 +407,7 @@ bool ELF64Loader::LoadPhdrData(u64 offset)
break; break;
} }
#ifdef LOADER_DEBUG #ifdef LOADER_DEBUG
LOGF_NOTICE(LOADER, " "); LOG_NOTICE(LOADER, " ");
#endif #endif
} }
@ -425,13 +425,13 @@ bool ELF64Loader::LoadShdrData(u64 offset)
if(i < shdr_name_arr.size()) if(i < shdr_name_arr.size())
{ {
#ifdef LOADER_DEBUG #ifdef LOADER_DEBUG
LOGF_NOTICE(LOADER, "Name: %s", shdr_name_arr[i].c_str()); LOG_NOTICE(LOADER, "Name: %s", shdr_name_arr[i].c_str());
#endif #endif
} }
#ifdef LOADER_DEBUG #ifdef LOADER_DEBUG
shdr.Show(); shdr.Show();
LOGF_NOTICE(LOADER, " "); LOG_NOTICE(LOADER, " ");
#endif #endif
if(shdr.sh_addr + shdr.sh_size > max_addr) max_addr = shdr.sh_addr + shdr.sh_size; if(shdr.sh_addr + shdr.sh_size > max_addr) max_addr = shdr.sh_addr + shdr.sh_size;

74
rpcs3/Loader/ELF64.h
View file

@ -49,25 +49,25 @@ struct Elf64_Ehdr
void Show() void Show()
{ {
#ifdef LOADER_DEBUG #ifdef LOADER_DEBUG
LOGF_NOTICE(LOADER, "Magic: %08x", e_magic); LOG_NOTICE(LOADER, "Magic: %08x", e_magic);
LOGF_NOTICE(LOADER, "Class: %s", "ELF64"); LOG_NOTICE(LOADER, "Class: %s", "ELF64");
LOGF_NOTICE(LOADER, "Data: %s", Ehdr_DataToString(e_data).c_str()); LOG_NOTICE(LOADER, "Data: %s", Ehdr_DataToString(e_data).c_str());
LOGF_NOTICE(LOADER, "Current Version: %d", e_curver); LOG_NOTICE(LOADER, "Current Version: %d", e_curver);
LOGF_NOTICE(LOADER, "OS/ABI: %s", Ehdr_OS_ABIToString(e_os_abi).c_str()); LOG_NOTICE(LOADER, "OS/ABI: %s", Ehdr_OS_ABIToString(e_os_abi).c_str());
LOGF_NOTICE(LOADER, "ABI version: %lld", e_abi_ver); LOG_NOTICE(LOADER, "ABI version: %lld", e_abi_ver);
LOGF_NOTICE(LOADER, "Type: %s", Ehdr_TypeToString(e_type).c_str()); LOG_NOTICE(LOADER, "Type: %s", Ehdr_TypeToString(e_type).c_str());
LOGF_NOTICE(LOADER, "Machine: %s", Ehdr_MachineToString(e_machine).c_str()); LOG_NOTICE(LOADER, "Machine: %s", Ehdr_MachineToString(e_machine).c_str());
LOGF_NOTICE(LOADER, "Version: %d", e_version); LOG_NOTICE(LOADER, "Version: %d", e_version);
LOGF_NOTICE(LOADER, "Entry point address: 0x%08llx", e_entry); LOG_NOTICE(LOADER, "Entry point address: 0x%08llx", e_entry);
LOGF_NOTICE(LOADER, "Program headers offset: 0x%08llx", e_phoff); LOG_NOTICE(LOADER, "Program headers offset: 0x%08llx", e_phoff);
LOGF_NOTICE(LOADER, "Section headers offset: 0x%08llx", e_shoff); LOG_NOTICE(LOADER, "Section headers offset: 0x%08llx", e_shoff);
LOGF_NOTICE(LOADER, "Flags: 0x%x", e_flags); LOG_NOTICE(LOADER, "Flags: 0x%x", e_flags);
LOGF_NOTICE(LOADER, "Size of this header: %d", e_ehsize); LOG_NOTICE(LOADER, "Size of this header: %d", e_ehsize);
LOGF_NOTICE(LOADER, "Size of program headers: %d", e_phentsize); LOG_NOTICE(LOADER, "Size of program headers: %d", e_phentsize);
LOGF_NOTICE(LOADER, "Number of program headers: %d", e_phnum); LOG_NOTICE(LOADER, "Number of program headers: %d", e_phnum);
LOGF_NOTICE(LOADER, "Size of section headers: %d", e_shentsize); LOG_NOTICE(LOADER, "Size of section headers: %d", e_shentsize);
LOGF_NOTICE(LOADER, "Number of section headers: %d", e_shnum); LOG_NOTICE(LOADER, "Number of section headers: %d", e_shnum);
LOGF_NOTICE(LOADER, "Section header string table index: %d", e_shstrndx); LOG_NOTICE(LOADER, "Section header string table index: %d", e_shstrndx);
#endif #endif
} }
@ -105,16 +105,16 @@ struct Elf64_Shdr
void Show() void Show()
{ {
#ifdef LOADER_DEBUG #ifdef LOADER_DEBUG
LOGF_NOTICE(LOADER, "Name offset: %x", sh_name); LOG_NOTICE(LOADER, "Name offset: %x", sh_name);
LOGF_NOTICE(LOADER, "Type: %d", sh_type); LOG_NOTICE(LOADER, "Type: %d", sh_type);
LOGF_NOTICE(LOADER, "Addr: %llx", sh_addr); LOG_NOTICE(LOADER, "Addr: %llx", sh_addr);
LOGF_NOTICE(LOADER, "Offset: %llx", sh_offset); LOG_NOTICE(LOADER, "Offset: %llx", sh_offset);
LOGF_NOTICE(LOADER, "Size: %llx", sh_size); LOG_NOTICE(LOADER, "Size: %llx", sh_size);
LOGF_NOTICE(LOADER, "EntSize: %lld", sh_entsize); LOG_NOTICE(LOADER, "EntSize: %lld", sh_entsize);
LOGF_NOTICE(LOADER, "Flags: %llx", sh_flags); LOG_NOTICE(LOADER, "Flags: %llx", sh_flags);
LOGF_NOTICE(LOADER, "Link: %x", sh_link); LOG_NOTICE(LOADER, "Link: %x", sh_link);
LOGF_NOTICE(LOADER, "Info: %x", sh_info); LOG_NOTICE(LOADER, "Info: %x", sh_info);
LOGF_NOTICE(LOADER, "Address align: %llx", sh_addralign); LOG_NOTICE(LOADER, "Address align: %llx", sh_addralign);
#endif #endif
} }
}; };
@ -145,14 +145,14 @@ struct Elf64_Phdr
void Show() void Show()
{ {
#ifdef LOADER_DEBUG #ifdef LOADER_DEBUG
LOGF_NOTICE(LOADER, "Type: %s", Phdr_TypeToString(p_type).c_str()); LOG_NOTICE(LOADER, "Type: %s", Phdr_TypeToString(p_type).c_str());
LOGF_NOTICE(LOADER, "Offset: 0x%08llx", p_offset); LOG_NOTICE(LOADER, "Offset: 0x%08llx", p_offset);
LOGF_NOTICE(LOADER, "Virtual address: 0x%08llx", p_vaddr); LOG_NOTICE(LOADER, "Virtual address: 0x%08llx", p_vaddr);
LOGF_NOTICE(LOADER, "Physical address: 0x%08llx", p_paddr); LOG_NOTICE(LOADER, "Physical address: 0x%08llx", p_paddr);
LOGF_NOTICE(LOADER, "File size: 0x%08llx", p_filesz); LOG_NOTICE(LOADER, "File size: 0x%08llx", p_filesz);
LOGF_NOTICE(LOADER, "Memory size: 0x%08llx", p_memsz); LOG_NOTICE(LOADER, "Memory size: 0x%08llx", p_memsz);
LOGF_NOTICE(LOADER, "Flags: %s", Phdr_FlagsToString(p_flags).c_str()); LOG_NOTICE(LOADER, "Flags: %s", Phdr_FlagsToString(p_flags).c_str());
LOGF_NOTICE(LOADER, "Align: 0x%llx", p_align); LOG_NOTICE(LOADER, "Align: 0x%llx", p_align);
#endif #endif
} }
}; };

8
rpcs3/Loader/PKG.cpp
View file

@ -27,15 +27,15 @@ bool PKGLoader::Install(std::string dest)
if (rDirExists(dest+titleID)) { if (rDirExists(dest+titleID)) {
rMessageDialog d_overwrite(NULL, "Another installation was found. Do you want to overwrite it?", "PKG Decrypter / Installer", rYES_NO|rCENTRE); rMessageDialog d_overwrite(NULL, "Another installation was found. Do you want to overwrite it?", "PKG Decrypter / Installer", rYES_NO|rCENTRE);
if (d_overwrite.ShowModal() != rID_YES) { if (d_overwrite.ShowModal() != rID_YES) {
LOGF_ERROR(LOADER, "PKG Loader: Another installation found in: %s", titleID.c_str()); LOG_ERROR(LOADER, "PKG Loader: Another installation found in: %s", titleID.c_str());
return false; return false;
} }
// TODO: Remove the following two lines and remove the folder dest+titleID // TODO: Remove the following two lines and remove the folder dest+titleID
LOGF_ERROR(LOADER, "PKG Loader: Another installation found in: %s", titleID.c_str()); LOG_ERROR(LOADER, "PKG Loader: Another installation found in: %s", titleID.c_str());
return false; return false;
} }
if (!rMkdir(dest+titleID)) { if (!rMkdir(dest+titleID)) {
LOGF_ERROR(LOADER, "PKG Loader: Could not make the installation directory: %s", titleID.c_str()); LOG_ERROR(LOADER, "PKG Loader: Could not make the installation directory: %s", titleID.c_str());
return false; return false;
} }
@ -47,7 +47,7 @@ bool PKGLoader::Install(std::string dest)
} }
else else
{ {
LOGF_NOTICE(LOADER, "PKG Loader: Package successfully installed in: /dev_hdd0/game/%s", titleID.c_str()); LOG_NOTICE(LOADER, "PKG Loader: Package successfully installed in: /dev_hdd0/game/%s", titleID.c_str());
return true; return true;
} }
} }

2
rpcs3/Loader/PSF.cpp
View file

@ -43,7 +43,7 @@ bool PSFLoader::LoadHeader()
if(!m_header.CheckMagic()) if(!m_header.CheckMagic())
return false; return false;
if(m_show_log) LOGF_NOTICE(LOADER, "PSF version: %x", m_header.psf_version); if(m_show_log) LOG_NOTICE(LOADER, "PSF version: %x", m_header.psf_version);
m_psfindxs.clear(); m_psfindxs.clear();
m_entries.clear(); m_entries.clear();

34
rpcs3/Loader/SELF.h
View file

@ -24,14 +24,14 @@ struct SceHeader
void Show() void Show()
{ {
LOGF_NOTICE(LOADER, "Magic: %08x", se_magic); LOG_NOTICE(LOADER, "Magic: %08x", se_magic);
LOGF_NOTICE(LOADER, "Class: %s", "SELF"); LOG_NOTICE(LOADER, "Class: %s", "SELF");
LOGF_NOTICE(LOADER, "hver: 0x%08x", se_hver); LOG_NOTICE(LOADER, "hver: 0x%08x", se_hver);
LOGF_NOTICE(LOADER, "flags: 0x%04x", se_flags); LOG_NOTICE(LOADER, "flags: 0x%04x", se_flags);
LOGF_NOTICE(LOADER, "type: 0x%04x", se_type); LOG_NOTICE(LOADER, "type: 0x%04x", se_type);
LOGF_NOTICE(LOADER, "meta: 0x%08x", se_meta); LOG_NOTICE(LOADER, "meta: 0x%08x", se_meta);
LOGF_NOTICE(LOADER, "hsize: 0x%llx", se_hsize); LOG_NOTICE(LOADER, "hsize: 0x%llx", se_hsize);
LOGF_NOTICE(LOADER, "esize: 0x%llx", se_esize); LOG_NOTICE(LOADER, "esize: 0x%llx", se_esize);
} }
bool CheckMagic() const { return se_magic == 0x53434500; } bool CheckMagic() const { return se_magic == 0x53434500; }
@ -66,15 +66,15 @@ struct SelfHeader
void Show() void Show()
{ {
LOGF_NOTICE(LOADER, "header type: 0x%llx", se_htype); LOG_NOTICE(LOADER, "header type: 0x%llx", se_htype);
LOGF_NOTICE(LOADER, "app info offset: 0x%llx", se_appinfooff); LOG_NOTICE(LOADER, "app info offset: 0x%llx", se_appinfooff);
LOGF_NOTICE(LOADER, "elf offset: 0x%llx", se_elfoff); LOG_NOTICE(LOADER, "elf offset: 0x%llx", se_elfoff);
LOGF_NOTICE(LOADER, "program header offset: 0x%llx", se_phdroff); LOG_NOTICE(LOADER, "program header offset: 0x%llx", se_phdroff);
LOGF_NOTICE(LOADER, "section header offset: 0x%llx", se_shdroff); LOG_NOTICE(LOADER, "section header offset: 0x%llx", se_shdroff);
LOGF_NOTICE(LOADER, "section info offset: 0x%llx", se_secinfoff); LOG_NOTICE(LOADER, "section info offset: 0x%llx", se_secinfoff);
LOGF_NOTICE(LOADER, "sce version offset: 0x%llx", se_sceveroff); LOG_NOTICE(LOADER, "sce version offset: 0x%llx", se_sceveroff);
LOGF_NOTICE(LOADER, "control info offset: 0x%llx", se_controloff); LOG_NOTICE(LOADER, "control info offset: 0x%llx", se_controloff);
LOGF_NOTICE(LOADER, "control info size: 0x%llx", se_controlsize); LOG_NOTICE(LOADER, "control info size: 0x%llx", se_controlsize);
} }
}; };

4
rpcs3/Loader/TROPUSR.cpp
View file

@ -177,7 +177,7 @@ u32 TROPUSRLoader::GetTrophiesCount()
u32 TROPUSRLoader::GetTrophyUnlockState(u32 id) u32 TROPUSRLoader::GetTrophyUnlockState(u32 id)
{ {
if (id >= m_table6.size()) if (id >= m_table6.size())
LOGF_WARNING(LOADER, "TROPUSRLoader::GetUnlockState: Invalid id=%d", id); LOG_WARNING(LOADER, "TROPUSRLoader::GetUnlockState: Invalid id=%d", id);
return m_table6[id].trophy_state; // Let's assume the trophies are stored ordered return m_table6[id].trophy_state; // Let's assume the trophies are stored ordered
} }
@ -185,7 +185,7 @@ u32 TROPUSRLoader::GetTrophyUnlockState(u32 id)
u32 TROPUSRLoader::GetTrophyTimestamp(u32 id) u32 TROPUSRLoader::GetTrophyTimestamp(u32 id)
{ {
if (id >= m_table6.size()) if (id >= m_table6.size())
LOGF_WARNING(LOADER, "TROPUSRLoader::GetTrophyTimestamp: Invalid id=%d", id); LOG_WARNING(LOADER, "TROPUSRLoader::GetTrophyTimestamp: Invalid id=%d", id);
// TODO: What timestamp does sceNpTrophyGetTrophyInfo want, timestamp1 or timestamp2? // TODO: What timestamp does sceNpTrophyGetTrophyInfo want, timestamp1 or timestamp2?
return m_table6[id].timestamp2; // Let's assume the trophies are stored ordered return m_table6[id].timestamp2; // Let's assume the trophies are stored ordered

4
rpcs3/Loader/TRP.cpp
View file

@ -51,7 +51,7 @@ bool TRPLoader::LoadHeader(bool show)
return false; return false;
if (show) if (show)
LOGF_NOTICE(LOADER, "TRP version: %x", m_header.trp_version); LOG_NOTICE(LOADER, "TRP version: %x", m_header.trp_version);
m_entries.clear(); m_entries.clear();
m_entries.resize(m_header.trp_files_count); m_entries.resize(m_header.trp_files_count);
@ -62,7 +62,7 @@ bool TRPLoader::LoadHeader(bool show)
return false; return false;
if (show) if (show)
LOGF_NOTICE(LOADER, "TRP entry #%d: %s", m_entries[i].name); LOG_NOTICE(LOADER, "TRP entry #%d: %s", m_entries[i].name);
} }
return true; return true;