archive/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2024-09-20 03:11:51 +02:00
Code Issues Projects Releases Packages Wiki Activity

Clean up DisassembleBlock and JitInterface::GetHostCode

Browse source
This commit is contained in:
Pokechu22 2022-12-01 17:16:11 -08:00
parent 5842b90bee
commit 6a6d24550e
5 changed files with 83 additions and 42 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

27
Source/Core/Core/PowerPC/JitInterface.cpp
View file

@ -146,43 +146,42 @@ void GetProfileResults(Profiler::ProfileStats* prof_stats)
});
}
int GetHostCode(u32* address, const u8** code, u32* code_size)
std::variant<GetHostCodeError, GetHostCodeResult> GetHostCode(u32 address)
{
if (!g_jit)
{
*code_size = 0;
return 1;
return GetHostCodeError::NoJitActive;
}
JitBlock* block = g_jit->GetBlockCache()->GetBlockFromStartAddress(*address, MSR.Hex);
JitBlock* block = g_jit->GetBlockCache()->GetBlockFromStartAddress(address, MSR.Hex);
if (!block)
{
for (int i = 0; i < 500; i++)
{
block = g_jit->GetBlockCache()->GetBlockFromStartAddress(*address - 4 * i, MSR.Hex);
block = g_jit->GetBlockCache()->GetBlockFromStartAddress(address - 4 * i, MSR.Hex);
if (block)
break;
}
if (block)
{
if (!(block->effectiveAddress <= *address &&
block->originalSize + block->effectiveAddress >= *address))
if (!(block->effectiveAddress <= address &&
block->originalSize + block->effectiveAddress >= address))
block = nullptr;
}
// Do not merge this "if" with the above - block_num changes inside it.
// Do not merge this "if" with the above - block changes inside it.
if (!block)
{
*code_size = 0;
return 2;
return GetHostCodeError::NoTranslation;
}
}
*code = block->checkedEntry;
*code_size = block->codeSize;
*address = block->effectiveAddress;
return 0;
GetHostCodeResult result;
result.code = block->checkedEntry;
result.code_size = block->codeSize;
result.entry_address = block->effectiveAddress;
return result;
}
bool HandleFault(uintptr_t access_address, SContext* ctx)

15
Source/Core/Core/PowerPC/JitInterface.h
View file

@ -4,6 +4,7 @@
#pragma once
#include <string>
#include <variant>
#include "Common/CommonTypes.h"
#include "Core/MachineContext.h"
@ -43,10 +44,22 @@ enum class ProfilingState
Disabled
};
enum class GetHostCodeError
{
NoJitActive,
NoTranslation,
};
struct GetHostCodeResult
{
const u8* code;
u32 code_size;
u32 entry_address;
};
void SetProfilingState(ProfilingState state);
void WriteProfileResults(const std::string& filename);
void GetProfileResults(Profiler::ProfileStats* prof_stats);
int GetHostCode(u32* address, const u8** code, u32* code_size);
std::variant<GetHostCodeError, GetHostCodeResult> GetHostCode(u32 address);
// Memory Utilities
bool HandleFault(uintptr_t access_address, SContext* ctx);

22
Source/Core/DolphinQt/Debugger/JITWidget.cpp
View file

