public void EmitStoreFloat(RegistersEnum rg, byte size = 32, bool adr = false, int off = 0)
{
EmitInstruction(new NCAsm.x86.x87.FloatStoreAndPop()
{
DestinationReg = rg, Size = size, DestinationIsIndirect = adr, DestinationDisplacement = off
});
}
public static RegistersEnum?Get32BitRegisterForRegister(RegistersEnum aReg)
{
if (Is32Bit(aReg))
{
return(aReg);
}
if (Is128Bit(aReg))
{
throw new Exception("128bit registers don't have 32bit variants!");
}
if (Is16Bit(aReg))
{
if (m32BitTo16BitMapping.ContainsValue(aReg))
{
return((from item in m32BitTo16BitMapping
where item.Value == aReg
select item.Key).Single());
}
return(null);
}
if (m32BitTo8BitMapping.ContainsValue(aReg))
{
return((from item in m32BitTo8BitMapping
where item.Value == aReg
select item.Key).Single());
}
return(null);
}
public void EmitMovToRegister(RegistersEnum dst, ushort v)
{
EmitInstruction(new Mov()
{
DestinationReg = dst, SourceValue = v, Size = 16
});
}
public void EmitMovToRegister(RegistersEnum dst, bool v)
{
EmitInstruction(new Mov()
{
DestinationReg = dst, SourceValue = (v ? (ushort)EmitContext.TRUE : (ushort)0), Size = 16
});
}
public void EmitBoolean(RegistersEnum rg, bool v)
{
EmitInstruction(new Mov()
{
DestinationReg = rg, SourceValue = (v ? (ushort)EmitContext.TRUE : (ushort)0), Size = 80
});
}
public void EmitPushSigned(RegistersEnum rg, byte size = 80, bool adr = false, int off = 0)
{
if (Registers.Is8Bit(rg))
{
rg = ag.GetHolder(rg);
}
if (size == 8)
{
ag.SetAsUsed(rg);
RegistersEnum drg = ag.GetNextRegister();
ag.FreeRegister();
ag.FreeRegister();
EmitInstruction(new MoveSignExtend()
{
DestinationReg = drg, Size = 8, SourceReg = rg, SourceDisplacement = off, SourceIsIndirect = adr
});
EmitInstruction(new Push()
{
DestinationReg = drg, Size = 16
});
}
else
{
EmitInstruction(new Push()
{
DestinationReg = rg, Size = 16, DestinationIsIndirect = adr, DestinationDisplacement = off
});
}
}
public static Register OldToNewRegister(RegistersEnum register)
{
Register xResult;
if (!mRegisters.TryGetValue(register.ToString(), out xResult))
{
throw new NotImplementedException($"Register {register} not yet implemented!");
}
return xResult;
}
public static Register OldToNewRegister(RegistersEnum register)
{
Register xResult;
if (!mRegisters.TryGetValue(register.ToString(), out xResult))
{
throw new NotImplementedException($"Register {register} not yet implemented!");
}
return(xResult);
}
public RegistersEnum SetAsUsed(RegistersEnum reg)
{
if (rg.Contains(reg))
{
return(GetNextRegister());
}
else
{
rg.Push(reg);
return(reg);
}
}
public static bool Is8Bit(RegistersEnum aRegister)
{
return
(aRegister == AL ||
aRegister == AH ||
aRegister == BL ||
aRegister == BH ||
aRegister == CL ||
aRegister == CH ||
aRegister == DL ||
aRegister == DH);
}
public static bool Is8Bit(RegistersEnum aRegister)
{
return
(aRegister == RegistersEnum.AL ||
aRegister == RegistersEnum.AH ||
aRegister == RegistersEnum.BL ||
aRegister == RegistersEnum.BH ||
aRegister == RegistersEnum.CL ||
aRegister == RegistersEnum.CH ||
aRegister == RegistersEnum.DL ||
aRegister == RegistersEnum.DH);
}
//public static Guid Get
public static bool Is80Bit(RegistersEnum aRegister)
{
return
(aRegister == RegistersEnum.ST0 ||
aRegister == RegistersEnum.ST1 ||
aRegister == RegistersEnum.ST2 ||
aRegister == RegistersEnum.ST3 ||
aRegister == RegistersEnum.ST4 ||
aRegister == RegistersEnum.ST5 ||
aRegister == RegistersEnum.ST6 ||
aRegister == RegistersEnum.ST7);
}
public void EmitMovToRegisterSigned(RegistersEnum rg, RegistersEnum src, byte size = 80, bool adr = false, int off = 0)
{
if (size == 8)
{
EmitInstruction(new MoveSignExtend()
{
DestinationReg = rg, Size = 8, SourceReg = src, SourceDisplacement = off, SourceIsIndirect = adr
});
}
else
{
EmitInstruction(new Mov()
{
DestinationReg = rg, Size = 16, SourceReg = src, SourceDisplacement = off, SourceIsIndirect = adr
});
}
}
public void EmitBoolean(RegistersEnum rg, ConditionalTestEnum tr, ConditionalTestEnum fls)
{
// EmitInstruction(new Xor() { SourceReg = ag.GetHolder(rg), DestinationReg = ag.GetHolder(rg), Size = 80 });
EmitInstruction(new ConditionalSet()
{
Condition = tr, DestinationReg = GetLow(rg), Size = 80
});
EmitInstruction(new MoveZeroExtend()
{
SourceReg = GetLow(rg), DestinationReg = ag.GetHolder(rg), Size = 80
});
/*
* EmitInstruction(new ConditionalMove() { Condition = tr, DestinationReg = rg, Size = 80, SourceValue = TRUE });
* EmitInstruction(new ConditionalMove() { Condition = fls, DestinationReg = rg, Size = 80, SourceValue = 0 });
*
* */
}
public static byte GetSize(RegistersEnum aRegister)
{
if (Is128Bit(aRegister))
{
return(128);
}
if (Is32Bit(aRegister))
{
return(32);
}
if (Is16Bit(aRegister))
{
return(16);
}
if (Is8Bit(aRegister))
{
return(8);
}
throw new NotImplementedException();
}
public bool PushAllFromRegister(EmitContext ec, RegistersEnum rg, int size, int offset = 0)
{
int s = size / 2;
if (size % 2 != 0)
{
ec.EmitInstruction(new Mov()
{
DestinationReg = RegistersEnum.DL, SourceReg = rg, SourceDisplacement = offset - 1 + size, SourceIsIndirect = true, Size = 8
});
ec.EmitPush(RegistersEnum.DX);
}
for (int i = s - 1; i >= 0; i--)
{
ec.EmitInstruction(new Push()
{
DestinationReg = rg, DestinationDisplacement = offset + 2 * i, DestinationIsIndirect = true, Size = 16
});
}
return(true);
}
public bool PopAllToRegister(EmitContext ec, RegistersEnum rg, int size, int offset = 0)
{
int s = size / 2;
for (int i = 0; i < s; i++)
{
ec.EmitInstruction(new Pop()
{
DestinationReg = rg, DestinationDisplacement = offset + 2 * i, DestinationIsIndirect = true, Size = 16
});
}
if (size % 2 != 0)
{
ec.EmitPop(RegistersEnum.DX);
ec.EmitInstruction(new Mov()
{
DestinationReg = rg, DestinationDisplacement = offset - 1 + size, DestinationIsIndirect = true, Size = 8, SourceReg = RegistersEnum.DL
});
}
return(true);
}
public RegistersEnum GetHigh(RegistersEnum reg)
{
if (reg == RegistersEnum.AX)
{
return(RegistersEnum.AH);
}
else if (reg == RegistersEnum.BX)
{
return(RegistersEnum.BH);
}
else if (reg == RegistersEnum.CX)
{
return(RegistersEnum.CH);
}
else if (reg == RegistersEnum.DX)
{
return(RegistersEnum.DH);
}
else
{
return(reg);
}
}
public RegistersEnum GetHolder(RegistersEnum reg)
{
if (reg == RegistersEnum.AL | reg == RegistersEnum.AH)
{
return(RegistersEnum.AX);
}
else if (reg == RegistersEnum.BL | reg == RegistersEnum.BH)
{
return(RegistersEnum.BX);
}
else if (reg == RegistersEnum.CL | reg == RegistersEnum.CH)
{
return(RegistersEnum.CX);
}
else if (reg == RegistersEnum.DL | reg == RegistersEnum.DH)
{
return(RegistersEnum.DX);
}
else
{
return(reg);
}
}
public RegistersEnum GetLow(RegistersEnum reg)
{
if (reg == RegistersEnum.AX)
{
return(RegistersEnum.AL);
}
else if (reg == RegistersEnum.BX)
{
return(RegistersEnum.BL);
}
else if (reg == RegistersEnum.CX)
{
return(RegistersEnum.CL);
}
else if (reg == RegistersEnum.DX)
{
return(RegistersEnum.DL);
}
else
{
return(reg);
}
}
public void EmitMovFromRegister(RegistersEnum rg, RegistersEnum src, byte size = 80, bool adr = false, int off = 0)
{
if (size == 8)
{
if (off != 0)
{
EmitInstruction(new Mov()
{
DestinationReg = rg, Size = 8, DestinationIsIndirect = adr, DestinationDisplacement = off, SourceReg = GetLow(src)
});
}
else
{
EmitInstruction(new Mov()
{
DestinationReg = rg, Size = 8, DestinationIsIndirect = adr, SourceReg = GetLow(src)
});
}
}
else
{
if (off != 0)
{
EmitInstruction(new Mov()
{
DestinationReg = rg, Size = 16, DestinationIsIndirect = adr, DestinationDisplacement = off, SourceReg = src
});
}
else
{
EmitInstruction(new Mov()
{
DestinationReg = rg, Size = 16, DestinationIsIndirect = adr, SourceReg = src
});
}
}
}
public void EmitBooleanWithJump(RegistersEnum rg, ConditionalTestEnum TR)
{
string lbname = EmitContext.GenerateLabelName(LabelType.BOOL_EXPR);
Label truelb = DefineLabel(lbname + "_TRUE");
Label falselb = DefineLabel(lbname + "_FALSE");
Label boolexprlb = DefineLabel(lbname + "_END");
// jumps
EmitInstruction(new ConditionalJump()
{
Condition = TR, DestinationLabel = truelb.Name
});
EmitInstruction(new Jump()
{
DestinationLabel = falselb.Name
}); // false
// emit true and false
// true
MarkLabel(truelb);
EmitInstruction(new Mov()
{
DestinationReg = EmitContext.A, SourceValue = TRUE, Size = 8
});
EmitInstruction(new Jump()
{
DestinationLabel = boolexprlb.Name
}); // exit
// false
MarkLabel(falselb);
EmitInstruction(new Mov()
{
DestinationReg = EmitContext.A, SourceValue = 0, Size = 8
});
// mark exit
MarkLabel(boolexprlb);
}
public static RegistersEnum? Get16BitRegisterForRegister( RegistersEnum aReg )
{
if( Is32Bit( aReg ) )
{
//if( m32BitTo16BitMapping.ContainsKey( aReg ) )
//{
// return m32BitTo16BitMapping[ aReg ];
//}
return null;
}
if( Is128Bit( aReg ) )
{
throw new Exception( "128bit registers don't have 8bit variants!" );
}
if( Is16Bit( aReg ) )
{
return aReg;
}
//if( m16BitTo8BitMapping.ContainsKey( aReg ) )
//{
// return m16BitTo8BitMapping[ aReg ];
//}
return aReg;
}
public static RegistersEnum?Get16BitRegisterForRegister(RegistersEnum aReg)
{
if (Is32Bit(aReg))
{
if (m32BitTo16BitMapping.ContainsKey(aReg))
{
return(m32BitTo16BitMapping[aReg]);
}
return(null);
}
if (Is128Bit(aReg))
{
throw new Exception("128bit registers don't have 8bit variants!");
}
if (Is16Bit(aReg))
{
return(aReg);
}
if (m16BitTo8BitMapping.ContainsKey(aReg))
{
return(m16BitTo8BitMapping[aReg]);
}
return(aReg);
}
public static bool IsSegment(RegistersEnum aRegister)
{
return aRegister == CS || aRegister == DS || aRegister == ES || aRegister == FS || aRegister == GS || aRegister == SS;
}
public static bool Is16Bit(RegistersEnum aRegister)
{
return aRegister == AX || aRegister == BX || aRegister == CX || aRegister == DX || aRegister == CS || aRegister == DS || aRegister == ES || aRegister == FS || aRegister == GS || aRegister == SS || aRegister == SI || aRegister == DI || aRegister == SP || aRegister == BP;
}
public static bool IsCR(RegistersEnum aReg)
{
return aReg == RegistersEnum.CR0 ||aReg == RegistersEnum.CR1 ||aReg == RegistersEnum.CR2 ||aReg == RegistersEnum.CR3 ||aReg == RegistersEnum.CR4;
}
public static bool Is16Bit( RegistersEnum aRegister )
{
return Reg16.Contains( aRegister );
}
public static string GetRegisterName( RegistersEnum aRegister )
{
return mRegToName[ aRegister ];
}
public static bool Is16Bit(RegistersEnum aRegister)
{
return(aRegister == RegistersEnum.AX || aRegister == RegistersEnum.BX || aRegister == RegistersEnum.CX || aRegister == RegistersEnum.DX || aRegister == RegistersEnum.CS || aRegister == RegistersEnum.DS || aRegister == RegistersEnum.ES || aRegister == RegistersEnum.FS || aRegister == RegistersEnum.GS || aRegister == RegistersEnum.SS || aRegister == RegistersEnum.SI || aRegister == RegistersEnum.DI || aRegister == RegistersEnum.SP || aRegister == RegistersEnum.BP);
}
public static bool IsSegment(RegistersEnum aRegister)
{
return aRegister == RegistersEnum.CS || aRegister == RegistersEnum.DS || aRegister == RegistersEnum.ES || aRegister == RegistersEnum.FS || aRegister == RegistersEnum.GS || aRegister == RegistersEnum.SS;
}
public static bool Is32Bit(RegistersEnum aRegister)
{
return aRegister == RegistersEnum.EAX || aRegister == RegistersEnum.EBX || aRegister == RegistersEnum.ECX || aRegister == RegistersEnum.EDX || aRegister == RegistersEnum.ESP || aRegister == RegistersEnum.EBP || aRegister == RegistersEnum.ESI || aRegister == RegistersEnum.EDI || aRegister == RegistersEnum.CR0 || aRegister == RegistersEnum.CR1 || aRegister == RegistersEnum.CR2 || aRegister == RegistersEnum.CR3 || aRegister == RegistersEnum.CR4
|| aRegister == RegistersEnum.EIP;
}
public static bool Is16Bit(RegistersEnum aRegister)
{
return aRegister == RegistersEnum.AX || aRegister == RegistersEnum.BX || aRegister == RegistersEnum.CX || aRegister == RegistersEnum.DX || aRegister == RegistersEnum.CS || aRegister == RegistersEnum.DS || aRegister == RegistersEnum.ES || aRegister == RegistersEnum.FS || aRegister == RegistersEnum.GS || aRegister == RegistersEnum.SS || aRegister == RegistersEnum.SI || aRegister == RegistersEnum.DI || aRegister == RegistersEnum.SP || aRegister == RegistersEnum.BP;
}
public static bool Is32Bit( RegistersEnum aRegister )
{
return Reg32.Contains( aRegister );
}
//public static Guid Get
public static bool Is128Bit( RegistersEnum aRegister )
{
return Reg_XMM.Contains( aRegister ) || Reg_YMM.Contains( aRegister );
}
public static bool Is8Bit(RegistersEnum aRegister)
{
return
aRegister == AL ||
aRegister == AH ||
aRegister == BL ||
aRegister == BH ||
aRegister == CL ||
aRegister == CH ||
aRegister == DL ||
aRegister == DH;
}
public static bool Is128Bit(RegistersEnum aRegister)
{
return aRegister == RegistersEnum.XMM0 || aRegister == RegistersEnum.XMM1 || aRegister == RegistersEnum.XMM2 || aRegister == RegistersEnum.XMM3 || aRegister == RegistersEnum.XMM4 || aRegister == RegistersEnum.XMM5 || aRegister == RegistersEnum.XMM6 || aRegister == RegistersEnum.XMM7;
}
public static bool Is32Bit(RegistersEnum aRegister)
{
return(aRegister == RegistersEnum.EAX || aRegister == RegistersEnum.EBX || aRegister == RegistersEnum.ECX || aRegister == RegistersEnum.EDX || aRegister == RegistersEnum.ESP || aRegister == RegistersEnum.EBP || aRegister == RegistersEnum.ESI || aRegister == RegistersEnum.EDI || aRegister == RegistersEnum.CR0 || aRegister == RegistersEnum.CR1 || aRegister == RegistersEnum.CR2 || aRegister == RegistersEnum.CR3 || aRegister == RegistersEnum.CR4 ||
aRegister == RegistersEnum.EIP);
}
//public static Guid Get
public static bool Is80Bit(RegistersEnum aRegister)
{
return
aRegister == RegistersEnum.ST0 ||
aRegister == RegistersEnum.ST1 ||
aRegister == RegistersEnum.ST2 ||
aRegister == RegistersEnum.ST3 ||
aRegister == RegistersEnum.ST4 ||
aRegister == RegistersEnum.ST5 ||
aRegister == RegistersEnum.ST6 ||
aRegister == RegistersEnum.ST7;
}
public static RegistersEnum? Get32BitRegisterForRegister( RegistersEnum aReg )
{
if( Is32Bit( aReg ) )
{
return aReg;
}
if( Is128Bit( aReg ) )
{
throw new Exception( "128bit registers don't have 32bit variants!" );
}
if( Is16Bit( aReg ) )
{
//if( m32BitTo16BitMapping.ContainsValue( aReg ) )
//{
// return ( from item in m32BitTo16BitMapping
// where item.Value == aReg
// select item.Key ).Single();
//}
return null;
}
//if( m32BitTo8BitMapping.ContainsValue( aReg ) )
//{
// return ( from item in m32BitTo8BitMapping
// where item.Value == aReg
// select item.Key ).Single();
//}
return null;
}
public static bool Is8Bit(RegistersEnum aRegister)
{
return
aRegister == RegistersEnum.AL ||
aRegister == RegistersEnum.AH ||
aRegister == RegistersEnum.BL ||
aRegister == RegistersEnum.BH ||
aRegister == RegistersEnum.CL ||
aRegister == RegistersEnum.CH ||
aRegister == RegistersEnum.DL ||
aRegister == RegistersEnum.DH;
}
public static byte GetSize( RegistersEnum aRegister )
{
if( Is128Bit( aRegister ) ) { return 128; }
if( Is32Bit( aRegister ) ) { return 32; }
if( Is16Bit( aRegister ) ) { return 16; }
if( Is8Bit( aRegister ) ) { return 8; }
throw new NotImplementedException();
}
protected Register(string name, RegistersEnum regEnum, RegisterSize size)
{
Size = size;
Name = name;
RegEnum = regEnum;
}
public static bool IsSegment( RegistersEnum aRegister )
{
return Reg_Seg.Contains( aRegister );
}
public Register32(string name, RegistersEnum regEnum) : base(name, regEnum, RegisterSize.Int32)
{
}
public static bool Is64Bit( RegistersEnum aRegister )
{
return Reg64.Contains( aRegister );
}
public RegisterXMM(string name, RegistersEnum regEnum) : base(name, regEnum, RegisterSize.XMM)
{
}
public static bool IsCR( RegistersEnum aReg )
{
return Reg_CR.Contains( aReg );
}
public Register8(string name, RegistersEnum regEnum) : base(name, regEnum, RegisterSize.Byte8)
{
}
protected Register(string name, RegistersEnum regEnum, RegisterSize size)
{
Size = size;
Name = name;
RegEnum = regEnum;
}
public Register32(string name, RegistersEnum regEnum) : base(name, regEnum, RegisterSize.Int32)
{
}
public Register8(string name, RegistersEnum regEnum) : base(name, regEnum, RegisterSize.Byte8)
{
}
public RegisterFPU(string name, RegistersEnum regEnum): base(name, regEnum, RegisterSize.FPU)
{
}
public RegisterFPU(string name, RegistersEnum regEnum) : base(name, regEnum, RegisterSize.FPU)
{
}
public RegisterXMM(string name, RegistersEnum regEnum) : base(name, regEnum, RegisterSize.XMM)
{
}
public RegisterSegment(string name, RegistersEnum regEnum) : base(name, regEnum, RegisterSize.Short16)
{
}
public RegisterSegment(string name, RegistersEnum regEnum): base(name, regEnum, RegisterSize.Short16)
{
}
