internal byte Sbc(byte a, byte b, RegisterFlags affectedFlags = RegisterFlags.None, RegisterFlags setFlags = RegisterFlags.None, RegisterFlags resetFlags = RegisterFlags.None) { _registers.ClearFlags(resetFlags); _registers.SetFlags(setFlags); return(Perform(a, b, (x, y) => x - (y + (_registers.GetFlags(RegisterFlags.C) ? 1 : 0)), affectedFlags)); }
private byte Perform(byte a, byte b, Func <byte, byte, int> operation, RegisterFlags affectedFlags) { int intermediate = operation(a, b); byte result = (byte)(intermediate & 0xFF); int carryBits = (a ^ b ^ intermediate); _registers.ClearFlags(affectedFlags); var setAffected = RegisterFlags.None; if ((carryBits & 0x100) == 0x100) { setAffected |= RegisterFlags.C; } if ((carryBits & 0x10) == 0x10) { setAffected |= RegisterFlags.H; } if (result == 0) { setAffected |= RegisterFlags.Z; } _registers.SetFlags(setAffected & affectedFlags); return(result); }
private byte PerformMath(byte a, byte b, Func <byte, byte, int> function, RegisterFlags affectedFlags) { int intermediate = function(a, b); int carryBits = a ^ b ^ intermediate; byte result = (byte)(intermediate & 0xFF); _registers.ClearFlags(affectedFlags); RegisterFlags flags = None; if ((carryBits & 0x100) == 0x100) { flags |= C; } if ((carryBits & 0x10) == 0x10) { flags |= H; } if (result == 0) { flags |= Z; } _registers.SetFlags(flags & affectedFlags); return(result); }
private Register(RegisterName register, RegisterFlags flags, RegisterSize size, RegisterName?containing = null) { RegisterName = register; Flags = flags; Size = size; Containing = containing; }
internal ushort Add(ushort a, sbyte b, RegisterFlags affectedFlags = RegisterFlags.None, RegisterFlags setFlags = RegisterFlags.None, RegisterFlags resetFlags = RegisterFlags.None) { _registers.ClearFlags(resetFlags); _registers.SetFlags(setFlags); return(Perform(a, b, (x, y) => x + y, affectedFlags)); }
/// <summary> /// Clears the provided flags in the flags (F) register. /// </summary> /// <param name="flags">The flags to clear.</param> public void ClearFlags(RegisterFlags flags) { unchecked { F &= (byte)~(byte)flags; } }
private ushort PerformMath(ushort a, ushort b, Func <ushort, ushort, int> function, RegisterFlags affectedFlags) { int intermediate = function(a, b); ushort result = (ushort)(intermediate & 0xFFFF); int carryBits = a ^ b ^ intermediate; _registers.ClearFlags(affectedFlags); RegisterFlags flags = None; if ((carryBits & 0x10000) == 0x10000) { flags |= C; } // for ushort + ushort half carry is checked for upper byte if ((carryBits & 0x1000) == 0x1000) { flags |= H; } if (result == 0) { flags |= Z; } _registers.SetFlags(flags & affectedFlags); return(result); }
internal byte Sub(byte a, byte b, RegisterFlags affectedFlags = RegisterFlags.None, RegisterFlags setFlags = RegisterFlags.None, RegisterFlags resetFlags = RegisterFlags.None) { _registers.ClearFlags(resetFlags); _registers.SetFlags(setFlags); return(Perform(a, b, (x, y) => x - y, affectedFlags)); }
private void Register <T> (IDictionary <Type, T> dict, Type key, T value, RegisterFlags flags) { Store(dict, key, value, flags); var strategy = ProcessInjectionStrategy(flags); SetInjectionStrategy(key, strategy); }
public bool AreFlagsSet(RegisterFlags flags) { if (flags == RegisterFlags.None) { return(F == 0); } return((F & (byte)flags) == (byte)flags); }
internal void RegisterType(Type key, Type value, RegisterFlags flags) { if (value != null && value.IsInterface) { throw new CannotRegisterInterfaceAsValueException(value.Name + " is an interface"); } Register(typeMap, key, value, flags); }
private static InjectionStrategy ProcessInjectionStrategy(RegisterFlags flags) { var injectionStrategy = InjectionStrategy.Once; if (flags.Has(RegisterFlags.PreventInjections)) { injectionStrategy = InjectionStrategy.Never; } else if (flags.Has(RegisterFlags.NoCache)) { injectionStrategy = InjectionStrategy.Always; } return(injectionStrategy); }
static string ParseRegisterFlags(RegisterFlags registerFlags, bool preventInjections) { registerFlags &= ~RegisterFlags.Parameter; if (preventInjections) { registerFlags |= RegisterFlags.PreventInjections; } if (registerFlags > RegisterFlags.None) { registerFlags &= ~RegisterFlags.None; } var flags = Regex.Split(registerFlags.ToString(), ", "); var names = flags.Select(f => "RegisterFlags." + f).ToArray(); return(string.Join(" | ", names)); }
private byte RrcWork(byte targetValue, RegisterFlags affectedFlags) { byte result = (byte)((targetValue >> 1) | ((targetValue & 1) << 7)); _registers.ClearFlags(affectedFlags); RegisterFlags flags = None; if ((targetValue & (1 << 7)) == (1 << 7)) { flags |= C; } if (result == 0) { flags |= Z; } _registers.SetFlags(flags & affectedFlags); return(result); }
private byte RrWork(byte targetValue, RegisterFlags affectedFlags) { byte carry = (byte)(_registers.AreFlagsSet(C) ? 1 << 7 : 0); byte result = (byte)((targetValue >> 1) | carry); _registers.ClearFlags(affectedFlags); RegisterFlags flags = None; if ((targetValue & (1 << 7)) == (1 << 7)) { flags |= C; } if (result == 0) { flags |= Z; } _registers.SetFlags(flags & affectedFlags); return(result); }
internal byte Rrc(byte value, RegisterFlags affectedFlags = RegisterFlags.None, RegisterFlags setFlags = RegisterFlags.None, RegisterFlags resetFlags = RegisterFlags.None) { byte newValue = (byte)((value >> 1) | ((value & 1) << 7)); _registers.ClearFlags(affectedFlags | resetFlags); _registers.SetFlags(setFlags); var flags = RegisterFlags.None; if (newValue == 0) { flags |= RegisterFlags.Z; } if ((value & 1) == 1) { flags |= RegisterFlags.C; } _registers.SetFlags(flags & affectedFlags); return(newValue); }
internal byte Rl(byte value, RegisterFlags affectedFlags = RegisterFlags.None, RegisterFlags setFlags = RegisterFlags.None, RegisterFlags resetFlags = RegisterFlags.None) { byte newValue = (byte)((value << 1) | (_registers.GetFlags(RegisterFlags.C) ? 1 : 0)); _registers.ClearFlags(affectedFlags | resetFlags); _registers.SetFlags(setFlags); var flags = RegisterFlags.None; if (newValue == 0) { flags |= RegisterFlags.Z; } if ((value & (1 << 7)) == (1 << 7)) { flags |= RegisterFlags.C; } _registers.SetFlags(flags & affectedFlags); return(newValue); }
private byte Perform(byte a, byte b, Func <byte, byte, int> operation, RegisterFlags affectedFlags) { int intermediate = operation(a, b); byte result = (byte)(intermediate & 0xFF); _registers.ClearFlags(affectedFlags); var setAffected = RegisterFlags.None; if ((intermediate & (1 << 8)) == (1 << 8)) { setAffected |= RegisterFlags.C; } if ((operation((byte)(a & 0xF), (byte)(b & 0xF)) & (1 << 4)) == (1 << 4)) { setAffected |= RegisterFlags.H; } if (result == 0) { setAffected |= RegisterFlags.Z; } _registers.SetFlags(setAffected & affectedFlags); return(result); }
void VerifyRegisterProperties(Register register, int number, Register baseRegister, Register fullRegister, Register fullRegister32, int size, RegisterFlags flags) { var info = register.GetInfo(); Assert.Equal(register, info.Register); Assert.Equal(baseRegister, info.Base); Assert.Equal(number, info.Number); Assert.Equal(fullRegister, info.FullRegister); Assert.Equal(fullRegister32, info.FullRegister32); Assert.Equal(size, info.Size); Assert.Equal(baseRegister, register.GetBaseRegister()); Assert.Equal(number, register.GetNumber()); Assert.Equal(fullRegister, register.GetFullRegister()); Assert.Equal(fullRegister32, register.GetFullRegister32()); Assert.Equal(size, register.GetSize()); const RegisterFlags allFlags = RegisterFlags.SegmentRegister | RegisterFlags.GPR | RegisterFlags.GPR8 | RegisterFlags.GPR16 | RegisterFlags.GPR32 | RegisterFlags.GPR64 | RegisterFlags.XMM | RegisterFlags.YMM | RegisterFlags.ZMM | RegisterFlags.VectorRegister | RegisterFlags.IP | RegisterFlags.K | RegisterFlags.BND | RegisterFlags.CR | RegisterFlags.DR | RegisterFlags.TR | RegisterFlags.ST | RegisterFlags.MM | RegisterFlags.TMM; // If it fails, update the flags above and the code below, eg. add a IsTMM() test Assert.Equal(flags, flags & allFlags); Assert.Equal((flags & RegisterFlags.SegmentRegister) != 0, register.IsSegmentRegister()); Assert.Equal((flags & RegisterFlags.GPR) != 0, register.IsGPR()); Assert.Equal((flags & RegisterFlags.GPR8) != 0, register.IsGPR8()); Assert.Equal((flags & RegisterFlags.GPR16) != 0, register.IsGPR16()); Assert.Equal((flags & RegisterFlags.GPR32) != 0, register.IsGPR32()); Assert.Equal((flags & RegisterFlags.GPR64) != 0, register.IsGPR64()); Assert.Equal((flags & RegisterFlags.XMM) != 0, register.IsXMM()); Assert.Equal((flags & RegisterFlags.YMM) != 0, register.IsYMM()); Assert.Equal((flags & RegisterFlags.ZMM) != 0, register.IsZMM()); Assert.Equal((flags & RegisterFlags.VectorRegister) != 0, register.IsVectorRegister()); Assert.Equal((flags & RegisterFlags.IP) != 0, register.IsIP()); Assert.Equal((flags & RegisterFlags.K) != 0, register.IsK()); Assert.Equal((flags & RegisterFlags.BND) != 0, register.IsBND()); Assert.Equal((flags & RegisterFlags.CR) != 0, register.IsCR()); Assert.Equal((flags & RegisterFlags.DR) != 0, register.IsDR()); Assert.Equal((flags & RegisterFlags.TR) != 0, register.IsTR()); Assert.Equal((flags & RegisterFlags.ST) != 0, register.IsST()); Assert.Equal((flags & RegisterFlags.MM) != 0, register.IsMM()); Assert.Equal((flags & RegisterFlags.TMM) != 0, register.IsTMM()); }
private ushort Perform(ushort a, ushort b, Func <ushort, ushort, int> operation, RegisterFlags affectedFlags) { int intermediate = operation(a, b); ushort result = (ushort)(intermediate & 0xFFFF); int carryBits = (a ^ b ^ intermediate); int halfCarryBits = (a ^ b ^ result); _registers.ClearFlags(affectedFlags); var setAffected = RegisterFlags.None; if ((carryBits & 0x10000) == 0x10000) { setAffected |= RegisterFlags.C; } if ((halfCarryBits & 0x1000) == 0x1000) { setAffected |= RegisterFlags.H; } if (result == 0) { setAffected |= RegisterFlags.Z; } _registers.SetFlags(setAffected & affectedFlags); return(result); }
internal void RegisterHandler(Type key, Func <object, object> handler, RegisterFlags flags) { Register(handlerMap, key, handler, flags); }
/// <summary> /// Sets the provided flags in the flags (F) register. /// </summary> /// <param name="flags">The flags to set.</param> public void SetFlags(RegisterFlags flags) { F |= (byte)flags; }
/// <summary> /// Overwrites the flags (F) register. /// </summary> /// <param name="newFlags">The new value.</param> public void OverwriteFlags(RegisterFlags newFlags) { F = (byte)newFlags; }
/// <summary> /// Gets a value indicating whether the given flag(s) are set or not. /// </summary> /// <param name="flag">The flag(s) to check.</param> /// <returns>True if all flags specified are set, false otherwise.</returns> public bool GetFlags(RegisterFlags flag) { return((F & (byte)flag) == (byte)flag); }
void VerifyRegisterProperties(Register register, int number, Register baseRegister, Register fullRegister, Register fullRegister32, int size, RegisterFlags flags) { var info = register.GetInfo(); Assert.Equal(register, info.Register); Assert.Equal(baseRegister, info.Base); Assert.Equal(number, info.Number); Assert.Equal(fullRegister, info.FullRegister); Assert.Equal(fullRegister32, info.FullRegister32); Assert.Equal(size, info.Size); Assert.Equal(baseRegister, register.GetBaseRegister()); Assert.Equal(number, register.GetNumber()); Assert.Equal(fullRegister, register.GetFullRegister()); Assert.Equal(fullRegister32, register.GetFullRegister32()); Assert.Equal(size, register.GetSize()); Assert.Equal((flags & RegisterFlags.SegmentRegister) != 0, register.IsSegmentRegister()); Assert.Equal((flags & RegisterFlags.GPR) != 0, register.IsGPR()); Assert.Equal((flags & RegisterFlags.GPR8) != 0, register.IsGPR8()); Assert.Equal((flags & RegisterFlags.GPR16) != 0, register.IsGPR16()); Assert.Equal((flags & RegisterFlags.GPR32) != 0, register.IsGPR32()); Assert.Equal((flags & RegisterFlags.GPR64) != 0, register.IsGPR64()); Assert.Equal((flags & RegisterFlags.XMM) != 0, register.IsXMM()); Assert.Equal((flags & RegisterFlags.YMM) != 0, register.IsYMM()); Assert.Equal((flags & RegisterFlags.ZMM) != 0, register.IsZMM()); Assert.Equal((flags & RegisterFlags.VectorRegister) != 0, register.IsVectorRegister()); Assert.Equal((flags & RegisterFlags.IP) != 0, register.IsIP()); Assert.Equal((flags & RegisterFlags.K) != 0, register.IsK()); Assert.Equal((flags & RegisterFlags.BND) != 0, register.IsBND()); Assert.Equal((flags & RegisterFlags.CR) != 0, register.IsCR()); Assert.Equal((flags & RegisterFlags.DR) != 0, register.IsDR()); Assert.Equal((flags & RegisterFlags.TR) != 0, register.IsTR()); Assert.Equal((flags & RegisterFlags.ST) != 0, register.IsST()); Assert.Equal((flags & RegisterFlags.MM) != 0, register.IsMM()); }
private ushort Perform(ushort a, ushort b, Func <ushort, ushort, int> operation, RegisterFlags affectedFlags) { int intermediate = operation(a, b); ushort result = (ushort)(intermediate & 0xFFFF); _registers.ClearFlags(affectedFlags); var setAffected = RegisterFlags.None; if ((intermediate & (1 << 16)) == (1 << 16)) { setAffected |= RegisterFlags.C; } if ((operation((ushort)(a & 0xFFF), (ushort)(b & 0xFFF)) & (1 << 12)) == (1 << 12)) { setAffected |= RegisterFlags.H; } if (result == 0) { setAffected |= RegisterFlags.Z; } _registers.SetFlags(setAffected & affectedFlags); return(result); }
internal byte Decrement(byte value, RegisterFlags affectedFlags = RegisterFlags.None, RegisterFlags setFlags = RegisterFlags.None, RegisterFlags resetFlags = RegisterFlags.None) { return(Sub(value, 1, affectedFlags, setFlags, resetFlags)); }
internal byte Increment(byte value, RegisterFlags affectedFlags = RegisterFlags.None, RegisterFlags setFlags = RegisterFlags.None, RegisterFlags resetFlags = RegisterFlags.None) { return(Add(value, (byte)1, affectedFlags, setFlags, resetFlags)); }
private static void Store <T> (IDictionary <Type, T> dict, Type key, T value, RegisterFlags flags) { if (!dict.AddNewEntry(key, value)) { if (flags.Has(RegisterFlags.Rebind)) { dict.UpdateEntry(key, value); } else { throw new AlreadyRegisteredException(key + " not storable in " + dict); } } }
internal ushort Increment(ushort value, RegisterFlags affectedFlags = RegisterFlags.None, RegisterFlags setFlags = RegisterFlags.None, RegisterFlags resetFlags = RegisterFlags.None) { return(Add(value, 1, affectedFlags, setFlags, resetFlags)); }