public override FlagGroupStorage GetFlagGroup(uint grf)
{
FlagGroupStorage f;
if (flagGroups.TryGetValue(grf, out f))
{
return(f);
}
PrimitiveType dt = Bits.IsSingleBitSet(grf) ? PrimitiveType.Bool : PrimitiveType.Byte;
var fl = new FlagGroupStorage(Registers.f, grf, GrfToString(grf), dt);
flagGroups.Add(grf, fl);
return(fl);
}
public override FlagGroupStorage GetFlagGroup(RegisterStorage flagRegister, uint grf)
{
foreach (FlagGroupStorage f in Registers.flagBits)
{
if (f.FlagGroupBits == grf)
{
return(f);
}
}
PrimitiveType dt = Bits.IsSingleBitSet(grf) ? PrimitiveType.Bool : PrimitiveType.Byte;
var fl = new FlagGroupStorage(Registers.f, grf, GrfToString(Registers.f, "", grf), dt);
return(fl);
}
public override FlagGroupStorage GetFlagGroup(RegisterStorage flagRegister, uint grf)
{
FlagGroupStorage f;
if (flagGroupCache.TryGetValue(grf, out f))
{
return(f);
}
var dt = Bits.IsSingleBitSet(grf) ? PrimitiveType.Bool : PrimitiveType.Byte;
f = new FlagGroupStorage(Registers.eflags, grf, GrfToString(flagRegister, "", grf), dt);
flagGroupCache.Add(grf, f);
return(f);
}
public override FlagGroupStorage GetFlagGroup(uint grf)
{
foreach (FlagGroupStorage f in flagGroups)
{
if (f.FlagGroupBits == grf)
{
return(f);
}
}
PrimitiveType dt = Bits.IsSingleBitSet(grf) ? PrimitiveType.Bool : PrimitiveType.Byte;
var fl = new FlagGroupStorage(grf, GrfToString(grf), dt);
flagGroups.Add(fl);
return(fl);
}
static Registers()
{
var factory = new StorageFactory();
GpRegs = factory.RangeOfReg32(32, "r{0}");
msr = factory.Reg32("msr");
C = new FlagGroupStorage(msr, (uint)FlagM.CY, "C", PrimitiveType.Bool);
RegistersByDomain = GpRegs
.Concat(new[] { msr })
.ToDictionary(r => r.Domain);
RegistersByName = GpRegs
.Concat(new[] { msr })
.ToDictionary(r => r.Name);
}
public override FlagGroupStorage GetFlagGroup(RegisterStorage flagRegister, uint grf)
{
if (flagRegister != Registers.CcRegister)
{
throw new ArgumentException($"'{flagRegister.Name}' is not a flag register on this architecture.");
}
if (flagGroups.TryGetValue(grf, out var flags))
{
return(flags);
}
PrimitiveType dt = Bits.IsSingleBitSet(grf) ? PrimitiveType.Bool : PrimitiveType.Byte;
var fl = new FlagGroupStorage(flagRegister, grf, GrfToString(flagRegister, "", grf), dt);
flagGroups.Add(grf, fl);
return(fl);
}
static Registers()
{
GpRegisters = Enumerable.Range(0, 16)
.Select(n => new RegisterStorage($"r{n}", n, 0, PrimitiveType.Word64))
.ToArray();
FpRegisters = Enumerable.Range(0, 16)
.Select(n => new RegisterStorage($"f{n}", n + 16, 0, PrimitiveType.Word64))
.ToArray();
RegistersByName = GpRegisters.Concat(FpRegisters)
.ToDictionary(r => r.Name);
//$REVIEW: this is probably not correct, but close enough to get us started.
var ccReg = new RegisterStorage("ccReg", 40, 0, PrimitiveType.Byte);
CC = new FlagGroupStorage(ccReg, 0xF, "CC", PrimitiveType.Byte);
}
public bool IsLiveOut(Identifier id)
{
FlagGroupStorage flags = id.Storage as FlagGroupStorage;
if (flags != null)
{
uint grf = flags.FlagGroupBits;
return((grf & grfLiveOut) != 0);
}
RegisterStorage reg = id.Storage as RegisterStorage;
if (reg != null)
{
return(LiveOut[reg.Number]);
}
return(false);
}
static Registers()
{
var factory = new StorageFactory();
GpRegs = factory.RangeOfReg(16, i => regNames[i], PrimitiveType.Word32);
fp = GpRegs[9];
ap = GpRegs[10];
sp = GpRegs[12];
psw = GpRegs[11];
C = new FlagGroupStorage(psw, (uint)FlagM.C, "C", PrimitiveType.Bool);
V = new FlagGroupStorage(psw, (uint)FlagM.C, "V", PrimitiveType.Bool);
Z = new FlagGroupStorage(psw, (uint)FlagM.C, "Z", PrimitiveType.Bool);
N = new FlagGroupStorage(psw, (uint)FlagM.C, "N", PrimitiveType.Bool);
Flags = new FlagGroupStorage[] { C, V, Z, N };
NZV = new FlagGroupStorage(psw, (uint)(FlagM.N | FlagM.Z | FlagM.V), "NZV", PrimitiveType.Byte);
NZVC = new FlagGroupStorage(psw, (uint)(FlagM.N | FlagM.Z | FlagM.V | FlagM.C), "NZVC", PrimitiveType.Byte);
}
private void RewriteBcc(ConditionCode cc, FlagGroupStorage flags)
{
var addr = ((M68kAddressOperand)instr.Operands[0]).Address;
if ((addr.ToUInt32() & 1) != 0)
{
iclass = InstrClass.Invalid;
m.Invalid();
}
else
{
m.Branch(
m.Test(cc, binder.EnsureFlagGroup(flags)),
addr,
InstrClass.ConditionalTransfer);
}
}
public override FlagGroupStorage GetFlagGroup(RegisterStorage flagRegister, uint grf)
{
if (flagGroups.TryGetValue(grf, out var f))
{
return f;
}
var dt = Bits.IsSingleBitSet(grf) ? PrimitiveType.Bool : PrimitiveType.Byte;
var flagregister =
#if NATIVE
this.regsByName["cpsr"];
#else
Registers.cpsr;
#endif
var fl = new FlagGroupStorage(flagregister, grf, GrfToString(flagRegister, "", grf), dt);
flagGroups.Add(grf, fl);
return fl;
}
private void RewriteUnary(
Func <Expression, Expression> fn,
FlagGroupStorage mod,
FlagGroupStorage?clr = null,
FlagGroupStorage?set = null)
{
var reg = RewriteOp(0);
m.Assign(reg, fn(reg));
EmitFlags(reg, mod);
if (clr != null)
{
m.Assign(binder.EnsureFlagGroup(clr), 0);
}
if (set != null)
{
m.Assign(binder.EnsureFlagGroup(set), 1);
}
}
public override FlagGroupStorage GetFlagGroup(RegisterStorage flagRegister, uint grf)
{
if (flagGroups.TryGetValue(grf, out var fstg))
{
return(fstg);
}
var sb = new StringBuilder();
foreach (var flag in Registers.Flags)
{
if ((grf & flag.FlagGroupBits) != 0)
{
sb.Append(flag.Name);
}
}
fstg = new FlagGroupStorage(flagRegister, grf, sb.ToString(), PrimitiveType.Byte);
this.flagGroups.Add(grf, fstg);
return(fstg);
}
public StorageTests()
{
this.eax = new RegisterStorage("eax", 0, 0, PrimitiveType.Word32);
this.ax = new RegisterStorage("ax", 0, 0, PrimitiveType.Word16);
this.al = new RegisterStorage("al", 0, 0, PrimitiveType.Byte);
this.ah = new RegisterStorage("ah", 0, 8, PrimitiveType.Byte);
this.freg = new RegisterStorage("eflags", 70, 0, PrimitiveType.Word32);
this.szc = new FlagGroupStorage(freg, 0x7, "szc", PrimitiveType.Byte);
this.sz = new FlagGroupStorage(freg, 0x6, "sz", PrimitiveType.Byte);
this.c = new FlagGroupStorage(freg, 0x1, "c", PrimitiveType.Bool);
this.z = new FlagGroupStorage(freg, 0x2, "z", PrimitiveType.Bool);
this.s = new FlagGroupStorage(freg, 0x4, "s", PrimitiveType.Bool);
this.fpu0 = new FpuStackStorage(0, PrimitiveType.Real64);
this.fpu1 = new FpuStackStorage(1, PrimitiveType.Real64);
this.tmpWord32 = new TemporaryStorage("tmp", 0, PrimitiveType.Word32);
}
public override IEnumerable <FlagGroupStorage> GetSubFlags(FlagGroupStorage flags)
{
if (flags.FlagRegister != Registers.psr)
{
yield break;
}
var grf = flags.FlagGroupBits;
if ((grf & Registers.N.FlagGroupBits) != 0)
{
yield return(Registers.N);
}
if ((grf & Registers.Z.FlagGroupBits) != 0)
{
yield return(Registers.Z);
}
if ((grf & Registers.V.FlagGroupBits) != 0)
{
yield return(Registers.V);
}
if ((grf & Registers.C.FlagGroupBits) != 0)
{
yield return(Registers.C);
}
if ((grf & Registers.E.FlagGroupBits) != 0)
{
yield return(Registers.E);
}
if ((grf & Registers.L.FlagGroupBits) != 0)
{
yield return(Registers.L);
}
if ((grf & Registers.G.FlagGroupBits) != 0)
{
yield return(Registers.G);
}
if ((grf & Registers.U.FlagGroupBits) != 0)
{
yield return(Registers.U);
}
}
static Registers()
{
GpRegisters = new RegisterStorage[]
{
pc,
sp,
sr,
new RegisterStorage("cg2", 3, 0, Msp430Architecture.Word20),
}.Concat(
Enumerable.Range(4, 12)
.Select(i => new RegisterStorage(
string.Format("r{0}", i), i, 0, Msp430Architecture.Word20)))
.ToArray();
NZC = new FlagGroupStorage(sr, (uint)(FlagM.NF | FlagM.ZF | FlagM.CF), "NZC", PrimitiveType.Byte);
V = new FlagGroupStorage(sr, (uint)FlagM.VF, "V", PrimitiveType.Bool);
VNZC = new FlagGroupStorage(sr, (uint)(FlagM.VF | FlagM.NF | FlagM.ZF | FlagM.CF), "VNZC", PrimitiveType.Byte);
ByName = GpRegisters.ToDictionary(r => r.Name);
}
static Registers()
{
var factory = new StorageFactory();
CoreRegisters = factory.RangeOfReg32(64, "r{0}");
Gp = RenameRegister(26, "gp");
Fp = RenameRegister(27, "fp");
Sp = RenameRegister(28, "sp");
Blink = RenameRegister(31, "blink");
Mlo = RenameRegister(57, "mlo");
Mhi = RenameRegister(59, "mhi");
LP_count = RenameRegister(60, "lp_count");
Pcl = RenameRegister(63, "pcl");
var sysFactory = new StorageFactory(StorageDomain.SystemRegister);
Status32 = sysFactory.Reg("STATUS32", PrimitiveType.Word32);
LpStart = sysFactory.Reg("LP_START", PrimitiveType.Word32);
LpEnd = sysFactory.Reg("LP_END", PrimitiveType.Word32);
AuxMacmode = sysFactory.Reg("AUX_MACMODE", PrimitiveType.Word32);
Z = new FlagGroupStorage(Status32, (uint)FlagM.ZF, "Z", PrimitiveType.Bool);
N = new FlagGroupStorage(Status32, (uint)FlagM.NF, "N", PrimitiveType.Bool);
C = new FlagGroupStorage(Status32, (uint)FlagM.CF, "C", PrimitiveType.Bool);
V = new FlagGroupStorage(Status32, (uint)FlagM.VF, "V", PrimitiveType.Bool);
S = new FlagGroupStorage(AuxMacmode, (uint)AuxFlagM.Sat, "S", PrimitiveType.Bool);
ZNCV = new FlagGroupStorage(Status32, (uint)(FlagM.ZF | FlagM.NF | FlagM.CF | FlagM.VF), "ZNCV", PrimitiveType.Byte);
ZNC = new FlagGroupStorage(Status32, (uint)(FlagM.ZF | FlagM.NF | FlagM.CF), "ZNC", PrimitiveType.Byte);
ZNV = new FlagGroupStorage(Status32, (uint)(FlagM.ZF | FlagM.NF | FlagM.VF), "ZNV", PrimitiveType.Byte);
ZN = new FlagGroupStorage(Status32, (uint)(FlagM.ZF | FlagM.NF), "ZN", PrimitiveType.Byte);
ByStorageDomain = factory.DomainsToRegisters
.Concat(sysFactory.DomainsToRegisters)
.ToDictionary(k => k.Key, v => v.Value);
ByName = factory.NamesToRegisters
.Concat(sysFactory.NamesToRegisters)
.ToDictionary(k => k.Key, v => v.Value);
}
public void SetFlagGroup(FlagGroupStorage reg, Constant value)
{
uint mask = reg.FlagGroupBits;
if (value.IsValid)
{
validFlags |= mask;
if (value.ToBoolean())
{
this.flags |= mask;
}
else
{
this.flags &= ~mask;
}
}
else
{
validFlags &= ~mask;
}
}
public override IEnumerable <FlagGroupStorage> GetSubFlags(FlagGroupStorage flags)
{
uint grf = flags.FlagGroupBits;
if ((grf & (uint)FlagM.CF) != 0)
{
yield return(Registers.C);
}
if ((grf & (uint)FlagM.PF) != 0)
{
yield return(Registers.P);
}
if ((grf & (uint)FlagM.ZF) != 0)
{
yield return(Registers.Z);
}
if ((grf & (uint)FlagM.NF) != 0)
{
yield return(Registers.N);
}
}
public override IEnumerable <FlagGroupStorage> GetSubFlags(FlagGroupStorage flags)
{
uint grf = flags.FlagGroupBits;
if ((grf & Registers.N.FlagGroupBits) != 0)
{
yield return(Registers.N);
}
if ((grf & Registers.Z.FlagGroupBits) != 0)
{
yield return(Registers.Z);
}
if ((grf & Registers.V.FlagGroupBits) != 0)
{
yield return(Registers.V);
}
if ((grf & Registers.C.FlagGroupBits) != 0)
{
yield return(Registers.C);
}
}
public override IEnumerable <FlagGroupStorage> GetSubFlags(FlagGroupStorage flags)
{
uint grf = flags.FlagGroupBits;
if ((grf & Registers.CFlag.FlagGroupBits) != 0)
{
yield return(Registers.CFlag);
}
if ((grf & Registers.AFlag.FlagGroupBits) != 0)
{
yield return(Registers.AFlag);
}
if ((grf & Registers.OFlag.FlagGroupBits) != 0)
{
yield return(Registers.OFlag);
}
if ((grf & Registers.PFlag.FlagGroupBits) != 0)
{
yield return(Registers.PFlag);
}
}
public override IEnumerable <FlagGroupStorage> GetSubFlags(FlagGroupStorage flags)
{
uint grf = flags.FlagGroupBits;
if ((grf & (uint)FlagM.NF) != 0)
{
yield return(GetFlagGroup(flags.FlagRegister, (uint)FlagM.NF));
}
if ((grf & (uint)FlagM.ZF) != 0)
{
yield return(GetFlagGroup(flags.FlagRegister, (uint)FlagM.ZF));
}
if ((grf & (uint)FlagM.CF) != 0)
{
yield return(GetFlagGroup(flags.FlagRegister, (uint)FlagM.CF));
}
if ((grf & (uint)FlagM.VF) != 0)
{
yield return(GetFlagGroup(flags.FlagRegister, (uint)FlagM.VF));
}
}
public override IEnumerable <FlagGroupStorage> GetSubFlags(FlagGroupStorage flags)
{
uint grf = flags.FlagGroupBits;
var ccr = Registers.CcRegister;
if ((grf & (uint)FlagM.NF) != 0)
{
yield return(this.GetFlagGroup(ccr, (uint)FlagM.NF) !);
}
if ((grf & (uint)FlagM.ZF) != 0)
{
yield return(this.GetFlagGroup(ccr, (uint)FlagM.ZF) !);
}
if ((grf & (uint)FlagM.VF) != 0)
{
yield return(this.GetFlagGroup(ccr, (uint)FlagM.VF) !);
}
if ((grf & (uint)FlagM.CF) != 0)
{
yield return(this.GetFlagGroup(ccr, (uint)FlagM.CF) !);
}
}
static Registers()
{
var factory = new StorageFactory();
GpRegs = factory.RangeOfReg(16, n => $"gp{n}", PrimitiveType.Word16);
pir = factory.Reg16("pir");
mk = factory.Reg16("mk");
ft = factory.Reg16("ft");
ic = factory.Reg16("ic");
sw = factory.Reg16("sw");
ta = factory.Reg16("ta");
tb = factory.Reg16("tb");
go = factory.Reg16("go");
sys = factory.Reg16("sys");
ByName = factory.NamesToRegisters;
ByDomain = factory.DomainsToRegisters;
C = new FlagGroupStorage(Registers.sw, (uint)FlagM.CF, "C", PrimitiveType.Byte);
P = new FlagGroupStorage(Registers.sw, (uint)FlagM.PF, "P", PrimitiveType.Byte);
Z = new FlagGroupStorage(Registers.sw, (uint)FlagM.ZF, "Z", PrimitiveType.Byte);
N = new FlagGroupStorage(Registers.sw, (uint)FlagM.NF, "N", PrimitiveType.Byte);
}
static Registers()
{
var f = new StorageFactory();
ax = f.Reg16("ax");
bc = f.Reg16("bc");
de = f.Reg16("de");
hl = f.Reg16("hl");
sp = f.Reg16("sp");
psw = f.Reg("psw", PrimitiveType.Byte);
es = f.Reg("es", PrimitiveType.Byte);
cs = f.Reg("cs", PrimitiveType.Byte);
x = new RegisterStorage("x", ax.Number, 0, PrimitiveType.Byte);
a = new RegisterStorage("a", ax.Number, 8, PrimitiveType.Byte);
c = new RegisterStorage("c", bc.Number, 0, PrimitiveType.Byte);
b = new RegisterStorage("b", bc.Number, 8, PrimitiveType.Byte);
e = new RegisterStorage("e", de.Number, 0, PrimitiveType.Byte);
d = new RegisterStorage("d", de.Number, 8, PrimitiveType.Byte);
l = new RegisterStorage("l", hl.Number, 0, PrimitiveType.Byte);
h = new RegisterStorage("h", hl.Number, 8, PrimitiveType.Byte);
WordRegs = new RegisterStorage[5] {
ax, bc, de, hl, sp
};
ByteRegs = new RegisterStorage[8] {
x, a, c, b, e, d, l, h
};
GpRegsByName = new ReadOnlyDictionary <string, RegisterStorage>(WordRegs.Concat(ByteRegs)
.ToDictionary(r => r.Name));
C = new FlagGroupStorage(psw, (uint)FlagM.CF, "C", PrimitiveType.Bool);
cy = new FlagGroupStorage(psw, (uint)FlagM.CF, "cy", PrimitiveType.Bool);
CZ = new FlagGroupStorage(psw, (uint)(FlagM.CF | FlagM.ZF), "CZ", PrimitiveType.Byte);
Z = new FlagGroupStorage(psw, (uint)FlagM.ZF, "Z", PrimitiveType.Bool);
}
static Registers()
{
var factory = new StorageFactory();
GpRegisters = factory.RangeOfReg32(16, "r{0}");
CrRegisters = factory.RangeOfReg32(32, "cr{0}");
Replace(CrRegisters, 0, "psr");
Replace(CrRegisters, 1, "vbr");
Replace(CrRegisters, 2, "epsr");
Replace(CrRegisters, 3, "fpsr");
Replace(CrRegisters, 4, "epc");
Replace(CrRegisters, 5, "fpc");
Replace(CrRegisters, 6, "ss0");
Replace(CrRegisters, 7, "ss1");
Replace(CrRegisters, 8, "ss2");
Replace(CrRegisters, 9, "ss3");
Replace(CrRegisters, 10, "ss4");
Replace(CrRegisters, 11, "gcr");
Replace(CrRegisters, 12, "gsr");
R0 = GpRegisters[0];
PSR = factory.Reg32("psr");
C = new FlagGroupStorage(PSR, (uint)FlagM.CF, "C", PrimitiveType.Bool);
}
static Registers()
{
var factory = new StorageFactory();
GpRegisters = factory.RangeOfReg64(16, "r{0}");
VecRegisters = factory.RangeOfReg(32, n => $"v{n}", PrimitiveType.Word128);
FpRegisters = VecRegisters
.Take(16)
.Select((vr, i) => new RegisterStorage($"f{i}", vr.Number, 64, PrimitiveType.Word64))
.ToArray();
RegistersByDomain = GpRegisters
.Concat(VecRegisters)
.ToDictionary(r => r.Domain);
RegistersByName = GpRegisters
.Concat(FpRegisters)
.Concat(VecRegisters)
.ToDictionary(r => r.Name);
//$REVIEW: this should be a PSW.
var ccReg = factory.Reg("ccReg", PrimitiveType.Byte);
CC = new FlagGroupStorage(ccReg, 0xF, "CC", PrimitiveType.Byte);
}
private void RewriteBranch(H8Instruction instr, ConditionCode cc, FlagGroupStorage grf)
{
var test = m.Test(cc, binder.EnsureFlagGroup(grf));
m.Branch(test, ((AddressOperand)instr.Operands[0]).Address);
}
private void EmitCond(FlagGroupStorage grf, Expression e)
{
m.Assign(binder.EnsureFlagGroup(grf), m.Cond(e));
}
public Identifier EnsureFlagGroup(FlagGroupStorage grf)
{
if (grf.FlagGroupBits == 0)
return null;
var id = FindFlagGroup(grf.FlagGroupBits);
if (id == null)
{
id = new Identifier(grf.Name, grf.DataType, new FlagGroupStorage(grf.FlagGroupBits, grf.Name, grf.DataType));
identifiers.Add(id);
}
return id;
}
public FlagGroupStorage GetFlagGroup(uint grf)
{
FlagGroupStorage f;
if (flagGroups.TryGetValue(grf, out f))
return f;
PrimitiveType dt = Bits.IsSingleBitSet(grf) ? PrimitiveType.Bool : PrimitiveType.Byte;
var fl = new FlagGroupStorage(grf, GrfToString(grf), dt);
flagGroups.Add(grf, fl);
return fl;
}
public FlagGroupStorage GetFlagGroup(uint grf)
{
foreach (FlagGroupStorage f in flagGroups)
{
if (f.FlagGroupBits == grf)
return f;
}
PrimitiveType dt = Bits.IsSingleBitSet(grf) ? PrimitiveType.Bool : PrimitiveType.Byte;
var fl = new FlagGroupStorage(grf, GrfToString(grf), dt);
flagGroups.Add(fl);
return fl;
}
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);
}
public void SetFlagGroup(FlagGroupStorage reg, Constant value)
{
uint mask = reg.FlagGroupBits;
if (value.IsValid)
{
validFlags |= mask;
if (value.ToBoolean())
{
this.flags |= mask;
}
else
{
this.flags &= ~mask;
}
}
else
{
validFlags &= ~mask;
}
}
public Expression?VisitFlagGroupStorage(FlagGroupStorage grf)
{
if (!map !.TryGetValue(grf, out var cb))
{
return(null);
}
public override FlagGroupStorage GetFlagGroup(uint grf)
{
FlagGroupStorage fl;
if (flagGroups.TryGetValue(grf, out fl))
return fl;
PrimitiveType dt = Bits.IsSingleBitSet(grf) ? PrimitiveType.Bool : PrimitiveType.Byte;
fl = new FlagGroupStorage(Registers.psr, grf, GrfToString(grf), dt);
flagGroups.Add(grf, fl);
return fl;
}
static Registers()
{
g0 = new RegisterStorage("g0", 0, PrimitiveType.Word32);
g1 = new RegisterStorage("g1", 1, PrimitiveType.Word32);
g2 = new RegisterStorage("g2", 2, PrimitiveType.Word32);
g3 = new RegisterStorage("g3", 3, PrimitiveType.Word32);
g4 = new RegisterStorage("g4", 4, PrimitiveType.Word32);
g5 = new RegisterStorage("g5", 5, PrimitiveType.Word32);
g6 = new RegisterStorage("g6", 6, PrimitiveType.Word32);
g7 = new RegisterStorage("g7", 7, PrimitiveType.Word32);
o0 = new RegisterStorage("o0", 8, PrimitiveType.Word32); // outgoing paramter 0 / return valie from callee
o1 = new RegisterStorage("o1", 9, PrimitiveType.Word32);
o2 = new RegisterStorage("o2", 10, PrimitiveType.Word32);
o3 = new RegisterStorage("o3", 11, PrimitiveType.Word32);
o4 = new RegisterStorage("o4", 12, PrimitiveType.Word32);
o5 = new RegisterStorage("o5", 13, PrimitiveType.Word32);
sp = new RegisterStorage("sp", 14, PrimitiveType.Word32); // stack pointer
o7 = new RegisterStorage("o7", 15, PrimitiveType.Word32);
l0 = new RegisterStorage("l0", 16, PrimitiveType.Word32);
l1 = new RegisterStorage("l1", 17, PrimitiveType.Word32);
l2 = new RegisterStorage("l2", 18, PrimitiveType.Word32);
l3 = new RegisterStorage("l3", 19, PrimitiveType.Word32);
l4 = new RegisterStorage("l4", 20, PrimitiveType.Word32);
l5 = new RegisterStorage("l5", 21, PrimitiveType.Word32);
lp = new RegisterStorage("lp", 22, PrimitiveType.Word32);
l7 = new RegisterStorage("l7", 23, PrimitiveType.Word32);
i0 = new RegisterStorage("i0", 24, PrimitiveType.Word32); // incoming parameters / return value to caller
i1 = new RegisterStorage("i1", 25, PrimitiveType.Word32);
i2 = new RegisterStorage("i2", 26, PrimitiveType.Word32);
i3 = new RegisterStorage("i3", 27, PrimitiveType.Word32);
i4 = new RegisterStorage("i4", 28, PrimitiveType.Word32);
i5 = new RegisterStorage("i5", 29, PrimitiveType.Word32);
i6 = new RegisterStorage("i6", 30, PrimitiveType.Word32); // frame pointer
i7 = new RegisterStorage("i7", 31, PrimitiveType.Word32); // return address - 8
y = new RegisterStorage("y", 32, PrimitiveType.Word32);
// 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 = new RegisterStorage("f0", 0, PrimitiveType.Word32);
f1 = new RegisterStorage("f1", 1, PrimitiveType.Word32);
f2 = new RegisterStorage("f2", 2, PrimitiveType.Word32);
f3 = new RegisterStorage("f3", 3, PrimitiveType.Word32);
f4 = new RegisterStorage("f4", 4, PrimitiveType.Word32);
f5 = new RegisterStorage("f5", 5, PrimitiveType.Word32);
f6 = new RegisterStorage("f6", 6, PrimitiveType.Word32);
f7 = new RegisterStorage("f7", 7, PrimitiveType.Word32);
f8 = new RegisterStorage("f8", 8, PrimitiveType.Word32);
f9 = new RegisterStorage("f9", 9, PrimitiveType.Word32);
f10= new RegisterStorage("f10", 10, PrimitiveType.Word32);
f11= new RegisterStorage("f11", 11, PrimitiveType.Word32);
f12= new RegisterStorage("f12", 12, PrimitiveType.Word32);
f13= new RegisterStorage("f13", 13, PrimitiveType.Word32);
f14= new RegisterStorage("f14", 14, PrimitiveType.Word32);
f15= new RegisterStorage("f15", 15, PrimitiveType.Word32);
f16= new RegisterStorage("f16", 16, PrimitiveType.Word32);
f17= new RegisterStorage("f17", 17, PrimitiveType.Word32);
f18= new RegisterStorage("f18", 18, PrimitiveType.Word32);
f19= new RegisterStorage("f19", 19, PrimitiveType.Word32);
f20= new RegisterStorage("f20", 20, PrimitiveType.Word32);
f21= new RegisterStorage("f21", 21, PrimitiveType.Word32);
f22= new RegisterStorage("f22", 22, PrimitiveType.Word32);
f23= new RegisterStorage("f23", 23, PrimitiveType.Word32);
f24= new RegisterStorage("f24", 24, PrimitiveType.Word32);
f25= new RegisterStorage("f25", 25, PrimitiveType.Word32);
f26= new RegisterStorage("f26", 26, PrimitiveType.Word32);
f27= new RegisterStorage("f27", 27, PrimitiveType.Word32);
f28= new RegisterStorage("f28", 28, PrimitiveType.Word32);
f29= new RegisterStorage("f29", 29, PrimitiveType.Word32);
f30= new RegisterStorage("f30", 30, PrimitiveType.Word32);
f31= new RegisterStorage("f31", 31, PrimitiveType.Word32);
N = new FlagGroupStorage((uint) FlagM.NF, "N", PrimitiveType.Bool);
Z = new FlagGroupStorage((uint) FlagM.ZF, "Z", PrimitiveType.Bool);
V = new FlagGroupStorage((uint) FlagM.VF, "V", PrimitiveType.Bool);
C = new FlagGroupStorage((uint) FlagM.CF, "C", PrimitiveType.Bool);
E = new FlagGroupStorage((uint) FlagM.EF, "E", PrimitiveType.Bool);
L = new FlagGroupStorage((uint) FlagM.LF, "L", PrimitiveType.Bool);
G = new FlagGroupStorage((uint) FlagM.GF, "G", PrimitiveType.Bool);
U = new FlagGroupStorage((uint) FlagM.UF, "U", PrimitiveType.Bool);
iRegs = new RegisterStorage[]
{
g0,
g1,
g2,
g3,
g4,
g5,
g6,
g7,
o0,
o1,
o2,
o3,
o4,
o5,
sp,
o7,
l0,
l1,
l2,
l3,
l4,
l5,
lp,
l7,
i0,
i1,
i2,
i3,
i4,
i5,
i6,
i7,
y,
};
fRegs = 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,
};
}
