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) { }
public RegisterFPU(string name, RegistersEnum regEnum): base(name, regEnum, RegisterSize.FPU) { }
public RegisterFPU(string name, RegistersEnum regEnum) : base(name, regEnum, RegisterSize.FPU) { }
public RegisterSegment(string name, RegistersEnum regEnum) : base(name, regEnum, RegisterSize.Short16) { }
public RegisterSegment(string name, RegistersEnum regEnum): base(name, regEnum, RegisterSize.Short16) { }