Emulation/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2024-06-02 19:28:11 -04:00
Code Issues Packages Projects Releases Wiki Activity
dolphin/Source/Core/Core/PowerPC/Expression.cpp
Admiral H. Curtiss c26373bd95
Merge pull request #12738 from mitaclaw/expression-sprs 
Expression: Support All SPRs + MSR
2024-05-04 17:35:12 +02:00

498 lines
15 KiB
C++
Raw Blame History

// Copyright 2020 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include "Core/PowerPC/Expression.h"
#include <algorithm>
#include <array>
#include <cstdlib>
#include <fmt/format.h>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
// https://github.com/zserge/expr/ is a C program and sorta valid C++.
// When included in a C++ program, it's treated as a C++ code, and it may cause
// issues: <cmath> may already be included, if so, including <math.h> may
// not do anything. <math.h> is obligated to put its functions in the global
// namespace, while <cmath> may or may not. The C code we're interpreting as
// C++ won't call functions by their qualified names. The code may work anyway
// if <cmath> puts its functions in the global namespace, or if the functions
// are actually macros that expand inline, both of which are common.
// NetBSD 10.0 i386 is an exception, and we need `using` there.
using std::isinf;
using std::isnan;
#include <expr.h>
#include "Common/CommonTypes.h"
#include "Common/Logging/Log.h"
#include "Core/Core.h"
#include "Core/Debugger/Debugger_SymbolMap.h"
#include "Core/PowerPC/MMU.h"
#include "Core/PowerPC/PowerPC.h"
#include "Core/System.h"
template <typename T>
static T HostRead(const Core::CPUThreadGuard& guard, u32 address);
template <typename T>
static void HostWrite(const Core::CPUThreadGuard& guard, T var, u32 address);
template <>
u8 HostRead(const Core::CPUThreadGuard& guard, u32 address)
{
return PowerPC::MMU::HostRead_U8(guard, address);
}
template <>
u16 HostRead(const Core::CPUThreadGuard& guard, u32 address)
{
return PowerPC::MMU::HostRead_U16(guard, address);
}
template <>
u32 HostRead(const Core::CPUThreadGuard& guard, u32 address)
{
return PowerPC::MMU::HostRead_U32(guard, address);
}
template <>
u64 HostRead(const Core::CPUThreadGuard& guard, u32 address)
{
return PowerPC::MMU::HostRead_U64(guard, address);
}
template <>
void HostWrite(const Core::CPUThreadGuard& guard, u8 var, u32 address)
{
PowerPC::MMU::HostWrite_U8(guard, var, address);
}
template <>
void HostWrite(const Core::CPUThreadGuard& guard, u16 var, u32 address)
{
PowerPC::MMU::HostWrite_U16(guard, var, address);
}
template <>
void HostWrite(const Core::CPUThreadGuard& guard, u32 var, u32 address)
{
PowerPC::MMU::HostWrite_U32(guard, var, address);
}
template <>
void HostWrite(const Core::CPUThreadGuard& guard, u64 var, u32 address)
{
PowerPC::MMU::HostWrite_U64(guard, var, address);
}
template <typename T, typename U = T>
static double HostReadFunc(expr_func* f, vec_expr_t* args, void* c)
{
if (vec_len(args) != 1)
return 0;
const u32 address = static_cast<u32>(expr_eval(&vec_nth(args, 0)));
Core::CPUThreadGuard guard(Core::System::GetInstance());
return std::bit_cast<T>(HostRead<U>(guard, address));
}
template <typename T, typename U = T>
static double HostWriteFunc(expr_func* f, vec_expr_t* args, void* c)
{
if (vec_len(args) != 2)
return 0;
const T var = static_cast<T>(expr_eval(&vec_nth(args, 0)));
const u32 address = static_cast<u32>(expr_eval(&vec_nth(args, 1)));
Core::CPUThreadGuard guard(Core::System::GetInstance());
HostWrite<U>(guard, std::bit_cast<U>(var), address);
return var;
}
template <typename T, typename U = T>
static double CastFunc(expr_func* f, vec_expr_t* args, void* c)
{
if (vec_len(args) != 1)
return 0;
return std::bit_cast<T>(static_cast<U>(expr_eval(&vec_nth(args, 0))));
}
static double CallstackFunc(expr_func* f, vec_expr_t* args, void* c)
{
if (vec_len(args) != 1)
return 0;
std::vector<Dolphin_Debugger::CallstackEntry> stack;
{
Core::CPUThreadGuard guard(Core::System::GetInstance());
const bool success = Dolphin_Debugger::GetCallstack(guard, stack);
if (!success)
return 0;
}
double num = expr_eval(&vec_nth(args, 0));
if (!std::isnan(num))
{
u32 address = static_cast<u32>(num);
return std::any_of(stack.begin(), stack.end(),
[address](const auto& s) { return s.vAddress == address; });
}
const char* cstr = expr_get_str(&vec_nth(args, 0));
if (cstr != nullptr)
{
return std::any_of(stack.begin(), stack.end(),
[cstr](const auto& s) { return s.Name.find(cstr) != std::string::npos; });
}
return 0;
}
static std::optional<std::string> ReadStringArg(const Core::CPUThreadGuard& guard, expr* e)
{
double num = expr_eval(e);
if (!std::isnan(num))
{
u32 address = static_cast<u32>(num);
return PowerPC::MMU::HostGetString(guard, address);
}
const char* cstr = expr_get_str(e);
if (cstr != nullptr)
{
return std::string(cstr);
}
return std::nullopt;
}
static double StreqFunc(expr_func* f, vec_expr_t* args, void* c)
{
if (vec_len(args) != 2)
return 0;
std::array<std::string, 2> strs;
Core::CPUThreadGuard guard(Core::System::GetInstance());
for (int i = 0; i < 2; i++)
{
std::optional<std::string> arg = ReadStringArg(guard, &vec_nth(args, i));
if (arg == std::nullopt)
return 0;
strs[i] = std::move(*arg);
}
return strs[0] == strs[1];
}
static std::array<expr_func, 23> g_expr_funcs{{
// For internal storage and comparisons, everything is auto-converted to Double.
// If u64 ints are added, this could produce incorrect results.
{"read_u8", HostReadFunc<u8>},
{"read_s8", HostReadFunc<s8, u8>},
{"read_u16", HostReadFunc<u16>},
{"read_s16", HostReadFunc<s16, u16>},
{"read_u32", HostReadFunc<u32>},
{"read_s32", HostReadFunc<s32, u32>},
{"read_f32", HostReadFunc<float, u32>},
{"read_f64", HostReadFunc<double, u64>},
{"write_u8", HostWriteFunc<u8>},
{"write_u16", HostWriteFunc<u16>},
{"write_u32", HostWriteFunc<u32>},
{"write_f32", HostWriteFunc<float, u32>},
{"write_f64", HostWriteFunc<double, u64>},
{"u8", CastFunc<u8>},
{"s8", CastFunc<s8, u8>},
{"u16", CastFunc<u16>},
{"s16", CastFunc<s16, u16>},
{"u32", CastFunc<u32>},
{"s32", CastFunc<s32, u32>},
{"callstack", CallstackFunc},
{"streq", StreqFunc},
{},
}};
void ExprDeleter::operator()(expr* expression) const
{
expr_destroy(expression, nullptr);
}
void ExprVarListDeleter::operator()(expr_var_list* vars) const
{
// Free list elements
expr_destroy(nullptr, vars);
// Free list object
delete vars;
}
Expression::Expression(std::string_view text, ExprPointer ex, ExprVarListPointer vars)
: m_text(text), m_expr(std::move(ex)), m_vars(std::move(vars))
{
using LookupKV = std::pair<std::string_view, Expression::VarBinding>;
static constexpr auto sorted_lookup = []() consteval
{
using enum Expression::VarBindingType;
auto unsorted_lookup = std::to_array<LookupKV>({
{"r0", {GPR, 0}},
{"r1", {GPR, 1}},
{"r2", {GPR, 2}},
{"r3", {GPR, 3}},
{"r4", {GPR, 4}},
{"r5", {GPR, 5}},
{"r6", {GPR, 6}},
{"r7", {GPR, 7}},
{"r8", {GPR, 8}},
{"r9", {GPR, 9}},
{"r10", {GPR, 10}},
{"r11", {GPR, 11}},
{"r12", {GPR, 12}},
{"r13", {GPR, 13}},
{"r14", {GPR, 14}},
{"r15", {GPR, 15}},
{"r16", {GPR, 16}},
{"r17", {GPR, 17}},
{"r18", {GPR, 18}},
{"r19", {GPR, 19}},
{"r20", {GPR, 20}},
{"r21", {GPR, 21}},
{"r22", {GPR, 22}},
{"r23", {GPR, 23}},
{"r24", {GPR, 24}},
{"r25", {GPR, 25}},
{"r26", {GPR, 26}},
{"r27", {GPR, 27}},
{"r28", {GPR, 28}},
{"r29", {GPR, 29}},
{"r30", {GPR, 30}},
{"r31", {GPR, 31}},
{"f0", {FPR, 0}},
{"f1", {FPR, 1}},
{"f2", {FPR, 2}},
{"f3", {FPR, 3}},
{"f4", {FPR, 4}},
{"f5", {FPR, 5}},
{"f6", {FPR, 6}},
{"f7", {FPR, 7}},
{"f8", {FPR, 8}},
{"f9", {FPR, 9}},
{"f10", {FPR, 10}},
{"f11", {FPR, 11}},
{"f12", {FPR, 12}},
{"f13", {FPR, 13}},
{"f14", {FPR, 14}},
{"f15", {FPR, 15}},
{"f16", {FPR, 16}},
{"f17", {FPR, 17}},
{"f18", {FPR, 18}},
{"f19", {FPR, 19}},
{"f20", {FPR, 20}},
{"f21", {FPR, 21}},
{"f22", {FPR, 22}},
{"f23", {FPR, 23}},
{"f24", {FPR, 24}},
{"f25", {FPR, 25}},
{"f26", {FPR, 26}},
{"f27", {FPR, 27}},
{"f28", {FPR, 28}},
{"f29", {FPR, 29}},
{"f30", {FPR, 30}},
{"f31", {FPR, 31}},
{"pc", {PCtr}},
{"msr", {MSR}},
{"xer", {SPR, SPR_XER}},
{"lr", {SPR, SPR_LR}},
{"ctr", {SPR, SPR_CTR}},
{"dsisr", {SPR, SPR_DSISR}},
{"dar", {SPR, SPR_DAR}},
{"dec", {SPR, SPR_DEC}},
{"sdr1", {SPR, SPR_SDR}},
{"srr0", {SPR, SPR_SRR0}},
{"srr1", {SPR, SPR_SRR1}},
{"tbl", {SPR, SPR_TL}},
{"tbu", {SPR, SPR_TU}},
{"pvr", {SPR, SPR_PVR}},
{"sprg0", {SPR, SPR_SPRG0}},
{"sprg1", {SPR, SPR_SPRG1}},
{"sprg2", {SPR, SPR_SPRG2}},
{"sprg3", {SPR, SPR_SPRG3}},
{"ear", {SPR, SPR_EAR}},
{"ibat0u", {SPR, SPR_IBAT0U}},
{"ibat0l", {SPR, SPR_IBAT0L}},
{"ibat1u", {SPR, SPR_IBAT1U}},
{"ibat1l", {SPR, SPR_IBAT1L}},
{"ibat2u", {SPR, SPR_IBAT2U}},
{"ibat2l", {SPR, SPR_IBAT2L}},
{"ibat3u", {SPR, SPR_IBAT3U}},
{"ibat3l", {SPR, SPR_IBAT3L}},
{"ibat4u", {SPR, SPR_IBAT4U}},
{"ibat4l", {SPR, SPR_IBAT4L}},
{"ibat5u", {SPR, SPR_IBAT5U}},
{"ibat5l", {SPR, SPR_IBAT5L}},
{"ibat6u", {SPR, SPR_IBAT6U}},
{"ibat6l", {SPR, SPR_IBAT6L}},
{"ibat7u", {SPR, SPR_IBAT7U}},
{"ibat7l", {SPR, SPR_IBAT7L}},
{"dbat0u", {SPR, SPR_DBAT0U}},
{"dbat0l", {SPR, SPR_DBAT0L}},
{"dbat1u", {SPR, SPR_DBAT1U}},
{"dbat1l", {SPR, SPR_DBAT1L}},
{"dbat2u", {SPR, SPR_DBAT2U}},
{"dbat2l", {SPR, SPR_DBAT2L}},
{"dbat3u", {SPR, SPR_DBAT3U}},
{"dbat3l", {SPR, SPR_DBAT3L}},
{"dbat4u", {SPR, SPR_DBAT4U}},
{"dbat4l", {SPR, SPR_DBAT4L}},
{"dbat5u", {SPR, SPR_DBAT5U}},
{"dbat5l", {SPR, SPR_DBAT5L}},
{"dbat6u", {SPR, SPR_DBAT6U}},
{"dbat6l", {SPR, SPR_DBAT6L}},
{"dbat7u", {SPR, SPR_DBAT7U}},
{"dbat7l", {SPR, SPR_DBAT7L}},
{"gqr0", {SPR, SPR_GQR0 + 0}},
{"gqr1", {SPR, SPR_GQR0 + 1}},
{"gqr2", {SPR, SPR_GQR0 + 2}},
{"gqr3", {SPR, SPR_GQR0 + 3}},
{"gqr4", {SPR, SPR_GQR0 + 4}},
{"gqr5", {SPR, SPR_GQR0 + 5}},
{"gqr6", {SPR, SPR_GQR0 + 6}},
{"gqr7", {SPR, SPR_GQR0 + 7}},
{"hid0", {SPR, SPR_HID0}},
{"hid1", {SPR, SPR_HID1}},
{"hid2", {SPR, SPR_HID2}},
{"hid4", {SPR, SPR_HID4}},
{"iabr", {SPR, SPR_IABR}},
{"dabr", {SPR, SPR_DABR}},
{"wpar", {SPR, SPR_WPAR}},
{"dmau", {SPR, SPR_DMAU}},
{"dmal", {SPR, SPR_DMAL}},
{"ecid_u", {SPR, SPR_ECID_U}},
{"ecid_m", {SPR, SPR_ECID_M}},
{"ecid_l", {SPR, SPR_ECID_L}},
{"usia", {SPR, SPR_USIA}},
{"sia", {SPR, SPR_SIA}},
{"l2cr", {SPR, SPR_L2CR}},
{"ictc", {SPR, SPR_ICTC}},
{"mmcr0", {SPR, SPR_MMCR0}},
{"mmcr1", {SPR, SPR_MMCR1}},
{"pmc1", {SPR, SPR_PMC1}},
{"pmc2", {SPR, SPR_PMC2}},
{"pmc3", {SPR, SPR_PMC3}},
{"pmc4", {SPR, SPR_PMC4}},
{"thrm1", {SPR, SPR_THRM1}},
{"thrm2", {SPR, SPR_THRM2}},
{"thrm3", {SPR, SPR_THRM3}},
});
std::ranges::sort(unsorted_lookup, {}, &LookupKV::first);
return unsorted_lookup;
}
();
static_assert(std::ranges::adjacent_find(sorted_lookup, {}, &LookupKV::first) ==
sorted_lookup.end(),
"Expression: Sorted lookup should not contain duplicate keys.");
for (auto* v = m_vars->head; v != nullptr; v = v->next)
{
const auto iter = std::ranges::lower_bound(sorted_lookup, v->name, {}, &LookupKV::first);
if (iter != sorted_lookup.end() && iter->first == v->name)
m_binds.emplace_back(iter->second);
else
m_binds.emplace_back();
}
}
std::optional<Expression> Expression::TryParse(std::string_view text)
{
ExprVarListPointer vars{new expr_var_list{}};
ExprPointer ex{expr_create(text.data(), text.length(), vars.get(), g_expr_funcs.data())};
if (!ex)
return std::nullopt;
return Expression{text, std::move(ex), std::move(vars)};
}
double Expression::Evaluate(Core::System& system) const
{
SynchronizeBindings(system, SynchronizeDirection::From);
double result = expr_eval(m_expr.get());
SynchronizeBindings(system, SynchronizeDirection::To);
Reporting(result);
return result;
}
void Expression::SynchronizeBindings(Core::System& system, SynchronizeDirection dir) const
{
auto& ppc_state = system.GetPPCState();
auto bind = m_binds.begin();
for (auto* v = m_vars->head; v != nullptr; v = v->next, ++bind)
{
switch (bind->type)
{
case VarBindingType::Zero:
if (dir == SynchronizeDirection::From)
v->value = 0;
break;
case VarBindingType::GPR:
if (dir == SynchronizeDirection::From)
v->value = static_cast<double>(ppc_state.gpr[bind->index]);
else
ppc_state.gpr[bind->index] = static_cast<u32>(static_cast<s64>(v->value));
break;
case VarBindingType::FPR:
if (dir == SynchronizeDirection::From)
v->value = ppc_state.ps[bind->index].PS0AsDouble();
else
ppc_state.ps[bind->index].SetPS0(v->value);
break;
case VarBindingType::SPR:
if (dir == SynchronizeDirection::From)
v->value = static_cast<double>(ppc_state.spr[bind->index]);
else
ppc_state.spr[bind->index] = static_cast<u32>(static_cast<s64>(v->value));
break;
case VarBindingType::PCtr:
if (dir == SynchronizeDirection::From)
v->value = static_cast<double>(ppc_state.pc);
break;
case VarBindingType::MSR:
if (dir == SynchronizeDirection::From)
v->value = static_cast<double>(ppc_state.msr.Hex);
else
ppc_state.msr.Hex = static_cast<u32>(static_cast<s64>(v->value));
break;
}
}
}
void Expression::Reporting(const double result) const
{
bool is_nan = std::isnan(result);
std::string message;
for (auto* v = m_vars->head; v != nullptr; v = v->next)
{
if (std::isnan(v->value))
is_nan = true;
fmt::format_to(std::back_inserter(message), " {}={}", v->name, v->value);
}
if (is_nan)
{
message.append("\nBreakpoint condition encountered a NaN");
Core::DisplayMessage("Breakpoint condition has encountered a NaN.", 2000);
}
if (result != 0.0 || is_nan)
NOTICE_LOG_FMT(MEMMAP, "Breakpoint condition returned: {}. Vars:{}", result, message);
}
std::string Expression::GetText() const
{
return m_text;
}
Reference in a new issue View git blame Copy permalink