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