H3cJP/yuzu
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #393 from lioncash/loader

Browse Source 
loader: Move old logging macros over to new fmt-capable ones
This commit is contained in:
bunnei 2018-04-24 22:44:18 -04:00 committed by GitHub
commit 6c9ca8cbca
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 25 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/core/loader/deconstructed_rom_directory.cpp
View File

@ -132,7 +132,7 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(
const VAddr load_addr = next_load_addr; const VAddr load_addr = next_load_addr;
next_load_addr = AppLoader_NSO::LoadModule(path, load_addr); next_load_addr = AppLoader_NSO::LoadModule(path, load_addr);
if (next_load_addr) { if (next_load_addr) {
LOG_DEBUG(Loader, "loaded module %s @ 0x%" PRIx64, module, load_addr); NGLOG_DEBUG(Loader, "loaded module {} @ {:#X}", module, load_addr);
} else { } else {
next_load_addr = load_addr; next_load_addr = load_addr;
} }
@ -163,7 +163,7 @@ ResultStatus AppLoader_DeconstructedRomDirectory::ReadRomFS(
std::shared_ptr<FileUtil::IOFile>& romfs_file, u64& offset, u64& size) { std::shared_ptr<FileUtil::IOFile>& romfs_file, u64& offset, u64& size) {
if (filepath_romfs.empty()) { if (filepath_romfs.empty()) {
LOG_DEBUG(Loader, "No RomFS available"); NGLOG_DEBUG(Loader, "No RomFS available");
return ResultStatus::ErrorNotUsed; return ResultStatus::ErrorNotUsed;
} }
@ -176,8 +176,8 @@ ResultStatus AppLoader_DeconstructedRomDirectory::ReadRomFS(
offset = 0; offset = 0;
size = romfs_file->GetSize(); size = romfs_file->GetSize();
LOG_DEBUG(Loader, "RomFS offset: 0x%016" PRIX64, offset); NGLOG_DEBUG(Loader, "RomFS offset: {:#018X}", offset);
LOG_DEBUG(Loader, "RomFS size: 0x%016" PRIX64, size); NGLOG_DEBUG(Loader, "RomFS size: {:#018X}", size);
// Reset read pointer // Reset read pointer
file.Seek(0, SEEK_SET); file.Seek(0, SEEK_SET);

20
src/core/loader/elf.cpp
View File

@ -273,18 +273,18 @@ const char* ElfReader::GetSectionName(int section) const {
} }
SharedPtr<CodeSet> ElfReader::LoadInto(u32 vaddr) { SharedPtr<CodeSet> ElfReader::LoadInto(u32 vaddr) {
LOG_DEBUG(Loader, "String section: %i", header->e_shstrndx); NGLOG_DEBUG(Loader, "String section: {}", header->e_shstrndx);
// Should we relocate? // Should we relocate?
relocate = (header->e_type != ET_EXEC); relocate = (header->e_type != ET_EXEC);
if (relocate) { if (relocate) {
LOG_DEBUG(Loader, "Relocatable module"); NGLOG_DEBUG(Loader, "Relocatable module");
entryPoint += vaddr; entryPoint += vaddr;
} else { } else {
LOG_DEBUG(Loader, "Prerelocated executable"); NGLOG_DEBUG(Loader, "Prerelocated executable");
} }
LOG_DEBUG(Loader, "%i segments:", header->e_phnum); NGLOG_DEBUG(Loader, "{} segments:", header->e_phnum);
// First pass : Get the bits into RAM // First pass : Get the bits into RAM
u32 base_addr = relocate ? vaddr : 0; u32 base_addr = relocate ? vaddr : 0;
@ -304,8 +304,8 @@ SharedPtr<CodeSet> ElfReader::LoadInto(u32 vaddr) {
for (unsigned int i = 0; i < header->e_phnum; ++i) { for (unsigned int i = 0; i < header->e_phnum; ++i) {
Elf32_Phdr* p = &segments[i]; Elf32_Phdr* p = &segments[i];
LOG_DEBUG(Loader, "Type: %i Vaddr: %08X Filesz: %8X Memsz: %8X ", p->p_type, p->p_vaddr, NGLOG_DEBUG(Loader, "Type: {} Vaddr: {:08X} Filesz: {:08X} Memsz: {:08X} ", p->p_type,
p->p_filesz, p->p_memsz); p->p_vaddr, p->p_filesz, p->p_memsz);
if (p->p_type == PT_LOAD) { if (p->p_type == PT_LOAD) {
CodeSet::Segment* codeset_segment; CodeSet::Segment* codeset_segment;
@ -317,15 +317,15 @@ SharedPtr<CodeSet> ElfReader::LoadInto(u32 vaddr) {
} else if (permission_flags == (PF_R | PF_W)) { } else if (permission_flags == (PF_R | PF_W)) {
codeset_segment = &codeset->data; codeset_segment = &codeset->data;
} else { } else {
LOG_ERROR(Loader, "Unexpected ELF PT_LOAD segment id %u with flags %X", i, NGLOG_ERROR(Loader, "Unexpected ELF PT_LOAD segment id {} with flags {:X}", i,
p->p_flags); p->p_flags);
continue; continue;
} }
if (codeset_segment->size != 0) { if (codeset_segment->size != 0) {
LOG_ERROR(Loader, NGLOG_ERROR(Loader,
"ELF has more than one segment of the same type. Skipping extra " "ELF has more than one segment of the same type. Skipping extra "
"segment (id %i)", "segment (id {})",
i); i);
continue; continue;
} }
@ -345,7 +345,7 @@ SharedPtr<CodeSet> ElfReader::LoadInto(u32 vaddr) {
codeset->entrypoint = base_addr + header->e_entry; codeset->entrypoint = base_addr + header->e_entry;
codeset->memory = std::make_shared<std::vector<u8>>(std::move(program_image)); codeset->memory = std::make_shared<std::vector<u8>>(std::move(program_image));
LOG_DEBUG(Loader, "Done loading."); NGLOG_DEBUG(Loader, "Done loading.");
return codeset; return codeset;
} }

4
src/core/loader/linker.cpp
View File

@ -84,7 +84,7 @@ void Linker::WriteRelocations(std::vector<u8>& program_image, const std::vector<
} }
break; break;
default: default:
LOG_CRITICAL(Loader, "Unknown relocation type: %d", static_cast<int>(rela.type)); NGLOG_CRITICAL(Loader, "Unknown relocation type: {}", static_cast<int>(rela.type));
break; break;
} }
} }
@ -141,7 +141,7 @@ void Linker::ResolveImports() {
if (search != exports.end()) { if (search != exports.end()) {
Memory::Write64(import.second.ea, search->second + import.second.addend); Memory::Write64(import.second.ea, search->second + import.second.addend);
} else { } else {
LOG_ERROR(Loader, "Unresolved import: %s", import.first.c_str()); NGLOG_ERROR(Loader, "Unresolved import: {}", import.first);
} }
} }
} }

8
src/core/loader/loader.cpp
View File

@ -41,7 +41,7 @@ FileType IdentifyFile(FileUtil::IOFile& file, const std::string& filepath) {
FileType IdentifyFile(const std::string& file_name) { FileType IdentifyFile(const std::string& file_name) {
FileUtil::IOFile file(file_name, "rb"); FileUtil::IOFile file(file_name, "rb");
if (!file.IsOpen()) { if (!file.IsOpen()) {
LOG_ERROR(Loader, "Failed to load file %s", file_name.c_str()); NGLOG_ERROR(Loader, "Failed to load file {}", file_name);
return FileType::Unknown; return FileType::Unknown;
} }
@ -116,7 +116,7 @@ static std::unique_ptr<AppLoader> GetFileLoader(FileUtil::IOFile&& file, FileTyp
std::unique_ptr<AppLoader> GetLoader(const std::string& filename) { std::unique_ptr<AppLoader> GetLoader(const std::string& filename) {
FileUtil::IOFile file(filename, "rb"); FileUtil::IOFile file(filename, "rb");
if (!file.IsOpen()) { if (!file.IsOpen()) {
LOG_ERROR(Loader, "Failed to load file %s", filename.c_str()); NGLOG_ERROR(Loader, "Failed to load file {}", filename);
return nullptr; return nullptr;
} }
@ -127,12 +127,12 @@ std::unique_ptr<AppLoader> GetLoader(const std::string& filename) {
FileType filename_type = GuessFromExtension(filename_extension); FileType filename_type = GuessFromExtension(filename_extension);
if (type != filename_type) { if (type != filename_type) {
LOG_WARNING(Loader, "File %s has a different type than its extension.", filename.c_str()); NGLOG_WARNING(Loader, "File {} has a different type than its extension.", filename);
if (FileType::Unknown == type) if (FileType::Unknown == type)
type = filename_type; type = filename_type;
} }
LOG_DEBUG(Loader, "Loading file %s as %s...", filename.c_str(), GetFileTypeString(type)); NGLOG_DEBUG(Loader, "Loading file {} as {}...", filename, GetFileTypeString(type));
return GetFileLoader(std::move(file), type, filename_filename, filename); return GetFileLoader(std::move(file), type, filename_filename, filename);
} }

5
src/core/loader/nso.cpp
View File

@ -73,7 +73,7 @@ static std::vector<u8> ReadSegment(FileUtil::IOFile& file, const NsoSegmentHeade
file.Seek(header.offset, SEEK_SET); file.Seek(header.offset, SEEK_SET);
if (compressed_size != file.ReadBytes(compressed_data.data(), compressed_size)) { if (compressed_size != file.ReadBytes(compressed_data.data(), compressed_size)) {
LOG_CRITICAL(Loader, "Failed to read %d NSO LZ4 compressed bytes", compressed_size); NGLOG_CRITICAL(Loader, "Failed to read {} NSO LZ4 compressed bytes", compressed_size);
return {}; return {};
} }
@ -158,8 +158,7 @@ ResultStatus AppLoader_NSO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
// Load module // Load module
LoadModule(filepath, Memory::PROCESS_IMAGE_VADDR); LoadModule(filepath, Memory::PROCESS_IMAGE_VADDR);
LOG_DEBUG(Loader, "loaded module %s @ 0x%" PRIx64, filepath.c_str(), NGLOG_DEBUG(Loader, "loaded module {} @ {:#X}", filepath, Memory::PROCESS_IMAGE_VADDR);
Memory::PROCESS_IMAGE_VADDR);
process->svc_access_mask.set(); process->svc_access_mask.set();
process->address_mappings = default_address_mappings; process->address_mappings = default_address_mappings;