From 4ac773e8b4c1e3e7d871ef4be3388c67252d8837 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sat, 14 May 2016 18:20:55 -0700 Subject: [PATCH 1/5] jit-ir: Implement bit reverse instruction. --- Core/MIPS/IR/IRCompALU.cpp | 30 +++++++++++++++++++----------- Core/MIPS/IR/IRInst.cpp | 1 + Core/MIPS/IR/IRInst.h | 1 + Core/MIPS/IR/IRInterpreter.cpp | 3 +++ Core/MIPS/IR/IRInterpreter.h | 15 +++++++++++++++ Core/MIPS/IR/IRPassSimplify.cpp | 3 +++ 6 files changed, 42 insertions(+), 11 deletions(-) diff --git a/Core/MIPS/IR/IRCompALU.cpp b/Core/MIPS/IR/IRCompALU.cpp index 8ffa632aff..54a2d3b5ea 100644 --- a/Core/MIPS/IR/IRCompALU.cpp +++ b/Core/MIPS/IR/IRCompALU.cpp @@ -54,7 +54,7 @@ void IRFrontend::Comp_IType(MIPSOpcode op) { MIPSGPReg rs = _RS; // noop, won't write to ZERO. - if (rt == 0) + if (rt == MIPS_REG_ZERO) return; switch (op >> 26) { @@ -92,7 +92,7 @@ void IRFrontend::Comp_RType2(MIPSOpcode op) { MIPSGPReg rd = _RD; // Don't change $zr. - if (rd == 0) + if (rd == MIPS_REG_ZERO) return; switch (op & 63) { @@ -104,7 +104,8 @@ void IRFrontend::Comp_RType2(MIPSOpcode op) { ir.Write(IROp::Clz, rd, IRTEMP_0); break; default: - DISABLE; + Comp_Generic(op); + break; } } @@ -198,23 +199,22 @@ void IRFrontend::Comp_ShiftType(MIPSOpcode op) { CONDITIONAL_DISABLE; MIPSGPReg rs = _RS; MIPSGPReg rd = _RD; - int fd = _FD; int sa = _SA; // noop, won't write to ZERO. - if (rd == 0) + if (rd == MIPS_REG_ZERO) return; - // WARNING : ROTR + // WARNING: srl/rotr and srlv/rotrv share encodings (differentiated using unused bits.) switch (op & 0x3f) { case 0: CompShiftImm(op, IROp::ShlImm, sa); break; //sll case 2: CompShiftImm(op, (rs == 1 ? IROp::RorImm : IROp::ShrImm), sa); break; //srl case 3: CompShiftImm(op, IROp::SarImm, sa); break; //sra case 4: CompShiftVar(op, IROp::Shl, IROp::ShlImm); break; //sllv - case 6: CompShiftVar(op, (fd == 1 ? IROp::Ror : IROp::Shr), (fd == 1 ? IROp::RorImm : IROp::ShrImm)); break; //srlv + case 6: CompShiftVar(op, (sa == 1 ? IROp::Ror : IROp::Shr), (sa == 1 ? IROp::RorImm : IROp::ShrImm)); break; //srlv case 7: CompShiftVar(op, IROp::Sar, IROp::SarImm); break; //srav default: - DISABLE; + Comp_Generic(op); break; } } @@ -229,7 +229,7 @@ void IRFrontend::Comp_Special3(MIPSOpcode op) { u32 mask = 0xFFFFFFFFUL >> (32 - size); // Don't change $zr. - if (rt == 0) + if (rt == MIPS_REG_ZERO) return; switch (op & 0x3f) { @@ -254,6 +254,10 @@ void IRFrontend::Comp_Special3(MIPSOpcode op) { ir.Write(IROp::Or, rt, rt, IRTEMP_0); } break; + + default: + Comp_Generic(op); + break; } } @@ -262,8 +266,9 @@ void IRFrontend::Comp_Allegrex(MIPSOpcode op) { CONDITIONAL_DISABLE; MIPSGPReg rt = _RT; MIPSGPReg rd = _RD; + // Don't change $zr. - if (rd == 0) + if (rd == MIPS_REG_ZERO) return; switch ((op >> 6) & 31) { @@ -275,7 +280,10 @@ void IRFrontend::Comp_Allegrex(MIPSOpcode op) { ir.Write(IROp::Ext16to32, rd, rt); break; - case 20: //bitrev + case 20: // bitrev + ir.Write(IROp::ReverseBits, rd, rt); + break; + default: Comp_Generic(op); return; diff --git a/Core/MIPS/IR/IRInst.cpp b/Core/MIPS/IR/IRInst.cpp index c44cc91837..0fc0c24029 100644 --- a/Core/MIPS/IR/IRInst.cpp +++ b/Core/MIPS/IR/IRInst.cpp @@ -53,6 +53,7 @@ static const IRMeta irMeta[] = { { IROp::MfHi, "MfHi", "G" }, { IROp::Ext8to32, "Ext8to32", "GG" }, { IROp::Ext16to32, "Ext16to32", "GG" }, + { IROp::ReverseBits, "ReverseBits", "GG" }, { IROp::Load8, "Load8", "GGC" }, { IROp::Load8Ext, "Load8", "GGC" }, { IROp::Load16, "Load16", "GGC" }, diff --git a/Core/MIPS/IR/IRInst.h b/Core/MIPS/IR/IRInst.h index 11c4903e43..85ebd9c94f 100644 --- a/Core/MIPS/IR/IRInst.h +++ b/Core/MIPS/IR/IRInst.h @@ -111,6 +111,7 @@ enum class IROp : u8 { Ext8to32, Ext16to32, + ReverseBits, FAdd, FSub, diff --git a/Core/MIPS/IR/IRInterpreter.cpp b/Core/MIPS/IR/IRInterpreter.cpp index c9540c69f6..af155eaf88 100644 --- a/Core/MIPS/IR/IRInterpreter.cpp +++ b/Core/MIPS/IR/IRInterpreter.cpp @@ -87,6 +87,9 @@ u32 IRInterpret(MIPSState *mips, const IRInst *inst, const u32 *constPool, int c case IROp::Ext16to32: mips->r[inst->dest] = (s32)(s16)mips->r[inst->src1]; break; + case IROp::ReverseBits: + mips->r[inst->dest] = ReverseBits32(mips->r[inst->src1]); + break; case IROp::Load8: mips->r[inst->dest] = Memory::ReadUnchecked_U8(mips->r[inst->src1] + constPool[inst->src2]); diff --git a/Core/MIPS/IR/IRInterpreter.h b/Core/MIPS/IR/IRInterpreter.h index fe9f8e4ba9..562153673a 100644 --- a/Core/MIPS/IR/IRInterpreter.h +++ b/Core/MIPS/IR/IRInterpreter.h @@ -5,4 +5,19 @@ class MIPSState; struct IRInst; +inline static u32 ReverseBits32(u32 v) { + // http://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel + // swap odd and even bits + v = ((v >> 1) & 0x55555555) | ((v & 0x55555555) << 1); + // swap consecutive pairs + v = ((v >> 2) & 0x33333333) | ((v & 0x33333333) << 2); + // swap nibbles ... + v = ((v >> 4) & 0x0F0F0F0F) | ((v & 0x0F0F0F0F) << 4); + // swap bytes + v = ((v >> 8) & 0x00FF00FF) | ((v & 0x00FF00FF) << 8); + // swap 2-byte long pairs + v = ( v >> 16 ) | ( v << 16); + return v; +} + u32 IRInterpret(MIPSState *mips, const IRInst *inst, const u32 *constPool, int count); diff --git a/Core/MIPS/IR/IRPassSimplify.cpp b/Core/MIPS/IR/IRPassSimplify.cpp index f0f899bc69..9f07bde9ab 100644 --- a/Core/MIPS/IR/IRPassSimplify.cpp +++ b/Core/MIPS/IR/IRPassSimplify.cpp @@ -1,6 +1,7 @@ #include #include "Common/Log.h" +#include "Core/MIPS/IR/IRInterpreter.h" #include "Core/MIPS/IR/IRPassSimplify.h" #include "Core/MIPS/IR/IRRegCache.h" @@ -51,6 +52,7 @@ u32 Evaluate(u32 a, IROp op) { case IROp::BSwap32: return swap32(a); case IROp::Ext8to32: return (u32)(s32)(s8)(u8)a; case IROp::Ext16to32: return (u32)(s32)(s16)(u16)a; + case IROp::ReverseBits: return ReverseBits32(a); case IROp::Clz: { int x = 31; int count = 0; @@ -277,6 +279,7 @@ bool PropagateConstants(const IRWriter &in, IRWriter &out) { case IROp::BSwap32: case IROp::Ext8to32: case IROp::Ext16to32: + case IROp::ReverseBits: case IROp::Clz: if (gpr.IsImm(inst.src1)) { gpr.SetImm(inst.dest, Evaluate(gpr.GetImm(inst.src1), inst.op)); From a05ae2a0a6c2a3a2c0e64e6d47162f8f5c850808 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sat, 14 May 2016 18:38:54 -0700 Subject: [PATCH 2/5] Correct divide by zero HI/LO values a bit. Interpreter is now correct, but it's probably not all that important to get right in jit. --- Core/MIPS/ARM/ArmCompALU.cpp | 6 +++--- Core/MIPS/ARM64/Arm64CompALU.cpp | 4 ++-- Core/MIPS/IR/IRCompALU.cpp | 1 + Core/MIPS/MIPSInt.cpp | 10 ++++++---- Core/MIPS/x86/CompALU.cpp | 23 +++++++++++++---------- 5 files changed, 25 insertions(+), 19 deletions(-) diff --git a/Core/MIPS/ARM/ArmCompALU.cpp b/Core/MIPS/ARM/ArmCompALU.cpp index 6232044290..3601833ac5 100644 --- a/Core/MIPS/ARM/ArmCompALU.cpp +++ b/Core/MIPS/ARM/ArmCompALU.cpp @@ -760,9 +760,9 @@ namespace MIPSComp if (gpr.IsImm(rt) && (gpr.GetImm(rt) & (gpr.GetImm(rt) - 1)) == 0) { u32 denominator = gpr.GetImm(rt); if (denominator == 0) { - // TODO: Is this correct? - gpr.SetImm(MIPS_REG_LO, 0); - gpr.SetImm(MIPS_REG_HI, 0); + gpr.MapDirtyIn(MIPS_REG_HI, rs); + gpr.SetImm(MIPS_REG_LO, -1); + MOV(gpr.R(MIPS_REG_HI), gpr.R(rs)); } else { gpr.MapDirtyDirtyIn(MIPS_REG_LO, MIPS_REG_HI, rs); // Remainder is just an AND, neat. diff --git a/Core/MIPS/ARM64/Arm64CompALU.cpp b/Core/MIPS/ARM64/Arm64CompALU.cpp index 4a87760410..2e24a26f77 100644 --- a/Core/MIPS/ARM64/Arm64CompALU.cpp +++ b/Core/MIPS/ARM64/Arm64CompALU.cpp @@ -636,8 +636,8 @@ void Arm64Jit::Comp_MulDivType(MIPSOpcode op) { if (gpr.IsImm(rt) && (gpr.GetImm(rt) & (gpr.GetImm(rt) - 1)) == 0) { u32 denominator = gpr.GetImm(rt); if (denominator == 0) { - // TODO: Is this correct? - gpr.SetImm(MIPS_REG_LO, 0); + // TODO: This isn't exactly right. + gpr.SetImm(MIPS_REG_LO, -1); } else { gpr.MapDirtyIn(MIPS_REG_LO, rs); // Remainder is just an AND, neat. diff --git a/Core/MIPS/IR/IRCompALU.cpp b/Core/MIPS/IR/IRCompALU.cpp index 54a2d3b5ea..15d5f6cbb8 100644 --- a/Core/MIPS/IR/IRCompALU.cpp +++ b/Core/MIPS/IR/IRCompALU.cpp @@ -294,6 +294,7 @@ void IRFrontend::Comp_Allegrex2(MIPSOpcode op) { CONDITIONAL_DISABLE; MIPSGPReg rt = _RT; MIPSGPReg rd = _RD; + // Don't change $zr. if (rd == 0) return; diff --git a/Core/MIPS/MIPSInt.cpp b/Core/MIPS/MIPSInt.cpp index 0f067549b7..fe9373e9f5 100644 --- a/Core/MIPS/MIPSInt.cpp +++ b/Core/MIPS/MIPSInt.cpp @@ -660,11 +660,13 @@ namespace MIPSInt s32 b = (s32)R(rt); if (a == (s32)0x80000000 && b == -1) { LO = 0x80000000; + HI = -1; } else if (b != 0) { LO = (u32)(a / b); HI = (u32)(a % b); } else { - LO = HI = 0; // Not sure what the right thing to do is? + LO = a < 0 ? 1 : -1; + HI = a; } } break; @@ -672,12 +674,12 @@ namespace MIPSInt { u32 a = R(rs); u32 b = R(rt); - if (b != 0) - { + if (b != 0) { LO = (a/b); HI = (a%b); } else { - LO = HI = 0; + LO = a <= 0xFFFF ? 0xFFFF : -1; + HI = a; } } break; diff --git a/Core/MIPS/x86/CompALU.cpp b/Core/MIPS/x86/CompALU.cpp index e45622d048..f47010d4ee 100644 --- a/Core/MIPS/x86/CompALU.cpp +++ b/Core/MIPS/x86/CompALU.cpp @@ -1002,6 +1002,9 @@ namespace MIPSComp // For CMP. gpr.KillImmediate(rs, true, false); gpr.KillImmediate(rt, true, false); + + MOV(32, R(EAX), gpr.R(rs)); + CMP(32, gpr.R(rt), Imm32(0)); FixupBranch divZero = J_CC(CC_E); @@ -1010,14 +1013,13 @@ namespace MIPSComp FixupBranch notOverflow = J_CC(CC_NE); CMP(32, gpr.R(rt), Imm32((u32) -1)); FixupBranch notOverflow2 = J_CC(CC_NE); - // TODO: Should HI be set to anything? MOV(32, gpr.R(MIPS_REG_LO), Imm32(0x80000000)); + MOV(32, gpr.R(MIPS_REG_HI), Imm32(-1)); FixupBranch skip2 = J(); SetJumpTarget(notOverflow); SetJumpTarget(notOverflow2); - MOV(32, R(EAX), gpr.R(rs)); CDQ(); IDIV(32, gpr.R(rt)); MOV(32, gpr.R(MIPS_REG_HI), R(EDX)); @@ -1025,9 +1027,9 @@ namespace MIPSComp FixupBranch skip = J(); SetJumpTarget(divZero); - // TODO: Is this the right way to handle a divide by zero? - MOV(32, gpr.R(MIPS_REG_HI), Imm32(0)); - MOV(32, gpr.R(MIPS_REG_LO), Imm32(0)); + // TODO: This isn't exactly right. + MOV(32, gpr.R(MIPS_REG_HI), R(EAX)); + MOV(32, gpr.R(MIPS_REG_LO), Imm32(-1)); SetJumpTarget(skip); SetJumpTarget(skip2); @@ -1041,20 +1043,21 @@ namespace MIPSComp gpr.KillImmediate(MIPS_REG_HI, false, true); gpr.KillImmediate(MIPS_REG_LO, false, true); gpr.KillImmediate(rt, true, false); - CMP(32, gpr.R(rt), Imm32(0)); - FixupBranch divZero = J_CC(CC_E); MOV(32, R(EAX), gpr.R(rs)); MOV(32, R(EDX), Imm32(0)); + + CMP(32, gpr.R(rt), Imm32(0)); + FixupBranch divZero = J_CC(CC_E); + DIV(32, gpr.R(rt)); MOV(32, gpr.R(MIPS_REG_HI), R(EDX)); MOV(32, gpr.R(MIPS_REG_LO), R(EAX)); FixupBranch skip = J(); SetJumpTarget(divZero); - // TODO: Is this the right way to handle a divide by zero? - MOV(32, gpr.R(MIPS_REG_HI), Imm32(0)); - MOV(32, gpr.R(MIPS_REG_LO), Imm32(0)); + MOV(32, gpr.R(MIPS_REG_HI), R(EAX)); + MOV(32, gpr.R(MIPS_REG_LO), Imm32(-1)); SetJumpTarget(skip); gpr.UnlockAllX(); From 6413b44434efff3011dd6816b8258a83c69a2333 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sat, 14 May 2016 18:46:55 -0700 Subject: [PATCH 3/5] jit-ir: Enable IR for madd(u)/msub(u). --- Core/MIPS/IR/IRCompALU.cpp | 4 ---- Core/MIPS/IR/IRInterpreter.cpp | 32 ++++++++++++++++++++++++++++++++ Core/MIPS/IR/IRPassSimplify.cpp | 6 ++++++ 3 files changed, 38 insertions(+), 4 deletions(-) diff --git a/Core/MIPS/IR/IRCompALU.cpp b/Core/MIPS/IR/IRCompALU.cpp index 15d5f6cbb8..2eb984c998 100644 --- a/Core/MIPS/IR/IRCompALU.cpp +++ b/Core/MIPS/IR/IRCompALU.cpp @@ -358,22 +358,18 @@ void IRFrontend::Comp_MulDivType(MIPSOpcode op) { break; case 28: //madd - DISABLE; ir.Write(IROp::Madd, 0, rs, rt); break; case 29: //maddu - DISABLE; ir.Write(IROp::MaddU, 0, rs, rt); break; case 46: // msub - DISABLE; ir.Write(IROp::Msub, 0, rs, rt); break; case 47: // msubu - DISABLE; ir.Write(IROp::MsubU, 0, rs, rt); break; diff --git a/Core/MIPS/IR/IRInterpreter.cpp b/Core/MIPS/IR/IRInterpreter.cpp index af155eaf88..682b55f462 100644 --- a/Core/MIPS/IR/IRInterpreter.cpp +++ b/Core/MIPS/IR/IRInterpreter.cpp @@ -405,6 +405,38 @@ u32 IRInterpret(MIPSState *mips, const IRInst *inst, const u32 *constPool, int c memcpy(&mips->lo, &result, 8); break; } + case IROp::Madd: + { + s64 result; + memcpy(&result, &mips->lo, 8); + result += (s64)(s32)mips->r[inst->src1] * (s64)(s32)mips->r[inst->src2]; + memcpy(&mips->lo, &result, 8); + break; + } + case IROp::MaddU: + { + s64 result; + memcpy(&result, &mips->lo, 8); + result += (u64)mips->r[inst->src1] * (u64)mips->r[inst->src2]; + memcpy(&mips->lo, &result, 8); + break; + } + case IROp::Msub: + { + s64 result; + memcpy(&result, &mips->lo, 8); + result -= (s64)(s32)mips->r[inst->src1] * (s64)(s32)mips->r[inst->src2]; + memcpy(&mips->lo, &result, 8); + break; + } + case IROp::MsubU: + { + s64 result; + memcpy(&result, &mips->lo, 8); + result -= (u64)mips->r[inst->src1] * (u64)mips->r[inst->src2]; + memcpy(&mips->lo, &result, 8); + break; + } case IROp::BSwap16: { diff --git a/Core/MIPS/IR/IRPassSimplify.cpp b/Core/MIPS/IR/IRPassSimplify.cpp index 9f07bde9ab..21f8a56221 100644 --- a/Core/MIPS/IR/IRPassSimplify.cpp +++ b/Core/MIPS/IR/IRPassSimplify.cpp @@ -350,6 +350,12 @@ bool PropagateConstants(const IRWriter &in, IRWriter &out) { case IROp::Mult: case IROp::MultU: + case IROp::Madd: + case IROp::MaddU: + case IROp::Msub: + case IROp::MsubU: + case IROp::Div: + case IROp::DivU: gpr.MapInIn(inst.src1, inst.src2); goto doDefault; From c606f64f718f15c0b547e17a7558846b7cba268c Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sat, 14 May 2016 19:21:15 -0700 Subject: [PATCH 4/5] jit-ir: Add div/divu instructions. --- Core/MIPS/IR/IRCompALU.cpp | 2 -- Core/MIPS/IR/IRInterpreter.cpp | 30 ++++++++++++++++++++++++++++++ 2 files changed, 30 insertions(+), 2 deletions(-) diff --git a/Core/MIPS/IR/IRCompALU.cpp b/Core/MIPS/IR/IRCompALU.cpp index 2eb984c998..c7074bed79 100644 --- a/Core/MIPS/IR/IRCompALU.cpp +++ b/Core/MIPS/IR/IRCompALU.cpp @@ -348,12 +348,10 @@ void IRFrontend::Comp_MulDivType(MIPSOpcode op) { break; case 26: //div - DISABLE; ir.Write(IROp::Div, 0, rs, rt); break; case 27: //divu - DISABLE; ir.Write(IROp::DivU, 0, rs, rt); break; diff --git a/Core/MIPS/IR/IRInterpreter.cpp b/Core/MIPS/IR/IRInterpreter.cpp index 682b55f462..35bba645f8 100644 --- a/Core/MIPS/IR/IRInterpreter.cpp +++ b/Core/MIPS/IR/IRInterpreter.cpp @@ -438,6 +438,36 @@ u32 IRInterpret(MIPSState *mips, const IRInst *inst, const u32 *constPool, int c break; } + case IROp::Div: + { + s32 numerator = (s32)mips->r[inst->src1]; + s32 denominator = (s32)mips->r[inst->src2]; + if (numerator == (s32)0x80000000 && denominator == -1) { + mips->lo = 0x80000000; + mips->hi = -1; + } else if (denominator != 0) { + mips->lo = (u32)(numerator / denominator); + mips->hi = (u32)(numerator % denominator); + } else { + mips->lo = numerator < 0 ? 1 : -1; + mips->hi = numerator; + } + break; + } + case IROp::DivU: + { + u32 numerator = mips->r[inst->src1]; + u32 denominator = mips->r[inst->src2]; + if (denominator != 0) { + mips->lo = numerator / denominator; + mips->hi = numerator % denominator; + } else { + mips->lo = numerator <= 0xFFFF ? 0xFFFF : -1; + mips->hi = numerator; + } + break; + } + case IROp::BSwap16: { u32 x = mips->r[inst->src1]; From a5560c657eaa89e94eac9f5ac14b39c72d8312f7 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sat, 14 May 2016 19:21:52 -0700 Subject: [PATCH 5/5] Headless: Use --ir instead of -ir. Other multi-letter options are prefixed too, let's be consistent. --- headless/Headless.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/headless/Headless.cpp b/headless/Headless.cpp index f818da68ca..2cf222d05a 100644 --- a/headless/Headless.cpp +++ b/headless/Headless.cpp @@ -107,6 +107,7 @@ int printUsage(const char *progname, const char *reason) fprintf(stderr, " -v, --verbose show the full passed/failed result\n"); fprintf(stderr, " -i use the interpreter\n"); + fprintf(stderr, " --ir use ir interpreter\n"); fprintf(stderr, " -j use jit (default)\n"); fprintf(stderr, " -c, --compare compare with output in file.expected\n"); fprintf(stderr, "\nSee headless.txt for details.\n"); @@ -239,7 +240,7 @@ int main(int argc, const char* argv[]) cpuCore = CPU_CORE_INTERPRETER; else if (!strcmp(argv[i], "-j")) cpuCore = CPU_CORE_JIT; - else if (!strcmp(argv[i], "-ir")) + else if (!strcmp(argv[i], "--ir")) cpuCore = CPU_CORE_IRJIT; else if (!strcmp(argv[i], "-c") || !strcmp(argv[i], "--compare")) autoCompare = true;