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, }; }