CoCalc -- cpu_recompiler

GitHub Repository: stenzek/duckstation
Path: blob/master/src/core/cpu_recompiler_arm64.h
⁴²²³ views
1
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <[email protected]>
2
// SPDX-License-Identifier: CC-BY-NC-ND-4.0
3

4
#pragma once
5

6
#include "cpu_recompiler.h"
7

8
#include <memory>
9

10
#ifdef CPU_ARCH_ARM64
11

12
#include "vixl/aarch64/assembler-aarch64.h"
13

14
namespace CPU {
15

16
class ARM64Recompiler final : public Recompiler
17
{
18
public:
19
  ARM64Recompiler();
20
  ~ARM64Recompiler() override;
21

22
protected:
23
  const char* GetHostRegName(u32 reg) const override;
24

25
  const void* GetCurrentCodePointer() override;
26

27
  void LoadHostRegWithConstant(u32 reg, u32 val) override;
28
  void LoadHostRegFromCPUPointer(u32 reg, const void* ptr) override;
29
  void StoreConstantToCPUPointer(u32 val, const void* ptr) override;
30
  void StoreHostRegToCPUPointer(u32 reg, const void* ptr) override;
31
  void CopyHostReg(u32 dst, u32 src) override;
32

33
  void Reset(CodeCache::Block* block, u8* code_buffer, u32 code_buffer_space, u8* far_code_buffer,
34
             u32 far_code_space) override;
35
  void BeginBlock() override;
36
  void GenerateBlockProtectCheck(const u8* ram_ptr, const u8* shadow_ptr, u32 size) override;
37
  void GenerateICacheCheckAndUpdate() override;
38
  void GenerateCall(const void* func, s32 arg1reg = -1, s32 arg2reg = -1, s32 arg3reg = -1) override;
39
  void EndBlock(const std::optional<u32>& newpc, bool do_event_test) override;
40
  void EndBlockWithException(Exception excode) override;
41
  void EndAndLinkBlock(const std::optional<u32>& newpc, bool do_event_test, bool force_run_events);
42
  const void* EndCompile(u32* code_size, u32* far_code_size) override;
43

44
  void Flush(u32 flags) override;
45

46
  void Compile_Fallback() override;
47

48
  void CheckBranchTarget(const vixl::aarch64::Register& pcreg);
49
  void Compile_jr(CompileFlags cf) override;
50
  void Compile_jalr(CompileFlags cf) override;
51
  void Compile_bxx(CompileFlags cf, BranchCondition cond) override;
52

53
  void Compile_addi(CompileFlags cf, bool overflow);
54
  void Compile_addi(CompileFlags cf) override;
55
  void Compile_addiu(CompileFlags cf) override;
56
  void Compile_slti(CompileFlags cf, bool sign);
57
  void Compile_slti(CompileFlags cf) override;
58
  void Compile_sltiu(CompileFlags cf) override;
59
  void Compile_andi(CompileFlags cf) override;
60
  void Compile_ori(CompileFlags cf) override;
61
  void Compile_xori(CompileFlags cf) override;
62

63
  void Compile_shift(CompileFlags cf, void (vixl::aarch64::Assembler::*op)(const vixl::aarch64::Register&,
64
                                                                           const vixl::aarch64::Register&, unsigned));
65
  void Compile_sll(CompileFlags cf) override;
66
  void Compile_srl(CompileFlags cf) override;
67
  void Compile_sra(CompileFlags cf) override;
68
  void Compile_variable_shift(CompileFlags cf,
69
                              void (vixl::aarch64::Assembler::*op)(const vixl::aarch64::Register&,
70
                                                                   const vixl::aarch64::Register&,
71
                                                                   const vixl::aarch64::Register&),
72
                              void (vixl::aarch64::Assembler::*op_const)(const vixl::aarch64::Register&,
73
                                                                         const vixl::aarch64::Register&, unsigned));
74
  void Compile_sllv(CompileFlags cf) override;
75
  void Compile_srlv(CompileFlags cf) override;
76
  void Compile_srav(CompileFlags cf) override;
77
  void Compile_mult(CompileFlags cf, bool sign);
78
  void Compile_mult(CompileFlags cf) override;
79
  void Compile_multu(CompileFlags cf) override;
80
  void Compile_div(CompileFlags cf) override;
81
  void Compile_divu(CompileFlags cf) override;
82
  void TestOverflow(const vixl::aarch64::Register& result);
83
  void Compile_dst_op(CompileFlags cf,
84
                      void (vixl::aarch64::Assembler::*op)(const vixl::aarch64::Register&,
85
                                                           const vixl::aarch64::Register&,
86
                                                           const vixl::aarch64::Operand&),
87
                      bool commutative, bool logical, bool overflow);
88
  void Compile_add(CompileFlags cf) override;
89
  void Compile_addu(CompileFlags cf) override;
90
  void Compile_sub(CompileFlags cf) override;
91
  void Compile_subu(CompileFlags cf) override;
92
  void Compile_and(CompileFlags cf) override;
93
  void Compile_or(CompileFlags cf) override;
94
  void Compile_xor(CompileFlags cf) override;
95
  void Compile_nor(CompileFlags cf) override;
96
  void Compile_slt(CompileFlags cf, bool sign);
97
  void Compile_slt(CompileFlags cf) override;
98
  void Compile_sltu(CompileFlags cf) override;
99

100
  vixl::aarch64::Register
101
  ComputeLoadStoreAddressArg(CompileFlags cf, const std::optional<VirtualMemoryAddress>& address,
102
                             const std::optional<const vixl::aarch64::Register>& reg = std::nullopt);
103
  template<typename RegAllocFn>
104
  vixl::aarch64::Register GenerateLoad(const vixl::aarch64::Register& addr_reg, MemoryAccessSize size, bool sign,
105
                                       bool use_fastmem, const RegAllocFn& dst_reg_alloc);
106
  void GenerateStore(const vixl::aarch64::Register& addr_reg, const vixl::aarch64::Register& value_reg,
107
                     MemoryAccessSize size, bool use_fastmem);
108
  void Compile_lxx(CompileFlags cf, MemoryAccessSize size, bool sign, bool use_fastmem,
109
                   const std::optional<VirtualMemoryAddress>& address) override;
110
  void Compile_lwx(CompileFlags cf, MemoryAccessSize size, bool sign, bool use_fastmem,
111
                   const std::optional<VirtualMemoryAddress>& address) override;
112
  void Compile_lwc2(CompileFlags cf, MemoryAccessSize size, bool sign, bool use_fastmem,
113
                    const std::optional<VirtualMemoryAddress>& address) override;
114
  void Compile_sxx(CompileFlags cf, MemoryAccessSize size, bool sign, bool use_fastmem,
115
                   const std::optional<VirtualMemoryAddress>& address) override;
116
  void Compile_swx(CompileFlags cf, MemoryAccessSize size, bool sign, bool use_fastmem,
117
                   const std::optional<VirtualMemoryAddress>& address) override;
118
  void Compile_swc2(CompileFlags cf, MemoryAccessSize size, bool sign, bool use_fastmem,
119
                    const std::optional<VirtualMemoryAddress>& address) override;
120

121
  void TestInterrupts(const vixl::aarch64::Register& sr);
122
  void Compile_mtc0(CompileFlags cf) override;
123
  void Compile_rfe(CompileFlags cf) override;
124

125
  void Compile_mfc2(CompileFlags cf) override;
126
  void Compile_mtc2(CompileFlags cf) override;
127
  void Compile_cop2(CompileFlags cf) override;
128

129
  void GeneratePGXPCallWithMIPSRegs(const void* func, u32 arg1val, Reg arg2reg = Reg::count,
130
                                    Reg arg3reg = Reg::count) override;
131

132
private:
133
  void EmitMov(const vixl::aarch64::Register& dst, u32 val);
134
  void EmitCall(const void* ptr, bool force_inline = false);
135

136
  vixl::aarch64::Operand armCheckAddSubConstant(s32 val);
137
  vixl::aarch64::Operand armCheckAddSubConstant(u32 val);
138
  vixl::aarch64::Operand armCheckCompareConstant(s32 val);
139
  vixl::aarch64::Operand armCheckLogicalConstant(u32 val);
140

141
  void SwitchToFarCode(bool emit_jump, vixl::aarch64::Condition cond = vixl::aarch64::Condition::al);
142
  void SwitchToFarCodeIfBitSet(const vixl::aarch64::Register& reg, u32 bit);
143
  void SwitchToFarCodeIfRegZeroOrNonZero(const vixl::aarch64::Register& reg, bool nonzero);
144
  void SwitchToNearCode(bool emit_jump, vixl::aarch64::Condition cond = vixl::aarch64::Condition::al);
145

146
  void AssertRegOrConstS(CompileFlags cf) const;
147
  void AssertRegOrConstT(CompileFlags cf) const;
148
  vixl::aarch64::MemOperand MipsPtr(Reg r) const;
149
  vixl::aarch64::Register CFGetRegD(CompileFlags cf) const;
150
  vixl::aarch64::Register CFGetRegS(CompileFlags cf) const;
151
  vixl::aarch64::Register CFGetRegT(CompileFlags cf) const;
152
  vixl::aarch64::Register CFGetRegLO(CompileFlags cf) const;
153
  vixl::aarch64::Register CFGetRegHI(CompileFlags cf) const;
154

155
  void MoveSToReg(const vixl::aarch64::Register& dst, CompileFlags cf);
156
  void MoveTToReg(const vixl::aarch64::Register& dst, CompileFlags cf);
157
  void MoveMIPSRegToReg(const vixl::aarch64::Register& dst, Reg reg);
158

159
  vixl::aarch64::Assembler m_emitter;
160
  vixl::aarch64::Assembler m_far_emitter;
161
  vixl::aarch64::Assembler* armAsm;
162

163
#ifdef VIXL_DEBUG
164
  std::unique_ptr<vixl::CodeBufferCheckScope> m_emitter_check;
165
  std::unique_ptr<vixl::CodeBufferCheckScope> m_far_emitter_check;
166
#endif
167
};
168

169
} // namespace CPU
170

171
#endif // CPU_ARCH_ARM64
172

173
Product

Resources

Company
