1
// Copyright (c) 2012- PPSSPP Project.
3
// This program is free software: you can redistribute it and/or modify
4
// it under the terms of the GNU General Public License as published by
5
// the Free Software Foundation, version 2.0 or later versions.
7
// This program is distributed in the hope that it will be useful,
8
// but WITHOUT ANY WARRANTY; without even the implied warranty of
9
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10
// GNU General Public License 2.0 for more details.
12
// A copy of the GPL 2.0 should have been included with the program.
13
// If not, see http://www.gnu.org/licenses/
15
// Official git repository and contact information can be found at
16
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
18
#include "Core/Config.h"
19
#include "Core/MemMap.h"
20
#include "Common/Common.h"
21
#include "Core/MIPS/MIPS.h"
22
#include "Core/MIPS/MIPSCodeUtils.h"
23
#include "Core/MIPS/x86/Jit.h"
24
#include "Core/MIPS/x86/RegCache.h"
26
#define _RS MIPS_GET_RS(op)
27
#define _RT MIPS_GET_RT(op)
28
#define _RD MIPS_GET_RD(op)
29
#define _FS MIPS_GET_FS(op)
30
#define _FT MIPS_GET_FT(op)
31
#define _FD MIPS_GET_FD(op)
32
#define _SA MIPS_GET_SA(op)
33
#define _POS ((op>> 6) & 0x1F)
34
#define _SIZE ((op>>11) & 0x1F)
35
#define _IMM16 (signed short)(op & 0xFFFF)
36
#define _IMM26 (op & 0x03FFFFFF)
38
// All functions should have CONDITIONAL_DISABLE, so we can narrow things down to a file quickly.
39
// Currently known non working ones should have DISABLE.
41
// #define CONDITIONAL_DISABLE { Comp_Generic(op); return; }
42
#define CONDITIONAL_DISABLE ;
43
#define DISABLE { Comp_Generic(op); return; }
48
using namespace X64JitConstants;
50
void Jit::CopyFPReg(X64Reg dst, OpArg src) {
51
if (src.IsSimpleReg()) {
58
void Jit::CompFPTriArith(MIPSOpcode op, void (XEmitter::*arith)(X64Reg reg, OpArg), bool orderMatters) {
62
fpr.SpillLock(fd, fs, ft);
65
fpr.MapReg(fd, true, true);
66
(this->*arith)(fpr.RX(fd), fpr.R(ft));
67
} else if (ft == fd && !orderMatters) {
68
fpr.MapReg(fd, true, true);
69
(this->*arith)(fpr.RX(fd), fpr.R(fs));
70
} else if (ft != fd) {
71
// fs can't be fd (handled above.)
72
fpr.MapReg(fd, false, true);
73
CopyFPReg(fpr.RX(fd), fpr.R(fs));
74
(this->*arith)(fpr.RX(fd), fpr.R(ft));
76
// fd must be ft, and order must matter.
77
fpr.MapReg(fd, true, true);
78
CopyFPReg(XMM0, fpr.R(fs));
79
(this->*arith)(XMM0, fpr.R(ft));
80
MOVAPS(fpr.RX(fd), R(XMM0));
82
fpr.ReleaseSpillLocks();
85
void Jit::Comp_FPU3op(MIPSOpcode op) {
88
case 0: CompFPTriArith(op, &XEmitter::ADDSS, false); break; //F(fd) = F(fs) + F(ft); //add
89
case 1: CompFPTriArith(op, &XEmitter::SUBSS, true); break; //F(fd) = F(fs) - F(ft); //sub
90
case 2: CompFPTriArith(op, &XEmitter::MULSS, false); break; //F(fd) = F(fs) * F(ft); //mul
91
case 3: CompFPTriArith(op, &XEmitter::DIVSS, true); break; //F(fd) = F(fs) / F(ft); //div
93
_dbg_assert_msg_(CPU,0,"Trying to compile FPU3Op instruction that can't be interpreted");
98
static u32 MEMORY_ALIGNED16(ssLoadStoreTemp);
100
void Jit::Comp_FPULS(MIPSOpcode op) {
107
case 49: //FI(ft) = Memory::Read_U32(addr); break; //lwc1
111
fpr.MapReg(ft, false, true);
113
JitSafeMem safe(this, rs, offset);
115
if (safe.PrepareRead(src, 4))
116
MOVSS(fpr.RX(ft), src);
117
if (safe.PrepareSlowRead(safeMemFuncs.readU32))
118
MOVD_xmm(fpr.RX(ft), R(EAX));
122
fpr.ReleaseSpillLocks();
125
case 57: //Memory::Write_U32(FI(ft), addr); break; //swc1
129
fpr.MapReg(ft, true, false);
131
JitSafeMem safe(this, rs, offset);
133
if (safe.PrepareWrite(dest, 4))
134
MOVSS(dest, fpr.RX(ft));
135
if (safe.PrepareSlowWrite())
137
MOVSS(M(&ssLoadStoreTemp), fpr.RX(ft));
138
safe.DoSlowWrite(safeMemFuncs.writeU32, M(&ssLoadStoreTemp));
143
fpr.ReleaseSpillLocks();
148
_dbg_assert_msg_(CPU,0,"Trying to interpret FPULS instruction that can't be interpreted");
153
static const u64 MEMORY_ALIGNED16(ssOneBits[2]) = {0x0000000100000001ULL, 0x0000000100000001ULL};
154
static const u64 MEMORY_ALIGNED16(ssSignBits2[2]) = {0x8000000080000000ULL, 0x8000000080000000ULL};
155
static const u64 MEMORY_ALIGNED16(ssNoSignMask[2]) = {0x7FFFFFFF7FFFFFFFULL, 0x7FFFFFFF7FFFFFFFULL};
157
void Jit::CompFPComp(int lhs, int rhs, u8 compare, bool allowNaN) {
158
gpr.MapReg(MIPS_REG_FPCOND, false, true);
160
// This means that NaN also means true, e.g. !<> or !>, etc.
162
CopyFPReg(XMM0, fpr.R(lhs));
163
CopyFPReg(XMM1, fpr.R(lhs));
164
CMPSS(XMM0, fpr.R(rhs), compare);
165
CMPUNORDSS(XMM1, fpr.R(rhs));
169
CopyFPReg(XMM0, fpr.R(lhs));
170
CMPSS(XMM0, fpr.R(rhs), compare);
173
MOVD_xmm(gpr.R(MIPS_REG_FPCOND), XMM0);
176
void Jit::Comp_FPUComp(MIPSOpcode op) {
185
gpr.SetImm(MIPS_REG_FPCOND, 0);
190
CompFPComp(fs, ft, CMP_UNORD);
195
CompFPComp(fs, ft, CMP_EQ);
200
CompFPComp(fs, ft, CMP_EQ, true);
205
CompFPComp(fs, ft, CMP_LT);
210
CompFPComp(ft, fs, CMP_NLE);
215
CompFPComp(fs, ft, CMP_LE);
220
CompFPComp(ft, fs, CMP_NLT);
228
static u32 mxcsrTemp;
230
void Jit::Comp_FPU2op(MIPSOpcode op) {
236
auto execRounding = [&](void (XEmitter::*conv)(X64Reg, OpArg), int setMXCSR) {
237
fpr.SpillLock(fd, fs);
238
fpr.MapReg(fd, fs == fd, true);
240
// Small optimization: 0 is our default mode anyway.
241
if (setMXCSR == 0 && !js.hasSetRounding) {
244
if (setMXCSR != -1) {
245
STMXCSR(M(&mxcsrTemp));
246
MOV(32, R(TEMPREG), M(&mxcsrTemp));
247
AND(32, R(TEMPREG), Imm32(~(3 << 13)));
248
OR(32, R(TEMPREG), Imm32(setMXCSR << 13));
249
MOV(32, M(&mips_->temp), R(TEMPREG));
250
LDMXCSR(M(&mips_->temp));
253
(this->*conv)(TEMPREG, fpr.R(fs));
255
// Did we get an indefinite integer value?
256
CMP(32, R(TEMPREG), Imm32(0x80000000));
257
FixupBranch skip = J_CC(CC_NE);
259
CopyFPReg(fpr.RX(fd), fpr.R(fs));
261
XORPS(XMM1, R(XMM1));
262
CMPSS(fpr.RX(fd), R(XMM1), CMP_LT);
264
// At this point, -inf = 0xffffffff, inf/nan = 0x00000000.
265
// We want -inf to be 0x80000000 inf/nan to be 0x7fffffff, so we flip those bits.
266
MOVD_xmm(R(TEMPREG), fpr.RX(fd));
267
XOR(32, R(TEMPREG), Imm32(0x7fffffff));
270
MOVD_xmm(fpr.RX(fd), R(TEMPREG));
272
if (setMXCSR != -1) {
273
LDMXCSR(M(&mxcsrTemp));
278
case 5: //F(fd) = fabsf(F(fs)); break; //abs
279
fpr.SpillLock(fd, fs);
280
fpr.MapReg(fd, fd == fs, true);
281
if (fd != fs && fpr.IsMapped(fs)) {
282
MOVAPS(fpr.RX(fd), M(ssNoSignMask));
283
ANDPS(fpr.RX(fd), fpr.R(fs));
286
MOVSS(fpr.RX(fd), fpr.R(fs));
288
ANDPS(fpr.RX(fd), M(ssNoSignMask));
292
case 6: //F(fd) = F(fs); break; //mov
294
fpr.SpillLock(fd, fs);
295
fpr.MapReg(fd, fd == fs, true);
296
CopyFPReg(fpr.RX(fd), fpr.R(fs));
300
case 7: //F(fd) = -F(fs); break; //neg
301
fpr.SpillLock(fd, fs);
302
fpr.MapReg(fd, fd == fs, true);
303
if (fd != fs && fpr.IsMapped(fs)) {
304
MOVAPS(fpr.RX(fd), M(ssSignBits2));
305
XORPS(fpr.RX(fd), fpr.R(fs));
308
MOVSS(fpr.RX(fd), fpr.R(fs));
310
XORPS(fpr.RX(fd), M(ssSignBits2));
315
case 4: //F(fd) = sqrtf(F(fs)); break; //sqrt
316
fpr.SpillLock(fd, fs);
317
fpr.MapReg(fd, fd == fs, true);
318
SQRTSS(fpr.RX(fd), fpr.R(fs));
321
case 13: //FsI(fd) = F(fs)>=0 ? (int)floorf(F(fs)) : (int)ceilf(F(fs)); break;//trunc.w.s
322
execRounding(&XEmitter::CVTTSS2SI, -1);
325
case 32: //F(fd) = (float)FsI(fs); break; //cvt.s.w
326
fpr.SpillLock(fd, fs);
327
fpr.MapReg(fd, fs == fd, true);
328
if (fpr.IsMapped(fs)) {
329
CVTDQ2PS(fpr.RX(fd), fpr.R(fs));
331
// If fs was fd, we'd be in the case above since we mapped fd.
332
MOVSS(fpr.RX(fd), fpr.R(fs));
333
CVTDQ2PS(fpr.RX(fd), fpr.R(fd));
337
case 36: //FsI(fd) = (int) F(fs); break; //cvt.w.s
338
// Uses the current rounding mode.
339
execRounding(&XEmitter::CVTSS2SI, -1);
342
case 12: //FsI(fd) = (int)floorf(F(fs)+0.5f); break; //round.w.s
343
execRounding(&XEmitter::CVTSS2SI, 0);
345
case 14: //FsI(fd) = (int)ceilf (F(fs)); break; //ceil.w.s
346
execRounding(&XEmitter::CVTSS2SI, 2);
348
case 15: //FsI(fd) = (int)floorf(F(fs)); break; //floor.w.s
349
execRounding(&XEmitter::CVTSS2SI, 1);
355
fpr.ReleaseSpillLocks();
358
void Jit::Comp_mxc1(MIPSOpcode op) {
364
switch ((op >> 21) & 0x1f) {
365
case 0: // R(rt) = FI(fs); break; //mfc1
366
if (rt == MIPS_REG_ZERO)
368
gpr.MapReg(rt, false, true);
369
// If fs is not mapped, most likely it's being abandoned.
370
// Just load from memory in that case.
371
if (fpr.R(fs).IsSimpleReg()) {
372
MOVD_xmm(gpr.R(rt), fpr.RX(fs));
374
MOV(32, gpr.R(rt), fpr.R(fs));
378
case 2: // R(rt) = currentMIPS->ReadFCR(fs); break; //cfc1
379
if (rt == MIPS_REG_ZERO)
382
bool wasImm = gpr.IsImm(MIPS_REG_FPCOND);
384
gpr.Lock(rt, MIPS_REG_FPCOND);
385
gpr.MapReg(MIPS_REG_FPCOND, true, false);
387
gpr.MapReg(rt, false, true);
388
MOV(32, gpr.R(rt), M(&mips_->fcr31));
390
if (gpr.GetImm(MIPS_REG_FPCOND) & 1) {
391
OR(32, gpr.R(rt), Imm32(1 << 23));
393
AND(32, gpr.R(rt), Imm32(~(1 << 23)));
396
AND(32, gpr.R(rt), Imm32(~(1 << 23)));
397
MOV(32, R(TEMPREG), gpr.R(MIPS_REG_FPCOND));
398
AND(32, R(TEMPREG), Imm32(1));
399
SHL(32, R(TEMPREG), Imm8(23));
400
OR(32, gpr.R(rt), R(TEMPREG));
403
} else if (fs == 0) {
404
gpr.SetImm(rt, MIPSState::FCR0_VALUE);
410
case 4: //FI(fs) = R(rt); break; //mtc1
411
fpr.MapReg(fs, false, true);
412
if (gpr.IsImm(rt) && gpr.GetImm(rt) == 0) {
413
XORPS(fpr.RX(fs), fpr.R(fs));
415
gpr.KillImmediate(rt, true, false);
416
MOVD_xmm(fpr.RX(fs), gpr.R(rt));
420
case 6: //currentMIPS->WriteFCR(fs, R(rt)); break; //ctc1
422
// Must clear before setting, since ApplyRoundingMode() assumes it was cleared.
423
RestoreRoundingMode();
425
gpr.SetImm(MIPS_REG_FPCOND, (gpr.GetImm(rt) >> 23) & 1);
426
MOV(32, M(&mips_->fcr31), Imm32(gpr.GetImm(rt) & 0x0181FFFF));
427
if ((gpr.GetImm(rt) & 0x1000003) == 0) {
428
// Default nearest / no-flush mode, just leave it cleared.
430
UpdateRoundingMode();
434
gpr.Lock(rt, MIPS_REG_FPCOND);
435
gpr.MapReg(rt, true, false);
436
gpr.MapReg(MIPS_REG_FPCOND, false, true);
437
MOV(32, gpr.R(MIPS_REG_FPCOND), gpr.R(rt));
438
SHR(32, gpr.R(MIPS_REG_FPCOND), Imm8(23));
439
AND(32, gpr.R(MIPS_REG_FPCOND), Imm32(1));
440
MOV(32, M(&mips_->fcr31), gpr.R(rt));
441
AND(32, M(&mips_->fcr31), Imm32(0x0181FFFF));
443
UpdateRoundingMode();
453
} // namespace MIPSComp
added
removed
Core/MIPS/x86/CompFPU.cpp
