fabi/Xenia-Canary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

LIR skeleton, renaming some types to prevent conflict.

Browse Source
This commit is contained in:
Ben Vanik
2013-12-29 14:28:46 -08:00
parent 7d83ba0021
commit 3d01efffac
66 changed files with 817 additions and 762 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/alloy/frontend/ppc/ppc_disasm-private.h
View File

@@ -24,8 +24,8 @@ namespace ppc {
#define XEREGISTERINSTR(name, opcode) \
RegisterInstrDisassemble(opcode, (InstrDisassembleFn)InstrDisasm_##name);
//#define XEINSTRNOTIMPLEMENTED()
#define XEINSTRNOTIMPLEMENTED XEASSERTALWAYS
#define XEINSTRNOTIMPLEMENTED()
//#define XEINSTRNOTIMPLEMENTED XEASSERTALWAYS
} // namespace ppc

5
src/alloy/frontend/ppc/ppc_emit-private.h
View File

@@ -24,8 +24,9 @@ namespace ppc {
#define XEREGISTERINSTR(name, opcode) \
RegisterInstrEmit(opcode, (InstrEmitFn)InstrEmit_##name);
//#define XEINSTRNOTIMPLEMENTED()
#define XEINSTRNOTIMPLEMENTED XEASSERTALWAYS
#define XEINSTRNOTIMPLEMENTED()
//#define XEINSTRNOTIMPLEMENTED XEASSERTALWAYS
//#define XEINSTRNOTIMPLEMENTED() __debugbreak()
} // namespace ppc

562
src/alloy/frontend/ppc/ppc_emit_altivec.cc
View File

File diff suppressed because it is too large Load Diff

126
src/alloy/frontend/ppc/ppc_emit_alu.cc
View File

@@ -10,7 +10,7 @@
#include <alloy/frontend/ppc/ppc_emit-private.h>
#include <alloy/frontend/ppc/ppc_context.h>
#include <alloy/frontend/ppc/ppc_function_builder.h>
#include <alloy/frontend/ppc/ppc_hir_builder.h>
using namespace alloy::frontend::ppc;
@@ -25,7 +25,7 @@ namespace ppc {
// Integer arithmetic (A-3)
XEEMITTER(addx, 0x7C000214, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(addx, 0x7C000214, XO )(PPCHIRBuilder& f, InstrData& i) {
// RD <- (RA) + (RB)
Value* v = f.Add(
f.LoadGPR(i.XO.RA),
@@ -41,7 +41,7 @@ XEEMITTER(addx, 0x7C000214, XO )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(addcx, 0x7C000014, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(addcx, 0x7C000014, XO )(PPCHIRBuilder& f, InstrData& i) {
// RD <- (RA) + (RB)
// CA <- carry bit
Value* v = f.Add(
@@ -60,7 +60,7 @@ XEEMITTER(addcx, 0x7C000014, XO )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(addex, 0x7C000114, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(addex, 0x7C000114, XO )(PPCHIRBuilder& f, InstrData& i) {
// RD <- (RA) + (RB) + XER[CA]
Value* v = f.AddWithCarry(
f.LoadGPR(i.XO.RA),
@@ -79,7 +79,7 @@ XEEMITTER(addex, 0x7C000114, XO )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(addi, 0x38000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(addi, 0x38000000, D )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// RT <- EXTS(SI)
// else
@@ -93,7 +93,7 @@ XEEMITTER(addi, 0x38000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(addic, 0x30000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(addic, 0x30000000, D )(PPCHIRBuilder& f, InstrData& i) {
// RT <- (RA) + EXTS(SI)
Value* v = f.Add(
f.LoadGPR(i.D.RA),
@@ -104,7 +104,7 @@ XEEMITTER(addic, 0x30000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(addicx, 0x34000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(addicx, 0x34000000, D )(PPCHIRBuilder& f, InstrData& i) {
// RT <- (RA) + EXTS(SI)
Value* v = f.Add(
f.LoadGPR(i.D.RA),
@@ -116,7 +116,7 @@ XEEMITTER(addicx, 0x34000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(addis, 0x3C000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(addis, 0x3C000000, D )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// RT <- EXTS(SI) || i16.0
// else
@@ -130,7 +130,7 @@ XEEMITTER(addis, 0x3C000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(addmex, 0x7C0001D4, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(addmex, 0x7C0001D4, XO )(PPCHIRBuilder& f, InstrData& i) {
// RT <- (RA) + CA - 1
Value* v = f.AddWithCarry(
f.LoadGPR(i.XO.RA),
@@ -152,7 +152,7 @@ XEEMITTER(addmex, 0x7C0001D4, XO )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(addzex, 0x7C000194, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(addzex, 0x7C000194, XO )(PPCHIRBuilder& f, InstrData& i) {
// RT <- (RA) + CA
Value* v = f.AddWithCarry(
f.LoadGPR(i.XO.RA),
@@ -174,7 +174,7 @@ XEEMITTER(addzex, 0x7C000194, XO )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(divdx, 0x7C0003D2, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(divdx, 0x7C0003D2, XO )(PPCHIRBuilder& f, InstrData& i) {
// dividend <- (RA)
// divisor <- (RB)
// if divisor = 0 then
@@ -200,7 +200,7 @@ XEEMITTER(divdx, 0x7C0003D2, XO )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(divdux, 0x7C000392, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(divdux, 0x7C000392, XO )(PPCHIRBuilder& f, InstrData& i) {
// dividend <- (RA)
// divisor <- (RB)
// if divisor = 0 then
@@ -226,7 +226,7 @@ f.StoreGPR(i.XO.RT, v);
return 0;
}
XEEMITTER(divwx, 0x7C0003D6, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(divwx, 0x7C0003D6, XO )(PPCHIRBuilder& f, InstrData& i) {
// dividend[0:31] <- (RA)[32:63]
// divisor[0:31] <- (RB)[32:63]
// if divisor = 0 then
@@ -254,7 +254,7 @@ XEEMITTER(divwx, 0x7C0003D6, XO )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(divwux, 0x7C000396, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(divwux, 0x7C000396, XO )(PPCHIRBuilder& f, InstrData& i) {
// dividend[0:31] <- (RA)[32:63]
// divisor[0:31] <- (RB)[32:63]
// if divisor = 0 then
@@ -282,17 +282,17 @@ XEEMITTER(divwux, 0x7C000396, XO )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(mulhdx, 0x7C000092, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mulhdx, 0x7C000092, XO )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(mulhdux, 0x7C000012, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mulhdux, 0x7C000012, XO )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(mulhwx, 0x7C000096, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mulhwx, 0x7C000096, XO )(PPCHIRBuilder& f, InstrData& i) {
// RT[32:64] <- ((RA)[32:63] × (RB)[32:63])[0:31]
if (i.XO.OE) {
// With XER update.
@@ -310,7 +310,7 @@ XEEMITTER(mulhwx, 0x7C000096, XO )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(mulhwux, 0x7C000016, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mulhwux, 0x7C000016, XO )(PPCHIRBuilder& f, InstrData& i) {
// RT[32:64] <- ((RA)[32:63] × (RB)[32:63])[0:31]
if (i.XO.OE) {
// With XER update.
@@ -328,7 +328,7 @@ XEEMITTER(mulhwux, 0x7C000016, XO )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(mulldx, 0x7C0001D2, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mulldx, 0x7C0001D2, XO )(PPCHIRBuilder& f, InstrData& i) {
// RT <- ((RA) × (RB))[64:127]
if (i.XO.OE) {
// With XER update.
@@ -343,7 +343,7 @@ XEEMITTER(mulldx, 0x7C0001D2, XO )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(mulli, 0x1C000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mulli, 0x1C000000, D )(PPCHIRBuilder& f, InstrData& i) {
// prod[0:127] <- (RA) × EXTS(SI)
// RT <- prod[64:127]
Value* v = f.Mul(f.LoadGPR(i.D.RA), f.LoadConstant(XEEXTS16(i.D.DS)));
@@ -351,7 +351,7 @@ XEEMITTER(mulli, 0x1C000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(mullwx, 0x7C0001D6, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mullwx, 0x7C0001D6, XO )(PPCHIRBuilder& f, InstrData& i) {
// RT <- (RA)[32:63] × (RB)[32:63]
if (i.XO.OE) {
// With XER update.
@@ -368,7 +368,7 @@ XEEMITTER(mullwx, 0x7C0001D6, XO )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(negx, 0x7C0000D0, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(negx, 0x7C0000D0, XO )(PPCHIRBuilder& f, InstrData& i) {
// RT <- ¬(RA) + 1
if (i.XO.OE) {
// With XER update.
@@ -401,7 +401,7 @@ XEEMITTER(negx, 0x7C0000D0, XO )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(subfx, 0x7C000050, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(subfx, 0x7C000050, XO )(PPCHIRBuilder& f, InstrData& i) {
// RT <- ¬(RA) + (RB) + 1
Value* v = f.Sub(f.LoadGPR(i.XO.RB), f.LoadGPR(i.XO.RA));
f.StoreGPR(i.XO.RT, v);
@@ -415,7 +415,7 @@ XEEMITTER(subfx, 0x7C000050, XO )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(subfcx, 0x7C000010, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(subfcx, 0x7C000010, XO )(PPCHIRBuilder& f, InstrData& i) {
// RT <- ¬(RA) + (RB) + 1
Value* v = f.Sub(
f.LoadGPR(i.XO.RB),
@@ -433,7 +433,7 @@ XEEMITTER(subfcx, 0x7C000010, XO )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(subficx, 0x20000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(subficx, 0x20000000, D )(PPCHIRBuilder& f, InstrData& i) {
// RT <- ¬(RA) + EXTS(SI) + 1
Value* v = f.Sub(
f.LoadConstant(XEEXTS16(i.D.DS)),
@@ -444,7 +444,7 @@ XEEMITTER(subficx, 0x20000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(subfex, 0x7C000110, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(subfex, 0x7C000110, XO )(PPCHIRBuilder& f, InstrData& i) {
// RT <- ¬(RA) + (RB) + CA
Value* v = f.AddWithCarry(
f.Not(f.LoadGPR(i.XO.RA)),
@@ -463,7 +463,7 @@ XEEMITTER(subfex, 0x7C000110, XO )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(subfmex, 0x7C0001D0, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(subfmex, 0x7C0001D0, XO )(PPCHIRBuilder& f, InstrData& i) {
// RT <- ¬(RA) + CA - 1
Value* v = f.AddWithCarry(
f.Not(f.LoadGPR(i.XO.RA)),
@@ -482,7 +482,7 @@ XEEMITTER(subfmex, 0x7C0001D0, XO )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(subfzex, 0x7C000190, XO )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(subfzex, 0x7C000190, XO )(PPCHIRBuilder& f, InstrData& i) {
// RT <- ¬(RA) + CA
Value* v = f.AddWithCarry(
f.Not(f.LoadGPR(i.XO.RA)),
@@ -504,7 +504,7 @@ XEEMITTER(subfzex, 0x7C000190, XO )(PPCFunctionBuilder& f, InstrData& i) {
// Integer compare (A-4)
XEEMITTER(cmp, 0x7C000000, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(cmp, 0x7C000000, X )(PPCHIRBuilder& f, InstrData& i) {
// if L = 0 then
// a <- EXTS((RA)[32:63])
// b <- EXTS((RB)[32:63])
@@ -533,7 +533,7 @@ XEEMITTER(cmp, 0x7C000000, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(cmpi, 0x2C000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(cmpi, 0x2C000000, D )(PPCHIRBuilder& f, InstrData& i) {
// if L = 0 then
// a <- EXTS((RA)[32:63])
// else
@@ -560,7 +560,7 @@ XEEMITTER(cmpi, 0x2C000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(cmpl, 0x7C000040, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(cmpl, 0x7C000040, X )(PPCHIRBuilder& f, InstrData& i) {
// if L = 0 then
// a <- i32.0 || (RA)[32:63]
// b <- i32.0 || (RB)[32:63]
@@ -589,7 +589,7 @@ XEEMITTER(cmpl, 0x7C000040, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(cmpli, 0x28000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(cmpli, 0x28000000, D )(PPCHIRBuilder& f, InstrData& i) {
// if L = 0 then
// a <- i32.0 || (RA)[32:63]
// else
@@ -619,7 +619,7 @@ XEEMITTER(cmpli, 0x28000000, D )(PPCFunctionBuilder& f, InstrData& i) {
// Integer logical (A-5)
XEEMITTER(andx, 0x7C000038, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(andx, 0x7C000038, X )(PPCHIRBuilder& f, InstrData& i) {
// RA <- (RS) & (RB)
Value* ra = f.And(f.LoadGPR(i.X.RT), f.LoadGPR(i.X.RB));
if (i.X.Rc) {
@@ -629,7 +629,7 @@ XEEMITTER(andx, 0x7C000038, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(andcx, 0x7C000078, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(andcx, 0x7C000078, X )(PPCHIRBuilder& f, InstrData& i) {
// RA <- (RS) & ¬(RB)
Value* ra = f.And(f.LoadGPR(i.X.RT), f.Not(f.LoadGPR(i.X.RB)));
if (i.X.Rc) {
@@ -639,7 +639,7 @@ XEEMITTER(andcx, 0x7C000078, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(andix, 0x70000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(andix, 0x70000000, D )(PPCHIRBuilder& f, InstrData& i) {
// RA <- (RS) & (i48.0 || UI)
Value* ra = f.And(
f.LoadGPR(i.D.RT),
@@ -649,7 +649,7 @@ XEEMITTER(andix, 0x70000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(andisx, 0x74000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(andisx, 0x74000000, D )(PPCHIRBuilder& f, InstrData& i) {
// RA <- (RS) & (i32.0 || UI || i16.0)
Value* ra = f.And(
f.LoadGPR(i.D.RT),
@@ -659,7 +659,7 @@ XEEMITTER(andisx, 0x74000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(cntlzdx, 0x7C000074, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(cntlzdx, 0x7C000074, X )(PPCHIRBuilder& f, InstrData& i) {
// n <- 0
// do while n < 64
// if (RS)[n] = 1 then leave n
@@ -674,7 +674,7 @@ XEEMITTER(cntlzdx, 0x7C000074, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(cntlzwx, 0x7C000034, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(cntlzwx, 0x7C000034, X )(PPCHIRBuilder& f, InstrData& i) {
// n <- 32
// do while n < 64
// if (RS)[n] = 1 then leave n
@@ -690,7 +690,7 @@ XEEMITTER(cntlzwx, 0x7C000034, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(eqvx, 0x7C000238, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(eqvx, 0x7C000238, X )(PPCHIRBuilder& f, InstrData& i) {
// RA <- (RS) == (RB)
Value* ra = f.Xor(f.LoadGPR(i.X.RT), f.LoadGPR(i.X.RB));
ra = f.Not(ra);
@@ -701,7 +701,7 @@ XEEMITTER(eqvx, 0x7C000238, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(extsbx, 0x7C000774, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(extsbx, 0x7C000774, X )(PPCHIRBuilder& f, InstrData& i) {
// s <- (RS)[56]
// RA[56:63] <- (RS)[56:63]
// RA[0:55] <- i56.s
@@ -714,7 +714,7 @@ XEEMITTER(extsbx, 0x7C000774, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(extshx, 0x7C000734, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(extshx, 0x7C000734, X )(PPCHIRBuilder& f, InstrData& i) {
// s <- (RS)[48]
// RA[48:63] <- (RS)[48:63]
// RA[0:47] <- 48.s
@@ -727,7 +727,7 @@ XEEMITTER(extshx, 0x7C000734, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(extswx, 0x7C0007B4, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(extswx, 0x7C0007B4, X )(PPCHIRBuilder& f, InstrData& i) {
// s <- (RS)[32]
// RA[32:63] <- (RS)[32:63]
// RA[0:31] <- i32.s
@@ -740,12 +740,12 @@ XEEMITTER(extswx, 0x7C0007B4, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(nandx, 0x7C0003B8, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(nandx, 0x7C0003B8, X )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(norx, 0x7C0000F8, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(norx, 0x7C0000F8, X )(PPCHIRBuilder& f, InstrData& i) {
// RA <- ¬((RS) | (RB))
Value* ra = f.Or(
f.LoadGPR(i.X.RT),
@@ -758,7 +758,7 @@ XEEMITTER(norx, 0x7C0000F8, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(orx, 0x7C000378, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(orx, 0x7C000378, X )(PPCHIRBuilder& f, InstrData& i) {
// RA <- (RS) | (RB)
if (i.X.RT == i.X.RB && i.X.RT == i.X.RA &&
!i.X.Rc) {
@@ -781,7 +781,7 @@ XEEMITTER(orx, 0x7C000378, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(orcx, 0x7C000338, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(orcx, 0x7C000338, X )(PPCHIRBuilder& f, InstrData& i) {
// RA <- (RS) | ¬(RB)
Value* ra = f.Or(
f.LoadGPR(i.X.RT),
@@ -793,7 +793,7 @@ XEEMITTER(orcx, 0x7C000338, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(ori, 0x60000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(ori, 0x60000000, D )(PPCHIRBuilder& f, InstrData& i) {
// RA <- (RS) | (i48.0 || UI)
if (!i.D.RA && !i.D.RT && !i.D.DS) {
f.Nop();
@@ -806,7 +806,7 @@ XEEMITTER(ori, 0x60000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(oris, 0x64000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(oris, 0x64000000, D )(PPCHIRBuilder& f, InstrData& i) {
// RA <- (RS) | (i32.0 || UI || i16.0)
Value* ra = f.Or(
f.LoadGPR(i.D.RT),
@@ -815,7 +815,7 @@ XEEMITTER(oris, 0x64000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(xorx, 0x7C000278, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(xorx, 0x7C000278, X )(PPCHIRBuilder& f, InstrData& i) {
// RA <- (RS) XOR (RB)
Value* ra = f.Xor(
f.LoadGPR(i.X.RT),
@@ -827,7 +827,7 @@ XEEMITTER(xorx, 0x7C000278, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(xori, 0x68000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(xori, 0x68000000, D )(PPCHIRBuilder& f, InstrData& i) {
// RA <- (RS) XOR (i48.0 || UI)
Value* ra = f.Xor(
f.LoadGPR(i.D.RT),
@@ -836,7 +836,7 @@ XEEMITTER(xori, 0x68000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(xoris, 0x6C000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(xoris, 0x6C000000, D )(PPCHIRBuilder& f, InstrData& i) {
// RA <- (RS) XOR (i32.0 || UI || i16.0)
Value* ra = f.Xor(
f.LoadGPR(i.D.RT),
@@ -848,7 +848,7 @@ XEEMITTER(xoris, 0x6C000000, D )(PPCFunctionBuilder& f, InstrData& i) {
// Integer rotate (A-6)
XEEMITTER(rld, 0x78000000, MDS)(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(rld, 0x78000000, MDS)(PPCHIRBuilder& f, InstrData& i) {
if (i.MD.idx == 0) {
// XEEMITTER(rldiclx, 0x78000000, MD )
// n <- sh[5] || sh[0:4]
@@ -941,7 +941,7 @@ XEEMITTER(rld, 0x78000000, MDS)(PPCFunctionBuilder& f, InstrData& i) {
}
}
XEEMITTER(rlwimix, 0x50000000, M )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(rlwimix, 0x50000000, M )(PPCHIRBuilder& f, InstrData& i) {
// n <- SH
// r <- ROTL32((RS)[32:63], n)
// m <- MASK(MB+32, ME+32)
@@ -965,7 +965,7 @@ XEEMITTER(rlwimix, 0x50000000, M )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(rlwinmx, 0x54000000, M )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(rlwinmx, 0x54000000, M )(PPCHIRBuilder& f, InstrData& i) {
// n <- SH
// r <- ROTL32((RS)[32:63], n)
// m <- MASK(MB+32, ME+32)
@@ -992,7 +992,7 @@ XEEMITTER(rlwinmx, 0x54000000, M )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(rlwnmx, 0x5C000000, M )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(rlwnmx, 0x5C000000, M )(PPCHIRBuilder& f, InstrData& i) {
// n <- (RB)[59:63]
// r <- ROTL32((RS)[32:63], n)
// m <- MASK(MB+32, ME+32)
@@ -1016,7 +1016,7 @@ XEEMITTER(rlwnmx, 0x5C000000, M )(PPCFunctionBuilder& f, InstrData& i) {
// Integer shift (A-7)
XEEMITTER(sldx, 0x7C000036, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(sldx, 0x7C000036, X )(PPCHIRBuilder& f, InstrData& i) {
// n <- (RB)[59:63]
// r <- ROTL64((RS), n)
// if (RB)[58] = 0 then
@@ -1032,7 +1032,7 @@ XEEMITTER(sldx, 0x7C000036, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(slwx, 0x7C000030, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(slwx, 0x7C000030, X )(PPCHIRBuilder& f, InstrData& i) {
// n <- (RB)[59:63]
// r <- ROTL32((RS)[32:63], n)
// if (RB)[58] = 0 then
@@ -1050,7 +1050,7 @@ XEEMITTER(slwx, 0x7C000030, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(srdx, 0x7C000436, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(srdx, 0x7C000436, X )(PPCHIRBuilder& f, InstrData& i) {
// n <- (RB)[58:63]
// r <- ROTL64((RS), 64-n)
// if (RB)[57] = 0 then
@@ -1067,7 +1067,7 @@ XEEMITTER(srdx, 0x7C000436, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(srwx, 0x7C000430, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(srwx, 0x7C000430, X )(PPCHIRBuilder& f, InstrData& i) {
// n <- (RB)[59:63]
// r <- ROTL32((RS)[32:63], 64-n)
// if (RB)[58] = 0 then
@@ -1086,7 +1086,7 @@ XEEMITTER(srwx, 0x7C000430, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
// XEEMITTER(sradx, 0x7C000634, X )(PPCFunctionBuilder& f, InstrData& i) {
// XEEMITTER(sradx, 0x7C000634, X )(PPCHIRBuilder& f, InstrData& i) {
// // n <- rB[58-63]
// // r <- ROTL[64](rS, 64 - n)
// // if rB[57] = 0 then m ← MASK(n, 63)
@@ -1138,7 +1138,7 @@ XEEMITTER(srwx, 0x7C000430, X )(PPCFunctionBuilder& f, InstrData& i) {
// return 0;
// }
XEEMITTER(sradix, 0x7C000674, XS )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(sradix, 0x7C000674, XS )(PPCHIRBuilder& f, InstrData& i) {
// n <- sh[5] || sh[0-4]
// r <- ROTL[64](rS, 64 - n)
// m ← MASK(n, 63)
@@ -1167,7 +1167,7 @@ XEEMITTER(sradix, 0x7C000674, XS )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(srawx, 0x7C000630, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(srawx, 0x7C000630, X )(PPCHIRBuilder& f, InstrData& i) {
// n <- rB[59-63]
// r <- ROTL32((RS)[32:63], 64-n)
// m <- MASK(n+32, 63)
@@ -1196,7 +1196,7 @@ XEEMITTER(srawx, 0x7C000630, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(srawix, 0x7C000670, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(srawix, 0x7C000670, X )(PPCHIRBuilder& f, InstrData& i) {
// n <- SH
// r <- ROTL32((RS)[32:63], 64-n)
// m <- MASK(n+32, 63)

58
src/alloy/frontend/ppc/ppc_emit_control.cc
View File

@@ -10,7 +10,7 @@
#include <alloy/frontend/ppc/ppc_emit-private.h>
#include <alloy/frontend/ppc/ppc_context.h>
#include <alloy/frontend/ppc/ppc_function_builder.h>
#include <alloy/frontend/ppc/ppc_hir_builder.h>
using namespace alloy::frontend::ppc;
@@ -24,7 +24,7 @@ namespace ppc {
int InstrEmit_branch(
PPCFunctionBuilder& f, const char* src, uint64_t cia,
PPCHIRBuilder& f, const char* src, uint64_t cia,
Value* nia, bool lk, Value* cond = NULL, bool expect_true = true) {
uint32_t call_flags = 0;
@@ -93,7 +93,7 @@ int InstrEmit_branch(
}
XEEMITTER(bx, 0x48000000, I )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(bx, 0x48000000, I )(PPCHIRBuilder& f, InstrData& i) {
// if AA then
// NIA <- EXTS(LI || 0b00)
// else
@@ -112,7 +112,7 @@ XEEMITTER(bx, 0x48000000, I )(PPCFunctionBuilder& f, InstrData& i) {
f, "bx", i.address, f.LoadConstant(nia), i.I.LK);
}
XEEMITTER(bcx, 0x40000000, B )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(bcx, 0x40000000, B )(PPCHIRBuilder& f, InstrData& i) {
// if ¬BO[2] then
// CTR <- CTR - 1
// ctr_ok <- BO[2] | ((CTR[0:63] != 0) XOR BO[3])
@@ -188,7 +188,7 @@ XEEMITTER(bcx, 0x40000000, B )(PPCFunctionBuilder& f, InstrData& i) {
f, "bcx", i.address, f.LoadConstant(nia), i.B.LK, ok, expect_true);
}
XEEMITTER(bcctrx, 0x4C000420, XL )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(bcctrx, 0x4C000420, XL )(PPCHIRBuilder& f, InstrData& i) {
// cond_ok <- BO[0] | (CR[BI+32] ≡ BO[1])
// if cond_ok then
// NIA <- CTR[0:61] || 0b00
@@ -220,7 +220,7 @@ XEEMITTER(bcctrx, 0x4C000420, XL )(PPCFunctionBuilder& f, InstrData& i) {
f, "bcctrx", i.address, f.LoadCTR(), i.XL.LK, cond_ok, expect_true);
}
XEEMITTER(bclrx, 0x4C000020, XL )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(bclrx, 0x4C000020, XL )(PPCHIRBuilder& f, InstrData& i) {
// if ¬BO[2] then
// CTR <- CTR - 1
// ctr_ok <- BO[2] | ((CTR[0:63] != 0) XOR BO[3]
@@ -314,47 +314,47 @@ XEEMITTER(bclrx, 0x4C000020, XL )(PPCFunctionBuilder& f, InstrData& i) {
// Condition register logical (A-23)
XEEMITTER(crand, 0x4C000202, XL )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(crand, 0x4C000202, XL )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(crandc, 0x4C000102, XL )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(crandc, 0x4C000102, XL )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(creqv, 0x4C000242, XL )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(creqv, 0x4C000242, XL )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(crnand, 0x4C0001C2, XL )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(crnand, 0x4C0001C2, XL )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(crnor, 0x4C000042, XL )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(crnor, 0x4C000042, XL )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(cror, 0x4C000382, XL )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(cror, 0x4C000382, XL )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(crorc, 0x4C000342, XL )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(crorc, 0x4C000342, XL )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(crxor, 0x4C000182, XL )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(crxor, 0x4C000182, XL )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(mcrf, 0x4C000000, XL )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mcrf, 0x4C000000, XL )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
@@ -362,7 +362,7 @@ XEEMITTER(mcrf, 0x4C000000, XL )(PPCFunctionBuilder& f, InstrData& i) {
// System linkage (A-24)
XEEMITTER(sc, 0x44000002, SC )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(sc, 0x44000002, SC )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
@@ -370,7 +370,7 @@ XEEMITTER(sc, 0x44000002, SC )(PPCFunctionBuilder& f, InstrData& i) {
// Trap (A-25)
int InstrEmit_trap(PPCFunctionBuilder& f, InstrData& i,
int InstrEmit_trap(PPCHIRBuilder& f, InstrData& i,
Value* va, Value* vb, uint32_t TO) {
// if (a < b) & TO[0] then TRAP
// if (a > b) & TO[1] then TRAP
@@ -406,7 +406,7 @@ int InstrEmit_trap(PPCFunctionBuilder& f, InstrData& i,
return 0;
}
XEEMITTER(td, 0x7C000088, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(td, 0x7C000088, X )(PPCHIRBuilder& f, InstrData& i) {
// a <- (RA)
// b <- (RB)
// if (a < b) & TO[0] then TRAP
@@ -419,7 +419,7 @@ XEEMITTER(td, 0x7C000088, X )(PPCFunctionBuilder& f, InstrData& i) {
return InstrEmit_trap(f, i, ra, rb, i.X.RT);
}
XEEMITTER(tdi, 0x08000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(tdi, 0x08000000, D )(PPCHIRBuilder& f, InstrData& i) {
// a <- (RA)
// if (a < EXTS(SI)) & TO[0] then TRAP
// if (a > EXTS(SI)) & TO[1] then TRAP
@@ -431,7 +431,7 @@ XEEMITTER(tdi, 0x08000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return InstrEmit_trap(f, i, ra, rb, i.D.RT);
}
XEEMITTER(tw, 0x7C000008, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(tw, 0x7C000008, X )(PPCHIRBuilder& f, InstrData& i) {
// a <- EXTS((RA)[32:63])
// b <- EXTS((RB)[32:63])
// if (a < b) & TO[0] then TRAP
@@ -446,7 +446,7 @@ XEEMITTER(tw, 0x7C000008, X )(PPCFunctionBuilder& f, InstrData& i) {
return InstrEmit_trap(f, i, ra, rb, i.X.RT);
}
XEEMITTER(twi, 0x0C000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(twi, 0x0C000000, D )(PPCHIRBuilder& f, InstrData& i) {
// a <- EXTS((RA)[32:63])
// if (a < EXTS(SI)) & TO[0] then TRAP
// if (a > EXTS(SI)) & TO[1] then TRAP
@@ -462,12 +462,12 @@ XEEMITTER(twi, 0x0C000000, D )(PPCFunctionBuilder& f, InstrData& i) {
// Processor control (A-26)
XEEMITTER(mfcr, 0x7C000026, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mfcr, 0x7C000026, X )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(mfspr, 0x7C0002A6, XFX)(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mfspr, 0x7C0002A6, XFX)(PPCHIRBuilder& f, InstrData& i) {
// n <- spr[5:9] || spr[0:4]
// if length(SPR(n)) = 64 then
// RT <- SPR(n)
@@ -497,7 +497,7 @@ XEEMITTER(mfspr, 0x7C0002A6, XFX)(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(mftb, 0x7C0002E6, XFX)(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mftb, 0x7C0002E6, XFX)(PPCHIRBuilder& f, InstrData& i) {
Value* time;
LARGE_INTEGER counter;
if (QueryPerformanceCounter(&counter)) {
@@ -510,12 +510,12 @@ XEEMITTER(mftb, 0x7C0002E6, XFX)(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(mtcrf, 0x7C000120, XFX)(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mtcrf, 0x7C000120, XFX)(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(mtspr, 0x7C0003A6, XFX)(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mtspr, 0x7C0003A6, XFX)(PPCHIRBuilder& f, InstrData& i) {
// n <- spr[5:9] || spr[0:4]
// if length(SPR(n)) = 64 then
// SPR(n) <- (RS)
@@ -549,17 +549,17 @@ XEEMITTER(mtspr, 0x7C0003A6, XFX)(PPCFunctionBuilder& f, InstrData& i) {
// TODO(benvanik): MSR is used for toggling interrupts, and it'd be nice to
// obey that setting. It's usually guarding atomic stores.
XEEMITTER(mfmsr, 0x7C0000A6, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mfmsr, 0x7C0000A6, X )(PPCHIRBuilder& f, InstrData& i) {
f.Nop();
return 0;
}
XEEMITTER(mtmsr, 0x7C000124, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mtmsr, 0x7C000124, X )(PPCHIRBuilder& f, InstrData& i) {
f.Nop();
return 0;
}
XEEMITTER(mtmsrd, 0x7C000164, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mtmsrd, 0x7C000164, X )(PPCHIRBuilder& f, InstrData& i) {
f.Nop();
return 0;
}

82
src/alloy/frontend/ppc/ppc_emit_fpu.cc
View File

@@ -10,7 +10,7 @@
#include <alloy/frontend/ppc/ppc_emit-private.h>
#include <alloy/frontend/ppc/ppc_context.h>
#include <alloy/frontend/ppc/ppc_function_builder.h>
#include <alloy/frontend/ppc/ppc_hir_builder.h>
using namespace alloy::frontend::ppc;
@@ -35,7 +35,7 @@ namespace ppc {
// Floating-point arithmetic (A-8)
XEEMITTER(faddx, 0xFC00002A, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(faddx, 0xFC00002A, A )(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frA) + (frB)
Value* v = f.Add(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRB));
f.StoreFPR(i.A.FRT, v);
@@ -48,7 +48,7 @@ XEEMITTER(faddx, 0xFC00002A, A )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(faddsx, 0xEC00002A, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(faddsx, 0xEC00002A, A )(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frA) + (frB)
Value* v = f.Add(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRB));
v = f.Convert(f.Convert(v, FLOAT32_TYPE), FLOAT64_TYPE);
@@ -62,7 +62,7 @@ XEEMITTER(faddsx, 0xEC00002A, A )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(fdivx, 0xFC000024, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fdivx, 0xFC000024, A )(PPCHIRBuilder& f, InstrData& i) {
// frD <- frA / frB
Value* v = f.Div(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRB));
f.StoreFPR(i.A.FRT, v);
@@ -75,7 +75,7 @@ XEEMITTER(fdivx, 0xFC000024, A )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(fdivsx, 0xEC000024, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fdivsx, 0xEC000024, A )(PPCHIRBuilder& f, InstrData& i) {
// frD <- frA / frB
Value* v = f.Div(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRB));
v = f.Convert(f.Convert(v, FLOAT32_TYPE), FLOAT64_TYPE);
@@ -89,7 +89,7 @@ XEEMITTER(fdivsx, 0xEC000024, A )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(fmulx, 0xFC000032, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fmulx, 0xFC000032, A )(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frA) x (frC)
Value* v = f.Mul(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRC));
f.StoreFPR(i.A.FRT, v);
@@ -102,7 +102,7 @@ XEEMITTER(fmulx, 0xFC000032, A )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(fmulsx, 0xEC000032, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fmulsx, 0xEC000032, A )(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frA) x (frC)
Value* v = f.Mul(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRC));
v = f.Convert(f.Convert(v, FLOAT32_TYPE), FLOAT64_TYPE);
@@ -116,17 +116,17 @@ XEEMITTER(fmulsx, 0xEC000032, A )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(fresx, 0xEC000030, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fresx, 0xEC000030, A )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(frsqrtex, 0xFC000034, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(frsqrtex, 0xFC000034, A )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fsubx, 0xFC000028, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fsubx, 0xFC000028, A )(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frA) - (frB)
Value* v = f.Sub(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRB));
f.StoreFPR(i.A.FRT, v);
@@ -139,7 +139,7 @@ XEEMITTER(fsubx, 0xFC000028, A )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(fsubsx, 0xEC000028, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fsubsx, 0xEC000028, A )(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frA) - (frB)
Value* v = f.Sub(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRB));
v = f.Convert(f.Convert(v, FLOAT32_TYPE), FLOAT64_TYPE);
@@ -153,7 +153,7 @@ XEEMITTER(fsubsx, 0xEC000028, A )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(fselx, 0xFC00002E, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fselx, 0xFC00002E, A )(PPCHIRBuilder& f, InstrData& i) {
// if (frA) >= 0.0
// then frD <- (frC)
// else frD <- (frB)
@@ -168,7 +168,7 @@ XEEMITTER(fselx, 0xFC00002E, A )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(fsqrtx, 0xFC00002C, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fsqrtx, 0xFC00002C, A )(PPCHIRBuilder& f, InstrData& i) {
// Double precision:
// frD <- sqrt(frB)
Value* v = f.Sqrt(f.LoadFPR(i.A.FRA));
@@ -182,7 +182,7 @@ XEEMITTER(fsqrtx, 0xFC00002C, A )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(fsqrtsx, 0xEC00002C, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fsqrtsx, 0xEC00002C, A )(PPCHIRBuilder& f, InstrData& i) {
// Single precision:
// frD <- sqrt(frB)
Value* v = f.Sqrt(f.LoadFPR(i.A.FRA));
@@ -200,7 +200,7 @@ XEEMITTER(fsqrtsx, 0xEC00002C, A )(PPCFunctionBuilder& f, InstrData& i) {
// Floating-point multiply-add (A-9)
XEEMITTER(fmaddx, 0xFC00003A, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fmaddx, 0xFC00003A, A )(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frA x frC) + frB
Value* v = f.MulAdd(
f.LoadFPR(i.A.FRA),
@@ -216,7 +216,7 @@ XEEMITTER(fmaddx, 0xFC00003A, A )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(fmaddsx, 0xEC00003A, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fmaddsx, 0xEC00003A, A )(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frA x frC) + frB
Value* v = f.MulAdd(
f.LoadFPR(i.A.FRA),
@@ -233,7 +233,7 @@ XEEMITTER(fmaddsx, 0xEC00003A, A )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(fmsubx, 0xFC000038, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fmsubx, 0xFC000038, A )(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frA x frC) - frB
Value* v = f.MulSub(
f.LoadFPR(i.A.FRA),
@@ -249,7 +249,7 @@ XEEMITTER(fmsubx, 0xFC000038, A )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(fmsubsx, 0xEC000038, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fmsubsx, 0xEC000038, A )(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frA x frC) - frB
Value* v = f.MulSub(
f.LoadFPR(i.A.FRA),
@@ -266,17 +266,17 @@ XEEMITTER(fmsubsx, 0xEC000038, A )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(fnmaddx, 0xFC00003E, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fnmaddx, 0xFC00003E, A )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fnmaddsx, 0xEC00003E, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fnmaddsx, 0xEC00003E, A )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fnmsubx, 0xFC00003C, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fnmsubx, 0xFC00003C, A )(PPCHIRBuilder& f, InstrData& i) {
// frD <- -([frA x frC] - frB)
Value* v = f.Neg(f.MulSub(
f.LoadFPR(i.A.FRA),
@@ -292,7 +292,7 @@ XEEMITTER(fnmsubx, 0xFC00003C, A )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(fnmsubsx, 0xEC00003C, A )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fnmsubsx, 0xEC00003C, A )(PPCHIRBuilder& f, InstrData& i) {
// frD <- -([frA x frC] - frB)
Value* v = f.Neg(f.MulSub(
f.LoadFPR(i.A.FRA),
@@ -312,7 +312,7 @@ XEEMITTER(fnmsubsx, 0xEC00003C, A )(PPCFunctionBuilder& f, InstrData& i) {
// Floating-point rounding and conversion (A-10)
XEEMITTER(fcfidx, 0xFC00069C, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fcfidx, 0xFC00069C, X )(PPCHIRBuilder& f, InstrData& i) {
// frD <- signed_int64_to_double( frB )
Value* v = f.Convert(
f.Cast(f.LoadFPR(i.A.FRB), INT64_TYPE),
@@ -327,7 +327,7 @@ XEEMITTER(fcfidx, 0xFC00069C, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(fctidx, 0xFC00065C, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fctidx, 0xFC00065C, X )(PPCHIRBuilder& f, InstrData& i) {
// frD <- double_to_signed_int64( frB )
// TODO(benvanik): pull from FPSCR[RN]
RoundMode round_mode = ROUND_TO_ZERO;
@@ -343,12 +343,12 @@ XEEMITTER(fctidx, 0xFC00065C, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(fctidzx, 0xFC00065E, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fctidzx, 0xFC00065E, X )(PPCHIRBuilder& f, InstrData& i) {
// TODO(benvanik): assuming round to zero is always set, is that ok?
return InstrEmit_fctidx(f, i);
}
XEEMITTER(fctiwx, 0xFC00001C, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fctiwx, 0xFC00001C, X )(PPCHIRBuilder& f, InstrData& i) {
// frD <- double_to_signed_int32( frB )
// TODO(benvanik): pull from FPSCR[RN]
RoundMode round_mode = ROUND_TO_ZERO;
@@ -364,12 +364,12 @@ XEEMITTER(fctiwx, 0xFC00001C, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(fctiwzx, 0xFC00001E, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fctiwzx, 0xFC00001E, X )(PPCHIRBuilder& f, InstrData& i) {
// TODO(benvanik): assuming round to zero is always set, is that ok?
return InstrEmit_fctiwx(f, i);
}
XEEMITTER(frspx, 0xFC000018, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(frspx, 0xFC000018, X )(PPCHIRBuilder& f, InstrData& i) {
// frD <- Round_single(frB)
// TODO(benvanik): pull from FPSCR[RN]
RoundMode round_mode = ROUND_TO_ZERO;
@@ -388,7 +388,7 @@ XEEMITTER(frspx, 0xFC000018, X )(PPCFunctionBuilder& f, InstrData& i) {
// Floating-point compare (A-11)
int InstrEmit_fcmpx_(PPCFunctionBuilder& f, InstrData& i, bool ordered) {
int InstrEmit_fcmpx_(PPCHIRBuilder& f, InstrData& i, bool ordered) {
// if (FRA) is a NaN or (FRB) is a NaN then
// c <- 0b0001
// else if (FRA) < (FRB) then
@@ -410,42 +410,42 @@ int InstrEmit_fcmpx_(PPCFunctionBuilder& f, InstrData& i, bool ordered) {
f.UpdateCR(crf, f.LoadFPR(i.X.RA), f.LoadFPR(i.X.RB), false);
return 0;
}
XEEMITTER(fcmpo, 0xFC000040, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fcmpo, 0xFC000040, X )(PPCHIRBuilder& f, InstrData& i) {
return InstrEmit_fcmpx_(f, i, true);
}
XEEMITTER(fcmpu, 0xFC000000, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fcmpu, 0xFC000000, X )(PPCHIRBuilder& f, InstrData& i) {
return InstrEmit_fcmpx_(f, i, false);
}
// Floating-point status and control register (A
XEEMITTER(mcrfs, 0xFC000080, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mcrfs, 0xFC000080, X )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(mffsx, 0xFC00048E, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mffsx, 0xFC00048E, X )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(mtfsb0x, 0xFC00008C, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mtfsb0x, 0xFC00008C, X )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(mtfsb1x, 0xFC00004C, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mtfsb1x, 0xFC00004C, X )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(mtfsfx, 0xFC00058E, XFL)(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mtfsfx, 0xFC00058E, XFL)(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(mtfsfix, 0xFC00010C, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(mtfsfix, 0xFC00010C, X )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
@@ -453,7 +453,7 @@ XEEMITTER(mtfsfix, 0xFC00010C, X )(PPCFunctionBuilder& f, InstrData& i) {
// Floating-point move (A-21)
XEEMITTER(fabsx, 0xFC000210, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fabsx, 0xFC000210, X )(PPCHIRBuilder& f, InstrData& i) {
// frD <- abs(frB)
Value* v = f.Abs(f.LoadFPR(i.X.RB));
f.StoreFPR(i.X.RT, v);
@@ -465,7 +465,7 @@ XEEMITTER(fabsx, 0xFC000210, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(fmrx, 0xFC000090, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fmrx, 0xFC000090, X )(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frB)
Value* v = f.LoadFPR(i.X.RB);
f.StoreFPR(i.X.RT, v);
@@ -477,12 +477,12 @@ XEEMITTER(fmrx, 0xFC000090, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(fnabsx, 0xFC000110, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fnabsx, 0xFC000110, X )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(fnegx, 0xFC000050, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(fnegx, 0xFC000050, X )(PPCHIRBuilder& f, InstrData& i) {
// frD <- ¬ frB[0] || frB[1-63]
Value* v = f.Neg(f.LoadFPR(i.X.RB));
f.StoreFPR(i.X.RT, v);

172
src/alloy/frontend/ppc/ppc_emit_memory.cc
View File

@@ -10,7 +10,7 @@
#include <alloy/frontend/ppc/ppc_emit-private.h>
#include <alloy/frontend/ppc/ppc_context.h>
#include <alloy/frontend/ppc/ppc_function_builder.h>
#include <alloy/frontend/ppc/ppc_hir_builder.h>
using namespace alloy::frontend::ppc;
@@ -24,7 +24,7 @@ namespace ppc {
#define TRUNCATE_ADDRESSES 0
Value* CalculateEA(PPCFunctionBuilder& f, uint32_t ra, uint32_t rb) {
Value* CalculateEA(PPCHIRBuilder& f, uint32_t ra, uint32_t rb) {
#if TRUNCATE_ADDRESSES
return f.ZeroExtend(f.Add(
f.Truncate(f.LoadGPR(ra), INT32_TYPE),
@@ -34,7 +34,7 @@ Value* CalculateEA(PPCFunctionBuilder& f, uint32_t ra, uint32_t rb) {
#endif // TRUNCATE_ADDRESSES
}
Value* CalculateEA_0(PPCFunctionBuilder& f, uint32_t ra, uint32_t rb) {
Value* CalculateEA_0(PPCHIRBuilder& f, uint32_t ra, uint32_t rb) {
#if TRUNCATE_ADDRESSES
if (ra) {
return f.ZeroExtend(f.Add(
@@ -52,7 +52,7 @@ Value* CalculateEA_0(PPCFunctionBuilder& f, uint32_t ra, uint32_t rb) {
#endif // TRUNCATE_ADDRESSES
}
Value* CalculateEA_i(PPCFunctionBuilder& f, uint32_t ra, uint64_t imm) {
Value* CalculateEA_i(PPCHIRBuilder& f, uint32_t ra, uint64_t imm) {
#if TRUNCATE_ADDRESSES
return f.ZeroExtend(f.Add(
f.Truncate(f.LoadGPR(ra), INT32_TYPE),
@@ -62,7 +62,7 @@ Value* CalculateEA_i(PPCFunctionBuilder& f, uint32_t ra, uint64_t imm) {
#endif // TRUNCATE_ADDRESSES
}
Value* CalculateEA_0_i(PPCFunctionBuilder& f, uint32_t ra, uint64_t imm) {
Value* CalculateEA_0_i(PPCHIRBuilder& f, uint32_t ra, uint64_t imm) {
#if TRUNCATE_ADDRESSES
if (ra) {
return f.ZeroExtend(f.Add(
@@ -83,7 +83,7 @@ Value* CalculateEA_0_i(PPCFunctionBuilder& f, uint32_t ra, uint64_t imm) {
// Integer load (A-13)
XEEMITTER(lbz, 0x88000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lbz, 0x88000000, D )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -96,7 +96,7 @@ XEEMITTER(lbz, 0x88000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lbzu, 0x8C000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lbzu, 0x8C000000, D )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + EXTS(D)
// RT <- i56.0 || MEM(EA, 1)
// RA <- EA
@@ -107,7 +107,7 @@ XEEMITTER(lbzu, 0x8C000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lbzux, 0x7C0000EE, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lbzux, 0x7C0000EE, X )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + (RB)
// RT <- i56.0 || MEM(EA, 1)
// RA <- EA
@@ -118,7 +118,7 @@ XEEMITTER(lbzux, 0x7C0000EE, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lbzx, 0x7C0000AE, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lbzx, 0x7C0000AE, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -131,7 +131,7 @@ XEEMITTER(lbzx, 0x7C0000AE, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lha, 0xA8000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lha, 0xA8000000, D )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -144,17 +144,17 @@ XEEMITTER(lha, 0xA8000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lhau, 0xAC000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lhau, 0xAC000000, D )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(lhaux, 0x7C0002EE, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lhaux, 0x7C0002EE, X )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(lhax, 0x7C0002AE, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lhax, 0x7C0002AE, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -167,7 +167,7 @@ XEEMITTER(lhax, 0x7C0002AE, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lhz, 0xA0000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lhz, 0xA0000000, D )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -180,7 +180,7 @@ XEEMITTER(lhz, 0xA0000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lhzu, 0xA4000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lhzu, 0xA4000000, D )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + EXTS(D)
// RT <- i48.0 || MEM(EA, 2)
// RA <- EA
@@ -191,7 +191,7 @@ XEEMITTER(lhzu, 0xA4000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lhzux, 0x7C00026E, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lhzux, 0x7C00026E, X )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + (RB)
// RT <- i48.0 || MEM(EA, 2)
// RA <- EA
@@ -202,7 +202,7 @@ XEEMITTER(lhzux, 0x7C00026E, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lhzx, 0x7C00022E, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lhzx, 0x7C00022E, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -215,7 +215,7 @@ XEEMITTER(lhzx, 0x7C00022E, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lwa, 0xE8000002, DS )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lwa, 0xE8000002, DS )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -228,7 +228,7 @@ XEEMITTER(lwa, 0xE8000002, DS )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lwaux, 0x7C0002EA, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lwaux, 0x7C0002EA, X )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + (RB)
// RT <- EXTS(MEM(EA, 4))
// RA <- EA
@@ -239,7 +239,7 @@ XEEMITTER(lwaux, 0x7C0002EA, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lwax, 0x7C0002AA, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lwax, 0x7C0002AA, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -252,7 +252,7 @@ XEEMITTER(lwax, 0x7C0002AA, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lwz, 0x80000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lwz, 0x80000000, D )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -265,7 +265,7 @@ XEEMITTER(lwz, 0x80000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lwzu, 0x84000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lwzu, 0x84000000, D )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + EXTS(D)
// RT <- i32.0 || MEM(EA, 4)
// RA <- EA
@@ -276,7 +276,7 @@ XEEMITTER(lwzu, 0x84000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lwzux, 0x7C00006E, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lwzux, 0x7C00006E, X )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + (RB)
// RT <- i32.0 || MEM(EA, 4)
// RA <- EA
@@ -287,7 +287,7 @@ XEEMITTER(lwzux, 0x7C00006E, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lwzx, 0x7C00002E, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lwzx, 0x7C00002E, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -301,7 +301,7 @@ XEEMITTER(lwzx, 0x7C00002E, X )(PPCFunctionBuilder& f, InstrData& i) {
}
XEEMITTER(ld, 0xE8000000, DS )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(ld, 0xE8000000, DS )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -314,7 +314,7 @@ XEEMITTER(ld, 0xE8000000, DS )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(ldu, 0xE8000001, DS )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(ldu, 0xE8000001, DS )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + EXTS(DS || 0b00)
// RT <- MEM(EA, 8)
// RA <- EA
@@ -325,7 +325,7 @@ XEEMITTER(ldu, 0xE8000001, DS )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(ldux, 0x7C00006A, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(ldux, 0x7C00006A, X )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + (RB)
// RT <- MEM(EA, 8)
// RA <- EA
@@ -336,7 +336,7 @@ XEEMITTER(ldux, 0x7C00006A, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(ldx, 0x7C00002A, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(ldx, 0x7C00002A, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -352,7 +352,7 @@ XEEMITTER(ldx, 0x7C00002A, X )(PPCFunctionBuilder& f, InstrData& i) {
// Integer store (A-14)
XEEMITTER(stb, 0x98000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stb, 0x98000000, D )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -364,7 +364,7 @@ XEEMITTER(stb, 0x98000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stbu, 0x9C000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stbu, 0x9C000000, D )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + EXTS(D)
// MEM(EA, 1) <- (RS)[56:63]
// RA <- EA
@@ -374,7 +374,7 @@ XEEMITTER(stbu, 0x9C000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stbux, 0x7C0001EE, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stbux, 0x7C0001EE, X )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + (RB)
// MEM(EA, 1) <- (RS)[56:63]
// RA <- EA
@@ -384,7 +384,7 @@ XEEMITTER(stbux, 0x7C0001EE, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stbx, 0x7C0001AE, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stbx, 0x7C0001AE, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -396,7 +396,7 @@ XEEMITTER(stbx, 0x7C0001AE, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(sth, 0xB0000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(sth, 0xB0000000, D )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -408,7 +408,7 @@ XEEMITTER(sth, 0xB0000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(sthu, 0xB4000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(sthu, 0xB4000000, D )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + EXTS(D)
// MEM(EA, 2) <- (RS)[48:63]
// RA <- EA
@@ -418,7 +418,7 @@ XEEMITTER(sthu, 0xB4000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(sthux, 0x7C00036E, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(sthux, 0x7C00036E, X )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + (RB)
// MEM(EA, 2) <- (RS)[48:63]
// RA <- EA
@@ -428,7 +428,7 @@ XEEMITTER(sthux, 0x7C00036E, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(sthx, 0x7C00032E, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(sthx, 0x7C00032E, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -440,7 +440,7 @@ XEEMITTER(sthx, 0x7C00032E, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stw, 0x90000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stw, 0x90000000, D )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -452,7 +452,7 @@ XEEMITTER(stw, 0x90000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stwu, 0x94000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stwu, 0x94000000, D )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + EXTS(D)
// MEM(EA, 4) <- (RS)[32:63]
// RA <- EA
@@ -462,7 +462,7 @@ XEEMITTER(stwu, 0x94000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stwux, 0x7C00016E, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stwux, 0x7C00016E, X )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + (RB)
// MEM(EA, 4) <- (RS)[32:63]
// RA <- EA
@@ -472,7 +472,7 @@ XEEMITTER(stwux, 0x7C00016E, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stwx, 0x7C00012E, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stwx, 0x7C00012E, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -484,7 +484,7 @@ XEEMITTER(stwx, 0x7C00012E, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(std, 0xF8000000, DS )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(std, 0xF8000000, DS )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -496,7 +496,7 @@ XEEMITTER(std, 0xF8000000, DS )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stdu, 0xF8000001, DS )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stdu, 0xF8000001, DS )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + EXTS(DS || 0b00)
// MEM(EA, 8) <- (RS)
// RA <- EA
@@ -506,7 +506,7 @@ XEEMITTER(stdu, 0xF8000001, DS )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stdux, 0x7C00016A, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stdux, 0x7C00016A, X )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + (RB)
// MEM(EA, 8) <- (RS)
// RA <- EA
@@ -516,7 +516,7 @@ XEEMITTER(stdux, 0x7C00016A, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stdx, 0x7C00012A, X)(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stdx, 0x7C00012A, X)(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -531,7 +531,7 @@ XEEMITTER(stdx, 0x7C00012A, X)(PPCFunctionBuilder& f, InstrData& i) {
// Integer load and store with byte reverse (A-1
XEEMITTER(lhbrx, 0x7C00062C, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lhbrx, 0x7C00062C, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -544,7 +544,7 @@ XEEMITTER(lhbrx, 0x7C00062C, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lwbrx, 0x7C00042C, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lwbrx, 0x7C00042C, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -557,7 +557,7 @@ XEEMITTER(lwbrx, 0x7C00042C, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(ldbrx, 0x7C000428, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(ldbrx, 0x7C000428, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -570,7 +570,7 @@ XEEMITTER(ldbrx, 0x7C000428, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(sthbrx, 0x7C00072C, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(sthbrx, 0x7C00072C, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -582,7 +582,7 @@ XEEMITTER(sthbrx, 0x7C00072C, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stwbrx, 0x7C00052C, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stwbrx, 0x7C00052C, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -594,7 +594,7 @@ XEEMITTER(stwbrx, 0x7C00052C, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stdbrx, 0x7C000528, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stdbrx, 0x7C000528, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -609,12 +609,12 @@ XEEMITTER(stdbrx, 0x7C000528, X )(PPCFunctionBuilder& f, InstrData& i) {
// Integer load and store multiple (A-16)
XEEMITTER(lmw, 0xB8000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lmw, 0xB8000000, D )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(stmw, 0xBC000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stmw, 0xBC000000, D )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
@@ -622,22 +622,22 @@ XEEMITTER(stmw, 0xBC000000, D )(PPCFunctionBuilder& f, InstrData& i) {
// Integer load and store string (A-17)
XEEMITTER(lswi, 0x7C0004AA, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lswi, 0x7C0004AA, X )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(lswx, 0x7C00042A, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lswx, 0x7C00042A, X )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(stswi, 0x7C0005AA, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stswi, 0x7C0005AA, X )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(stswx, 0x7C00052A, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stswx, 0x7C00052A, X )(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
@@ -645,25 +645,25 @@ XEEMITTER(stswx, 0x7C00052A, X )(PPCFunctionBuilder& f, InstrData& i) {
// Memory synchronization (A-18)
XEEMITTER(eieio, 0x7C0006AC, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(eieio, 0x7C0006AC, X )(PPCHIRBuilder& f, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
f.Nop();
return 0;
}
XEEMITTER(sync, 0x7C0004AC, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(sync, 0x7C0004AC, X )(PPCHIRBuilder& f, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
f.Nop();
return 0;
}
XEEMITTER(isync, 0x4C00012C, XL )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(isync, 0x4C00012C, XL )(PPCHIRBuilder& f, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
f.Nop();
return 0;
}
XEEMITTER(ldarx, 0x7C0000A8, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(ldarx, 0x7C0000A8, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -679,7 +679,7 @@ XEEMITTER(ldarx, 0x7C0000A8, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lwarx, 0x7C000028, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lwarx, 0x7C000028, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -695,7 +695,7 @@ XEEMITTER(lwarx, 0x7C000028, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stdcx, 0x7C0001AD, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stdcx, 0x7C0001AD, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -712,7 +712,7 @@ XEEMITTER(stdcx, 0x7C0001AD, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stwcx, 0x7C00012D, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stwcx, 0x7C00012D, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -732,7 +732,7 @@ XEEMITTER(stwcx, 0x7C00012D, X )(PPCFunctionBuilder& f, InstrData& i) {
// Floating-point load (A-19)
XEEMITTER(lfd, 0xC8000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lfd, 0xC8000000, D )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -745,7 +745,7 @@ XEEMITTER(lfd, 0xC8000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lfdu, 0xCC000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lfdu, 0xCC000000, D )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + EXTS(D)
// FRT <- MEM(EA, 8)
// RA <- EA
@@ -756,7 +756,7 @@ XEEMITTER(lfdu, 0xCC000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lfdux, 0x7C0004EE, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lfdux, 0x7C0004EE, X )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + (RB)
// FRT <- MEM(EA, 8)
// RA <- EA
@@ -767,7 +767,7 @@ XEEMITTER(lfdux, 0x7C0004EE, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lfdx, 0x7C0004AE, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lfdx, 0x7C0004AE, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -780,7 +780,7 @@ XEEMITTER(lfdx, 0x7C0004AE, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lfs, 0xC0000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lfs, 0xC0000000, D )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -795,7 +795,7 @@ XEEMITTER(lfs, 0xC0000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lfsu, 0xC4000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lfsu, 0xC4000000, D )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + EXTS(D)
// FRT <- DOUBLE(MEM(EA, 4))
// RA <- EA
@@ -808,7 +808,7 @@ XEEMITTER(lfsu, 0xC4000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lfsux, 0x7C00046E, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lfsux, 0x7C00046E, X )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + (RB)
// FRT <- DOUBLE(MEM(EA, 4))
// RA <- EA
@@ -821,7 +821,7 @@ XEEMITTER(lfsux, 0x7C00046E, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(lfsx, 0x7C00042E, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(lfsx, 0x7C00042E, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -839,7 +839,7 @@ XEEMITTER(lfsx, 0x7C00042E, X )(PPCFunctionBuilder& f, InstrData& i) {
// Floating-point store (A-20)
XEEMITTER(stfd, 0xD8000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stfd, 0xD8000000, D )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -851,7 +851,7 @@ XEEMITTER(stfd, 0xD8000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stfdu, 0xDC000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stfdu, 0xDC000000, D )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + EXTS(D)
// MEM(EA, 8) <- (FRS)
// RA <- EA
@@ -861,7 +861,7 @@ XEEMITTER(stfdu, 0xDC000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stfdux, 0x7C0005EE, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stfdux, 0x7C0005EE, X )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + (RB)
// MEM(EA, 8) <- (FRS)
// RA <- EA
@@ -871,7 +871,7 @@ XEEMITTER(stfdux, 0x7C0005EE, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stfdx, 0x7C0005AE, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stfdx, 0x7C0005AE, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -883,7 +883,7 @@ XEEMITTER(stfdx, 0x7C0005AE, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stfiwx, 0x7C0007AE, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stfiwx, 0x7C0007AE, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -895,7 +895,7 @@ XEEMITTER(stfiwx, 0x7C0007AE, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stfs, 0xD0000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stfs, 0xD0000000, D )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -908,7 +908,7 @@ XEEMITTER(stfs, 0xD0000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stfsu, 0xD4000000, D )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stfsu, 0xD4000000, D )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + EXTS(D)
// MEM(EA, 4) <- SINGLE(FRS)
// RA <- EA
@@ -919,7 +919,7 @@ XEEMITTER(stfsu, 0xD4000000, D )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stfsux, 0x7C00056E, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stfsux, 0x7C00056E, X )(PPCHIRBuilder& f, InstrData& i) {
// EA <- (RA) + (RB)
// MEM(EA, 4) <- SINGLE(FRS)
// RA <- EA
@@ -930,7 +930,7 @@ XEEMITTER(stfsux, 0x7C00056E, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(stfsx, 0x7C00052E, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(stfsx, 0x7C00052E, X )(PPCHIRBuilder& f, InstrData& i) {
// if RA = 0 then
// b <- 0
// else
@@ -946,7 +946,7 @@ XEEMITTER(stfsx, 0x7C00052E, X )(PPCFunctionBuilder& f, InstrData& i) {
// Cache management (A-27)
XEEMITTER(dcbf, 0x7C0000AC, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(dcbf, 0x7C0000AC, X )(PPCHIRBuilder& f, InstrData& i) {
// No-op for now.
// TODO(benvanik): use prefetch
// XEINSTRNOTIMPLEMENTED();
@@ -954,7 +954,7 @@ XEEMITTER(dcbf, 0x7C0000AC, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(dcbst, 0x7C00006C, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(dcbst, 0x7C00006C, X )(PPCHIRBuilder& f, InstrData& i) {
// No-op for now.
// TODO(benvanik): use prefetch
// XEINSTRNOTIMPLEMENTED();
@@ -962,7 +962,7 @@ XEEMITTER(dcbst, 0x7C00006C, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(dcbt, 0x7C00022C, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(dcbt, 0x7C00022C, X )(PPCHIRBuilder& f, InstrData& i) {
// No-op for now.
// TODO(benvanik): use prefetch
// XEINSTRNOTIMPLEMENTED();
@@ -970,7 +970,7 @@ XEEMITTER(dcbt, 0x7C00022C, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(dcbtst, 0x7C0001EC, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(dcbtst, 0x7C0001EC, X )(PPCHIRBuilder& f, InstrData& i) {
// No-op for now.
// TODO(benvanik): use prefetch
// XEINSTRNOTIMPLEMENTED();
@@ -978,7 +978,7 @@ XEEMITTER(dcbtst, 0x7C0001EC, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(dcbz, 0x7C0007EC, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(dcbz, 0x7C0007EC, X )(PPCHIRBuilder& f, InstrData& i) {
// No-op for now.
// TODO(benvanik): use prefetch
// or dcbz128 0x7C2007EC
@@ -987,7 +987,7 @@ XEEMITTER(dcbz, 0x7C0007EC, X )(PPCFunctionBuilder& f, InstrData& i) {
return 0;
}
XEEMITTER(icbi, 0x7C0007AC, X )(PPCFunctionBuilder& f, InstrData& i) {
XEEMITTER(icbi, 0x7C0007AC, X )(PPCHIRBuilder& f, InstrData& i) {
// XEINSTRNOTIMPLEMENTED();
f.Nop();
return 0;

68
src/alloy/frontend/ppc/ppc_function_builder.cc → src/alloy/frontend/ppc/ppc_hir_builder.cc
View File

@@ -7,7 +7,7 @@
******************************************************************************
*/
#include <alloy/frontend/ppc/ppc_function_builder.h>
#include <alloy/frontend/ppc/ppc_hir_builder.h>
#include <alloy/frontend/tracing.h>
#include <alloy/frontend/ppc/ppc_context.h>
@@ -23,24 +23,24 @@ using namespace alloy::hir;
using namespace alloy::runtime;
PPCFunctionBuilder::PPCFunctionBuilder(PPCFrontend* frontend) :
PPCHIRBuilder::PPCHIRBuilder(PPCFrontend* frontend) :
frontend_(frontend),
FunctionBuilder() {
HIRBuilder() {
}
PPCFunctionBuilder::~PPCFunctionBuilder() {
PPCHIRBuilder::~PPCHIRBuilder() {
}
void PPCFunctionBuilder::Reset() {
void PPCHIRBuilder::Reset() {
start_address_ = 0;
instr_offset_list_ = NULL;
label_list_ = NULL;
FunctionBuilder::Reset();
HIRBuilder::Reset();
}
const bool FLAGS_annotate_disassembly = true;
int PPCFunctionBuilder::Emit(FunctionInfo* symbol_info) {
int PPCHIRBuilder::Emit(FunctionInfo* symbol_info) {
Memory* memory = frontend_->memory();
const uint8_t* p = memory->membase();
@@ -118,7 +118,7 @@ int PPCFunctionBuilder::Emit(FunctionInfo* symbol_info) {
continue;
}
typedef int (*InstrEmitter)(PPCFunctionBuilder& f, InstrData& i);
typedef int (*InstrEmitter)(PPCHIRBuilder& f, InstrData& i);
InstrEmitter emit = (InstrEmitter)i.type->emit;
/*if (i.address == FLAGS_break_on_instruction) {
@@ -130,7 +130,7 @@ int PPCFunctionBuilder::Emit(FunctionInfo* symbol_info) {
XELOGCPU("Unimplemented instr %.8X %.8X %s",
i.address, i.code, i.type->name);
Comment("UNIMPLEMENTED!");
DebugBreak();
//DebugBreak();
//TraceInvalidInstruction(i);
// This printf is handy for sort/uniquify to find instructions.
@@ -155,14 +155,14 @@ int PPCFunctionBuilder::Emit(FunctionInfo* symbol_info) {
return Finalize();
}
void PPCFunctionBuilder::AnnotateLabel(uint64_t address, Label* label) {
void PPCHIRBuilder::AnnotateLabel(uint64_t address, Label* label) {
char name_buffer[13];
xesnprintfa(name_buffer, XECOUNT(name_buffer), "loc_%.8X", address);
label->name = (char*)arena_->Alloc(sizeof(name_buffer));
xe_copy_struct(label->name, name_buffer, sizeof(name_buffer));
}
FunctionInfo* PPCFunctionBuilder::LookupFunction(uint64_t address) {
FunctionInfo* PPCHIRBuilder::LookupFunction(uint64_t address) {
Runtime* runtime = frontend_->runtime();
FunctionInfo* symbol_info;
if (runtime->LookupFunctionInfo(address, &symbol_info)) {
@@ -171,7 +171,7 @@ FunctionInfo* PPCFunctionBuilder::LookupFunction(uint64_t address) {
return symbol_info;
}
Label* PPCFunctionBuilder::LookupLabel(uint64_t address) {
Label* PPCHIRBuilder::LookupLabel(uint64_t address) {
if (address < start_address_) {
return NULL;
}
@@ -206,50 +206,50 @@ Label* PPCFunctionBuilder::LookupLabel(uint64_t address) {
return label;
}
//Value* PPCFunctionBuilder::LoadXER() {
//Value* PPCHIRBuilder::LoadXER() {
//}
//
//void PPCFunctionBuilder::StoreXER(Value* value) {
//void PPCHIRBuilder::StoreXER(Value* value) {
//}
Value* PPCFunctionBuilder::LoadLR() {
Value* PPCHIRBuilder::LoadLR() {
return LoadContext(offsetof(PPCContext, lr), INT64_TYPE);
}
void PPCFunctionBuilder::StoreLR(Value* value) {
void PPCHIRBuilder::StoreLR(Value* value) {
XEASSERT(value->type == INT64_TYPE);
StoreContext(offsetof(PPCContext, lr), value);
}
Value* PPCFunctionBuilder::LoadCTR() {
Value* PPCHIRBuilder::LoadCTR() {
return LoadContext(offsetof(PPCContext, ctr), INT64_TYPE);
}
void PPCFunctionBuilder::StoreCTR(Value* value) {
void PPCHIRBuilder::StoreCTR(Value* value) {
XEASSERT(value->type == INT64_TYPE);
StoreContext(offsetof(PPCContext, ctr), value);
}
Value* PPCFunctionBuilder::LoadCR(uint32_t n) {
Value* PPCHIRBuilder::LoadCR(uint32_t n) {
XEASSERTALWAYS();
return 0;
}
Value* PPCFunctionBuilder::LoadCRField(uint32_t n, uint32_t bit) {
Value* PPCHIRBuilder::LoadCRField(uint32_t n, uint32_t bit) {
return LoadContext(offsetof(PPCContext, cr0) + (4 * n) + bit, INT8_TYPE);
}
void PPCFunctionBuilder::StoreCR(uint32_t n, Value* value) {
void PPCHIRBuilder::StoreCR(uint32_t n, Value* value) {
// TODO(benvanik): split bits out and store in values.
XEASSERTALWAYS();
}
void PPCFunctionBuilder::UpdateCR(
void PPCHIRBuilder::UpdateCR(
uint32_t n, Value* lhs, bool is_signed) {
UpdateCR(n, lhs, LoadZero(lhs->type), is_signed);
}
void PPCFunctionBuilder::UpdateCR(
void PPCHIRBuilder::UpdateCR(
uint32_t n, Value* lhs, Value* rhs, bool is_signed) {
Value* lt;
Value* gt;
@@ -269,7 +269,7 @@ void PPCFunctionBuilder::UpdateCR(
// StoreContext(offsetof(PPCContext, cr) + (4 * n) + 3, so);
}
void PPCFunctionBuilder::UpdateCR6(Value* src_value) {
void PPCHIRBuilder::UpdateCR6(Value* src_value) {
// Testing for all 1's and all 0's.
// if (Rc) CR6 = all_equal | 0 | none_equal | 0
// TODO(benvanik): efficient instruction?
@@ -277,51 +277,51 @@ void PPCFunctionBuilder::UpdateCR6(Value* src_value) {
StoreContext(offsetof(PPCContext, cr6.cr6_none_equal), IsFalse(src_value));
}
Value* PPCFunctionBuilder::LoadXER() {
Value* PPCHIRBuilder::LoadXER() {
XEASSERTALWAYS();
return NULL;
}
void PPCFunctionBuilder::StoreXER(Value* value) {
void PPCHIRBuilder::StoreXER(Value* value) {
XEASSERTALWAYS();
}
Value* PPCFunctionBuilder::LoadCA() {
Value* PPCHIRBuilder::LoadCA() {
return LoadContext(offsetof(PPCContext, xer_ca), INT8_TYPE);
}
void PPCFunctionBuilder::StoreCA(Value* value) {
void PPCHIRBuilder::StoreCA(Value* value) {
StoreContext(offsetof(PPCContext, xer_ca), value);
}
Value* PPCFunctionBuilder::LoadGPR(uint32_t reg) {
Value* PPCHIRBuilder::LoadGPR(uint32_t reg) {
return LoadContext(
offsetof(PPCContext, r) + reg * 8, INT64_TYPE);
}
void PPCFunctionBuilder::StoreGPR(uint32_t reg, Value* value) {
void PPCHIRBuilder::StoreGPR(uint32_t reg, Value* value) {
XEASSERT(value->type == INT64_TYPE);
StoreContext(
offsetof(PPCContext, r) + reg * 8, value);
}
Value* PPCFunctionBuilder::LoadFPR(uint32_t reg) {
Value* PPCHIRBuilder::LoadFPR(uint32_t reg) {
return LoadContext(
offsetof(PPCContext, f) + reg * 8, FLOAT64_TYPE);
}
void PPCFunctionBuilder::StoreFPR(uint32_t reg, Value* value) {
void PPCHIRBuilder::StoreFPR(uint32_t reg, Value* value) {
XEASSERT(value->type == FLOAT64_TYPE);
StoreContext(
offsetof(PPCContext, f) + reg * 8, value);
}
Value* PPCFunctionBuilder::LoadVR(uint32_t reg) {
Value* PPCHIRBuilder::LoadVR(uint32_t reg) {
return LoadContext(
offsetof(PPCContext, v) + reg * 16, VEC128_TYPE);
}
void PPCFunctionBuilder::StoreVR(uint32_t reg, Value* value) {
void PPCHIRBuilder::StoreVR(uint32_t reg, Value* value) {
XEASSERT(value->type == VEC128_TYPE);
StoreContext(
offsetof(PPCContext, v) + reg * 16, value);

14
src/alloy/frontend/ppc/ppc_function_builder.h → src/alloy/frontend/ppc/ppc_hir_builder.h
View File

@@ -7,11 +7,11 @@
******************************************************************************
*/
#ifndef ALLOY_FRONTEND_PPC_PPC_FUNCTION_BUILDER_H_
#define ALLOY_FRONTEND_PPC_PPC_FUNCTION_BUILDER_H_
#ifndef ALLOY_FRONTEND_PPC_PPC_HIR_BUILDER_H_
#define ALLOY_FRONTEND_PPC_PPC_HIR_BUILDER_H_
#include <alloy/core.h>
#include <alloy/hir/function_builder.h>
#include <alloy/hir/hir_builder.h>
#include <alloy/runtime/function.h>
#include <alloy/runtime/symbol_info.h>
@@ -23,13 +23,13 @@ namespace ppc {
class PPCFrontend;
class PPCFunctionBuilder : public hir::FunctionBuilder {
class PPCHIRBuilder : public hir::HIRBuilder {
using Instr = alloy::hir::Instr;
using Label = alloy::hir::Label;
using Value = alloy::hir::Value;
public:
PPCFunctionBuilder(PPCFrontend* frontend);
virtual ~PPCFunctionBuilder();
PPCHIRBuilder(PPCFrontend* frontend);
virtual ~PPCHIRBuilder();
virtual void Reset();
@@ -83,4 +83,4 @@ private:
} // namespace alloy
#endif // ALLOY_FRONTEND_PPC_PPC_FUNCTION_BUILDER_H_
#endif // ALLOY_FRONTEND_PPC_PPC_HIR_BUILDER_H_

6
src/alloy/frontend/ppc/ppc_translator.cc
View File

@@ -10,10 +10,10 @@
#include <alloy/frontend/ppc/ppc_translator.h>
#include <alloy/alloy-private.h>
#include <alloy/compiler/passes.h>
#include <alloy/compiler/compiler_passes.h>
#include <alloy/frontend/tracing.h>
#include <alloy/frontend/ppc/ppc_frontend.h>
#include <alloy/frontend/ppc/ppc_function_builder.h>
#include <alloy/frontend/ppc/ppc_hir_builder.h>
#include <alloy/frontend/ppc/ppc_instr.h>
#include <alloy/frontend/ppc/ppc_scanner.h>
#include <alloy/runtime/runtime.h>
@@ -30,7 +30,7 @@ using namespace alloy::runtime;
PPCTranslator::PPCTranslator(PPCFrontend* frontend) :
frontend_(frontend) {
scanner_ = new PPCScanner(frontend);
builder_ = new PPCFunctionBuilder(frontend);
builder_ = new PPCHIRBuilder(frontend);
compiler_ = new Compiler(frontend->runtime());

4
src/alloy/frontend/ppc/ppc_translator.h
View File

@@ -21,7 +21,7 @@ namespace frontend {
namespace ppc {
class PPCFrontend;
class PPCFunctionBuilder;
class PPCHIRBuilder;
class PPCScanner;
@@ -43,7 +43,7 @@ private:
private:
PPCFrontend* frontend_;
PPCScanner* scanner_;
PPCFunctionBuilder* builder_;
PPCHIRBuilder* builder_;
compiler::Compiler* compiler_;
backend::Assembler* assembler_;

4
src/alloy/frontend/ppc/sources.gypi
View File

@@ -19,8 +19,8 @@
'ppc_emit_memory.cc',
'ppc_frontend.cc',
'ppc_frontend.h',
'ppc_function_builder.cc',
'ppc_function_builder.h',
'ppc_hir_builder.cc',
'ppc_hir_builder.h',
'ppc_instr.cc',
'ppc_instr.h',
'ppc_instr_tables.h',