@ -146,14 +146,11 @@ void JITWidget::Update()
// TODO: Actually do something with the table (Wx doesn't)
// Get host side code disassembly
u32 host_instructions_count = 0;
u32 host_code_size = 0;
std::string host_instructions_disasm;
host_instructions_disasm =
DisassembleBlock(m_disassembler.get(), &m_address, &host_instructions_count, &host_code_size);
auto host_instructions_disasm = DisassembleBlock(m_disassembler.get(), m_address);
m_address = host_instructions_disasm.entry_address;
m_host_asm_widget->setHtml(
QStringLiteral("<pre>%1</pre>").arg(QString::fromStdString(host_instructions_disasm)));
QStringLiteral("<pre>%1</pre>").arg(QString::fromStdString(host_instructions_disasm.text)));
// == Fill in ppc box
u32 ppc_addr = m_address;
@ -191,19 +188,24 @@ void JITWidget::Update()
ppc_disasm << st.numCycles << " estimated cycles" << std::endl;
ppc_disasm << "Num instr: PPC: " << code_block.m_num_instructions
<< " Host: " << host_instructions_count;
<< " Host: " << host_instructions_disasm.instruction_count;
if (code_block.m_num_instructions != 0)
{
ppc_disasm << " (blowup: "
<< 100 * host_instructions_count / code_block.m_num_instructions - 100 << "%)";
<< 100 * host_instructions_disasm.instruction_count /
code_block.m_num_instructions -
100
<< "%)";
}
ppc_disasm << std::endl;
ppc_disasm << "Num bytes: PPC: " << code_block.m_num_instructions * 4
<< " Host: " << host_code_size;
<< " Host: " << host_instructions_disasm.code_size;
if (code_block.m_num_instructions != 0)
{
ppc_disasm << " (blowup: " << 100 * host_code_size / (4 * code_block.m_num_instructions) - 100
ppc_disasm << " (blowup: "
<< 100 * host_instructions_disasm.code_size / (4 * code_block.m_num_instructions) -
100
<< "%)";
}
ppc_disasm << std::endl;

50
Source/Core/UICommon/Disassembler.cpp
View file

@ -16,6 +16,8 @@
#include <disasm.h> // Bochs
#endif
#include "Common/Assert.h"
#include "Common/VariantUtil.h"
#include "Core/PowerPC/JitInterface.h"
#if defined(HAVE_LLVM)
@ -169,21 +171,39 @@ std::unique_ptr<HostDisassembler> GetNewDisassembler(const std::string& arch)
return std::make_unique<HostDisassembler>();
}
std::string DisassembleBlock(HostDisassembler* disasm, u32* address, u32* host_instructions_count,
u32* code_size)
DisassembleResult DisassembleBlock(HostDisassembler* disasm, u32 address)
{
const u8* code;
int res = JitInterface::GetHostCode(address, &code, code_size);
auto res = JitInterface::GetHostCode(address);
if (res == 1)
{
*host_instructions_count = 0;
return "(No JIT active)";
}
else if (res == 2)
{
*host_instructions_count = 0;
return "(No translation)";
}
return disasm->DisassembleHostBlock(code, *code_size, host_instructions_count, (u64)code);
return std::visit(overloaded{[&](JitInterface::GetHostCodeError error) {
DisassembleResult result;
switch (error)
{
case JitInterface::GetHostCodeError::NoJitActive:
result.text = "(No JIT active)";
break;
case JitInterface::GetHostCodeError::NoTranslation:
result.text = "(No translation)";
break;
default:
ASSERT(false);
break;
}
result.entry_address = address;
result.instruction_count = 0;
result.code_size = 0;
return result;
},
[&](JitInterface::GetHostCodeResult host_result) {
DisassembleResult new_result;
u32 instruction_count = 0;
new_result.text = disasm->DisassembleHostBlock(
host_result.code, host_result.code_size, &instruction_count,
(u64)host_result.code);
new_result.entry_address = host_result.entry_address;
new_result.code_size = host_result.code_size;
new_result.instruction_count = instruction_count;
return new_result;
}},
res);
}

11
Source/Core/UICommon/Disassembler.h
View file

@ -18,6 +18,13 @@ public:
}
};
struct DisassembleResult
{
std::string text;
u32 entry_address;
u32 instruction_count;
u32 code_size;
};
std::unique_ptr<HostDisassembler> GetNewDisassembler(const std::string& arch);
std::string DisassembleBlock(HostDisassembler* disasm, u32* address, u32* host_instructions_count,
u32* code_size);
DisassembleResult DisassembleBlock(HostDisassembler* disasm, u32 address);