131 lines
4.9 KiB
C++
131 lines
4.9 KiB
C++
/* This file is part of the dynarmic project.
|
|
* Copyright (c) 2016 MerryMage
|
|
* SPDX-License-Identifier: 0BSD
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <array>
|
|
#include <optional>
|
|
#include <string>
|
|
#include <type_traits>
|
|
#include <vector>
|
|
|
|
#include <tsl/robin_map.h>
|
|
#include <tsl/robin_set.h>
|
|
|
|
#include <xbyak_util.h>
|
|
|
|
#include "backend/x64/exception_handler.h"
|
|
#include "backend/x64/reg_alloc.h"
|
|
#include "common/bit_util.h"
|
|
#include "common/fp/fpcr.h"
|
|
#include "ir/location_descriptor.h"
|
|
#include "ir/terminal.h"
|
|
|
|
namespace Dynarmic::IR {
|
|
class Block;
|
|
class Inst;
|
|
} // namespace Dynarmic::IR
|
|
|
|
namespace Dynarmic {
|
|
enum class OptimizationFlag : u32;
|
|
} // namespace Dynarmic
|
|
|
|
namespace Dynarmic::Backend::X64 {
|
|
|
|
class BlockOfCode;
|
|
|
|
using A64FullVectorWidth = std::integral_constant<size_t, 128>;
|
|
|
|
// Array alias that always sizes itself according to the given type T
|
|
// relative to the size of a vector register. e.g. T = u32 would result
|
|
// in a std::array<u32, 4>.
|
|
template <typename T>
|
|
using VectorArray = std::array<T, A64FullVectorWidth::value / Common::BitSize<T>()>;
|
|
|
|
template <typename T>
|
|
using HalfVectorArray = std::array<T, A64FullVectorWidth::value / Common::BitSize<T>() / 2>;
|
|
|
|
struct EmitContext {
|
|
EmitContext(RegAlloc& reg_alloc, IR::Block& block);
|
|
|
|
size_t GetInstOffset(IR::Inst* inst) const;
|
|
void EraseInstruction(IR::Inst* inst);
|
|
|
|
virtual FP::FPCR FPCR(bool fpcr_controlled = true) const = 0;
|
|
|
|
virtual bool HasOptimization(OptimizationFlag flag) const = 0;
|
|
|
|
RegAlloc& reg_alloc;
|
|
IR::Block& block;
|
|
};
|
|
|
|
class EmitX64 {
|
|
public:
|
|
struct BlockDescriptor {
|
|
CodePtr entrypoint; // Entrypoint of emitted code
|
|
size_t size; // Length in bytes of emitted code
|
|
};
|
|
|
|
explicit EmitX64(BlockOfCode& code);
|
|
virtual ~EmitX64();
|
|
|
|
/// Looks up an emitted host block in the cache.
|
|
std::optional<BlockDescriptor> GetBasicBlock(IR::LocationDescriptor descriptor) const;
|
|
|
|
/// Empties the entire cache.
|
|
virtual void ClearCache();
|
|
|
|
/// Invalidates a selection of basic blocks.
|
|
void InvalidateBasicBlocks(const tsl::robin_set<IR::LocationDescriptor>& locations);
|
|
|
|
protected:
|
|
// Microinstruction emitters
|
|
#define OPCODE(name, type, ...) void Emit##name(EmitContext& ctx, IR::Inst* inst);
|
|
#define A32OPC(...)
|
|
#define A64OPC(...)
|
|
#include "ir/opcodes.inc"
|
|
#undef OPCODE
|
|
#undef A32OPC
|
|
#undef A64OPC
|
|
|
|
// Helpers
|
|
virtual std::string LocationDescriptorToFriendlyName(const IR::LocationDescriptor&) const = 0;
|
|
void EmitAddCycles(size_t cycles);
|
|
Xbyak::Label EmitCond(IR::Cond cond);
|
|
BlockDescriptor RegisterBlock(const IR::LocationDescriptor& location_descriptor, CodePtr entrypoint, CodePtr entrypoint_far, size_t size);
|
|
void PushRSBHelper(Xbyak::Reg64 loc_desc_reg, Xbyak::Reg64 index_reg, IR::LocationDescriptor target);
|
|
|
|
// Terminal instruction emitters
|
|
void EmitTerminal(IR::Terminal terminal, IR::LocationDescriptor initial_location, bool is_single_step);
|
|
virtual void EmitTerminalImpl(IR::Term::Interpret terminal, IR::LocationDescriptor initial_location, bool is_single_step) = 0;
|
|
virtual void EmitTerminalImpl(IR::Term::ReturnToDispatch terminal, IR::LocationDescriptor initial_location, bool is_single_step) = 0;
|
|
virtual void EmitTerminalImpl(IR::Term::LinkBlock terminal, IR::LocationDescriptor initial_location, bool is_single_step) = 0;
|
|
virtual void EmitTerminalImpl(IR::Term::LinkBlockFast terminal, IR::LocationDescriptor initial_location, bool is_single_step) = 0;
|
|
virtual void EmitTerminalImpl(IR::Term::PopRSBHint terminal, IR::LocationDescriptor initial_location, bool is_single_step) = 0;
|
|
virtual void EmitTerminalImpl(IR::Term::FastDispatchHint terminal, IR::LocationDescriptor initial_location, bool is_single_step) = 0;
|
|
virtual void EmitTerminalImpl(IR::Term::If terminal, IR::LocationDescriptor initial_location, bool is_single_step) = 0;
|
|
virtual void EmitTerminalImpl(IR::Term::CheckBit terminal, IR::LocationDescriptor initial_location, bool is_single_step) = 0;
|
|
virtual void EmitTerminalImpl(IR::Term::CheckHalt terminal, IR::LocationDescriptor initial_location, bool is_single_step) = 0;
|
|
|
|
// Patching
|
|
struct PatchInformation {
|
|
std::vector<CodePtr> jg;
|
|
std::vector<CodePtr> jmp;
|
|
std::vector<CodePtr> mov_rcx;
|
|
};
|
|
void Patch(const IR::LocationDescriptor& target_desc, CodePtr target_code_ptr);
|
|
virtual void Unpatch(const IR::LocationDescriptor& target_desc);
|
|
virtual void EmitPatchJg(const IR::LocationDescriptor& target_desc, CodePtr target_code_ptr = nullptr) = 0;
|
|
virtual void EmitPatchJmp(const IR::LocationDescriptor& target_desc, CodePtr target_code_ptr = nullptr) = 0;
|
|
virtual void EmitPatchMovRcx(CodePtr target_code_ptr = nullptr) = 0;
|
|
|
|
// State
|
|
BlockOfCode& code;
|
|
ExceptionHandler exception_handler;
|
|
tsl::robin_map<IR::LocationDescriptor, BlockDescriptor> block_descriptors;
|
|
tsl::robin_map<IR::LocationDescriptor, PatchInformation> patch_information;
|
|
};
|
|
|
|
} // namespace Dynarmic::Backend::X64
|