ShuriZma
/
xenia
mirror of https://github.com/xenia-project/xenia.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Adding the first instructions, mfspr/mtspr.

This commit is contained in:
Ben Vanik 2013-05-24 01:37:02 -07:00
parent 71bd3c799f
commit 605d66ecf6
6 changed files with 590 additions and 634 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

134
src/xenia/cpu/x64/x64_emit_alu.cc
View File

@ -25,7 +25,7 @@ namespace x64 {
// // Integer arithmetic (A-3)
// XEEMITTER(addx, 0x7C000214, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(addx, 0x7C000214, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // RD <- (RA) + (RB)
// if (i.XO.OE) {
@ -58,17 +58,17 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(addcx, 0x7C000014, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(addcx, 0x7C000014, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(addex, 0x7C000114, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(addex, 0x7C000114, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(addi, 0x38000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(addi, 0x38000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // RT <- EXTS(SI)
// // else
@ -83,7 +83,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(addic, 0x30000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(addic, 0x30000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // RT <- (RA) + EXTS(SI)
// // TODO(benvanik): track exception
@ -96,12 +96,12 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(addicx, 0x34000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(addicx, 0x34000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(addis, 0x3C000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(addis, 0x3C000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // RT <- EXTS(SI) || i16.0
// // else
@ -116,12 +116,12 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(addmex, 0x7C0001D4, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(addmex, 0x7C0001D4, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(addzex, 0x7C000194, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(addzex, 0x7C000194, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // RT <- (RA) + CA
// // TODO(benvanik): handle overflow exception.
@ -148,17 +148,17 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(divdx, 0x7C0003D2, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(divdx, 0x7C0003D2, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(divdux, 0x7C000392, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(divdux, 0x7C000392, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// // XEEMITTER(divwx, 0x7C0003D6, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// // XEEMITTER(divwx, 0x7C0003D6, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // // dividend[0:31] <- (RA)[32:63]
// // // divisor[0:31] <- (RB)[32:63]
// // // if divisor = 0 then
@ -211,7 +211,7 @@ namespace x64 {
// // return 0;
// // }
// // XEEMITTER(divwux, 0x7C000396, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// // XEEMITTER(divwux, 0x7C000396, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // // dividend[0:31] <- (RA)[32:63]
// // // divisor[0:31] <- (RB)[32:63]
// // // if divisor = 0 then
@ -264,32 +264,32 @@ namespace x64 {
// // return 0;
// // }
// XEEMITTER(mulhdx, 0x7C000092, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(mulhdx, 0x7C000092, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(mulhdux, 0x7C000012, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(mulhdux, 0x7C000012, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(mulhwx, 0x7C000096, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(mulhwx, 0x7C000096, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(mulhwux, 0x7C000016, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(mulhwux, 0x7C000016, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(mulldx, 0x7C0001D2, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(mulldx, 0x7C0001D2, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(mulli, 0x1C000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(mulli, 0x1C000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // prod[0:127] <- (RA) × EXTS(SI)
// // RT <- prod[64:127]
@ -304,7 +304,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(mullwx, 0x7C0001D6, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(mullwx, 0x7C0001D6, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // RT <- (RA)[32:63] × (RB)[32:63]
// if (i.XO.OE) {
@ -326,7 +326,7 @@ namespace x64 {
// return 0;
// }
// // XEEMITTER(negx, 0x7C0000D0, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// // XEEMITTER(negx, 0x7C0000D0, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // // RT <- ¬(RA) + 1
// // if (i.XO.OE) {
@ -364,7 +364,7 @@ namespace x64 {
// // }
// // }
// XEEMITTER(subfx, 0x7C000050, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(subfx, 0x7C000050, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // RT <- ¬(RA) + (RB) + 1
// if (i.XO.OE) {
@ -400,12 +400,12 @@ namespace x64 {
// }
// }
// XEEMITTER(subfcx, 0x7C000010, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(subfcx, 0x7C000010, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// // XEEMITTER(subficx, 0x20000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// // XEEMITTER(subficx, 0x20000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // // RT <- ¬(RA) + EXTS(SI) + 1
// // Function* ssub_with_overflow = Intrinsic::getDeclaration(
@ -418,7 +418,7 @@ namespace x64 {
// // return 0;
// // }
// XEEMITTER(subfex, 0x7C000110, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(subfex, 0x7C000110, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // RT <- ¬(RA) + (RB) + CA
// // TODO(benvanik): possible that the add of rb+ca needs to also check for
@ -448,12 +448,12 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(subfmex, 0x7C0001D0, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(subfmex, 0x7C0001D0, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(subfzex, 0x7C000190, XO )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(subfzex, 0x7C000190, XO )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
@ -461,7 +461,7 @@ namespace x64 {
// // Integer compare (A-4)
// XEEMITTER(cmp, 0x7C000000, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(cmp, 0x7C000000, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if L = 0 then
// // a <- EXTS((RA)[32:63])
// // b <- EXTS((RB)[32:63])
@ -494,7 +494,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(cmpi, 0x2C000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(cmpi, 0x2C000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if L = 0 then
// // a <- EXTS((RA)[32:63])
// // else
@ -523,7 +523,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(cmpl, 0x7C000040, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(cmpl, 0x7C000040, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if L = 0 then
// // a <- i32.0 || (RA)[32:63]
// // b <- i32.0 || (RB)[32:63]
@ -556,7 +556,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(cmpli, 0x28000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(cmpli, 0x28000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if L = 0 then
// // a <- i32.0 || (RA)[32:63]
// // else
@ -588,7 +588,7 @@ namespace x64 {
// // Integer logical (A-5)
// XEEMITTER(andx, 0x7C000038, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(andx, 0x7C000038, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // RA <- (RS) & (RB)
// jit_value_t v = jit_insn_and(f, e.gpr_value(i.X.RT), e.gpr_value(i.X.RB));
@ -602,7 +602,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(andcx, 0x7C000078, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(andcx, 0x7C000078, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // RA <- (RS) & ¬(RB)
// jit_value_t v = jit_insn_xor(f, e.gpr_value(i.X.RB),
@ -618,7 +618,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(andix, 0x70000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(andix, 0x70000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // RA <- (RS) & (i48.0 || UI)
// jit_value_t v = jit_insn_and(f, e.gpr_value(i.D.RT), e.get_uint64(i.D.DS));
@ -630,7 +630,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(andisx, 0x74000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(andisx, 0x74000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // RA <- (RS) & (i32.0 || UI || i16.0)
// jit_value_t v = jit_insn_and(f, e.gpr_value(i.D.RT),
@ -643,12 +643,12 @@ namespace x64 {
// return 1;
// }
// XEEMITTER(cntlzdx, 0x7C000074, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(cntlzdx, 0x7C000074, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// // XEEMITTER(cntlzwx, 0x7C000034, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// // XEEMITTER(cntlzwx, 0x7C000034, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // // n <- 32
// // // do while n < 64
// // // if (RS) = 1 then leave n
@ -675,12 +675,12 @@ namespace x64 {
// // return 0;
// // }
// XEEMITTER(eqvx, 0x7C000238, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(eqvx, 0x7C000238, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(extsbx, 0x7C000774, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(extsbx, 0x7C000774, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // s <- (RS)[56]
// // RA[56:63] <- (RS)[56:63]
// // RA[0:55] <- i56.s
@ -698,22 +698,22 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(extshx, 0x7C000734, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(extshx, 0x7C000734, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(extswx, 0x7C0007B4, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(extswx, 0x7C0007B4, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(nandx, 0x7C0003B8, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(nandx, 0x7C0003B8, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(norx, 0x7C0000F8, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(norx, 0x7C0000F8, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // RA <- ¬((RS) | (RB))
// jit_value_t v = jit_insn_or(f, e.gpr_value(i.X.RT), e.gpr_value(i.X.RB));
@ -728,7 +728,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(orx, 0x7C000378, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(orx, 0x7C000378, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // RA <- (RS) | (RB)
// jit_value_t v = jit_insn_or(f, e.gpr_value(i.X.RT), e.gpr_value(i.X.RB));
@ -742,12 +742,12 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(orcx, 0x7C000338, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(orcx, 0x7C000338, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(ori, 0x60000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(ori, 0x60000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // RA <- (RS) | (i48.0 || UI)
// jit_value_t v = jit_insn_or(f, e.gpr_value(i.D.RT),
@ -757,7 +757,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(oris, 0x64000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(oris, 0x64000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // RA <- (RS) | (i32.0 || UI || i16.0)
// jit_value_t v = jit_insn_or(f, e.gpr_value(i.D.RT),
@ -767,7 +767,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(xorx, 0x7C000278, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(xorx, 0x7C000278, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // RA <- (RS) XOR (RB)
// jit_value_t v = jit_insn_xor(f, e.gpr_value(i.X.RT), e.gpr_value(i.X.RB));
@ -781,7 +781,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(xori, 0x68000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(xori, 0x68000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // RA <- (RS) XOR (i48.0 || UI)
// jit_value_t v = jit_insn_xor(f, e.gpr_value(i.D.RT),
@ -791,7 +791,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(xoris, 0x6C000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(xoris, 0x6C000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // RA <- (RS) XOR (i32.0 || UI || i16.0)
// jit_value_t v = jit_insn_xor(f, e.gpr_value(i.D.RT),
@ -804,22 +804,22 @@ namespace x64 {
// // Integer rotate (A-6)
// XEEMITTER(rldclx, 0x78000010, MDS)(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(rldclx, 0x78000010, MDS)(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(rldcrx, 0x78000012, MDS)(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(rldcrx, 0x78000012, MDS)(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(rldicx, 0x78000008, MD )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(rldicx, 0x78000008, MD )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(rldiclx, 0x78000000, MD )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(rldiclx, 0x78000000, MD )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // n <- sh[5] || sh[0:4]
// // r <- ROTL64((RS), n)
// // b <- mb[5] || mb[0:4]
@ -847,17 +847,17 @@ namespace x64 {
// return 1;
// }
// XEEMITTER(rldicrx, 0x78000004, MD )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(rldicrx, 0x78000004, MD )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(rldimix, 0x7800000C, MD )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(rldimix, 0x7800000C, MD )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(rlwimix, 0x50000000, M )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(rlwimix, 0x50000000, M )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // n <- SH
// // r <- ROTL32((RS)[32:63], n)
// // m <- MASK(MB+32, ME+32)
@ -884,7 +884,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(rlwinmx, 0x54000000, M )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(rlwinmx, 0x54000000, M )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // n <- SH
// // r <- ROTL32((RS)[32:63], n)
// // m <- MASK(MB+32, ME+32)
@ -923,7 +923,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(rlwnmx, 0x5C000000, M )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(rlwnmx, 0x5C000000, M )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
@ -931,12 +931,12 @@ namespace x64 {
// // Integer shift (A-7)
// XEEMITTER(sldx, 0x7C000036, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(sldx, 0x7C000036, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(slwx, 0x7C000030, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(slwx, 0x7C000030, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // n <- (RB)[59:63]
// // r <- ROTL32((RS)[32:63], n)
// // if (RB)[58] = 0 then
@ -957,22 +957,22 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(sradx, 0x7C000634, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(sradx, 0x7C000634, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(sradix, 0x7C000674, XS )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(sradix, 0x7C000674, XS )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(srawx, 0x7C000630, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(srawx, 0x7C000630, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(srawix, 0x7C000670, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(srawix, 0x7C000670, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // n <- SH
// // r <- ROTL32((RS)[32:63], 64-n)
// // m <- MASK(n+32, 63)
@ -1009,12 +1009,12 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(srdx, 0x7C000436, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(srdx, 0x7C000436, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(srwx, 0x7C000430, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(srwx, 0x7C000430, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }

188
src/xenia/cpu/x64/x64_emit_control.cc
View File

@ -25,7 +25,7 @@ namespace x64 {
// int XeEmitIndirectBranchTo(
// X64Emitter& e, Compiler& c, const char* src, uint32_t cia,
// X64Emitter& e, X86Compiler& c, const char* src, uint32_t cia,
// bool lk, uint32_t reg) {
// // TODO(benvanik): run a DFA pass to see if we can detect whether this is
// // a normal function return that is pulling the LR from the stack that
@ -64,7 +64,7 @@ namespace x64 {
// }
// int XeEmitBranchTo(
// X64Emitter& e, Compiler& c, const char* src, uint32_t cia,
// X64Emitter& e, X86Compiler& c, const char* src, uint32_t cia,
// bool lk, jit_value_t condition) {
// FunctionBlock* fn_block = e.fn_block();
@ -154,7 +154,7 @@ namespace x64 {
// }
// XEEMITTER(bx, 0x48000000, I )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(bx, 0x48000000, I )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if AA then
// // NIA <- EXTS(LI || 0b00)
// // else
@ -175,7 +175,7 @@ namespace x64 {
// return XeEmitBranchTo(e, f, "bx", i.address, i.I.LK, NULL);
// }
// XEEMITTER(bcx, 0x40000000, B )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(bcx, 0x40000000, B )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if ¬BO[2] then
// // CTR <- CTR - 1
// // ctr_ok <- BO[2] | ((CTR[0:63] != 0) XOR BO[3])
@ -251,7 +251,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(bcctrx, 0x4C000420, XL )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(bcctrx, 0x4C000420, XL )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // cond_ok <- BO[0] | (CR[BI+32] ≡ BO[1])
// // if cond_ok then
// // NIA <- CTR[0:61] || 0b00
@ -294,7 +294,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(bclrx, 0x4C000020, XL )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(bclrx, 0x4C000020, XL )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if ¬BO[2] then
// // CTR <- CTR - 1
// // ctr_ok <- BO[2] | ((CTR[0:63] != 0) XOR BO[3]
@ -363,47 +363,47 @@ namespace x64 {
// // Condition register logical (A-23)
// XEEMITTER(crand, 0x4C000202, XL )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(crand, 0x4C000202, XL )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(crandc, 0x4C000102, XL )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(crandc, 0x4C000102, XL )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(creqv, 0x4C000242, XL )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(creqv, 0x4C000242, XL )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(crnand, 0x4C0001C2, XL )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(crnand, 0x4C0001C2, XL )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(crnor, 0x4C000042, XL )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(crnor, 0x4C000042, XL )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(cror, 0x4C000382, XL )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(cror, 0x4C000382, XL )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(crorc, 0x4C000342, XL )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(crorc, 0x4C000342, XL )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(crxor, 0x4C000182, XL )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(crxor, 0x4C000182, XL )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(mcrf, 0x4C000000, XL )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(mcrf, 0x4C000000, XL )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
@ -411,7 +411,7 @@ namespace x64 {
// // System linkage (A-24)
// XEEMITTER(sc, 0x44000002, SC )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(sc, 0x44000002, SC )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
@ -419,7 +419,7 @@ namespace x64 {
// // Trap (A-25)
// int XeEmitTrap(X64Emitter& e, Compiler& c, InstrData& i,
// int XeEmitTrap(X64Emitter& e, X86Compiler& c, InstrData& i,
// jit_value_t va, jit_value_t vb, uint32_t TO) {
// // if (a < b) & TO[0] then TRAP
// // if (a > b) & TO[1] then TRAP
@ -517,7 +517,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(td, 0x7C000088, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(td, 0x7C000088, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // a <- (RA)
// // b <- (RB)
// // if (a < b) & TO[0] then TRAP
@ -531,7 +531,7 @@ namespace x64 {
// i.X.RT);
// }
// XEEMITTER(tdi, 0x08000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(tdi, 0x08000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // a <- (RA)
// // if (a < EXTS(SI)) & TO[0] then TRAP
// // if (a > EXTS(SI)) & TO[1] then TRAP
@ -544,7 +544,7 @@ namespace x64 {
// i.D.RT);
// }
// XEEMITTER(tw, 0x7C000008, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(tw, 0x7C000008, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // a <- EXTS((RA)[32:63])
// // b <- EXTS((RB)[32:63])
// // if (a < b) & TO[0] then TRAP
@ -560,7 +560,7 @@ namespace x64 {
// i.X.RT);
// }
// XEEMITTER(twi, 0x0C000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(twi, 0x0C000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // a <- EXTS((RA)[32:63])
// // if (a < EXTS(SI)) & TO[0] then TRAP
// // if (a > EXTS(SI)) & TO[1] then TRAP
@ -575,85 +575,85 @@ namespace x64 {
// }
// // Processor control (A-26)
// Processor control (A-26)
// XEEMITTER(mfcr, 0x7C000026, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
XEEMITTER(mfcr, 0x7C000026, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
// XEEMITTER(mfspr, 0x7C0002A6, XFX)(X64Emitter& e, Compiler& c, InstrData& i) {
// // n <- spr[5:9] || spr[0:4]
// // if length(SPR(n)) = 64 then
// // RT <- SPR(n)
// // else
// // RT <- i32.0 || SPR(n)
XEEMITTER(mfspr, 0x7C0002A6, XFX)(X64Emitter& e, X86Compiler& c, InstrData& i) {
// n <- spr[5:9] || spr[0:4]
// if length(SPR(n)) = 64 then
// RT <- SPR(n)
// else
// RT <- i32.0 || SPR(n)
// const uint32_t n = ((i.XFX.spr & 0x1F) << 5) | ((i.XFX.spr >> 5) & 0x1F);
// jit_value_t v = NULL;
// switch (n) {
// case 1:
// // XER
// v = e.xer_value();
// break;
// case 8:
// // LR
// v = e.lr_value();
// break;
// case 9:
// // CTR
// v = e.ctr_value();
// break;
// default:
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
const uint32_t n = ((i.XFX.spr & 0x1F) << 5) | ((i.XFX.spr >> 5) & 0x1F);
GpVar v;
switch (n) {
case 1:
// XER
v = e.xer_value();
break;
case 8:
// LR
v = e.lr_value();
break;
case 9:
// CTR
v = e.ctr_value();
break;
default:
XEINSTRNOTIMPLEMENTED();
return 1;
}
// e.update_gpr_value(i.XFX.RT, v);
e.update_gpr_value(i.XFX.RT, v);
// return 0;
// }
return 0;
}
// XEEMITTER(mftb, 0x7C0002E6, XFX)(X64Emitter& e, Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
XEEMITTER(mftb, 0x7C0002E6, XFX)(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
// XEEMITTER(mtcrf, 0x7C000120, XFX)(X64Emitter& e, Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
XEEMITTER(mtcrf, 0x7C000120, XFX)(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
// XEEMITTER(mtspr, 0x7C0003A6, XFX)(X64Emitter& e, Compiler& c, InstrData& i) {
// // n <- spr[5:9] || spr[0:4]
// // if length(SPR(n)) = 64 then
// // SPR(n) <- (RS)
// // else
// // SPR(n) <- (RS)[32:63]
XEEMITTER(mtspr, 0x7C0003A6, XFX)(X64Emitter& e, X86Compiler& c, InstrData& i) {
// n <- spr[5:9] || spr[0:4]
// if length(SPR(n)) = 64 then
// SPR(n) <- (RS)
// else
// SPR(n) <- (RS)[32:63]
// jit_value_t v = e.gpr_value(i.XFX.RT);
GpVar& v = e.gpr_value(i.XFX.RT);
// const uint32_t n = ((i.XFX.spr & 0x1F) << 5) | ((i.XFX.spr >> 5) & 0x1F);
// switch (n) {
// case 1:
// // XER
// e.update_xer_value(v);
// break;
// case 8:
// // LR
// e.update_lr_value(v);
// break;
// case 9:
// // CTR
// e.update_ctr_value(v);
// break;
// default:
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
const uint32_t n = ((i.XFX.spr & 0x1F) << 5) | ((i.XFX.spr >> 5) & 0x1F);
switch (n) {
case 1:
// XER
e.update_xer_value(v);
break;
case 8:
// LR
e.update_lr_value(v);
break;
case 9:
// CTR
e.update_ctr_value(v);
break;
default:
XEINSTRNOTIMPLEMENTED();
return 1;
}
// return 0;
// }
return 0;
}
void X64RegisterEmitCategoryControl() {
@ -675,11 +675,11 @@ void X64RegisterEmitCategoryControl() {
// XEREGISTERINSTR(tdi, 0x08000000);
// XEREGISTERINSTR(tw, 0x7C000008);
// XEREGISTERINSTR(twi, 0x0C000000);
// XEREGISTERINSTR(mfcr, 0x7C000026);
// XEREGISTERINSTR(mfspr, 0x7C0002A6);
// XEREGISTERINSTR(mftb, 0x7C0002E6);
// XEREGISTERINSTR(mtcrf, 0x7C000120);
// XEREGISTERINSTR(mtspr, 0x7C0003A6);
XEREGISTERINSTR(mfcr, 0x7C000026);
XEREGISTERINSTR(mfspr, 0x7C0002A6);
XEREGISTERINSTR(mftb, 0x7C0002E6);
XEREGISTERINSTR(mtcrf, 0x7C000120);
XEREGISTERINSTR(mtspr, 0x7C0003A6);
}

78
src/xenia/cpu/x64/x64_emit_fpu.cc
View File

@ -25,67 +25,67 @@ namespace x64 {
// Floating-point arithmetic (A-8)
XEEMITTER(faddx, 0xFC00002A, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(faddx, 0xFC00002A, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(faddsx, 0xEC00002A, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(faddsx, 0xEC00002A, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fdivx, 0xFC000024, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fdivx, 0xFC000024, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fdivsx, 0xEC000024, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fdivsx, 0xEC000024, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fmulx, 0xFC000032, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fmulx, 0xFC000032, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fmulsx, 0xEC000032, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fmulsx, 0xEC000032, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fresx, 0xEC000030, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fresx, 0xEC000030, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(frsqrtex, 0xFC000034, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(frsqrtex, 0xFC000034, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fsubx, 0xFC000028, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fsubx, 0xFC000028, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fsubsx, 0xEC000028, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fsubsx, 0xEC000028, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fselx, 0xFC00002E, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fselx, 0xFC00002E, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fsqrtx, 0xFC00002C, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fsqrtx, 0xFC00002C, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fsqrtsx, 0xEC00002C, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fsqrtsx, 0xEC00002C, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
@ -93,42 +93,42 @@ XEEMITTER(fsqrtsx, 0xEC00002C, A )(X64Emitter& e, Compiler& c, InstrData&
// Floating-point multiply-add (A-9)
XEEMITTER(fmaddx, 0xFC00003A, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fmaddx, 0xFC00003A, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fmaddsx, 0xEC00003A, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fmaddsx, 0xEC00003A, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fmsubx, 0xFC000038, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fmsubx, 0xFC000038, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fmsubsx, 0xEC000038, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fmsubsx, 0xEC000038, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fnmaddx, 0xFC00003E, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fnmaddx, 0xFC00003E, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fnmaddsx, 0xEC00003E, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fnmaddsx, 0xEC00003E, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fnmsubx, 0xFC00003C, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fnmsubx, 0xFC00003C, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fnmsubsx, 0xEC00003C, A )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fnmsubsx, 0xEC00003C, A )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
@ -136,32 +136,32 @@ XEEMITTER(fnmsubsx, 0xEC00003C, A )(X64Emitter& e, Compiler& c, InstrData&
// Floating-point rounding and conversion (A-10)
XEEMITTER(fcfidx, 0xFC00069C, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fcfidx, 0xFC00069C, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fctidx, 0xFC00065C, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fctidx, 0xFC00065C, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fctidzx, 0xFC00065E, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fctidzx, 0xFC00065E, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fctiwx, 0xFC00001C, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fctiwx, 0xFC00001C, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fctiwzx, 0xFC00001E, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fctiwzx, 0xFC00001E, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(frspx, 0xFC000018, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(frspx, 0xFC000018, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
@ -169,12 +169,12 @@ XEEMITTER(frspx, 0xFC000018, X )(X64Emitter& e, Compiler& c, InstrData&
// Floating-point compare (A-11)
XEEMITTER(fcmpo, 0xFC000040, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fcmpo, 0xFC000040, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fcmpu, 0xFC000000, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fcmpu, 0xFC000000, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// if (FRA) is a NaN or (FRB) is a NaN then
// c <- 0b0001
// else if (FRA) < (FRB) then
@ -195,32 +195,32 @@ XEEMITTER(fcmpu, 0xFC000000, X )(X64Emitter& e, Compiler& c, InstrData&
// Floating-point status and control register (A
XEEMITTER(mcrfs, 0xFC000080, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(mcrfs, 0xFC000080, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(mffsx, 0xFC00048E, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(mffsx, 0xFC00048E, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(mtfsb0x, 0xFC00008C, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(mtfsb0x, 0xFC00008C, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(mtfsb1x, 0xFC00004C, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(mtfsb1x, 0xFC00004C, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(mtfsfx, 0xFC00058E, XFL)(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(mtfsfx, 0xFC00058E, XFL)(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(mtfsfix, 0xFC00010C, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(mtfsfix, 0xFC00010C, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
@ -228,22 +228,22 @@ XEEMITTER(mtfsfix, 0xFC00010C, X )(X64Emitter& e, Compiler& c, InstrData&
// Floating-point move (A-21)
XEEMITTER(fabsx, 0xFC000210, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fabsx, 0xFC000210, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fmrx, 0xFC000090, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fmrx, 0xFC000090, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fnabsx, 0xFC000110, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fnabsx, 0xFC000110, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fnegx, 0xFC000050, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(fnegx, 0xFC000050, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}

162
src/xenia/cpu/x64/x64_emit_memory.cc
View File

@ -25,7 +25,7 @@ namespace x64 {
// // Integer load (A-13)
// XEEMITTER(lbz, 0x88000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lbz, 0x88000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -43,7 +43,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(lbzu, 0x8C000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lbzu, 0x8C000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + EXTS(D)
// // RT <- i56.0 || MEM(EA, 1)
// // RA <- EA
@ -57,7 +57,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(lbzux, 0x7C0000EE, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lbzux, 0x7C0000EE, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + (RB)
// // RT <- i56.0 || MEM(EA, 1)
// // RA <- EA
@ -70,7 +70,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(lbzx, 0x7C0000AE, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lbzx, 0x7C0000AE, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -88,7 +88,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(ld, 0xE8000000, DS )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(ld, 0xE8000000, DS )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -106,7 +106,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(ldu, 0xE8000001, DS )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(ldu, 0xE8000001, DS )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + EXTS(DS || 0b00)
// // RT <- MEM(EA, 8)
// // RA <- EA
@ -120,17 +120,17 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(ldux, 0x7C00006A, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(ldux, 0x7C00006A, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(ldx, 0x7C00002A, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(ldx, 0x7C00002A, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(lha, 0xA8000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lha, 0xA8000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -149,17 +149,17 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(lhau, 0xAC000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lhau, 0xAC000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(lhaux, 0x7C0002EE, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lhaux, 0x7C0002EE, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(lhax, 0x7C0002AE, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lhax, 0x7C0002AE, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -178,7 +178,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(lhz, 0xA0000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lhz, 0xA0000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -196,7 +196,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(lhzu, 0xA4000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lhzu, 0xA4000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + EXTS(D)
// // RT <- i48.0 || MEM(EA, 2)
// // RA <- EA
@ -210,7 +210,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(lhzux, 0x7C00026E, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lhzux, 0x7C00026E, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + (RB)
// // RT <- i48.0 || MEM(EA, 2)
// // RA <- EA
@ -223,7 +223,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(lhzx, 0x7C00022E, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lhzx, 0x7C00022E, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -241,7 +241,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(lwa, 0xE8000002, DS )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lwa, 0xE8000002, DS )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -260,7 +260,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(lwaux, 0x7C0002EA, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lwaux, 0x7C0002EA, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + (RB)
// // RT <- EXTS(MEM(EA, 4))
// // RA <- EA
@ -274,7 +274,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(lwax, 0x7C0002AA, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lwax, 0x7C0002AA, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -293,7 +293,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(lwz, 0x80000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lwz, 0x80000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -311,7 +311,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(lwzu, 0x84000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lwzu, 0x84000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + EXTS(D)
// // RT <- i32.0 || MEM(EA, 4)
// // RA <- EA
@ -325,7 +325,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(lwzux, 0x7C00006E, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lwzux, 0x7C00006E, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + (RB)
// // RT <- i32.0 || MEM(EA, 4)
// // RA <- EA
@ -338,7 +338,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(lwzx, 0x7C00002E, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lwzx, 0x7C00002E, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -359,7 +359,7 @@ namespace x64 {
// // Integer store (A-14)
// XEEMITTER(stb, 0x98000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stb, 0x98000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -377,7 +377,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(stbu, 0x9C000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stbu, 0x9C000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + EXTS(D)
// // MEM(EA, 1) <- (RS)[56:63]
// // RA <- EA
@ -391,7 +391,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(stbux, 0x7C0001EE, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stbux, 0x7C0001EE, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + (RB)
// // MEM(EA, 1) <- (RS)[56:63]
// // RA <- EA
@ -404,7 +404,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(stbx, 0x7C0001AE, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stbx, 0x7C0001AE, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -422,7 +422,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(std, 0xF8000000, DS )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(std, 0xF8000000, DS )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -440,7 +440,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(stdu, 0xF8000001, DS )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stdu, 0xF8000001, DS )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + EXTS(DS || 0b00)
// // MEM(EA, 8) <- (RS)
// // RA <- EA
@ -454,7 +454,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(stdux, 0x7C00016A, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stdux, 0x7C00016A, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -472,7 +472,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(stdx, 0x7C00012A, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stdx, 0x7C00012A, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + (RB)
// // MEM(EA, 8) <- (RS)
// // RA <- EA
@ -485,7 +485,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(sth, 0xB0000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(sth, 0xB0000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -503,7 +503,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(sthu, 0xB4000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(sthu, 0xB4000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + EXTS(D)
// // MEM(EA, 2) <- (RS)[48:63]
// // RA <- EA
@ -517,7 +517,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(sthux, 0x7C00036E, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(sthux, 0x7C00036E, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + (RB)
// // MEM(EA, 2) <- (RS)[48:63]
// // RA <- EA
@ -530,7 +530,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(sthx, 0x7C00032E, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(sthx, 0x7C00032E, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -548,7 +548,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(stw, 0x90000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stw, 0x90000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -566,7 +566,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(stwu, 0x94000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stwu, 0x94000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + EXTS(D)
// // MEM(EA, 4) <- (RS)[32:63]
// // RA <- EA
@ -580,7 +580,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(stwux, 0x7C00016E, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stwux, 0x7C00016E, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + (RB)
// // MEM(EA, 4) <- (RS)[32:63]
// // RA <- EA
@ -593,7 +593,7 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(stwx, 0x7C00012E, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stwx, 0x7C00012E, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -614,32 +614,32 @@ namespace x64 {
// // Integer load and store with byte reverse (A-1
// XEEMITTER(lhbrx, 0x7C00062C, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lhbrx, 0x7C00062C, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(lwbrx, 0x7C00042C, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lwbrx, 0x7C00042C, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(ldbrx, 0x7C000428, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(ldbrx, 0x7C000428, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(sthbrx, 0x7C00072C, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(sthbrx, 0x7C00072C, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(stwbrx, 0x7C00052C, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stwbrx, 0x7C00052C, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(stdbrx, 0x7C000528, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stdbrx, 0x7C000528, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
@ -647,12 +647,12 @@ namespace x64 {
// // Integer load and store multiple (A-16)
// XEEMITTER(lmw, 0xB8000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lmw, 0xB8000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(stmw, 0xBC000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stmw, 0xBC000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
@ -660,22 +660,22 @@ namespace x64 {
// // Integer load and store string (A-17)
// XEEMITTER(lswi, 0x7C0004AA, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lswi, 0x7C0004AA, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(lswx, 0x7C00042A, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lswx, 0x7C00042A, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(stswi, 0x7C0005AA, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stswi, 0x7C0005AA, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(stswx, 0x7C00052A, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stswx, 0x7C00052A, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
@ -683,22 +683,22 @@ namespace x64 {
// // Memory synchronization (A-18)
// XEEMITTER(eieio, 0x7C0006AC, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(eieio, 0x7C0006AC, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(isync, 0x4C00012C, XL )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(isync, 0x4C00012C, XL )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(ldarx, 0x7C0000A8, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(ldarx, 0x7C0000A8, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(lwarx, 0x7C000028, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lwarx, 0x7C000028, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -721,12 +721,12 @@ namespace x64 {
// return 0;
// }
// XEEMITTER(stdcx, 0x7C0001AD, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stdcx, 0x7C0001AD, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
// return 1;
// }
// XEEMITTER(stwcx, 0x7C00012D, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stwcx, 0x7C00012D, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -752,7 +752,7 @@ namespace x64 {
// return 0;
// }
XEEMITTER(sync, 0x7C0004AC, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(sync, 0x7C0004AC, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
@ -760,7 +760,7 @@ XEEMITTER(sync, 0x7C0004AC, X )(X64Emitter& e, Compiler& c, InstrData&
// // Floating-point load (A-19)
// XEEMITTER(lfd, 0xC8000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lfd, 0xC8000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -779,7 +779,7 @@ XEEMITTER(sync, 0x7C0004AC, X )(X64Emitter& e, Compiler& c, InstrData&
// return 0;
// }
// XEEMITTER(lfdu, 0xCC000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lfdu, 0xCC000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + EXTS(D)
// // FRT <- MEM(EA, 8)
// // RA <- EA
@ -793,7 +793,7 @@ XEEMITTER(sync, 0x7C0004AC, X )(X64Emitter& e, Compiler& c, InstrData&
// return 0;
// }
// XEEMITTER(lfdux, 0x7C0004EE, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lfdux, 0x7C0004EE, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + (RB)
// // FRT <- MEM(EA, 8)
// // RA <- EA
@ -807,7 +807,7 @@ XEEMITTER(sync, 0x7C0004AC, X )(X64Emitter& e, Compiler& c, InstrData&
// return 0;
// }
// XEEMITTER(lfdx, 0x7C0004AE, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lfdx, 0x7C0004AE, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -826,7 +826,7 @@ XEEMITTER(sync, 0x7C0004AC, X )(X64Emitter& e, Compiler& c, InstrData&
// return 0;
// }
// XEEMITTER(lfs, 0xC0000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lfs, 0xC0000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -845,7 +845,7 @@ XEEMITTER(sync, 0x7C0004AC, X )(X64Emitter& e, Compiler& c, InstrData&
// return 0;
// }
// XEEMITTER(lfsu, 0xC4000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lfsu, 0xC4000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + EXTS(D)
// // FRT <- DOUBLE(MEM(EA, 4))
// // RA <- EA
@ -859,7 +859,7 @@ XEEMITTER(sync, 0x7C0004AC, X )(X64Emitter& e, Compiler& c, InstrData&
// return 0;
// }
// XEEMITTER(lfsux, 0x7C00046E, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lfsux, 0x7C00046E, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + (RB)
// // FRT <- DOUBLE(MEM(EA, 4))
// // RA <- EA
@ -873,7 +873,7 @@ XEEMITTER(sync, 0x7C0004AC, X )(X64Emitter& e, Compiler& c, InstrData&
// return 0;
// }
// XEEMITTER(lfsx, 0x7C00042E, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(lfsx, 0x7C00042E, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -895,7 +895,7 @@ XEEMITTER(sync, 0x7C0004AC, X )(X64Emitter& e, Compiler& c, InstrData&
// // Floating-point store (A-20)
// XEEMITTER(stfd, 0xD8000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stfd, 0xD8000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -914,7 +914,7 @@ XEEMITTER(sync, 0x7C0004AC, X )(X64Emitter& e, Compiler& c, InstrData&
// return 0;
// }
// XEEMITTER(stfdu, 0xDC000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stfdu, 0xDC000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + EXTS(D)
// // MEM(EA, 8) <- (FRS)
// // RA <- EA
@ -929,7 +929,7 @@ XEEMITTER(sync, 0x7C0004AC, X )(X64Emitter& e, Compiler& c, InstrData&
// return 0;
// }
// XEEMITTER(stfdux, 0x7C0005EE, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stfdux, 0x7C0005EE, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + (RB)
// // MEM(EA, 8) <- (FRS)
// // RA <- EA
@ -943,7 +943,7 @@ XEEMITTER(sync, 0x7C0004AC, X )(X64Emitter& e, Compiler& c, InstrData&
// return 0;
// }
// XEEMITTER(stfdx, 0x7C0005AE, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stfdx, 0x7C0005AE, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -962,7 +962,7 @@ XEEMITTER(sync, 0x7C0004AC, X )(X64Emitter& e, Compiler& c, InstrData&
// return 0;
// }
// XEEMITTER(stfiwx, 0x7C0007AE, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stfiwx, 0x7C0007AE, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -981,7 +981,7 @@ XEEMITTER(sync, 0x7C0004AC, X )(X64Emitter& e, Compiler& c, InstrData&
// return 0;
// }
// XEEMITTER(stfs, 0xD0000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stfs, 0xD0000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -1000,7 +1000,7 @@ XEEMITTER(sync, 0x7C0004AC, X )(X64Emitter& e, Compiler& c, InstrData&
// return 0;
// }
// XEEMITTER(stfsu, 0xD4000000, D )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stfsu, 0xD4000000, D )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + EXTS(D)
// // MEM(EA, 4) <- SINGLE(FRS)
// // RA <- EA
@ -1015,7 +1015,7 @@ XEEMITTER(sync, 0x7C0004AC, X )(X64Emitter& e, Compiler& c, InstrData&
// return 0;
// }
// XEEMITTER(stfsux, 0x7C00056E, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stfsux, 0x7C00056E, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // EA <- (RA) + (RB)
// // MEM(EA, 4) <- SINGLE(FRS)
// // RA <- EA
@ -1029,7 +1029,7 @@ XEEMITTER(sync, 0x7C0004AC, X )(X64Emitter& e, Compiler& c, InstrData&
// return 0;
// }
// XEEMITTER(stfsx, 0x7C00052E, X )(X64Emitter& e, Compiler& c, InstrData& i) {
// XEEMITTER(stfsx, 0x7C00052E, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// // if RA = 0 then
// // b <- 0
// // else
@ -1051,35 +1051,35 @@ XEEMITTER(sync, 0x7C0004AC, X )(X64Emitter& e, Compiler& c, InstrData&
// Cache management (A-27)
XEEMITTER(dcbf, 0x7C0000AC, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(dcbf, 0x7C0000AC, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(dcbst, 0x7C00006C, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(dcbst, 0x7C00006C, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(dcbt, 0x7C00022C, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(dcbt, 0x7C00022C, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// No-op for now.
// TODO(benvanik): use @llvm.prefetch
return 0;
}
XEEMITTER(dcbtst, 0x7C0001EC, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(dcbtst, 0x7C0001EC, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// No-op for now.
// TODO(benvanik): use @llvm.prefetch
return 0;
}
XEEMITTER(dcbz, 0x7C0007EC, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(dcbz, 0x7C0007EC, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
// or dcbz128 0x7C2007EC
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(icbi, 0x7C0007AC, X )(X64Emitter& e, Compiler& c, InstrData& i) {
XEEMITTER(icbi, 0x7C0007AC, X )(X64Emitter& e, X86Compiler& c, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}

591
src/xenia/cpu/x64/x64_emitter.cc
View File

@ -571,7 +571,7 @@ void X64Emitter::GenerateBasicBlock(FunctionBlock* block) {
continue;
}
typedef int (*InstrEmitter)(X64Emitter& g, Compiler& c, InstrData& i);
typedef int (*InstrEmitter)(X64Emitter& g, X86Compiler& c, InstrData& i);
InstrEmitter emit = (InstrEmitter)i.type->emit;
if (!i.type->emit || emit(*this, compiler_, i)) {
// This printf is handy for sort/uniquify to find instructions.
@ -599,142 +599,6 @@ void X64Emitter::GenerateBasicBlock(FunctionBlock* block) {
// TODO(benvanik): finish up BB
}
// jit_value_t X64Emitter::get_int32(int32_t value) {
// return jit_value_create_nint_constant(fn_, jit_type_int, value);
// }
// jit_value_t X64Emitter::get_uint32(uint32_t value) {
// return jit_value_create_nint_constant(fn_, jit_type_uint, value);
// }
// jit_value_t X64Emitter::get_int64(int64_t value) {
// return jit_value_create_nint_constant(fn_, jit_type_nint, value);
// }
// jit_value_t X64Emitter::get_uint64(uint64_t value) {
// return jit_value_create_nint_constant(fn_, jit_type_nuint, value);
// }
// jit_value_t X64Emitter::make_signed(jit_value_t value) {
// jit_type_t source_type = jit_value_get_type(value);
// source_type = jit_type_normalize(source_type);
// jit_type_t signed_source_type = source_type;
// switch (jit_type_get_kind(source_type)) {
// case JIT_TYPE_UBYTE: signed_source_type = jit_type_sbyte; break;
// case JIT_TYPE_USHORT: signed_source_type = jit_type_short; break;
// case JIT_TYPE_UINT: signed_source_type = jit_type_int; break;
// case JIT_TYPE_NUINT: signed_source_type = jit_type_nint; break;
// case JIT_TYPE_ULONG: signed_source_type = jit_type_long; break;
// }
// if (signed_source_type != source_type) {
// value = jit_insn_convert(fn_, value, signed_source_type, 0);
// }
// return value;
// }
// jit_value_t X64Emitter::make_unsigned(jit_value_t value) {
// jit_type_t source_type = jit_value_get_type(value);
// source_type = jit_type_normalize(source_type);
// jit_type_t unsigned_source_type = source_type;
// switch (jit_type_get_kind(source_type)) {
// case JIT_TYPE_SBYTE: unsigned_source_type = jit_type_ubyte; break;
// case JIT_TYPE_SHORT: unsigned_source_type = jit_type_ushort; break;
// case JIT_TYPE_INT: unsigned_source_type = jit_type_uint; break;
// case JIT_TYPE_NINT: unsigned_source_type = jit_type_nuint; break;
// case JIT_TYPE_LONG: unsigned_source_type = jit_type_ulong; break;
// }
// if (unsigned_source_type != source_type) {
// value = jit_insn_convert(fn_, value, unsigned_source_type, 0);
// }
// return value;
// }
// jit_value_t X64Emitter::sign_extend(jit_value_t value,
// jit_type_t target_type) {
// // TODO(benvanik): better conversion checking.
// // X64 follows the C rules, which is that the source type indicates whether
// // sign extension occurs.
// // For example, int -> ulong is sign extended,
// // uint -> ulong is zero extended.
// // We convert to the same type with the expected sign and then use the built
// // in convert, only if needed.
// // No-op if the same types.
// jit_type_t source_type = jit_value_get_type(value);
// source_type = jit_type_normalize(source_type);
// target_type = jit_type_normalize(target_type);
// if (source_type == target_type) {
// return value;
// }
// // If just a sign change, simple conversion.
// if (jit_type_get_size(source_type) == jit_type_get_size(target_type)) {
// return jit_insn_convert(fn_, value, target_type, 0);
// }
// // Otherwise, need to convert to signed of the current type then extend.
// value = make_signed(value);
// return jit_insn_convert(fn_, value, target_type, 0);
// }
// jit_value_t X64Emitter::zero_extend(jit_value_t value,
// jit_type_t target_type) {
// // See the comment in ::sign_extend for more information.
// // No-op if the same types.
// jit_type_t source_type = jit_value_get_type(value);
// source_type = jit_type_normalize(source_type);
// target_type = jit_type_normalize(target_type);
// if (source_type == target_type) {
// return value;
// }
// // If just a sign change, simple conversion.
// if (jit_type_get_size(source_type) == jit_type_get_size(target_type)) {
// return jit_insn_convert(fn_, value, target_type, 0);
// }
// // Otherwise, need to convert to signed of the current type then extend.
// value = make_unsigned(value);
// return jit_insn_convert(fn_, value, target_type, 0);
// }
// jit_value_t X64Emitter::trunc_to_sbyte(jit_value_t value) {
// jit_type_t source_type = jit_value_get_type(value);
// source_type = jit_type_normalize(source_type);
// if (source_type == jit_type_sbyte) {
// return value;
// }
// return jit_insn_convert(fn_, value, jit_type_sbyte, 0);
// }
// jit_value_t X64Emitter::trunc_to_ubyte(jit_value_t value) {
// jit_type_t source_type = jit_value_get_type(value);
// source_type = jit_type_normalize(source_type);
// if (source_type == jit_type_ubyte) {
// return value;
// }
// return jit_insn_convert(fn_, value, jit_type_ubyte, 0);
// }
// jit_value_t X64Emitter::trunc_to_short(jit_value_t value) {
// jit_type_t source_type = jit_value_get_type(value);
// source_type = jit_type_normalize(source_type);
// if (source_type == jit_type_sbyte) {
// return value;
// }
// return jit_insn_convert(fn_, value, jit_type_short, 0);
// }
// jit_value_t X64Emitter::trunc_to_int(jit_value_t value) {
// jit_type_t source_type = jit_value_get_type(value);
// source_type = jit_type_normalize(source_type);
// if (source_type == jit_type_sbyte) {
// return value;
// }
// return jit_insn_convert(fn_, value, jit_type_int, 0);
// }
// int X64Emitter::branch_to_block(uint32_t address) {
// std::map<uint32_t, jit_label_t>::iterator it = bbs_.find(address);
// return jit_insn_branch(fn_, &it->second);
@ -1027,21 +891,6 @@ void X64Emitter::TraceBranch(uint32_t cia) {
// return 0;
// }
// jit_value_t X64Emitter::LoadStateValue(size_t offset, jit_type_t type,
// const char* name) {
// // Load from ppc_state[offset].
// // TODO(benvanik): tag with debug info?
// return jit_insn_load_relative(
// fn_, jit_value_get_param(fn_, 0), offset, type);
// }
// void X64Emitter::StoreStateValue(size_t offset, jit_type_t type,
// jit_value_t value) {
// // Store to ppc_state[offset].
// jit_insn_store_relative(
// fn_, jit_value_get_param(fn_, 0), offset, value);
// }
void X64Emitter::SetupLocals() {
X86Compiler& c = compiler_;
@ -1142,7 +991,9 @@ void X64Emitter::FillRegisters() {
}
// (cr >> 28 - n * 4) & 0xF
c.mov(cr_tmp, cr);
c.shr(cr_tmp, imm(28 - n * 4));
if (n < 4) {
c.shr(cr_tmp, imm(28 - n * 4));
}
c.and_(cr_tmp, imm(0xF));
c.mov(cr_n, cr_tmp);
}
@ -1211,10 +1062,15 @@ void X64Emitter::SpillRegisters() {
}
if (cr_tmp.getId() == kInvalidValue) {
cr_tmp = c.newGpVar();
if (FLAGS_annotate_disassembly) {
c.comment("Spilling CR");
}
}
// cr |= (cr_n << n * 4)
c.mov(cr_tmp, cr_n);
c.shl(cr_tmp, imm(n * 4));
if (n) {
c.shl(cr_tmp, imm(n * 4));
}
if (cr.getId() == kInvalidValue) {
cr = c.newGpVar();
c.mov(cr, cr_tmp);
@ -1223,9 +1079,6 @@ void X64Emitter::SpillRegisters() {
}
}
if (cr.getId() != kInvalidValue) {
if (FLAGS_annotate_disassembly) {
c.comment("Spilling CR");
}
c.mov(ptr(c.getGpArg(0), offsetof(xe_ppc_state_t, cr)),
cr);
}
@ -1253,189 +1106,193 @@ void X64Emitter::SpillRegisters() {
}
}
// jit_value_t X64Emitter::xer_value() {
// XEASSERTNOTNULL(locals_.xer);
// return jit_insn_load(fn_, locals_.xer);
// }
GpVar& X64Emitter::xer_value() {
X86Compiler& c = compiler_;
XEASSERT(locals_.xer.getId() != kInvalidValue);
return locals_.xer;
}
// void X64Emitter::update_xer_value(jit_value_t value) {
// XEASSERTNOTNULL(locals_.xer);
void X64Emitter::update_xer_value(GpVar& value) {
X86Compiler& c = compiler_;
XEASSERT(locals_.xer.getId() != kInvalidValue);
c.mov(locals_.xer, zero_extend(value, 8));
}
// // Extend to 64bits if needed.
// value = zero_extend(value, jit_type_nuint);
// jit_insn_store(fn_, locals_.xer, value);
// }
#if 0
void X64Emitter::update_xer_with_overflow(GpVar& value) {
X86Compiler& c = compiler_;
XEASSERT(locals_.xer.getId() != kInvalidValue);
// void X64Emitter::update_xer_with_overflow(jit_value_t value) {
// XEASSERTNOTNULL(locals_.xer);
// Expects a i1 indicating overflow.
// Trust the caller that if it's larger than that it's already truncated.
value = zero_extend(value, 8);
// // Expects a i1 indicating overflow.
// // Trust the caller that if it's larger than that it's already truncated.
// value = zero_extend(value, jit_type_nuint);
GpVar& xer = xer_value();
xer = jit_insn_and(fn_, xer, get_uint64(0xFFFFFFFFBFFFFFFF)); // clear bit 30
xer = jit_insn_or(fn_, xer, jit_insn_shl(fn_, value, get_uint32(31)));
xer = jit_insn_or(fn_, xer, jit_insn_shl(fn_, value, get_uint32(30)));
jit_insn_store(fn_, locals_.xer, value);
}
#endif
// jit_value_t xer = xer_value();
// xer = jit_insn_and(fn_, xer, get_uint64(0xFFFFFFFFBFFFFFFF)); // clear bit 30
// xer = jit_insn_or(fn_, xer, jit_insn_shl(fn_, value, get_uint32(31)));
// xer = jit_insn_or(fn_, xer, jit_insn_shl(fn_, value, get_uint32(30)));
// jit_insn_store(fn_, locals_.xer, value);
// }
#if 0
void X64Emitter::update_xer_with_carry(GpVar& value) {
X86Compiler& c = compiler_;
XEASSERT(locals_.xer.getId() != kInvalidValue);
// void X64Emitter::update_xer_with_carry(jit_value_t value) {
// XEASSERTNOTNULL(locals_.xer);
// Expects a i1 indicating carry.
// Trust the caller that if it's larger than that it's already truncated.
value = zero_extend(value, jit_type_nuint);
// // Expects a i1 indicating carry.
// // Trust the caller that if it's larger than that it's already truncated.
// value = zero_extend(value, jit_type_nuint);
GpVar& xer = xer_value();
xer = jit_insn_and(fn_, xer, get_uint64(0xFFFFFFFFDFFFFFFF)); // clear bit 29
xer = jit_insn_or(fn_, xer, jit_insn_shl(fn_, value, get_uint32(29)));
jit_insn_store(fn_, locals_.xer, value);
}
#endif
// jit_value_t xer = xer_value();
// xer = jit_insn_and(fn_, xer, get_uint64(0xFFFFFFFFDFFFFFFF)); // clear bit 29
// xer = jit_insn_or(fn_, xer, jit_insn_shl(fn_, value, get_uint32(29)));
// jit_insn_store(fn_, locals_.xer, value);
// }
#if 0
void X64Emitter::update_xer_with_overflow_and_carry(GpVar& value) {
X86Compiler& c = compiler_;
XEASSERT(locals_.xer.getId() != kInvalidValue);
// void X64Emitter::update_xer_with_overflow_and_carry(jit_value_t value) {
// XEASSERTNOTNULL(locals_.xer);
// Expects a i1 indicating overflow.
// Trust the caller that if it's larger than that it's already truncated.
value = zero_extend(value, jit_type_nuint);
// // Expects a i1 indicating overflow.
// // Trust the caller that if it's larger than that it's already truncated.
// value = zero_extend(value, jit_type_nuint);
// This is effectively an update_xer_with_overflow followed by an
// update_xer_with_carry, but since the logic is largely the same share it.
GpVar& xer = xer_value();
// clear bit 30 & 29
xer = jit_insn_and(fn_, xer, get_uint64(0xFFFFFFFF9FFFFFFF));
xer = jit_insn_or(fn_, xer, jit_insn_shl(fn_, value, get_uint32(31)));
xer = jit_insn_or(fn_, xer, jit_insn_shl(fn_, value, get_uint32(30)));
xer = jit_insn_or(fn_, xer, jit_insn_shl(fn_, value, get_uint32(29)));
jit_insn_store(fn_, locals_.xer, value);
}
#endif
// // This is effectively an update_xer_with_overflow followed by an
// // update_xer_with_carry, but since the logic is largely the same share it.
// jit_value_t xer = xer_value();
// // clear bit 30 & 29
// xer = jit_insn_and(fn_, xer, get_uint64(0xFFFFFFFF9FFFFFFF));
// xer = jit_insn_or(fn_, xer, jit_insn_shl(fn_, value, get_uint32(31)));
// xer = jit_insn_or(fn_, xer, jit_insn_shl(fn_, value, get_uint32(30)));
// xer = jit_insn_or(fn_, xer, jit_insn_shl(fn_, value, get_uint32(29)));
// jit_insn_store(fn_, locals_.xer, value);
// }
GpVar& X64Emitter::lr_value() {
X86Compiler& c = compiler_;
XEASSERT(locals_.lr.getId() != kInvalidValue);
return locals_.lr;
}
// jit_value_t X64Emitter::lr_value() {
// XEASSERTNOTNULL(locals_.lr);
// return jit_insn_load(fn_, locals_.lr);
// }
void X64Emitter::update_lr_value(GpVar& value) {
X86Compiler& c = compiler_;
XEASSERT(locals_.lr.getId() != kInvalidValue);
c.mov(locals_.lr, zero_extend(value, 8));
}
// void X64Emitter::update_lr_value(jit_value_t value) {
// XEASSERTNOTNULL(locals_.lr);
GpVar& X64Emitter::ctr_value() {
X86Compiler& c = compiler_;
XEASSERT(locals_.ctr.getId() != kInvalidValue);
return locals_.ctr;
}
// // Extend to 64bits if needed.
// value = zero_extend(value, jit_type_nuint);
// jit_insn_store(fn_, locals_.lr, value);
// }
void X64Emitter::update_ctr_value(GpVar& value) {
X86Compiler& c = compiler_;
XEASSERT(locals_.ctr.getId() != kInvalidValue);
c.mov(locals_.ctr, zero_extend(value, 8));
}
// jit_value_t X64Emitter::ctr_value() {
// XEASSERTNOTNULL(locals_.ctr);
// return jit_insn_load(fn_, locals_.ctr);
// }
GpVar& X64Emitter::cr_value(uint32_t n) {
X86Compiler& c = compiler_;
XEASSERT(n >= 0 && n < 8);
XEASSERT(locals_.cr[n].getId() != kInvalidValue);
return locals_.cr[n];
}
// void X64Emitter::update_ctr_value(jit_value_t value) {
// XEASSERTNOTNULL(locals_.ctr);
void X64Emitter::update_cr_value(uint32_t n, GpVar& value) {
X86Compiler& c = compiler_;
XEASSERT(n >= 0 && n < 8);
XEASSERT(locals_.cr[n].getId() != kInvalidValue);
c.mov(locals_.cr[n], trunc(value, 1));
}
// // Extend to 64bits if needed.
// value = zero_extend(value, jit_type_nuint);
// jit_insn_store(fn_, locals_.ctr, value);
// }
#if 0
void X64Emitter::update_cr_with_cond(
uint32_t n, GpVar& lhs, GpVar& rhs, bool is_signed) {
X86Compiler& c = compiler_;
// bit0 = RA < RB
// bit1 = RA > RB
// bit2 = RA = RB
// bit3 = XER[SO]
// jit_value_t X64Emitter::cr_value(uint32_t n) {
// XEASSERT(n >= 0 && n < 8);
// XEASSERTNOTNULL(locals_.cr[n]);
// TODO(benvanik): inline this using the x86 cmp instruction - this prevents
// the need for a lot of the compares and ensures we lower to the best
// possible x86.
// GpVar& cmp = InlineAsm::get(
// FunctionType::get(),
// "cmp $0, $1 \n"
// "mov from compare registers \n",
// "r,r", ??
// true);
// jit_value_t value = jit_insn_load(fn_, locals_.cr[n]);
// value = zero_extend(value, jit_type_nuint);
// return value;
// }
// Convert input signs, if needed.
if (is_signed) {
lhs = make_signed(lhs);
rhs = make_signed(rhs);
} else {
lhs = make_unsigned(lhs);
rhs = make_unsigned(rhs);
}
GpVar& c = jit_insn_lt(fn_, lhs, rhs);
c = jit_insn_or(fn_, c,
jit_insn_shl(fn_, jit_insn_gt(fn_, lhs, rhs), get_uint32(1)));
c = jit_insn_or(fn_, c,
jit_insn_shl(fn_, jit_insn_eq(fn_, lhs, rhs), get_uint32(2)));
// void X64Emitter::update_cr_value(uint32_t n, jit_value_t value) {
// XEASSERT(n >= 0 && n < 8);
// XEASSERTNOTNULL(locals_.cr[n]);
// TODO(benvanik): set bit 4 to XER[SO]
// // Truncate to 8 bits if needed.
// // TODO(benvanik): also widen?
// value = trunc_to_ubyte(value);
// Insert the 4 bits into their location in the CR.
update_cr_value(n, c);
}
#endif
// jit_insn_store(fn_, locals_.cr[n], value);
// }
GpVar& X64Emitter::gpr_value(uint32_t n) {
X86Compiler& c = compiler_;
XEASSERT(n >= 0 && n < 32);
XEASSERT(locals_.gpr[n].getId() != kInvalidValue);
// void X64Emitter::update_cr_with_cond(
// uint32_t n, jit_value_t lhs, jit_value_t rhs, bool is_signed) {
// // bit0 = RA < RB
// // bit1 = RA > RB
// // bit2 = RA = RB
// // bit3 = XER[SO]
// Actually r0 is writable, even though nobody should ever do that.
// Perhaps we can check usage and enable this if safe?
// if (n == 0) {
// return get_uint64(0);
// }
// // TODO(benvanik): inline this using the x86 cmp instruction - this prevents
// // the need for a lot of the compares and ensures we lower to the best
// // possible x86.
// // jit_value_t cmp = InlineAsm::get(
// // FunctionType::get(),
// // "cmp $0, $1 \n"
// // "mov from compare registers \n",
// // "r,r", ??
// // true);
return locals_.gpr[n];
}
// // Convert input signs, if needed.
// if (is_signed) {
// lhs = make_signed(lhs);
// rhs = make_signed(rhs);
// } else {
// lhs = make_unsigned(lhs);
// rhs = make_unsigned(rhs);
// }
// jit_value_t c = jit_insn_lt(fn_, lhs, rhs);
// c = jit_insn_or(fn_, c,
// jit_insn_shl(fn_, jit_insn_gt(fn_, lhs, rhs), get_uint32(1)));
// c = jit_insn_or(fn_, c,
// jit_insn_shl(fn_, jit_insn_eq(fn_, lhs, rhs), get_uint32(2)));
void X64Emitter::update_gpr_value(uint32_t n, GpVar& value) {
X86Compiler& c = compiler_;
XEASSERT(n >= 0 && n < 32);
XEASSERT(locals_.gpr[n].getId() != kInvalidValue);
// // TODO(benvanik): set bit 4 to XER[SO]
// See above - r0 can be written.
// if (n == 0) {
// // Ignore writes to zero.
// return;
// }
// // Insert the 4 bits into their location in the CR.
// update_cr_value(n, c);
// }
c.mov(locals_.gpr[n], zero_extend(value, 8));
}
// jit_value_t X64Emitter::gpr_value(uint32_t n) {
// XEASSERT(n >= 0 && n < 32);
// XEASSERTNOTNULL(locals_.gpr[n]);
GpVar& X64Emitter::fpr_value(uint32_t n) {
X86Compiler& c = compiler_;
XEASSERT(n >= 0 && n < 32);
XEASSERT(locals_.fpr[n].getId() != kInvalidValue);
return locals_.fpr[n];
}
// // Actually r0 is writable, even though nobody should ever do that.
// // Perhaps we can check usage and enable this if safe?
// // if (n == 0) {
// // return get_uint64(0);
// // }
void X64Emitter::update_fpr_value(uint32_t n, GpVar& value) {
X86Compiler& c = compiler_;
XEASSERT(n >= 0 && n < 32);
XEASSERT(locals_.fpr[n].getId() != kInvalidValue);
c.mov(locals_.fpr[n], value);
}
// return jit_insn_load(fn_, locals_.gpr[n]);
// }
// void X64Emitter::update_gpr_value(uint32_t n, jit_value_t value) {
// XEASSERT(n >= 0 && n < 32);
// XEASSERTNOTNULL(locals_.gpr[n]);
// // See above - r0 can be written.
// // if (n == 0) {
// // // Ignore writes to zero.
// // return;
// // }
// // Extend to 64bits if needed.
// value = zero_extend(value, jit_type_nuint);
// jit_insn_store(fn_, locals_.gpr[n], value);
// }
// jit_value_t X64Emitter::fpr_value(uint32_t n) {
// XEASSERT(n >= 0 && n < 32);
// XEASSERTNOTNULL(locals_.fpr[n]);
// return jit_insn_load(fn_, locals_.fpr[n]);
// }
// void X64Emitter::update_fpr_value(uint32_t n, jit_value_t value) {
// XEASSERT(n >= 0 && n < 32);
// XEASSERTNOTNULL(locals_.fpr[n]);
// jit_insn_store(fn_, locals_.fpr[n], value);
// }
// jit_value_t X64Emitter::TouchMemoryAddress(uint32_t cia, jit_value_t addr) {
// GpVar& X64Emitter::TouchMemoryAddress(uint32_t cia, GpVar& addr) {
// // Input address is always in 32-bit space.
// addr = jit_insn_and(fn_,
// zero_extend(addr, jit_type_nuint),
@ -1471,8 +1328,8 @@ void X64Emitter::SpillRegisters() {
// return addr;
// }
// jit_value_t X64Emitter::ReadMemory(
// uint32_t cia, jit_value_t addr, uint32_t size, bool acquire) {
// GpVar& X64Emitter::ReadMemory(
// uint32_t cia, GpVar& addr, uint32_t size, bool acquire) {
// jit_type_t data_type = NULL;
// bool needs_swap = false;
// switch (size) {
@ -1517,7 +1374,7 @@ void X64Emitter::SpillRegisters() {
// }
// void X64Emitter::WriteMemory(
// uint32_t cia, jit_value_t addr, uint32_t size, jit_value_t value,
// uint32_t cia, GpVar& addr, uint32_t size, GpVar& value,
// bool release) {
// jit_type_t data_type = NULL;
// bool needs_swap = false;
@ -1564,3 +1421,111 @@ void X64Emitter::SpillRegisters() {
// jit_value_t address = TouchMemoryAddress(cia, addr);
// jit_insn_store_relative(fn_, address, 0, value);
// }
// jit_value_t X64Emitter::get_int32(int32_t value) {
// return jit_value_create_nint_constant(fn_, jit_type_int, value);
// }
// jit_value_t X64Emitter::get_uint32(uint32_t value) {
// return jit_value_create_nint_constant(fn_, jit_type_uint, value);
// }
// jit_value_t X64Emitter::get_int64(int64_t value) {
// return jit_value_create_nint_constant(fn_, jit_type_nint, value);
// }
// jit_value_t X64Emitter::get_uint64(uint64_t value) {
// return jit_value_create_nint_constant(fn_, jit_type_nuint, value);
// }
#if 0
GpVar X64Emitter::sign_extend(GpVar& value, int size) {
X86Compiler& c = compiler_;
// No-op if the same size.
if (value.getSize() == size) {
return value;
}
// TODO(benvanik): use movsx if value is in memory.
// errrr.... could pin values to rax for cbw/cwde/cdqe
// or, could use shift trick (may be slower):
// shlq $(target_len-src_len), reg
// sarq $(target_len-src_len), reg
GpVar tmp;
switch (size) {
case 1:
tmp = c.newGpVar(kX86VarTypeGpd);
return value.r8();
case 2:
tmp = c.newGpVar(kX86VarTypeGpd);
return value.r16();
case 4:
tmp = c.newGpVar(kX86VarTypeGpd);
return value.r32();
default:
case 8:
tmp = c.newGpVar(kX86VarTypeGpq);
c.mov(tmp, value);
if (value.getSize() == 4) {
c.cdqe(value);
}
return value.r64();
}
}
#endif
GpVar X64Emitter::zero_extend(GpVar& value, int size) {
X86Compiler& c = compiler_;
// No-op if the same size.
if (value.getSize() == size) {
return value;
}
// TODO(benvanik): use movzx if value is in memory.
GpVar tmp;
switch (size) {
case 1:
tmp = c.newGpVar(kX86VarTypeGpd);
c.mov(tmp, value.r8());
break;
case 2:
tmp = c.newGpVar(kX86VarTypeGpd);
c.mov(tmp, value.r16());
break;
case 4:
tmp = c.newGpVar(kX86VarTypeGpd);
c.mov(tmp, value.r32());
break;
default:
case 8:
tmp = c.newGpVar(kX86VarTypeGpq);
c.mov(tmp, value.r64());
break;
}
return tmp;
}
GpVar X64Emitter::trunc(GpVar& value, int size) {
X86Compiler& c = compiler_;
// No-op if the same size.
if (value.getSize() == size) {
return value;
}
switch (size) {
case 1:
return value.r8();
case 2:
return value.r16();
case 4:
return value.r32();
default:
case 8:
return value.r64();
}
}

71
src/xenia/cpu/x64/x64_emitter.h
View File

@ -41,19 +41,6 @@ public:
sdb::FunctionSymbol* symbol();
sdb::FunctionBlock* fn_block();
// jit_value_t get_int32(int32_t value);
// jit_value_t get_uint32(uint32_t value);
// jit_value_t get_int64(int64_t value);
// jit_value_t get_uint64(uint64_t value);
// jit_value_t make_signed(jit_value_t value);
// jit_value_t make_unsigned(jit_value_t value);
// jit_value_t sign_extend(jit_value_t value, jit_type_t target_type);
// jit_value_t zero_extend(jit_value_t value, jit_type_t target_type);
// jit_value_t trunc_to_sbyte(jit_value_t value);
// jit_value_t trunc_to_ubyte(jit_value_t value);
// jit_value_t trunc_to_short(jit_value_t value);
// jit_value_t trunc_to_int(jit_value_t value);
// int branch_to_block(uint32_t address);
// int branch_to_block_if(uint32_t address, jit_value_t value);
// int branch_to_block_if_not(uint32_t address, jit_value_t value);
@ -72,41 +59,45 @@ public:
// int GenerateIndirectionBranch(uint32_t cia, jit_value_t target,
// bool lk, bool likely_local);
// jit_value_t LoadStateValue(size_t offset, jit_type_t type,
// const char* name = "");
// void StoreStateValue(size_t offset, jit_type_t type, jit_value_t value);
void FillRegisters();
void SpillRegisters();
// jit_value_t xer_value();
// void update_xer_value(jit_value_t value);
// void update_xer_with_overflow(jit_value_t value);
// void update_xer_with_carry(jit_value_t value);
// void update_xer_with_overflow_and_carry(jit_value_t value);
AsmJit::GpVar& xer_value();
void update_xer_value(AsmJit::GpVar& value);
void update_xer_with_overflow(AsmJit::GpVar& value);
void update_xer_with_carry(AsmJit::GpVar& value);
void update_xer_with_overflow_and_carry(AsmJit::GpVar& value);
// jit_value_t lr_value();
// void update_lr_value(jit_value_t value);
AsmJit::GpVar& lr_value();
void update_lr_value(AsmJit::GpVar& value);
// jit_value_t ctr_value();
// void update_ctr_value(jit_value_t value);
AsmJit::GpVar& ctr_value();
void update_ctr_value(AsmJit::GpVar& value);
// jit_value_t cr_value(uint32_t n);
// void update_cr_value(uint32_t n, jit_value_t value);
// void update_cr_with_cond(uint32_t n, jit_value_t lhs, jit_value_t rhs,
// bool is_signed);
AsmJit::GpVar& cr_value(uint32_t n);
void update_cr_value(uint32_t n, AsmJit::GpVar& value);
void update_cr_with_cond(uint32_t n, AsmJit::GpVar& lhs, AsmJit::GpVar& rhs,
bool is_signed);
// jit_value_t gpr_value(uint32_t n);
// void update_gpr_value(uint32_t n, jit_value_t value);
// jit_value_t fpr_value(uint32_t n);
// void update_fpr_value(uint32_t n, jit_value_t value);
AsmJit::GpVar& gpr_value(uint32_t n);
void update_gpr_value(uint32_t n, AsmJit::GpVar& value);
AsmJit::GpVar& fpr_value(uint32_t n);
void update_fpr_value(uint32_t n, AsmJit::GpVar& value);
// jit_value_t TouchMemoryAddress(uint32_t cia, jit_value_t addr);
// jit_value_t ReadMemory(
// uint32_t cia, jit_value_t addr, uint32_t size, bool acquire = false);
// void WriteMemory(
// uint32_t cia, jit_value_t addr, uint32_t size, jit_value_t value,
// bool release = false);
AsmJit::GpVar& TouchMemoryAddress(uint32_t cia, AsmJit::GpVar& addr);
AsmJit::GpVar& ReadMemory(
uint32_t cia, AsmJit::GpVar& addr, uint32_t size, bool acquire = false);
void WriteMemory(
uint32_t cia, AsmJit::GpVar& addr, uint32_t size, AsmJit::GpVar& value,
bool release = false);
// jit_value_t get_int32(int32_t value);
// jit_value_t get_uint32(uint32_t value);
// jit_value_t get_int64(int64_t value);
// jit_value_t get_uint64(uint64_t value);
AsmJit::GpVar sign_extend(AsmJit::GpVar& value, int size);
AsmJit::GpVar zero_extend(AsmJit::GpVar& value, int size);
AsmJit::GpVar trunc(AsmJit::GpVar& value, int size);
private:
static void* OnDemandCompileTrampoline(