Merge branch 'master' into quickstart-faq
VolcaEM
GitHub
commit
0f4512291a
@ -1,24 +1,58 @@
|
|||||||
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
||||||
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
|
<assembly manifestVersion="1.0"
|
||||||
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
|
xmlns="urn:schemas-microsoft-com:asm.v1"
|
||||||
<security>
|
xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
|
||||||
<requestedPrivileges>
|
<asmv3:application>
|
||||||
<requestedExecutionLevel level="asInvoker" uiAccess="false"/>
|
<asmv3:windowsSettings>
|
||||||
</requestedPrivileges>
|
<!-- Windows 7/8/8.1/10 -->
|
||||||
</security>
|
<dpiAware
|
||||||
</trustInfo>
|
xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">
|
||||||
<application xmlns="urn:schemas-microsoft-com:asm.v3">
|
true/pm
|
||||||
<windowsSettings>
|
</dpiAware>
|
||||||
<dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">True/PM</dpiAware>
|
<!-- Windows 10, version 1607 or later -->
|
||||||
<longPathAware xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">true</longPathAware>
|
<dpiAwareness
|
||||||
</windowsSettings>
|
xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
|
||||||
</application>
|
PerMonitorV2
|
||||||
<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
|
</dpiAwareness>
|
||||||
<application>
|
<!-- Windows 10, version 1703 or later -->
|
||||||
<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
|
<gdiScaling
|
||||||
<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
|
xmlns="http://schemas.microsoft.com/SMI/2017/WindowsSettings">
|
||||||
<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
|
true
|
||||||
<supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
|
</gdiScaling>
|
||||||
</application>
|
<ws2:longPathAware
|
||||||
</compatibility>
|
xmlns:ws3="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
|
||||||
|
true
|
||||||
|
</ws2:longPathAware>
|
||||||
|
</asmv3:windowsSettings>
|
||||||
|
</asmv3:application>
|
||||||
|
<compatibility
|
||||||
|
xmlns="urn:schemas-microsoft-com:compatibility.v1">
|
||||||
|
<application>
|
||||||
|
<!-- Windows 10 -->
|
||||||
|
<supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
|
||||||
|
<!-- Windows 8.1 -->
|
||||||
|
<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
|
||||||
|
<!-- Windows 8 -->
|
||||||
|
<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
|
||||||
|
<!-- Windows 7 -->
|
||||||
|
<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
|
||||||
|
</application>
|
||||||
|
</compatibility>
|
||||||
|
<trustInfo
|
||||||
|
xmlns="urn:schemas-microsoft-com:asm.v3">
|
||||||
|
<security>
|
||||||
|
<requestedPrivileges>
|
||||||
|
<!--
|
||||||
|
UAC settings:
|
||||||
|
- app should run at same integrity level as calling process
|
||||||
|
- app does not need to manipulate windows belonging to
|
||||||
|
higher-integrity-level processes
|
||||||
|
-->
|
||||||
|
<requestedExecutionLevel
|
||||||
|
level="asInvoker"
|
||||||
|
uiAccess="false"
|
||||||
|
/>
|
||||||
|
</requestedPrivileges>
|
||||||
|
</security>
|
||||||
|
</trustInfo>
|
||||||
</assembly>
|
</assembly>
|
||||||
@ -0,0 +1 @@
|
|||||||
|
Subproject commit 7d01cb01cb1a926ecb4c9c98b107ef3c26f59dfb
|
||||||
@ -1 +1 @@
|
|||||||
Subproject commit a62c5bbc100a5e5a31ea0ccc4a78d8fa6a4167ce
|
Subproject commit eefca56afd49379bdebc97ded8b480839f930881
|
||||||
@ -0,0 +1,72 @@
|
|||||||
|
// Copyright 2020 yuzu Emulator Project
|
||||||
|
// Licensed under GPLv2 or any later version
|
||||||
|
// Refer to the license.txt file included.
|
||||||
|
|
||||||
|
#include <boost/container_hash/hash.hpp>
|
||||||
|
#include "common/assert.h"
|
||||||
|
#include "common/logging/log.h"
|
||||||
|
#include "core/settings.h"
|
||||||
|
#include "video_core/engines/maxwell_3d.h"
|
||||||
|
#include "video_core/macro/macro.h"
|
||||||
|
#include "video_core/macro/macro_hle.h"
|
||||||
|
#include "video_core/macro/macro_interpreter.h"
|
||||||
|
#include "video_core/macro/macro_jit_x64.h"
|
||||||
|
|
||||||
|
namespace Tegra {
|
||||||
|
|
||||||
|
MacroEngine::MacroEngine(Engines::Maxwell3D& maxwell3d)
|
||||||
|
: hle_macros{std::make_unique<Tegra::HLEMacro>(maxwell3d)} {}
|
||||||
|
|
||||||
|
MacroEngine::~MacroEngine() = default;
|
||||||
|
|
||||||
|
void MacroEngine::AddCode(u32 method, u32 data) {
|
||||||
|
uploaded_macro_code[method].push_back(data);
|
||||||
|
}
|
||||||
|
|
||||||
|
void MacroEngine::Execute(Engines::Maxwell3D& maxwell3d, u32 method,
|
||||||
|
const std::vector<u32>& parameters) {
|
||||||
|
auto compiled_macro = macro_cache.find(method);
|
||||||
|
if (compiled_macro != macro_cache.end()) {
|
||||||
|
const auto& cache_info = compiled_macro->second;
|
||||||
|
if (cache_info.has_hle_program) {
|
||||||
|
cache_info.hle_program->Execute(parameters, method);
|
||||||
|
} else {
|
||||||
|
cache_info.lle_program->Execute(parameters, method);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// Macro not compiled, check if it's uploaded and if so, compile it
|
||||||
|
auto macro_code = uploaded_macro_code.find(method);
|
||||||
|
if (macro_code == uploaded_macro_code.end()) {
|
||||||
|
UNREACHABLE_MSG("Macro 0x{0:x} was not uploaded", method);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
auto& cache_info = macro_cache[method];
|
||||||
|
cache_info.hash = boost::hash_value(macro_code->second);
|
||||||
|
cache_info.lle_program = Compile(macro_code->second);
|
||||||
|
|
||||||
|
auto hle_program = hle_macros->GetHLEProgram(cache_info.hash);
|
||||||
|
if (hle_program.has_value()) {
|
||||||
|
cache_info.has_hle_program = true;
|
||||||
|
cache_info.hle_program = std::move(hle_program.value());
|
||||||
|
}
|
||||||
|
|
||||||
|
if (cache_info.has_hle_program) {
|
||||||
|
cache_info.hle_program->Execute(parameters, method);
|
||||||
|
} else {
|
||||||
|
cache_info.lle_program->Execute(parameters, method);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
std::unique_ptr<MacroEngine> GetMacroEngine(Engines::Maxwell3D& maxwell3d) {
|
||||||
|
if (Settings::values.disable_macro_jit) {
|
||||||
|
return std::make_unique<MacroInterpreter>(maxwell3d);
|
||||||
|
}
|
||||||
|
#ifdef ARCHITECTURE_x86_64
|
||||||
|
return std::make_unique<MacroJITx64>(maxwell3d);
|
||||||
|
#else
|
||||||
|
return std::make_unique<MacroInterpreter>(maxwell3d);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace Tegra
|
||||||
@ -0,0 +1,141 @@
|
|||||||
|
// Copyright 2020 yuzu Emulator Project
|
||||||
|
// Licensed under GPLv2 or any later version
|
||||||
|
// Refer to the license.txt file included.
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <memory>
|
||||||
|
#include <unordered_map>
|
||||||
|
#include <vector>
|
||||||
|
#include "common/bit_field.h"
|
||||||
|
#include "common/common_types.h"
|
||||||
|
|
||||||
|
namespace Tegra {
|
||||||
|
|
||||||
|
namespace Engines {
|
||||||
|
class Maxwell3D;
|
||||||
|
}
|
||||||
|
|
||||||
|
namespace Macro {
|
||||||
|
constexpr std::size_t NUM_MACRO_REGISTERS = 8;
|
||||||
|
enum class Operation : u32 {
|
||||||
|
ALU = 0,
|
||||||
|
AddImmediate = 1,
|
||||||
|
ExtractInsert = 2,
|
||||||
|
ExtractShiftLeftImmediate = 3,
|
||||||
|
ExtractShiftLeftRegister = 4,
|
||||||
|
Read = 5,
|
||||||
|
Unused = 6, // This operation doesn't seem to be a valid encoding.
|
||||||
|
Branch = 7,
|
||||||
|
};
|
||||||
|
|
||||||
|
enum class ALUOperation : u32 {
|
||||||
|
Add = 0,
|
||||||
|
AddWithCarry = 1,
|
||||||
|
Subtract = 2,
|
||||||
|
SubtractWithBorrow = 3,
|
||||||
|
// Operations 4-7 don't seem to be valid encodings.
|
||||||
|
Xor = 8,
|
||||||
|
Or = 9,
|
||||||
|
And = 10,
|
||||||
|
AndNot = 11,
|
||||||
|
Nand = 12
|
||||||
|
};
|
||||||
|
|
||||||
|
enum class ResultOperation : u32 {
|
||||||
|
IgnoreAndFetch = 0,
|
||||||
|
Move = 1,
|
||||||
|
MoveAndSetMethod = 2,
|
||||||
|
FetchAndSend = 3,
|
||||||
|
MoveAndSend = 4,
|
||||||
|
FetchAndSetMethod = 5,
|
||||||
|
MoveAndSetMethodFetchAndSend = 6,
|
||||||
|
MoveAndSetMethodSend = 7
|
||||||
|
};
|
||||||
|
|
||||||
|
enum class BranchCondition : u32 {
|
||||||
|
Zero = 0,
|
||||||
|
NotZero = 1,
|
||||||
|
};
|
||||||
|
|
||||||
|
union Opcode {
|
||||||
|
u32 raw;
|
||||||
|
BitField<0, 3, Operation> operation;
|
||||||
|
BitField<4, 3, ResultOperation> result_operation;
|
||||||
|
BitField<4, 1, BranchCondition> branch_condition;
|
||||||
|
// If set on a branch, then the branch doesn't have a delay slot.
|
||||||
|
BitField<5, 1, u32> branch_annul;
|
||||||
|
BitField<7, 1, u32> is_exit;
|
||||||
|
BitField<8, 3, u32> dst;
|
||||||
|
BitField<11, 3, u32> src_a;
|
||||||
|
BitField<14, 3, u32> src_b;
|
||||||
|
// The signed immediate overlaps the second source operand and the alu operation.
|
||||||
|
BitField<14, 18, s32> immediate;
|
||||||
|
|
||||||
|
BitField<17, 5, ALUOperation> alu_operation;
|
||||||
|
|
||||||
|
// Bitfield instructions data
|
||||||
|
BitField<17, 5, u32> bf_src_bit;
|
||||||
|
BitField<22, 5, u32> bf_size;
|
||||||
|
BitField<27, 5, u32> bf_dst_bit;
|
||||||
|
|
||||||
|
u32 GetBitfieldMask() const {
|
||||||
|
return (1 << bf_size) - 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
s32 GetBranchTarget() const {
|
||||||
|
return static_cast<s32>(immediate * sizeof(u32));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
union MethodAddress {
|
||||||
|
u32 raw;
|
||||||
|
BitField<0, 12, u32> address;
|
||||||
|
BitField<12, 6, u32> increment;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace Macro
|
||||||
|
|
||||||
|
class HLEMacro;
|
||||||
|
|
||||||
|
class CachedMacro {
|
||||||
|
public:
|
||||||
|
virtual ~CachedMacro() = default;
|
||||||
|
/**
|
||||||
|
* Executes the macro code with the specified input parameters.
|
||||||
|
* @param code The macro byte code to execute
|
||||||
|
* @param parameters The parameters of the macro
|
||||||
|
*/
|
||||||
|
virtual void Execute(const std::vector<u32>& parameters, u32 method) = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
class MacroEngine {
|
||||||
|
public:
|
||||||
|
explicit MacroEngine(Engines::Maxwell3D& maxwell3d);
|
||||||
|
virtual ~MacroEngine();
|
||||||
|
|
||||||
|
// Store the uploaded macro code to compile them when they're called.
|
||||||
|
void AddCode(u32 method, u32 data);
|
||||||
|
|
||||||
|
// Compiles the macro if its not in the cache, and executes the compiled macro
|
||||||
|
void Execute(Engines::Maxwell3D& maxwell3d, u32 method, const std::vector<u32>& parameters);
|
||||||
|
|
||||||
|
protected:
|
||||||
|
virtual std::unique_ptr<CachedMacro> Compile(const std::vector<u32>& code) = 0;
|
||||||
|
|
||||||
|
private:
|
||||||
|
struct CacheInfo {
|
||||||
|
std::unique_ptr<CachedMacro> lle_program{};
|
||||||
|
std::unique_ptr<CachedMacro> hle_program{};
|
||||||
|
u64 hash{};
|
||||||
|
bool has_hle_program{};
|
||||||
|
};
|
||||||
|
|
||||||
|
std::unordered_map<u32, CacheInfo> macro_cache;
|
||||||
|
std::unordered_map<u32, std::vector<u32>> uploaded_macro_code;
|
||||||
|
std::unique_ptr<HLEMacro> hle_macros;
|
||||||
|
};
|
||||||
|
|
||||||
|
std::unique_ptr<MacroEngine> GetMacroEngine(Engines::Maxwell3D& maxwell3d);
|
||||||
|
|
||||||
|
} // namespace Tegra
|
||||||
@ -0,0 +1,113 @@
|
|||||||
|
// Copyright 2020 yuzu Emulator Project
|
||||||
|
// Licensed under GPLv2 or any later version
|
||||||
|
// Refer to the license.txt file included.
|
||||||
|
|
||||||
|
#include <array>
|
||||||
|
#include <vector>
|
||||||
|
#include "video_core/engines/maxwell_3d.h"
|
||||||
|
#include "video_core/macro/macro_hle.h"
|
||||||
|
#include "video_core/rasterizer_interface.h"
|
||||||
|
|
||||||
|
namespace Tegra {
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
// HLE'd functions
|
||||||
|
static void HLE_771BB18C62444DA0(Engines::Maxwell3D& maxwell3d,
|
||||||
|
const std::vector<u32>& parameters) {
|
||||||
|
const u32 instance_count = parameters[2] & maxwell3d.GetRegisterValue(0xD1B);
|
||||||
|
|
||||||
|
maxwell3d.regs.draw.topology.Assign(
|
||||||
|
static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0] &
|
||||||
|
~(0x3ffffff << 26)));
|
||||||
|
maxwell3d.regs.vb_base_instance = parameters[5];
|
||||||
|
maxwell3d.mme_draw.instance_count = instance_count;
|
||||||
|
maxwell3d.regs.vb_element_base = parameters[3];
|
||||||
|
maxwell3d.regs.index_array.count = parameters[1];
|
||||||
|
maxwell3d.regs.index_array.first = parameters[4];
|
||||||
|
|
||||||
|
if (maxwell3d.ShouldExecute()) {
|
||||||
|
maxwell3d.GetRasterizer().Draw(true, true);
|
||||||
|
}
|
||||||
|
maxwell3d.regs.index_array.count = 0;
|
||||||
|
maxwell3d.mme_draw.instance_count = 0;
|
||||||
|
maxwell3d.mme_draw.current_mode = Engines::Maxwell3D::MMEDrawMode::Undefined;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void HLE_0D61FC9FAAC9FCAD(Engines::Maxwell3D& maxwell3d,
|
||||||
|
const std::vector<u32>& parameters) {
|
||||||
|
const u32 count = (maxwell3d.GetRegisterValue(0xD1B) & parameters[2]);
|
||||||
|
|
||||||
|
maxwell3d.regs.vertex_buffer.first = parameters[3];
|
||||||
|
maxwell3d.regs.vertex_buffer.count = parameters[1];
|
||||||
|
maxwell3d.regs.vb_base_instance = parameters[4];
|
||||||
|
maxwell3d.regs.draw.topology.Assign(
|
||||||
|
static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0]));
|
||||||
|
maxwell3d.mme_draw.instance_count = count;
|
||||||
|
|
||||||
|
if (maxwell3d.ShouldExecute()) {
|
||||||
|
maxwell3d.GetRasterizer().Draw(false, true);
|
||||||
|
}
|
||||||
|
maxwell3d.regs.vertex_buffer.count = 0;
|
||||||
|
maxwell3d.mme_draw.instance_count = 0;
|
||||||
|
maxwell3d.mme_draw.current_mode = Engines::Maxwell3D::MMEDrawMode::Undefined;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void HLE_0217920100488FF7(Engines::Maxwell3D& maxwell3d,
|
||||||
|
const std::vector<u32>& parameters) {
|
||||||
|
const u32 instance_count = (maxwell3d.GetRegisterValue(0xD1B) & parameters[2]);
|
||||||
|
const u32 element_base = parameters[4];
|
||||||
|
const u32 base_instance = parameters[5];
|
||||||
|
maxwell3d.regs.index_array.first = parameters[3];
|
||||||
|
maxwell3d.regs.reg_array[0x446] = element_base; // vertex id base?
|
||||||
|
maxwell3d.regs.index_array.count = parameters[1];
|
||||||
|
maxwell3d.regs.vb_element_base = element_base;
|
||||||
|
maxwell3d.regs.vb_base_instance = base_instance;
|
||||||
|
maxwell3d.mme_draw.instance_count = instance_count;
|
||||||
|
maxwell3d.CallMethodFromMME(0x8e3, 0x640);
|
||||||
|
maxwell3d.CallMethodFromMME(0x8e4, element_base);
|
||||||
|
maxwell3d.CallMethodFromMME(0x8e5, base_instance);
|
||||||
|
maxwell3d.regs.draw.topology.Assign(
|
||||||
|
static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0]));
|
||||||
|
if (maxwell3d.ShouldExecute()) {
|
||||||
|
maxwell3d.GetRasterizer().Draw(true, true);
|
||||||
|
}
|
||||||
|
maxwell3d.regs.reg_array[0x446] = 0x0; // vertex id base?
|
||||||
|
maxwell3d.regs.index_array.count = 0;
|
||||||
|
maxwell3d.regs.vb_element_base = 0x0;
|
||||||
|
maxwell3d.regs.vb_base_instance = 0x0;
|
||||||
|
maxwell3d.mme_draw.instance_count = 0;
|
||||||
|
maxwell3d.CallMethodFromMME(0x8e3, 0x640);
|
||||||
|
maxwell3d.CallMethodFromMME(0x8e4, 0x0);
|
||||||
|
maxwell3d.CallMethodFromMME(0x8e5, 0x0);
|
||||||
|
maxwell3d.mme_draw.current_mode = Engines::Maxwell3D::MMEDrawMode::Undefined;
|
||||||
|
}
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
constexpr std::array<std::pair<u64, HLEFunction>, 3> hle_funcs{{
|
||||||
|
std::make_pair<u64, HLEFunction>(0x771BB18C62444DA0, &HLE_771BB18C62444DA0),
|
||||||
|
std::make_pair<u64, HLEFunction>(0x0D61FC9FAAC9FCAD, &HLE_0D61FC9FAAC9FCAD),
|
||||||
|
std::make_pair<u64, HLEFunction>(0x0217920100488FF7, &HLE_0217920100488FF7),
|
||||||
|
}};
|
||||||
|
|
||||||
|
HLEMacro::HLEMacro(Engines::Maxwell3D& maxwell3d) : maxwell3d(maxwell3d) {}
|
||||||
|
HLEMacro::~HLEMacro() = default;
|
||||||
|
|
||||||
|
std::optional<std::unique_ptr<CachedMacro>> HLEMacro::GetHLEProgram(u64 hash) const {
|
||||||
|
const auto it = std::find_if(hle_funcs.cbegin(), hle_funcs.cend(),
|
||||||
|
[hash](const auto& pair) { return pair.first == hash; });
|
||||||
|
if (it == hle_funcs.end()) {
|
||||||
|
return std::nullopt;
|
||||||
|
}
|
||||||
|
return std::make_unique<HLEMacroImpl>(maxwell3d, it->second);
|
||||||
|
}
|
||||||
|
|
||||||
|
HLEMacroImpl::~HLEMacroImpl() = default;
|
||||||
|
|
||||||
|
HLEMacroImpl::HLEMacroImpl(Engines::Maxwell3D& maxwell3d, HLEFunction func)
|
||||||
|
: maxwell3d(maxwell3d), func(func) {}
|
||||||
|
|
||||||
|
void HLEMacroImpl::Execute(const std::vector<u32>& parameters, u32 method) {
|
||||||
|
func(maxwell3d, parameters);
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace Tegra
|
||||||
@ -0,0 +1,44 @@
|
|||||||
|
// Copyright 2020 yuzu Emulator Project
|
||||||
|
// Licensed under GPLv2 or any later version
|
||||||
|
// Refer to the license.txt file included.
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <memory>
|
||||||
|
#include <optional>
|
||||||
|
#include <vector>
|
||||||
|
#include "common/common_types.h"
|
||||||
|
#include "video_core/macro/macro.h"
|
||||||
|
|
||||||
|
namespace Tegra {
|
||||||
|
|
||||||
|
namespace Engines {
|
||||||
|
class Maxwell3D;
|
||||||
|
}
|
||||||
|
|
||||||
|
using HLEFunction = void (*)(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& parameters);
|
||||||
|
|
||||||
|
class HLEMacro {
|
||||||
|
public:
|
||||||
|
explicit HLEMacro(Engines::Maxwell3D& maxwell3d);
|
||||||
|
~HLEMacro();
|
||||||
|
|
||||||
|
std::optional<std::unique_ptr<CachedMacro>> GetHLEProgram(u64 hash) const;
|
||||||
|
|
||||||
|
private:
|
||||||
|
Engines::Maxwell3D& maxwell3d;
|
||||||
|
};
|
||||||
|
|
||||||
|
class HLEMacroImpl : public CachedMacro {
|
||||||
|
public:
|
||||||
|
explicit HLEMacroImpl(Engines::Maxwell3D& maxwell3d, HLEFunction func);
|
||||||
|
~HLEMacroImpl();
|
||||||
|
|
||||||
|
void Execute(const std::vector<u32>& parameters, u32 method) override;
|
||||||
|
|
||||||
|
private:
|
||||||
|
Engines::Maxwell3D& maxwell3d;
|
||||||
|
HLEFunction func;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace Tegra
|
||||||
@ -0,0 +1,621 @@
|
|||||||
|
// Copyright 2020 yuzu Emulator Project
|
||||||
|
// Licensed under GPLv2 or any later version
|
||||||
|
// Refer to the license.txt file included.
|
||||||
|
|
||||||
|
#include "common/assert.h"
|
||||||
|
#include "common/logging/log.h"
|
||||||
|
#include "common/microprofile.h"
|
||||||
|
#include "common/x64/xbyak_util.h"
|
||||||
|
#include "video_core/engines/maxwell_3d.h"
|
||||||
|
#include "video_core/macro/macro_interpreter.h"
|
||||||
|
#include "video_core/macro/macro_jit_x64.h"
|
||||||
|
|
||||||
|
MICROPROFILE_DEFINE(MacroJitCompile, "GPU", "Compile macro JIT", MP_RGB(173, 255, 47));
|
||||||
|
MICROPROFILE_DEFINE(MacroJitExecute, "GPU", "Execute macro JIT", MP_RGB(255, 255, 0));
|
||||||
|
|
||||||
|
namespace Tegra {
|
||||||
|
static const Xbyak::Reg64 STATE = Xbyak::util::rbx;
|
||||||
|
static const Xbyak::Reg32 RESULT = Xbyak::util::ebp;
|
||||||
|
static const Xbyak::Reg64 PARAMETERS = Xbyak::util::r12;
|
||||||
|
static const Xbyak::Reg32 METHOD_ADDRESS = Xbyak::util::r14d;
|
||||||
|
static const Xbyak::Reg64 BRANCH_HOLDER = Xbyak::util::r15;
|
||||||
|
|
||||||
|
static const std::bitset<32> PERSISTENT_REGISTERS = Common::X64::BuildRegSet({
|
||||||
|
STATE,
|
||||||
|
RESULT,
|
||||||
|
PARAMETERS,
|
||||||
|
METHOD_ADDRESS,
|
||||||
|
BRANCH_HOLDER,
|
||||||
|
});
|
||||||
|
|
||||||
|
MacroJITx64::MacroJITx64(Engines::Maxwell3D& maxwell3d)
|
||||||
|
: MacroEngine::MacroEngine(maxwell3d), maxwell3d(maxwell3d) {}
|
||||||
|
|
||||||
|
std::unique_ptr<CachedMacro> MacroJITx64::Compile(const std::vector<u32>& code) {
|
||||||
|
return std::make_unique<MacroJITx64Impl>(maxwell3d, code);
|
||||||
|
}
|
||||||
|
|
||||||
|
MacroJITx64Impl::MacroJITx64Impl(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& code)
|
||||||
|
: Xbyak::CodeGenerator(MAX_CODE_SIZE), code(code), maxwell3d(maxwell3d) {
|
||||||
|
Compile();
|
||||||
|
}
|
||||||
|
|
||||||
|
MacroJITx64Impl::~MacroJITx64Impl() = default;
|
||||||
|
|
||||||
|
void MacroJITx64Impl::Execute(const std::vector<u32>& parameters, u32 method) {
|
||||||
|
MICROPROFILE_SCOPE(MacroJitExecute);
|
||||||
|
ASSERT_OR_EXECUTE(program != nullptr, { return; });
|
||||||
|
JITState state{};
|
||||||
|
state.maxwell3d = &maxwell3d;
|
||||||
|
state.registers = {};
|
||||||
|
program(&state, parameters.data());
|
||||||
|
}
|
||||||
|
|
||||||
|
void MacroJITx64Impl::Compile_ALU(Macro::Opcode opcode) {
|
||||||
|
const bool is_a_zero = opcode.src_a == 0;
|
||||||
|
const bool is_b_zero = opcode.src_b == 0;
|
||||||
|
const bool valid_operation = !is_a_zero && !is_b_zero;
|
||||||
|
[[maybe_unused]] const bool is_move_operation = !is_a_zero && is_b_zero;
|
||||||
|
const bool has_zero_register = is_a_zero || is_b_zero;
|
||||||
|
const bool no_zero_reg_skip = opcode.alu_operation == Macro::ALUOperation::AddWithCarry ||
|
||||||
|
opcode.alu_operation == Macro::ALUOperation::SubtractWithBorrow;
|
||||||
|
|
||||||
|
Xbyak::Reg32 src_a;
|
||||||
|
Xbyak::Reg32 src_b;
|
||||||
|
|
||||||
|
if (!optimizer.zero_reg_skip || no_zero_reg_skip) {
|
||||||
|
src_a = Compile_GetRegister(opcode.src_a, RESULT);
|
||||||
|
src_b = Compile_GetRegister(opcode.src_b, eax);
|
||||||
|
} else {
|
||||||
|
if (!is_a_zero) {
|
||||||
|
src_a = Compile_GetRegister(opcode.src_a, RESULT);
|
||||||
|
}
|
||||||
|
if (!is_b_zero) {
|
||||||
|
src_b = Compile_GetRegister(opcode.src_b, eax);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
bool has_emitted = false;
|
||||||
|
|
||||||
|
switch (opcode.alu_operation) {
|
||||||
|
case Macro::ALUOperation::Add:
|
||||||
|
if (optimizer.zero_reg_skip) {
|
||||||
|
if (valid_operation) {
|
||||||
|
add(src_a, src_b);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
add(src_a, src_b);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!optimizer.can_skip_carry) {
|
||||||
|
setc(byte[STATE + offsetof(JITState, carry_flag)]);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case Macro::ALUOperation::AddWithCarry:
|
||||||
|
bt(dword[STATE + offsetof(JITState, carry_flag)], 0);
|
||||||
|
adc(src_a, src_b);
|
||||||
|
setc(byte[STATE + offsetof(JITState, carry_flag)]);
|
||||||
|
break;
|
||||||
|
case Macro::ALUOperation::Subtract:
|
||||||
|
if (optimizer.zero_reg_skip) {
|
||||||
|
if (valid_operation) {
|
||||||
|
sub(src_a, src_b);
|
||||||
|
has_emitted = true;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
sub(src_a, src_b);
|
||||||
|
has_emitted = true;
|
||||||
|
}
|
||||||
|
if (!optimizer.can_skip_carry && has_emitted) {
|
||||||
|
setc(byte[STATE + offsetof(JITState, carry_flag)]);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case Macro::ALUOperation::SubtractWithBorrow:
|
||||||
|
bt(dword[STATE + offsetof(JITState, carry_flag)], 0);
|
||||||
|
sbb(src_a, src_b);
|
||||||
|
setc(byte[STATE + offsetof(JITState, carry_flag)]);
|
||||||
|
break;
|
||||||
|
case Macro::ALUOperation::Xor:
|
||||||
|
if (optimizer.zero_reg_skip) {
|
||||||
|
if (valid_operation) {
|
||||||
|
xor_(src_a, src_b);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
xor_(src_a, src_b);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case Macro::ALUOperation::Or:
|
||||||
|
if (optimizer.zero_reg_skip) {
|
||||||
|
if (valid_operation) {
|
||||||
|
or_(src_a, src_b);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
or_(src_a, src_b);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case Macro::ALUOperation::And:
|
||||||
|
if (optimizer.zero_reg_skip) {
|
||||||
|
if (!has_zero_register) {
|
||||||
|
and_(src_a, src_b);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
and_(src_a, src_b);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case Macro::ALUOperation::AndNot:
|
||||||
|
if (optimizer.zero_reg_skip) {
|
||||||
|
if (!is_a_zero) {
|
||||||
|
not_(src_b);
|
||||||
|
and_(src_a, src_b);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
not_(src_b);
|
||||||
|
and_(src_a, src_b);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case Macro::ALUOperation::Nand:
|
||||||
|
if (optimizer.zero_reg_skip) {
|
||||||
|
if (!is_a_zero) {
|
||||||
|
and_(src_a, src_b);
|
||||||
|
not_(src_a);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
and_(src_a, src_b);
|
||||||
|
not_(src_a);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
UNIMPLEMENTED_MSG("Unimplemented ALU operation {}",
|
||||||
|
static_cast<std::size_t>(opcode.alu_operation.Value()));
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
Compile_ProcessResult(opcode.result_operation, opcode.dst);
|
||||||
|
}
|
||||||
|
|
||||||
|
void MacroJITx64Impl::Compile_AddImmediate(Macro::Opcode opcode) {
|
||||||
|
if (optimizer.skip_dummy_addimmediate) {
|
||||||
|
// Games tend to use this as an exit instruction placeholder. It's to encode an instruction
|
||||||
|
// without doing anything. In our case we can just not emit anything.
|
||||||
|
if (opcode.result_operation == Macro::ResultOperation::Move && opcode.dst == 0) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Check for redundant moves
|
||||||
|
if (optimizer.optimize_for_method_move &&
|
||||||
|
opcode.result_operation == Macro::ResultOperation::MoveAndSetMethod) {
|
||||||
|
if (next_opcode.has_value()) {
|
||||||
|
const auto next = *next_opcode;
|
||||||
|
if (next.result_operation == Macro::ResultOperation::MoveAndSetMethod &&
|
||||||
|
opcode.dst == next.dst) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (optimizer.zero_reg_skip && opcode.src_a == 0) {
|
||||||
|
if (opcode.immediate == 0) {
|
||||||
|
xor_(RESULT, RESULT);
|
||||||
|
} else {
|
||||||
|
mov(RESULT, opcode.immediate);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
auto result = Compile_GetRegister(opcode.src_a, RESULT);
|
||||||
|
if (opcode.immediate > 2) {
|
||||||
|
add(result, opcode.immediate);
|
||||||
|
} else if (opcode.immediate == 1) {
|
||||||
|
inc(result);
|
||||||
|
} else if (opcode.immediate < 0) {
|
||||||
|
sub(result, opcode.immediate * -1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Compile_ProcessResult(opcode.result_operation, opcode.dst);
|
||||||
|
}
|
||||||
|
|
||||||
|
void MacroJITx64Impl::Compile_ExtractInsert(Macro::Opcode opcode) {
|
||||||
|
auto dst = Compile_GetRegister(opcode.src_a, RESULT);
|
||||||
|
auto src = Compile_GetRegister(opcode.src_b, eax);
|
||||||
|
|
||||||
|
if (opcode.bf_src_bit != 0 && opcode.bf_src_bit != 31) {
|
||||||
|
shr(src, opcode.bf_src_bit);
|
||||||
|
} else if (opcode.bf_src_bit == 31) {
|
||||||
|
xor_(src, src);
|
||||||
|
}
|
||||||
|
// Don't bother masking the whole register since we're using a 32 bit register
|
||||||
|
if (opcode.bf_size != 31 && opcode.bf_size != 0) {
|
||||||
|
and_(src, opcode.GetBitfieldMask());
|
||||||
|
} else if (opcode.bf_size == 0) {
|
||||||
|
xor_(src, src);
|
||||||
|
}
|
||||||
|
if (opcode.bf_dst_bit != 31 && opcode.bf_dst_bit != 0) {
|
||||||
|
shl(src, opcode.bf_dst_bit);
|
||||||
|
} else if (opcode.bf_dst_bit == 31) {
|
||||||
|
xor_(src, src);
|
||||||
|
}
|
||||||
|
|
||||||
|
const u32 mask = ~(opcode.GetBitfieldMask() << opcode.bf_dst_bit);
|
||||||
|
if (mask != 0xffffffff) {
|
||||||
|
and_(dst, mask);
|
||||||
|
}
|
||||||
|
or_(dst, src);
|
||||||
|
Compile_ProcessResult(opcode.result_operation, opcode.dst);
|
||||||
|
}
|
||||||
|
|
||||||
|
void MacroJITx64Impl::Compile_ExtractShiftLeftImmediate(Macro::Opcode opcode) {
|
||||||
|
const auto dst = Compile_GetRegister(opcode.src_a, ecx);
|
||||||
|
const auto src = Compile_GetRegister(opcode.src_b, RESULT);
|
||||||
|
|
||||||
|
shr(src, dst.cvt8());
|
||||||
|
if (opcode.bf_size != 0 && opcode.bf_size != 31) {
|
||||||
|
and_(src, opcode.GetBitfieldMask());
|
||||||
|
} else if (opcode.bf_size == 0) {
|
||||||
|
xor_(src, src);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (opcode.bf_dst_bit != 0 && opcode.bf_dst_bit != 31) {
|
||||||
|
shl(src, opcode.bf_dst_bit);
|
||||||
|
} else if (opcode.bf_dst_bit == 31) {
|
||||||
|
xor_(src, src);
|
||||||
|
}
|
||||||
|
Compile_ProcessResult(opcode.result_operation, opcode.dst);
|
||||||
|
}
|
||||||
|
|
||||||
|
void MacroJITx64Impl::Compile_ExtractShiftLeftRegister(Macro::Opcode opcode) {
|
||||||
|
const auto dst = Compile_GetRegister(opcode.src_a, ecx);
|
||||||
|
const auto src = Compile_GetRegister(opcode.src_b, RESULT);
|
||||||
|
|
||||||
|
if (opcode.bf_src_bit != 0) {
|
||||||
|
shr(src, opcode.bf_src_bit);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (opcode.bf_size != 31) {
|
||||||
|
and_(src, opcode.GetBitfieldMask());
|
||||||
|
}
|
||||||
|
shl(src, dst.cvt8());
|
||||||
|
|
||||||
|
Compile_ProcessResult(opcode.result_operation, opcode.dst);
|
||||||
|
}
|
||||||
|
|
||||||
|
void MacroJITx64Impl::Compile_Read(Macro::Opcode opcode) {
|
||||||
|
if (optimizer.zero_reg_skip && opcode.src_a == 0) {
|
||||||
|
if (opcode.immediate == 0) {
|
||||||
|
xor_(RESULT, RESULT);
|
||||||
|
} else {
|
||||||
|
mov(RESULT, opcode.immediate);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
auto result = Compile_GetRegister(opcode.src_a, RESULT);
|
||||||
|
if (opcode.immediate > 2) {
|
||||||
|
add(result, opcode.immediate);
|
||||||
|
} else if (opcode.immediate == 1) {
|
||||||
|
inc(result);
|
||||||
|
} else if (opcode.immediate < 0) {
|
||||||
|
sub(result, opcode.immediate * -1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Equivalent to Engines::Maxwell3D::GetRegisterValue:
|
||||||
|
if (optimizer.enable_asserts) {
|
||||||
|
Xbyak::Label pass_range_check;
|
||||||
|
cmp(RESULT, static_cast<u32>(Engines::Maxwell3D::Regs::NUM_REGS));
|
||||||
|
jb(pass_range_check);
|
||||||
|
int3();
|
||||||
|
L(pass_range_check);
|
||||||
|
}
|
||||||
|
mov(rax, qword[STATE]);
|
||||||
|
mov(RESULT,
|
||||||
|
dword[rax + offsetof(Engines::Maxwell3D, regs) +
|
||||||
|
offsetof(Engines::Maxwell3D::Regs, reg_array) + RESULT.cvt64() * sizeof(u32)]);
|
||||||
|
|
||||||
|
Compile_ProcessResult(opcode.result_operation, opcode.dst);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void Send(Engines::Maxwell3D* maxwell3d, Macro::MethodAddress method_address, u32 value) {
|
||||||
|
maxwell3d->CallMethodFromMME(method_address.address, value);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Tegra::MacroJITx64Impl::Compile_Send(Xbyak::Reg32 value) {
|
||||||
|
Common::X64::ABI_PushRegistersAndAdjustStack(*this, PersistentCallerSavedRegs(), 0);
|
||||||
|
mov(Common::X64::ABI_PARAM1, qword[STATE]);
|
||||||
|
mov(Common::X64::ABI_PARAM2, METHOD_ADDRESS);
|
||||||
|
mov(Common::X64::ABI_PARAM3, value);
|
||||||
|
Common::X64::CallFarFunction(*this, &Send);
|
||||||
|
Common::X64::ABI_PopRegistersAndAdjustStack(*this, PersistentCallerSavedRegs(), 0);
|
||||||
|
|
||||||
|
Xbyak::Label dont_process{};
|
||||||
|
// Get increment
|
||||||
|
test(METHOD_ADDRESS, 0x3f000);
|
||||||
|
// If zero, method address doesn't update
|
||||||
|
je(dont_process);
|
||||||
|
|
||||||
|
mov(ecx, METHOD_ADDRESS);
|
||||||
|
and_(METHOD_ADDRESS, 0xfff);
|
||||||
|
shr(ecx, 12);
|
||||||
|
and_(ecx, 0x3f);
|
||||||
|
lea(eax, ptr[rcx + METHOD_ADDRESS.cvt64()]);
|
||||||
|
sal(ecx, 12);
|
||||||
|
or_(eax, ecx);
|
||||||
|
|
||||||
|
mov(METHOD_ADDRESS, eax);
|
||||||
|
|
||||||
|
L(dont_process);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Tegra::MacroJITx64Impl::Compile_Branch(Macro::Opcode opcode) {
|
||||||
|
ASSERT_MSG(!is_delay_slot, "Executing a branch in a delay slot is not valid");
|
||||||
|
const s32 jump_address =
|
||||||
|
static_cast<s32>(pc) + static_cast<s32>(opcode.GetBranchTarget() / sizeof(s32));
|
||||||
|
|
||||||
|
Xbyak::Label end;
|
||||||
|
auto value = Compile_GetRegister(opcode.src_a, eax);
|
||||||
|
test(value, value);
|
||||||
|
if (optimizer.has_delayed_pc) {
|
||||||
|
switch (opcode.branch_condition) {
|
||||||
|
case Macro::BranchCondition::Zero:
|
||||||
|
jne(end, T_NEAR);
|
||||||
|
break;
|
||||||
|
case Macro::BranchCondition::NotZero:
|
||||||
|
je(end, T_NEAR);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (opcode.branch_annul) {
|
||||||
|
xor_(BRANCH_HOLDER, BRANCH_HOLDER);
|
||||||
|
jmp(labels[jump_address], T_NEAR);
|
||||||
|
} else {
|
||||||
|
Xbyak::Label handle_post_exit{};
|
||||||
|
Xbyak::Label skip{};
|
||||||
|
jmp(skip, T_NEAR);
|
||||||
|
if (opcode.is_exit) {
|
||||||
|
L(handle_post_exit);
|
||||||
|
// Execute 1 instruction
|
||||||
|
mov(BRANCH_HOLDER, end_of_code);
|
||||||
|
// Jump to next instruction to skip delay slot check
|
||||||
|
jmp(labels[jump_address], T_NEAR);
|
||||||
|
} else {
|
||||||
|
L(handle_post_exit);
|
||||||
|
xor_(BRANCH_HOLDER, BRANCH_HOLDER);
|
||||||
|
jmp(labels[jump_address], T_NEAR);
|
||||||
|
}
|
||||||
|
L(skip);
|
||||||
|
mov(BRANCH_HOLDER, handle_post_exit);
|
||||||
|
jmp(delay_skip[pc], T_NEAR);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
switch (opcode.branch_condition) {
|
||||||
|
case Macro::BranchCondition::Zero:
|
||||||
|
je(labels[jump_address], T_NEAR);
|
||||||
|
break;
|
||||||
|
case Macro::BranchCondition::NotZero:
|
||||||
|
jne(labels[jump_address], T_NEAR);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
L(end);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Tegra::MacroJITx64Impl::Optimizer_ScanFlags() {
|
||||||
|
optimizer.can_skip_carry = true;
|
||||||
|
optimizer.has_delayed_pc = false;
|
||||||
|
for (auto raw_op : code) {
|
||||||
|
Macro::Opcode op{};
|
||||||
|
op.raw = raw_op;
|
||||||
|
|
||||||
|
if (op.operation == Macro::Operation::ALU) {
|
||||||
|
// Scan for any ALU operations which actually use the carry flag, if they don't exist in
|
||||||
|
// our current code we can skip emitting the carry flag handling operations
|
||||||
|
if (op.alu_operation == Macro::ALUOperation::AddWithCarry ||
|
||||||
|
op.alu_operation == Macro::ALUOperation::SubtractWithBorrow) {
|
||||||
|
optimizer.can_skip_carry = false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (op.operation == Macro::Operation::Branch) {
|
||||||
|
if (!op.branch_annul) {
|
||||||
|
optimizer.has_delayed_pc = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void MacroJITx64Impl::Compile() {
|
||||||
|
MICROPROFILE_SCOPE(MacroJitCompile);
|
||||||
|
bool keep_executing = true;
|
||||||
|
labels.fill(Xbyak::Label());
|
||||||
|
|
||||||
|
Common::X64::ABI_PushRegistersAndAdjustStack(*this, Common::X64::ABI_ALL_CALLEE_SAVED, 8);
|
||||||
|
// JIT state
|
||||||
|
mov(STATE, Common::X64::ABI_PARAM1);
|
||||||
|
mov(PARAMETERS, Common::X64::ABI_PARAM2);
|
||||||
|
xor_(RESULT, RESULT);
|
||||||
|
xor_(METHOD_ADDRESS, METHOD_ADDRESS);
|
||||||
|
xor_(BRANCH_HOLDER, BRANCH_HOLDER);
|
||||||
|
|
||||||
|
mov(dword[STATE + offsetof(JITState, registers) + 4], Compile_FetchParameter());
|
||||||
|
|
||||||
|
// Track get register for zero registers and mark it as no-op
|
||||||
|
optimizer.zero_reg_skip = true;
|
||||||
|
|
||||||
|
// AddImmediate tends to be used as a NOP instruction, if we detect this we can
|
||||||
|
// completely skip the entire code path and no emit anything
|
||||||
|
optimizer.skip_dummy_addimmediate = true;
|
||||||
|
|
||||||
|
// SMO tends to emit a lot of unnecessary method moves, we can mitigate this by only emitting
|
||||||
|
// one if our register isn't "dirty"
|
||||||
|
optimizer.optimize_for_method_move = true;
|
||||||
|
|
||||||
|
// Enable run-time assertions in JITted code
|
||||||
|
optimizer.enable_asserts = false;
|
||||||
|
|
||||||
|
// Check to see if we can skip emitting certain instructions
|
||||||
|
Optimizer_ScanFlags();
|
||||||
|
|
||||||
|
const u32 op_count = static_cast<u32>(code.size());
|
||||||
|
for (u32 i = 0; i < op_count; i++) {
|
||||||
|
if (i < op_count - 1) {
|
||||||
|
pc = i + 1;
|
||||||
|
next_opcode = GetOpCode();
|
||||||
|
} else {
|
||||||
|
next_opcode = {};
|
||||||
|
}
|
||||||
|
pc = i;
|
||||||
|
Compile_NextInstruction();
|
||||||
|
}
|
||||||
|
|
||||||
|
L(end_of_code);
|
||||||
|
|
||||||
|
Common::X64::ABI_PopRegistersAndAdjustStack(*this, Common::X64::ABI_ALL_CALLEE_SAVED, 8);
|
||||||
|
ret();
|
||||||
|
ready();
|
||||||
|
program = getCode<ProgramType>();
|
||||||
|
}
|
||||||
|
|
||||||
|
bool MacroJITx64Impl::Compile_NextInstruction() {
|
||||||
|
const auto opcode = GetOpCode();
|
||||||
|
if (labels[pc].getAddress()) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
L(labels[pc]);
|
||||||
|
|
||||||
|
switch (opcode.operation) {
|
||||||
|
case Macro::Operation::ALU:
|
||||||
|
Compile_ALU(opcode);
|
||||||
|
break;
|
||||||
|
case Macro::Operation::AddImmediate:
|
||||||
|
Compile_AddImmediate(opcode);
|
||||||
|
break;
|
||||||
|
case Macro::Operation::ExtractInsert:
|
||||||
|
Compile_ExtractInsert(opcode);
|
||||||
|
break;
|
||||||
|
case Macro::Operation::ExtractShiftLeftImmediate:
|
||||||
|
Compile_ExtractShiftLeftImmediate(opcode);
|
||||||
|
break;
|
||||||
|
case Macro::Operation::ExtractShiftLeftRegister:
|
||||||
|
Compile_ExtractShiftLeftRegister(opcode);
|
||||||
|
break;
|
||||||
|
case Macro::Operation::Read:
|
||||||
|
Compile_Read(opcode);
|
||||||
|
break;
|
||||||
|
case Macro::Operation::Branch:
|
||||||
|
Compile_Branch(opcode);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
UNIMPLEMENTED_MSG("Unimplemented opcode {}", opcode.operation.Value());
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (optimizer.has_delayed_pc) {
|
||||||
|
if (opcode.is_exit) {
|
||||||
|
mov(rax, end_of_code);
|
||||||
|
test(BRANCH_HOLDER, BRANCH_HOLDER);
|
||||||
|
cmove(BRANCH_HOLDER, rax);
|
||||||
|
// Jump to next instruction to skip delay slot check
|
||||||
|
je(labels[pc + 1], T_NEAR);
|
||||||
|
} else {
|
||||||
|
// TODO(ogniK): Optimize delay slot branching
|
||||||
|
Xbyak::Label no_delay_slot{};
|
||||||
|
test(BRANCH_HOLDER, BRANCH_HOLDER);
|
||||||
|
je(no_delay_slot, T_NEAR);
|
||||||
|
mov(rax, BRANCH_HOLDER);
|
||||||
|
xor_(BRANCH_HOLDER, BRANCH_HOLDER);
|
||||||
|
jmp(rax);
|
||||||
|
L(no_delay_slot);
|
||||||
|
}
|
||||||
|
L(delay_skip[pc]);
|
||||||
|
if (opcode.is_exit) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
test(BRANCH_HOLDER, BRANCH_HOLDER);
|
||||||
|
jne(end_of_code, T_NEAR);
|
||||||
|
if (opcode.is_exit) {
|
||||||
|
inc(BRANCH_HOLDER);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
Xbyak::Reg32 Tegra::MacroJITx64Impl::Compile_FetchParameter() {
|
||||||
|
mov(eax, dword[PARAMETERS]);
|
||||||
|
add(PARAMETERS, sizeof(u32));
|
||||||
|
return eax;
|
||||||
|
}
|
||||||
|
|
||||||
|
Xbyak::Reg32 MacroJITx64Impl::Compile_GetRegister(u32 index, Xbyak::Reg32 dst) {
|
||||||
|
if (index == 0) {
|
||||||
|
// Register 0 is always zero
|
||||||
|
xor_(dst, dst);
|
||||||
|
} else {
|
||||||
|
mov(dst, dword[STATE + offsetof(JITState, registers) + index * sizeof(u32)]);
|
||||||
|
}
|
||||||
|
|
||||||
|
return dst;
|
||||||
|
}
|
||||||
|
|
||||||
|
void MacroJITx64Impl::Compile_ProcessResult(Macro::ResultOperation operation, u32 reg) {
|
||||||
|
const auto SetRegister = [this](u32 reg, const Xbyak::Reg32& result) {
|
||||||
|
// Register 0 is supposed to always return 0. NOP is implemented as a store to the zero
|
||||||
|
// register.
|
||||||
|
if (reg == 0) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
mov(dword[STATE + offsetof(JITState, registers) + reg * sizeof(u32)], result);
|
||||||
|
};
|
||||||
|
const auto SetMethodAddress = [this](const Xbyak::Reg32& reg) { mov(METHOD_ADDRESS, reg); };
|
||||||
|
|
||||||
|
switch (operation) {
|
||||||
|
case Macro::ResultOperation::IgnoreAndFetch:
|
||||||
|
SetRegister(reg, Compile_FetchParameter());
|
||||||
|
break;
|
||||||
|
case Macro::ResultOperation::Move:
|
||||||
|
SetRegister(reg, RESULT);
|
||||||
|
break;
|
||||||
|
case Macro::ResultOperation::MoveAndSetMethod:
|
||||||
|
SetRegister(reg, RESULT);
|
||||||
|
SetMethodAddress(RESULT);
|
||||||
|
break;
|
||||||
|
case Macro::ResultOperation::FetchAndSend:
|
||||||
|
// Fetch parameter and send result.
|
||||||
|
SetRegister(reg, Compile_FetchParameter());
|
||||||
|
Compile_Send(RESULT);
|
||||||
|
break;
|
||||||
|
case Macro::ResultOperation::MoveAndSend:
|
||||||
|
// Move and send result.
|
||||||
|
SetRegister(reg, RESULT);
|
||||||
|
Compile_Send(RESULT);
|
||||||
|
break;
|
||||||
|
case Macro::ResultOperation::FetchAndSetMethod:
|
||||||
|
// Fetch parameter and use result as Method Address.
|
||||||
|
SetRegister(reg, Compile_FetchParameter());
|
||||||
|
SetMethodAddress(RESULT);
|
||||||
|
break;
|
||||||
|
case Macro::ResultOperation::MoveAndSetMethodFetchAndSend:
|
||||||
|
// Move result and use as Method Address, then fetch and send parameter.
|
||||||
|
SetRegister(reg, RESULT);
|
||||||
|
SetMethodAddress(RESULT);
|
||||||
|
Compile_Send(Compile_FetchParameter());
|
||||||
|
break;
|
||||||
|
case Macro::ResultOperation::MoveAndSetMethodSend:
|
||||||
|
// Move result and use as Method Address, then send bits 12:17 of result.
|
||||||
|
SetRegister(reg, RESULT);
|
||||||
|
SetMethodAddress(RESULT);
|
||||||
|
shr(RESULT, 12);
|
||||||
|
and_(RESULT, 0b111111);
|
||||||
|
Compile_Send(RESULT);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
UNIMPLEMENTED_MSG("Unimplemented macro operation {}", static_cast<std::size_t>(operation));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Macro::Opcode MacroJITx64Impl::GetOpCode() const {
|
||||||
|
ASSERT(pc < code.size());
|
||||||
|
return {code[pc]};
|
||||||
|
}
|
||||||
|
|
||||||
|
std::bitset<32> MacroJITx64Impl::PersistentCallerSavedRegs() const {
|
||||||
|
return PERSISTENT_REGISTERS & Common::X64::ABI_ALL_CALLER_SAVED;
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace Tegra
|
||||||
@ -0,0 +1,98 @@
|
|||||||
|
// Copyright 2020 yuzu Emulator Project
|
||||||
|
// Licensed under GPLv2 or any later version
|
||||||
|
// Refer to the license.txt file included.
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <array>
|
||||||
|
#include <bitset>
|
||||||
|
#include <xbyak.h>
|
||||||
|
#include "common/bit_field.h"
|
||||||
|
#include "common/common_types.h"
|
||||||
|
#include "common/x64/xbyak_abi.h"
|
||||||
|
#include "video_core/macro/macro.h"
|
||||||
|
|
||||||
|
namespace Tegra {
|
||||||
|
|
||||||
|
namespace Engines {
|
||||||
|
class Maxwell3D;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// MAX_CODE_SIZE is arbitrarily chosen based on current booting games
|
||||||
|
constexpr size_t MAX_CODE_SIZE = 0x10000;
|
||||||
|
|
||||||
|
class MacroJITx64 final : public MacroEngine {
|
||||||
|
public:
|
||||||
|
explicit MacroJITx64(Engines::Maxwell3D& maxwell3d);
|
||||||
|
|
||||||
|
protected:
|
||||||
|
std::unique_ptr<CachedMacro> Compile(const std::vector<u32>& code) override;
|
||||||
|
|
||||||
|
private:
|
||||||
|
Engines::Maxwell3D& maxwell3d;
|
||||||
|
};
|
||||||
|
|
||||||
|
class MacroJITx64Impl : public Xbyak::CodeGenerator, public CachedMacro {
|
||||||
|
public:
|
||||||
|
MacroJITx64Impl(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& code);
|
||||||
|
~MacroJITx64Impl();
|
||||||
|
|
||||||
|
void Execute(const std::vector<u32>& parameters, u32 method) override;
|
||||||
|
|
||||||
|
void Compile_ALU(Macro::Opcode opcode);
|
||||||
|
void Compile_AddImmediate(Macro::Opcode opcode);
|
||||||
|
void Compile_ExtractInsert(Macro::Opcode opcode);
|
||||||
|
void Compile_ExtractShiftLeftImmediate(Macro::Opcode opcode);
|
||||||
|
void Compile_ExtractShiftLeftRegister(Macro::Opcode opcode);
|
||||||
|
void Compile_Read(Macro::Opcode opcode);
|
||||||
|
void Compile_Branch(Macro::Opcode opcode);
|
||||||
|
|
||||||
|
private:
|
||||||
|
void Optimizer_ScanFlags();
|
||||||
|
|
||||||
|
void Compile();
|
||||||
|
bool Compile_NextInstruction();
|
||||||
|
|
||||||
|
Xbyak::Reg32 Compile_FetchParameter();
|
||||||
|
Xbyak::Reg32 Compile_GetRegister(u32 index, Xbyak::Reg32 dst);
|
||||||
|
|
||||||
|
void Compile_ProcessResult(Macro::ResultOperation operation, u32 reg);
|
||||||
|
void Compile_Send(Xbyak::Reg32 value);
|
||||||
|
|
||||||
|
Macro::Opcode GetOpCode() const;
|
||||||
|
std::bitset<32> PersistentCallerSavedRegs() const;
|
||||||
|
|
||||||
|
struct JITState {
|
||||||
|
Engines::Maxwell3D* maxwell3d{};
|
||||||
|
std::array<u32, Macro::NUM_MACRO_REGISTERS> registers{};
|
||||||
|
u32 carry_flag{};
|
||||||
|
};
|
||||||
|
static_assert(offsetof(JITState, maxwell3d) == 0, "Maxwell3D is not at 0x0");
|
||||||
|
using ProgramType = void (*)(JITState*, const u32*);
|
||||||
|
|
||||||
|
struct OptimizerState {
|
||||||
|
bool can_skip_carry{};
|
||||||
|
bool has_delayed_pc{};
|
||||||
|
bool zero_reg_skip{};
|
||||||
|
bool skip_dummy_addimmediate{};
|
||||||
|
bool optimize_for_method_move{};
|
||||||
|
bool enable_asserts{};
|
||||||
|
};
|
||||||
|
OptimizerState optimizer{};
|
||||||
|
|
||||||
|
std::optional<Macro::Opcode> next_opcode{};
|
||||||
|
ProgramType program{nullptr};
|
||||||
|
|
||||||
|
std::array<Xbyak::Label, MAX_CODE_SIZE> labels;
|
||||||
|
std::array<Xbyak::Label, MAX_CODE_SIZE> delay_skip;
|
||||||
|
Xbyak::Label end_of_code{};
|
||||||
|
|
||||||
|
bool is_delay_slot{};
|
||||||
|
u32 pc{};
|
||||||
|
std::optional<u32> delayed_pc;
|
||||||
|
|
||||||
|
const std::vector<u32>& code;
|
||||||
|
Engines::Maxwell3D& maxwell3d;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace Tegra
|
||||||
@ -1,7 +0,0 @@
|
|||||||
// Copyright 2018 yuzu Emulator Project
|
|
||||||
// Licensed under GPLv2 or any later version
|
|
||||||
// Refer to the license.txt file included.
|
|
||||||
|
|
||||||
#include "video_core/rasterizer_cache.h"
|
|
||||||
|
|
||||||
RasterizerCacheObject::~RasterizerCacheObject() = default;
|
|
||||||
@ -1,253 +0,0 @@
|
|||||||
// Copyright 2018 yuzu Emulator Project
|
|
||||||
// Licensed under GPLv2 or any later version
|
|
||||||
// Refer to the license.txt file included.
|
|
||||||
|
|
||||||
#pragma once
|
|
||||||
|
|
||||||
#include <mutex>
|
|
||||||
#include <set>
|
|
||||||
#include <unordered_map>
|
|
||||||
|
|
||||||
#include <boost/icl/interval_map.hpp>
|
|
||||||
#include <boost/range/iterator_range_core.hpp>
|
|
||||||
|
|
||||||
#include "common/common_types.h"
|
|
||||||
#include "core/settings.h"
|
|
||||||
#include "video_core/gpu.h"
|
|
||||||
#include "video_core/rasterizer_interface.h"
|
|
||||||
|
|
||||||
class RasterizerCacheObject {
|
|
||||||
public:
|
|
||||||
explicit RasterizerCacheObject(const VAddr cpu_addr) : cpu_addr{cpu_addr} {}
|
|
||||||
|
|
||||||
virtual ~RasterizerCacheObject();
|
|
||||||
|
|
||||||
VAddr GetCpuAddr() const {
|
|
||||||
return cpu_addr;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Gets the size of the shader in guest memory, required for cache management
|
|
||||||
virtual std::size_t GetSizeInBytes() const = 0;
|
|
||||||
|
|
||||||
/// Sets whether the cached object should be considered registered
|
|
||||||
void SetIsRegistered(bool registered) {
|
|
||||||
is_registered = registered;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns true if the cached object is registered
|
|
||||||
bool IsRegistered() const {
|
|
||||||
return is_registered;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns true if the cached object is dirty
|
|
||||||
bool IsDirty() const {
|
|
||||||
return is_dirty;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns ticks from when this cached object was last modified
|
|
||||||
u64 GetLastModifiedTicks() const {
|
|
||||||
return last_modified_ticks;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Marks an object as recently modified, used to specify whether it is clean or dirty
|
|
||||||
template <class T>
|
|
||||||
void MarkAsModified(bool dirty, T& cache) {
|
|
||||||
is_dirty = dirty;
|
|
||||||
last_modified_ticks = cache.GetModifiedTicks();
|
|
||||||
}
|
|
||||||
|
|
||||||
void SetMemoryMarked(bool is_memory_marked_) {
|
|
||||||
is_memory_marked = is_memory_marked_;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool IsMemoryMarked() const {
|
|
||||||
return is_memory_marked;
|
|
||||||
}
|
|
||||||
|
|
||||||
void SetSyncPending(bool is_sync_pending_) {
|
|
||||||
is_sync_pending = is_sync_pending_;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool IsSyncPending() const {
|
|
||||||
return is_sync_pending;
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
bool is_registered{}; ///< Whether the object is currently registered with the cache
|
|
||||||
bool is_dirty{}; ///< Whether the object is dirty (out of sync with guest memory)
|
|
||||||
bool is_memory_marked{}; ///< Whether the object is marking rasterizer memory.
|
|
||||||
bool is_sync_pending{}; ///< Whether the object is pending deletion.
|
|
||||||
u64 last_modified_ticks{}; ///< When the object was last modified, used for in-order flushing
|
|
||||||
VAddr cpu_addr{}; ///< Cpu address memory, unique from emulated virtual address space
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class T>
|
|
||||||
class RasterizerCache : NonCopyable {
|
|
||||||
friend class RasterizerCacheObject;
|
|
||||||
|
|
||||||
public:
|
|
||||||
explicit RasterizerCache(VideoCore::RasterizerInterface& rasterizer) : rasterizer{rasterizer} {}
|
|
||||||
|
|
||||||
/// Write any cached resources overlapping the specified region back to memory
|
|
||||||
void FlushRegion(VAddr addr, std::size_t size) {
|
|
||||||
std::lock_guard lock{mutex};
|
|
||||||
|
|
||||||
const auto& objects{GetSortedObjectsFromRegion(addr, size)};
|
|
||||||
for (auto& object : objects) {
|
|
||||||
FlushObject(object);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Mark the specified region as being invalidated
|
|
||||||
void InvalidateRegion(VAddr addr, u64 size) {
|
|
||||||
std::lock_guard lock{mutex};
|
|
||||||
|
|
||||||
const auto& objects{GetSortedObjectsFromRegion(addr, size)};
|
|
||||||
for (auto& object : objects) {
|
|
||||||
if (!object->IsRegistered()) {
|
|
||||||
// Skip duplicates
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
Unregister(object);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void OnCPUWrite(VAddr addr, std::size_t size) {
|
|
||||||
std::lock_guard lock{mutex};
|
|
||||||
|
|
||||||
for (const auto& object : GetSortedObjectsFromRegion(addr, size)) {
|
|
||||||
if (object->IsRegistered()) {
|
|
||||||
UnmarkMemory(object);
|
|
||||||
object->SetSyncPending(true);
|
|
||||||
marked_for_unregister.emplace_back(object);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void SyncGuestHost() {
|
|
||||||
std::lock_guard lock{mutex};
|
|
||||||
|
|
||||||
for (const auto& object : marked_for_unregister) {
|
|
||||||
if (object->IsRegistered()) {
|
|
||||||
object->SetSyncPending(false);
|
|
||||||
Unregister(object);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
marked_for_unregister.clear();
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Invalidates everything in the cache
|
|
||||||
void InvalidateAll() {
|
|
||||||
std::lock_guard lock{mutex};
|
|
||||||
|
|
||||||
while (interval_cache.begin() != interval_cache.end()) {
|
|
||||||
Unregister(*interval_cache.begin()->second.begin());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
protected:
|
|
||||||
/// Tries to get an object from the cache with the specified cache address
|
|
||||||
T TryGet(VAddr addr) const {
|
|
||||||
const auto iter = map_cache.find(addr);
|
|
||||||
if (iter != map_cache.end())
|
|
||||||
return iter->second;
|
|
||||||
return nullptr;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Register an object into the cache
|
|
||||||
virtual void Register(const T& object) {
|
|
||||||
std::lock_guard lock{mutex};
|
|
||||||
|
|
||||||
object->SetIsRegistered(true);
|
|
||||||
interval_cache.add({GetInterval(object), ObjectSet{object}});
|
|
||||||
map_cache.insert({object->GetCpuAddr(), object});
|
|
||||||
rasterizer.UpdatePagesCachedCount(object->GetCpuAddr(), object->GetSizeInBytes(), 1);
|
|
||||||
object->SetMemoryMarked(true);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Unregisters an object from the cache
|
|
||||||
virtual void Unregister(const T& object) {
|
|
||||||
std::lock_guard lock{mutex};
|
|
||||||
|
|
||||||
UnmarkMemory(object);
|
|
||||||
object->SetIsRegistered(false);
|
|
||||||
if (object->IsSyncPending()) {
|
|
||||||
marked_for_unregister.remove(object);
|
|
||||||
object->SetSyncPending(false);
|
|
||||||
}
|
|
||||||
const VAddr addr = object->GetCpuAddr();
|
|
||||||
interval_cache.subtract({GetInterval(object), ObjectSet{object}});
|
|
||||||
map_cache.erase(addr);
|
|
||||||
}
|
|
||||||
|
|
||||||
void UnmarkMemory(const T& object) {
|
|
||||||
if (!object->IsMemoryMarked()) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
rasterizer.UpdatePagesCachedCount(object->GetCpuAddr(), object->GetSizeInBytes(), -1);
|
|
||||||
object->SetMemoryMarked(false);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns a ticks counter used for tracking when cached objects were last modified
|
|
||||||
u64 GetModifiedTicks() {
|
|
||||||
std::lock_guard lock{mutex};
|
|
||||||
|
|
||||||
return ++modified_ticks;
|
|
||||||
}
|
|
||||||
|
|
||||||
virtual void FlushObjectInner(const T& object) = 0;
|
|
||||||
|
|
||||||
/// Flushes the specified object, updating appropriate cache state as needed
|
|
||||||
void FlushObject(const T& object) {
|
|
||||||
std::lock_guard lock{mutex};
|
|
||||||
|
|
||||||
if (!object->IsDirty()) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
FlushObjectInner(object);
|
|
||||||
object->MarkAsModified(false, *this);
|
|
||||||
}
|
|
||||||
|
|
||||||
std::recursive_mutex mutex;
|
|
||||||
|
|
||||||
private:
|
|
||||||
/// Returns a list of cached objects from the specified memory region, ordered by access time
|
|
||||||
std::vector<T> GetSortedObjectsFromRegion(VAddr addr, u64 size) {
|
|
||||||
if (size == 0) {
|
|
||||||
return {};
|
|
||||||
}
|
|
||||||
|
|
||||||
std::vector<T> objects;
|
|
||||||
const ObjectInterval interval{addr, addr + size};
|
|
||||||
for (auto& pair : boost::make_iterator_range(interval_cache.equal_range(interval))) {
|
|
||||||
for (auto& cached_object : pair.second) {
|
|
||||||
if (!cached_object) {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
objects.push_back(cached_object);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
std::sort(objects.begin(), objects.end(), [](const T& a, const T& b) -> bool {
|
|
||||||
return a->GetLastModifiedTicks() < b->GetLastModifiedTicks();
|
|
||||||
});
|
|
||||||
|
|
||||||
return objects;
|
|
||||||
}
|
|
||||||
|
|
||||||
using ObjectSet = std::set<T>;
|
|
||||||
using ObjectCache = std::unordered_map<VAddr, T>;
|
|
||||||
using IntervalCache = boost::icl::interval_map<VAddr, ObjectSet>;
|
|
||||||
using ObjectInterval = typename IntervalCache::interval_type;
|
|
||||||
|
|
||||||
static auto GetInterval(const T& object) {
|
|
||||||
return ObjectInterval::right_open(object->GetCpuAddr(),
|
|
||||||
object->GetCpuAddr() + object->GetSizeInBytes());
|
|
||||||
}
|
|
||||||
|
|
||||||
ObjectCache map_cache;
|
|
||||||
IntervalCache interval_cache; ///< Cache of objects
|
|
||||||
u64 modified_ticks{}; ///< Counter of cache state ticks, used for in-order flushing
|
|
||||||
VideoCore::RasterizerInterface& rasterizer;
|
|
||||||
std::list<T> marked_for_unregister;
|
|
||||||
};
|
|
||||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,29 @@
|
|||||||
|
// Copyright 2020 yuzu Emulator Project
|
||||||
|
// Licensed under GPLv2 or any later version
|
||||||
|
// Refer to the license.txt file included.
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <string>
|
||||||
|
#include <string_view>
|
||||||
|
|
||||||
|
#include "common/common_types.h"
|
||||||
|
|
||||||
|
namespace Tegra::Engines {
|
||||||
|
enum class ShaderType : u32;
|
||||||
|
}
|
||||||
|
|
||||||
|
namespace VideoCommon::Shader {
|
||||||
|
class ShaderIR;
|
||||||
|
class Registry;
|
||||||
|
} // namespace VideoCommon::Shader
|
||||||
|
|
||||||
|
namespace OpenGL {
|
||||||
|
|
||||||
|
class Device;
|
||||||
|
|
||||||
|
std::string DecompileAssemblyShader(const Device& device, const VideoCommon::Shader::ShaderIR& ir,
|
||||||
|
const VideoCommon::Shader::Registry& registry,
|
||||||
|
Tegra::Engines::ShaderType stage, std::string_view identifier);
|
||||||
|
|
||||||
|
} // namespace OpenGL
|
||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue