public void Setup()
{
m = new ProcedureBuilder();
ssaState = new SsaState(m.Procedure, null);
ssaIds = ssaState.Identifiers;
freg = new FlagRegister("flags", 32, PrimitiveType.Word32);
}
private void Test()
{
freg = new FlagRegister("freg", 9, PrimitiveType.Word32);
reg = new Identifier("reg", PrimitiveType.Word32, new RegisterStorage("reg", 1, 0, PrimitiveType.Word32));
SCZO = new Identifier("SCZO", PrimitiveType.Byte, new FlagGroupStorage(freg, 0xF, "SCZO", PrimitiveType.Byte));
new RtlTraceBuilder
{
{
new RtlTrace(0x1000)
{
(m) => {
m.Assign(reg, m.Word32(0));
m.Assign(SCZO, m.Cond(reg));
},
(m) => {
m.Assign(m.Load(PrimitiveType.Word32, m.Word32(0x1234)), reg);
},
(m) => {
m.Return(0, 0);
}
}
},
{
new RtlTrace(0x1010)
{
(m) => {
m.Assign(reg, m.Word32(1));
},
(m) => {
m.Goto(Address.Ptr32(0x1004));
}
}
},
};
}
public void Setup()
{
m = new ProcedureBuilder();
ssaState = new SsaState(m.Procedure, null);
ssaIds = ssaState.Identifiers;
freg = new FlagRegister("flags", 32, PrimitiveType.Word32);
}
private void Test()
{
freg = new FlagRegister("freg", PrimitiveType.Word32);
reg = new Identifier("reg", PrimitiveType.Word32, new RegisterStorage("reg", 1, 0, PrimitiveType.Word32));
SCZO = new Identifier("SCZO", PrimitiveType.Byte, new FlagGroupStorage(freg, 0xF, "SCZO", PrimitiveType.Byte));
var traces = new RtlTraceBuilder
{
{
new RtlTrace(0x1000)
{
(m) => {
m.Assign(reg, m.Word32(0));
m.Assign(SCZO, m.Cond(reg));
},
(m) => {
m.Assign(m.Load(PrimitiveType.Word32, m.Word32(0x1234)), reg);
},
(m) => {
m.Return(0, 0);
}
}
},
{
new RtlTrace(0x1010)
{
(m) => {
m.Assign(reg, m.Word32(1));
},
(m) => {
m.Goto(Address.Ptr32(0x1004));
}
}
},
};
}
public void Ibdr_RedundantFlagReg()
{
RunTest(m =>
{
var flags = new FlagRegister("flags", PrimitiveType.Word32);
var CN = m.Frame.EnsureFlagGroup(flags, 0x3, "CN", PrimitiveType.Byte);
var C = m.Frame.EnsureFlagGroup(flags, 0x1, "C", PrimitiveType.Bool);
var N = m.Frame.EnsureFlagGroup(flags, 0x2, "N", PrimitiveType.Bool);
var Z = m.Frame.EnsureFlagGroup(flags, 0x4, "Z", PrimitiveType.Bool);
var a = m.Frame.EnsureRegister(new RegisterStorage("a", 0, 0, PrimitiveType.Word32));
m.Assign(a, m.IAdd(a, 3));
m.Assign(N, m.Cond(a));
m.Assign(a, m.IAdd(a, a));
m.Assign(N, m.Cond(a));
m.BranchIf(m.Test(ConditionCode.LE, CN), "foo");
});
string expected = ToExpectedString(
"a = a + 0x00000003",
"a = a + a",
"N = cond(a)",
"branch Test(LE,CN) foo"
);
Assert.AreEqual(expected, testResult);
}
public void TerUnsignedSigned()
{
var pb = new ProgramBuilder();
pb.Add("register_tm_clones", m =>
{
var rax = new Identifier("rax", PrimitiveType.Word64, new RegisterStorage("rax", 0, 0, PrimitiveType.Word64));
var rsp = new Identifier("rsp", PrimitiveType.Word64, new RegisterStorage("rsp", 4, 0, PrimitiveType.Word64));
var rbp = new Identifier("rbp", PrimitiveType.Word64, new RegisterStorage("rbp", 5, 0, PrimitiveType.Word64));
var rsi = new Identifier("rsi", PrimitiveType.Word64, new RegisterStorage("rsi", 6, 0, PrimitiveType.Word64));
var rdi = new Identifier("rsp", PrimitiveType.Word64, new RegisterStorage("rdi", 7, 0, PrimitiveType.Word64));
var rflags = new FlagRegister("rflags", 42, PrimitiveType.Word64);
var SCZO = new Identifier("SCZO", PrimitiveType.Byte, new FlagGroupStorage(rflags, 0xF, "SZCO", PrimitiveType.Byte));
var Z = new Identifier("Z", PrimitiveType.Bool, new FlagGroupStorage(rflags, 0x2, "Z", PrimitiveType.Bool));
//m.Assign(rsp, m.Frame.FramePointer);
m.Assign(rdi, 0x0000000000201028);
m.Assign(rsi, 0x0000000000201028);
//m.Assign(rsp, m.ISub(rsp, 0x0000000000000008));
m.Assign(rsi, m.ISub(rsi, rdi));
m.BranchIf(m.Eq0(m.IAdd(m.Sar(rsi, 0x0000000000000003),
m.Sar(m.Shr(m.Sar(rsi, 0x0000000000000003), 0x3F), 1))), "mHyperSpace");
m.Label("mHello");
m.Store(m.Word64(42), rsi);
m.Label("mHyperspace");
m.Return();
});
RunTest(pb.BuildProgram());
}
public void VisitFlagGroup()
{
var flags = new FlagRegister("flags", PrimitiveType.Word32);
var f = new Identifier("grf", PrimitiveType.Word16, new FlagGroupStorage(flags, 0x11, "ZO", PrimitiveType.Byte));
var type = f.Storage.Accept(this);
Assert.AreEqual("grf", type);
}
public void TestBit(byte a, byte index, bool expectedZ)
{
var expectedFlags = new FlagRegister(expectedZ, false, true, false);
var reg = new Register <byte> {
Value = a
};
var flags = new FlagRegister();
Instructions.TestBit(reg, index, flags);
AssertFlags(expectedFlags, flags);
}
public void And(byte a, byte b, byte expected)
{
var expectedFlags = new FlagRegister(expected == 0, false, true, false);
var reg = new Register <byte> {
Value = a
};
var flags = new FlagRegister();
Instructions.And(reg, b, flags);
Assert.AreEqual(expected, reg.Value);
AssertFlags(expectedFlags, flags);
}
public void DecimalAdjust(byte a, byte expected, bool flagN, bool flagH, bool flagC)
{
var reg = new Register <byte> {
Value = a
};
var flags = new FlagRegister {
Subtract = flagN, HalfCarry = flagH, Carry = flagC
};
Instructions.DecimalAdjust(reg, flags);
Assert.AreEqual(expected, reg.Value);
}
public void ShiftRightLogical(byte a, byte expected, bool expectedC)
{
var expectedFlags = new FlagRegister(expected == 0, false, false, expectedC);
var reg = new Register <byte> {
Value = a
};
var flags = new FlagRegister();
Instructions.ShiftRightLogical(reg, flags);
Assert.AreEqual(expected, reg.Value);
AssertFlags(expectedFlags, flags);
}
public void TestInitialize()
{
m_registerSet = new CpuRegisterSet();
m_memory = new Memory();
m_gr = m_registerSet.GR[1];
m_pr = m_registerSet.PR;
m_fr = m_registerSet.FR;
m_logger = new TestLogger();
Operator.ReturningFromSubroutine += OnReturningFromSubroutine;
Operator.CallingSuperVisor += OnCallingSuperVisor;
}
public void Complement(byte a, byte expected)
{
var expectedFlags = new FlagRegister(false, true, true, false);
var reg = new Register <byte> {
Value = a
};
var flags = new FlagRegister();
Instructions.Complement(reg, flags);
Assert.AreEqual(expected, reg.Value);
AssertFlags(expectedFlags, flags);
}
public void Sub(byte a, byte b, byte expected,
bool expectedH, bool expectedC)
{
var expectedFlags = new FlagRegister(expected == 0, true, expectedH, expectedC);
var reg = new Register <byte> {
Value = a
};
var flags = new FlagRegister();
Instructions.Subtract(reg, b, flags);
Assert.AreEqual(expected, reg.Value);
AssertFlags(expectedFlags, flags);
}
public void Stgb_FlagReg()
{
var stgb = new StorageBinder();
var flagReg1 = new FlagRegister("flagreg1", 41, PrimitiveType.Word32);
var flagReg2 = new FlagRegister("flagreg2", 42, PrimitiveType.Word32);
var grf = stgb.EnsureFlagGroup(flagReg1, 0x05, "CZ", PrimitiveType.Byte);
var grf2 = stgb.EnsureFlagGroup(flagReg1, 0x05, "CZ", PrimitiveType.Byte);
Assert.AreSame(grf, grf2);
var grf3 = stgb.EnsureFlagGroup(flagReg2, 0x05, "cz", PrimitiveType.Byte);
Assert.AreNotSame(grf, grf3);
}
public void Setup()
{
m = new ProcedureBuilder(arch);
frame = m.Frame;
ax = frame.EnsureRegister(new RegisterStorage("ax", 0, 0, PrimitiveType.Word16));
bx = frame.EnsureRegister(new RegisterStorage("bx", 3, 0, PrimitiveType.Word16));
cx = frame.EnsureRegister(new RegisterStorage("cx", 1, 0, PrimitiveType.Word16));
dx = frame.EnsureRegister(new RegisterStorage("dx", 2, 0, PrimitiveType.Word16));
flags = new FlagRegister("flags", 4, PrimitiveType.Word16);
SCZ = frame.EnsureFlagGroup(flags, 7, "SCZ", PrimitiveType.Byte);
CF = frame.EnsureFlagGroup(flags, arch.CarryFlagMask, "C", PrimitiveType.Bool);
rw = new LongAddRewriter(m.Procedure, arch);
}
/// <summary>
/// Sets the flag value.
/// </summary>
public void SetFlagValue(FlagRegister f, bool value)
{
var oldValue = (FlagRegister)GetRegisterValue(RegisterName.FL);
if (value)
{
var newValue = (byte)(oldValue | f);
SetRegisterValue(RegisterName.FL, newValue);
}
else
{
var newValue = oldValue - f;
SetRegisterValue(RegisterName.FL, newValue);
}
}
public void RotateRightThroughCarry(byte a, bool initialC,
byte expected, bool expectedC)
{
var expectedFlags = new FlagRegister(expected == 0, false, false, expectedC);
var reg = new Register <byte> {
Value = a
};
var flags = new FlagRegister {
Carry = initialC
};
Instructions.RotateRightThroughCarry(reg, flags);
Assert.AreEqual(expected, reg.Value);
AssertFlags(expectedFlags, flags);
}
public void AddPlusCarry(byte a, byte b, byte expected,
bool expectedH, bool expectedC)
{
var expectedFlags = new FlagRegister(expected == 0, false, expectedH, expectedC);
var reg = new Register <byte> {
Value = a
};
var flags = new FlagRegister()
{
Carry = true
};
Instructions.AddPlusCarry(reg, b, flags);
Assert.AreEqual(expected, reg.Value);
AssertFlags(expectedFlags, flags);
}
// TODO: add IME here?
public RegisterField()
{
_flags = new FlagRegister();
A = new Register <byte>();
B = new Register <byte>();
C = new Register <byte>();
D = new Register <byte>();
E = new Register <byte>();
H = new Register <byte>();
L = new Register <byte>();
AF = new PairedRegister(A, F);
BC = new PairedRegister(B, C);
DE = new PairedRegister(D, E);
HL = new PairedRegister(H, L);
SP = new Register <ushort>();
PC = new Register <ushort>();
}
/// <summary>
/// Creates an instance of PowerPcArchitecture.
/// </summary>
/// <param name="wordWidth">Supplies the word width of the PowerPC architecture.</param>
public PowerPcArchitecture(string archId, PrimitiveType wordWidth) : base(archId)
{
WordWidth = wordWidth;
PointerType = PrimitiveType.Create(Domain.Pointer, wordWidth.Size);
FramePointerType = PointerType;
InstructionBitSize = 32;
this.lr = new RegisterStorage("lr", 0x68, 0, wordWidth);
this.ctr = new RegisterStorage("ctr", 0x6A, 0, wordWidth);
this.xer = new RegisterStorage("xer", 0x6B, 0, wordWidth);
this.fpscr = new RegisterStorage("fpscr", 0x6C, 0, wordWidth);
this.cr = new FlagRegister("cr", 0x80, wordWidth);
regs = new ReadOnlyCollection <RegisterStorage>(
Enumerable.Range(0, 0x20)
.Select(n => new RegisterStorage("r" + n, n, 0, wordWidth))
.Concat(Enumerable.Range(0, 0x20)
.Select(n => new RegisterStorage("f" + n, n + 0x20, 0, PrimitiveType.Word64)))
.Concat(Enumerable.Range(0, 0x20)
.Select(n => new RegisterStorage("v" + n, n + 0x40, 0, PrimitiveType.Word128)))
.Concat(Enumerable.Range(0, 8)
.Select(n => new RegisterStorage("cr" + n, n + 0x60, 0, PrimitiveType.Byte)))
.Concat(new[] { lr, ctr, xer })
.ToList());
fpregs = new ReadOnlyCollection <RegisterStorage>(
regs.Skip(0x20).Take(0x20).ToList());
vregs = new ReadOnlyCollection <RegisterStorage>(
regs.Skip(0x40).Take(0x20).ToList());
cregs = new ReadOnlyCollection <RegisterStorage>(
regs.Skip(0x60).Take(0x8).ToList());
spregs = new Dictionary <int, RegisterStorage>
{
{ 26, new RegisterStorage("srr0", 0x0100 + 26, 0, PrimitiveType.Word32) },
{ 27, new RegisterStorage("srr1", 0x0100 + 27, 0, PrimitiveType.Word32) },
};
//$REVIEW: using R1 as the stack register is a _convention_. It
// should be platform-specific at the very least.
StackRegister = regs[1];
}
/// <summary>
/// Creates an instance of PowerPcArchitecture.
/// </summary>
/// <param name="wordWidth">Supplies the word width of the PowerPC architecture.</param>
public PowerPcArchitecture(PrimitiveType wordWidth)
{
WordWidth = wordWidth;
PointerType = PrimitiveType.Create(Domain.Pointer, wordWidth.Size);
FramePointerType = PointerType;
InstructionBitSize = 32;
this.lr = new RegisterStorage("lr", 0x68, 0, wordWidth);
this.ctr = new RegisterStorage("ctr", 0x6A, 0, wordWidth);
this.xer = new RegisterStorage("xer", 0x6B, 0, wordWidth);
this.fpscr = new RegisterStorage("fpscr", 0x6C, 0, wordWidth);
this.cr = new FlagRegister("cr", wordWidth);
regs = new ReadOnlyCollection<RegisterStorage>(
Enumerable.Range(0, 0x20)
.Select(n => new RegisterStorage("r" + n, n, 0, wordWidth))
.Concat(Enumerable.Range(0, 0x20)
.Select(n => new RegisterStorage("f" + n, n + 0x20, 0, PrimitiveType.Word64)))
.Concat(Enumerable.Range(0, 0x20)
.Select(n => new RegisterStorage("v" + n, n + 0x40, 0, PrimitiveType.Word128)))
.Concat(Enumerable.Range(0, 8)
.Select(n => new RegisterStorage("cr" + n, n + 0x60, 0, PrimitiveType.Byte)))
.Concat(new[] { lr, ctr, xer })
.ToList());
fpregs = new ReadOnlyCollection<RegisterStorage>(
regs.Skip(0x20).Take(0x20).ToList());
vregs = new ReadOnlyCollection<RegisterStorage>(
regs.Skip(0x40).Take(0x20).ToList());
cregs = new ReadOnlyCollection<RegisterStorage>(
regs.Skip(0x60).Take(0x8).ToList());
//$REVIEW: using R1 as the stack register is a _convention_. It
// should be platform-specific at the very least.
StackRegister = regs[1];
}
public void CceAddAdcPattern()
{
var p = new ProgramBuilder(new FakeArchitecture());
p.Add("main", (m) =>
{
var r1 = MockReg(m, 1);
var r2 = MockReg(m, 2);
var r3 = MockReg(m, 3);
var r4 = MockReg(m, 4);
var flags = new FlagRegister("flags", 0x0A, PrimitiveType.Word32);
var SCZ = m.Frame.EnsureFlagGroup(flags, 0x7, "SZC", PrimitiveType.Byte);
var C = m.Frame.EnsureFlagGroup(flags, 0x4, "C", PrimitiveType.Byte);
m.Assign(r1, m.IAdd(r1, r2));
m.Assign(SCZ, m.Cond(r1));
m.Assign(r3, m.IAdd(m.IAdd(r3, r4), C));
m.Store(m.Word32(0x0444400), r1);
m.Store(m.Word32(0x0444404), r3);
m.Return();
});
RunTest(p, "Analysis/CceAddAdcPattern.txt");
}
public Identifier VisitFlagRegister(FlagRegister freg)
{
throw new NotImplementedException();
}
public void Setup()
{
m = new ProcedureBuilder(arch);
frame = m.Frame;
ax = frame.EnsureRegister(new RegisterStorage("ax", 0, 0, PrimitiveType.Word16));
bx = frame.EnsureRegister(new RegisterStorage("bx", 3, 0, PrimitiveType.Word16));
cx = frame.EnsureRegister(new RegisterStorage("cx", 1, 0, PrimitiveType.Word16));
dx = frame.EnsureRegister(new RegisterStorage("dx", 2, 0, PrimitiveType.Word16));
flags = new FlagRegister("flags", PrimitiveType.Word16);
SCZ = frame.EnsureFlagGroup(flags, 7, "SCZ", PrimitiveType.Byte);
CF = frame.EnsureFlagGroup(flags, arch.CarryFlagMask, "C", PrimitiveType.Bool);
rw = new LongAddRewriter(m.Procedure, arch);
Procedure proc = new Procedure("test", frame);
block = new Block(proc, "bloke");
}
public bool VisitFlagRegister(FlagRegister freg)
{
return(liveState.LiveStorages.ContainsKey(freg));
}
static Registers()
{
g0 = RegisterStorage.Reg32("g0", 0);
g1 = RegisterStorage.Reg32("g1", 1);
g2 = RegisterStorage.Reg32("g2", 2);
g3 = RegisterStorage.Reg32("g3", 3);
g4 = RegisterStorage.Reg32("g4", 4);
g5 = RegisterStorage.Reg32("g5", 5);
g6 = RegisterStorage.Reg32("g6", 6);
g7 = RegisterStorage.Reg32("g7", 7);
o0 = RegisterStorage.Reg32("o0", 8); // outgoing paramter 0 / return valie from callee
o1 = RegisterStorage.Reg32("o1", 9);
o2 = RegisterStorage.Reg32("o2", 10);
o3 = RegisterStorage.Reg32("o3", 11);
o4 = RegisterStorage.Reg32("o4", 12);
o5 = RegisterStorage.Reg32("o5", 13);
sp = RegisterStorage.Reg32("sp", 14); // stack pointer
o7 = RegisterStorage.Reg32("o7", 15);
l0 = RegisterStorage.Reg32("l0", 16);
l1 = RegisterStorage.Reg32("l1", 17);
l2 = RegisterStorage.Reg32("l2", 18);
l3 = RegisterStorage.Reg32("l3", 19);
l4 = RegisterStorage.Reg32("l4", 20);
l5 = RegisterStorage.Reg32("l5", 21);
l6 = RegisterStorage.Reg32("l6", 22);
l7 = RegisterStorage.Reg32("l7", 23);
i0 = RegisterStorage.Reg32("i0", 24); // incoming parameters / return value to caller
i1 = RegisterStorage.Reg32("i1", 25);
i2 = RegisterStorage.Reg32("i2", 26);
i3 = RegisterStorage.Reg32("i3", 27);
i4 = RegisterStorage.Reg32("i4", 28);
i5 = RegisterStorage.Reg32("i5", 29);
i6 = RegisterStorage.Reg32("i6", 30); // frame pointer
i7 = RegisterStorage.Reg32("i7", 31); // return address - 8
y = RegisterStorage.Reg32("y", 32);
// Sparc floating point registers can contain integers, which is
// why they can't be real32. This also forces our hand into
// making float-point versions of add, sub, mul, div.
f0 = RegisterStorage.Reg32("f0", 0);
f1 = RegisterStorage.Reg32("f1", 1);
f2 = RegisterStorage.Reg32("f2", 2);
f3 = RegisterStorage.Reg32("f3", 3);
f4 = RegisterStorage.Reg32("f4", 4);
f5 = RegisterStorage.Reg32("f5", 5);
f6 = RegisterStorage.Reg32("f6", 6);
f7 = RegisterStorage.Reg32("f7", 7);
f8 = RegisterStorage.Reg32("f8", 8);
f9 = RegisterStorage.Reg32("f9", 9);
f10 = RegisterStorage.Reg32("f10", 10);
f11 = RegisterStorage.Reg32("f11", 11);
f12 = RegisterStorage.Reg32("f12", 12);
f13 = RegisterStorage.Reg32("f13", 13);
f14 = RegisterStorage.Reg32("f14", 14);
f15 = RegisterStorage.Reg32("f15", 15);
f16 = RegisterStorage.Reg32("f16", 16);
f17 = RegisterStorage.Reg32("f17", 17);
f18 = RegisterStorage.Reg32("f18", 18);
f19 = RegisterStorage.Reg32("f19", 19);
f20 = RegisterStorage.Reg32("f20", 20);
f21 = RegisterStorage.Reg32("f21", 21);
f22 = RegisterStorage.Reg32("f22", 22);
f23 = RegisterStorage.Reg32("f23", 23);
f24 = RegisterStorage.Reg32("f24", 24);
f25 = RegisterStorage.Reg32("f25", 25);
f26 = RegisterStorage.Reg32("f26", 26);
f27 = RegisterStorage.Reg32("f27", 27);
f28 = RegisterStorage.Reg32("f28", 28);
f29 = RegisterStorage.Reg32("f29", 29);
f30 = RegisterStorage.Reg32("f30", 30);
f31 = RegisterStorage.Reg32("f31", 31);
psr = new FlagRegister("psr", 40, PrimitiveType.Word32);
N = new FlagGroupStorage(psr, (uint)FlagM.NF, "N", PrimitiveType.Bool);
Z = new FlagGroupStorage(psr, (uint)FlagM.ZF, "Z", PrimitiveType.Bool);
V = new FlagGroupStorage(psr, (uint)FlagM.VF, "V", PrimitiveType.Bool);
C = new FlagGroupStorage(psr, (uint)FlagM.CF, "C", PrimitiveType.Bool);
E = new FlagGroupStorage(psr, (uint)FlagM.EF, "E", PrimitiveType.Bool);
L = new FlagGroupStorage(psr, (uint)FlagM.LF, "L", PrimitiveType.Bool);
G = new FlagGroupStorage(psr, (uint)FlagM.GF, "G", PrimitiveType.Bool);
U = new FlagGroupStorage(psr, (uint)FlagM.UF, "U", PrimitiveType.Bool);
IntegerRegisters = new RegisterStorage[]
{
g0,
g1,
g2,
g3,
g4,
g5,
g6,
g7,
o0,
o1,
o2,
o3,
o4,
o5,
sp,
o7,
l0,
l1,
l2,
l3,
l4,
l5,
l6,
l7,
i0,
i1,
i2,
i3,
i4,
i5,
i6,
i7,
y,
};
FloatRegisters = new RegisterStorage[] {
f0,
f1,
f2,
f3,
f4,
f5,
f6,
f7,
f8,
f9,
f10,
f11,
f12,
f13,
f14,
f15,
f16,
f17,
f18,
f19,
f20,
f21,
f22,
f23,
f24,
f25,
f26,
f27,
f28,
f29,
f30,
f31,
};
mpNameToReg = IntegerRegisters.Concat(FloatRegisters).ToDictionary(k => k.Name, v => v);
}
static Registers()
{
d0 = new DataRegister("d0", 0, PrimitiveType.Word32);
d1 = new DataRegister("d1", 1, PrimitiveType.Word32);
d2 = new DataRegister("d2", 2, PrimitiveType.Word32);
d3 = new DataRegister("d3", 3, PrimitiveType.Word32);
d4 = new DataRegister("d4", 4, PrimitiveType.Word32);
d5 = new DataRegister("d5", 5, PrimitiveType.Word32);
d6 = new DataRegister("d6", 6, PrimitiveType.Word32);
d7 = new DataRegister("d7", 7, PrimitiveType.Word32);
a0 = new AddressRegister("a0", 8, PrimitiveType.Word32);
a1 = new AddressRegister("a1", 9, PrimitiveType.Word32);
a2 = new AddressRegister("a2", 10, PrimitiveType.Word32);
a3 = new AddressRegister("a3", 11, PrimitiveType.Word32);
a4 = new AddressRegister("a4", 12, PrimitiveType.Word32);
a5 = new AddressRegister("a5", 13, PrimitiveType.Word32);
a6 = new AddressRegister("a6", 14, PrimitiveType.Word32);
a7 = new AddressRegister("a7", 15, PrimitiveType.Word32);
fp0 = new FpRegister("fp0", 16, PrimitiveType.Real80);
fp1 = new FpRegister("fp1", 17, PrimitiveType.Real80);
fp2 = new FpRegister("fp2", 18, PrimitiveType.Real80);
fp3 = new FpRegister("fp3", 19, PrimitiveType.Real80);
fp4 = new FpRegister("fp4", 20, PrimitiveType.Real80);
fp5 = new FpRegister("fp5", 21, PrimitiveType.Real80);
fp6 = new FpRegister("fp6", 22, PrimitiveType.Real80);
fp7 = new FpRegister("fp7", 23, PrimitiveType.Real80);
ccr = new FlagRegister("ccr", 24, PrimitiveType.Byte);
sr = new RegisterStorage("sr", 25, 0, PrimitiveType.Word16);
usp = new RegisterStorage("usp", 26, 0, PrimitiveType.Word32);
pc = new AddressRegister("pc", 27, PrimitiveType.Pointer32);
fpsr = new FlagRegister("fpsr", 28, PrimitiveType.Word32);
Max = 28;
regs = new RegisterStorage[] {
d0,
d1,
d2,
d3,
d4,
d5,
d6,
d7,
a0,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
fp0,
fp1,
fp2,
fp3,
fp4,
fp5,
fp6,
fp7,
ccr,
sr,
usp,
pc,
fpsr,
};
}
public bool VisitFlagRegister(FlagRegister freg, bool defining)
{
return(false);
}
public void Ibdr_FlagReg()
{
RunTest(m =>
{
var flags = new FlagRegister("flags", PrimitiveType.Word32);
var CN = m.Frame.EnsureFlagGroup(flags, 0x3, "CN", PrimitiveType.Byte);
var C = m.Frame.EnsureFlagGroup(flags, 0x1, "C", PrimitiveType.Bool);
var N = m.Frame.EnsureFlagGroup(flags, 0x2, "N", PrimitiveType.Bool);
var Z = m.Frame.EnsureFlagGroup(flags, 0x4, "Z", PrimitiveType.Bool);
var a = m.Frame.EnsureRegister(RegisterStorage.Reg32("a", 0));
m.Assign(N, m.Cond(a));
m.Assign(C, m.Cond(a));
m.BranchIf(m.Test(ConditionCode.LE, CN), "foo");
});
string expected = ToExpectedString(
"N = cond(a)",
"C = cond(a)",
"branch Test(LE,CN) foo"
);
Assert.AreEqual(expected, testResult);
}
public bool GetFlagValue(FlagRegister f)
{
var value = (FlagRegister)GetRegisterValue(RegisterName.FL);
return((value & f) == f);
}
public Identifier VisitFlagRegister(FlagRegister freg)
{
return(frame.EnsureRegister(freg));
}
public Identifier EnsureFlagGroup(FlagRegister freg, uint grfMask, string name, DataType dt)
{
if (grfMask == 0)
return null;
Identifier id = FindFlagGroup(grfMask);
if (id == null)
{
id = new Identifier(name, dt, new FlagGroupStorage(freg, grfMask, name, dt));
identifiers.Add(id);
}
return id;
}
public void Setup()
{
ssaIds = new SsaIdentifierCollection();
freg = new FlagRegister("flags", PrimitiveType.Word32);
}
static Registers()
{
g0 = RegisterStorage.Reg32("g0", 0);
g1 = RegisterStorage.Reg32("g1", 1);
g2 = RegisterStorage.Reg32("g2", 2);
g3 = RegisterStorage.Reg32("g3", 3);
g4 = RegisterStorage.Reg32("g4", 4);
g5 = RegisterStorage.Reg32("g5", 5);
g6 = RegisterStorage.Reg32("g6", 6);
g7 = RegisterStorage.Reg32("g7", 7);
o0 = RegisterStorage.Reg32("o0", 8); // outgoing paramter 0 / return valie from callee
o1 = RegisterStorage.Reg32("o1", 9);
o2 = RegisterStorage.Reg32("o2", 10);
o3 = RegisterStorage.Reg32("o3", 11);
o4 = RegisterStorage.Reg32("o4", 12);
o5 = RegisterStorage.Reg32("o5", 13);
sp = RegisterStorage.Reg32("sp", 14); // stack pointer
o7 = RegisterStorage.Reg32("o7", 15);
l0 = RegisterStorage.Reg32("l0", 16);
l1 = RegisterStorage.Reg32("l1", 17);
l2 = RegisterStorage.Reg32("l2", 18);
l3 = RegisterStorage.Reg32("l3", 19);
l4 = RegisterStorage.Reg32("l4", 20);
l5 = RegisterStorage.Reg32("l5", 21);
l6 = RegisterStorage.Reg32("l6", 22);
l7 = RegisterStorage.Reg32("l7", 23);
i0 = RegisterStorage.Reg32("i0", 24); // incoming parameters / return value to caller
i1 = RegisterStorage.Reg32("i1", 25);
i2 = RegisterStorage.Reg32("i2", 26);
i3 = RegisterStorage.Reg32("i3", 27);
i4 = RegisterStorage.Reg32("i4", 28);
i5 = RegisterStorage.Reg32("i5", 29);
i6 = RegisterStorage.Reg32("i6", 30); // frame pointer
i7 = RegisterStorage.Reg32("i7", 31); // return address - 8
y = RegisterStorage.Reg32("y", 32);
// Sparc floating point registers can contain integers, which is
// why they can't be real32. This also forces our hand into
// making float-point versions of add, sub, mul, div.
f0 = RegisterStorage.Reg32("f0", 0);
f1 = RegisterStorage.Reg32("f1", 1);
f2 = RegisterStorage.Reg32("f2", 2);
f3 = RegisterStorage.Reg32("f3", 3);
f4 = RegisterStorage.Reg32("f4", 4);
f5 = RegisterStorage.Reg32("f5", 5);
f6 = RegisterStorage.Reg32("f6", 6);
f7 = RegisterStorage.Reg32("f7", 7);
f8 = RegisterStorage.Reg32("f8", 8);
f9 = RegisterStorage.Reg32("f9", 9);
f10= RegisterStorage.Reg32("f10", 10);
f11= RegisterStorage.Reg32("f11", 11);
f12= RegisterStorage.Reg32("f12", 12);
f13= RegisterStorage.Reg32("f13", 13);
f14= RegisterStorage.Reg32("f14", 14);
f15= RegisterStorage.Reg32("f15", 15);
f16 =RegisterStorage.Reg32("f16", 16);
f17= RegisterStorage.Reg32("f17", 17);
f18= RegisterStorage.Reg32("f18", 18);
f19= RegisterStorage.Reg32("f19", 19);
f20= RegisterStorage.Reg32("f20", 20);
f21= RegisterStorage.Reg32("f21", 21);
f22= RegisterStorage.Reg32("f22", 22);
f23= RegisterStorage.Reg32("f23", 23);
f24= RegisterStorage.Reg32("f24", 24);
f25= RegisterStorage.Reg32("f25", 25);
f26= RegisterStorage.Reg32("f26", 26);
f27= RegisterStorage.Reg32("f27", 27);
f28= RegisterStorage.Reg32("f28", 28);
f29= RegisterStorage.Reg32("f29", 29);
f30= RegisterStorage.Reg32("f30", 30);
f31= RegisterStorage.Reg32("f31", 31);
psr = new FlagRegister("psr", 40, PrimitiveType.Word32);
N = new FlagGroupStorage(psr, (uint) FlagM.NF, "N", PrimitiveType.Bool);
Z = new FlagGroupStorage(psr, (uint) FlagM.ZF, "Z", PrimitiveType.Bool);
V = new FlagGroupStorage(psr, (uint) FlagM.VF, "V", PrimitiveType.Bool);
C = new FlagGroupStorage(psr, (uint) FlagM.CF, "C", PrimitiveType.Bool);
E = new FlagGroupStorage(psr, (uint) FlagM.EF, "E", PrimitiveType.Bool);
L = new FlagGroupStorage(psr, (uint) FlagM.LF, "L", PrimitiveType.Bool);
G = new FlagGroupStorage(psr, (uint) FlagM.GF, "G", PrimitiveType.Bool);
U = new FlagGroupStorage(psr, (uint) FlagM.UF, "U", PrimitiveType.Bool);
IntegerRegisters = new RegisterStorage[]
{
g0,
g1,
g2,
g3,
g4,
g5,
g6,
g7,
o0,
o1,
o2,
o3,
o4,
o5,
sp,
o7,
l0,
l1,
l2,
l3,
l4,
l5,
l6,
l7,
i0,
i1,
i2,
i3,
i4,
i5,
i6,
i7,
y,
};
FloatRegisters = new RegisterStorage[] {
f0 ,
f1 ,
f2 ,
f3 ,
f4 ,
f5 ,
f6 ,
f7 ,
f8 ,
f9 ,
f10,
f11,
f12,
f13,
f14,
f15,
f16,
f17,
f18,
f19,
f20,
f21,
f22,
f23,
f24,
f25,
f26,
f27,
f28,
f29,
f30,
f31,
};
mpNameToReg = IntegerRegisters.Concat(FloatRegisters).ToDictionary(k => k.Name, v => v);
}
static Registers()
{
d0 = new DataRegister("d0", 0, PrimitiveType.Word32);
d1 = new DataRegister("d1", 1, PrimitiveType.Word32);
d2 = new DataRegister("d2", 2, PrimitiveType.Word32);
d3 = new DataRegister("d3", 3, PrimitiveType.Word32);
d4 = new DataRegister("d4", 4, PrimitiveType.Word32);
d5 = new DataRegister("d5", 5, PrimitiveType.Word32);
d6 = new DataRegister("d6", 6, PrimitiveType.Word32);
d7 = new DataRegister("d7", 7, PrimitiveType.Word32);
a0 = new AddressRegister("a0", 8, PrimitiveType.Word32);
a1 = new AddressRegister("a1", 9, PrimitiveType.Word32);
a2 = new AddressRegister("a2", 10, PrimitiveType.Word32);
a3 = new AddressRegister("a3", 11, PrimitiveType.Word32);
a4 = new AddressRegister("a4", 12, PrimitiveType.Word32);
a5 = new AddressRegister("a5", 13, PrimitiveType.Word32);
a6 = new AddressRegister("a6", 14, PrimitiveType.Word32);
a7 = new AddressRegister("a7", 15, PrimitiveType.Word32);
fp0 = new FpRegister("fp0", 16, PrimitiveType.Real64);
fp1 = new FpRegister("fp1", 17, PrimitiveType.Real64);
fp2 = new FpRegister("fp2", 18, PrimitiveType.Real64);
fp3 = new FpRegister("fp3", 19, PrimitiveType.Real64);
fp4 = new FpRegister("fp4", 20, PrimitiveType.Real64);
fp5 = new FpRegister("fp5", 21, PrimitiveType.Real64);
fp6 = new FpRegister("fp6", 22, PrimitiveType.Real64);
fp7 = new FpRegister("fp7", 23, PrimitiveType.Real64);
ccr = new FlagRegister("ccr", PrimitiveType.Byte);
sr = new RegisterStorage("sr", 25, 0, PrimitiveType.Word16);
usp = new RegisterStorage("usp", 26, 0, PrimitiveType.Word32);
pc = new AddressRegister("pc", 27, PrimitiveType.Pointer32);
Max = 28;
regs = new RegisterStorage[] {
d0,
d1,
d2,
d3,
d4,
d5,
d6,
d7,
a0,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
fp0,
fp1,
fp2,
fp3,
fp4,
fp5,
fp6,
fp7,
ccr,
sr,
usp,
pc,
};
}
public Storage VisitFlagRegister(FlagRegister freg)
{
return(null);
}
public void CceAddAdcPattern()
{
var p = new ProgramBuilder(new FakeArchitecture());
p.Add("main", (m) =>
{
var r1 = MockReg(m, 1);
var r2 = MockReg(m, 2);
var r3 = MockReg(m, 3);
var r4 = MockReg(m, 4);
var flags = new FlagRegister("flags", 0x0A, PrimitiveType.Word32);
var SCZ = m.Frame.EnsureFlagGroup(flags, 0x7, "SZC", PrimitiveType.Byte);
var C = m.Frame.EnsureFlagGroup(flags, 0x4, "C", PrimitiveType.Byte);
m.Assign(r1, m.IAdd(r1, r2));
m.Assign(SCZ, m.Cond(r1));
m.Assign(r3, m.IAdd(m.IAdd(r3, r4), C));
m.Store(m.Word32(0x0444400), r1);
m.Store(m.Word32(0x0444404), r3);
m.Return();
});
RunTest(p, "Analysis/CceAddAdcPattern.txt");
}
public Identifier VisitFlagRegister(FlagRegister freg)
{
return(procCalling.Frame.EnsureRegister(freg));
}
public Storage VisitFlagRegister(FlagRegister freg)
{
throw new NotImplementedException();
}
