public override void GetOpInfo(MasmFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { OpKind shortFormOpKind; switch (instr.CodeSize) { case CodeSize.Unknown: shortFormOpKind = instr.Op0Kind; break; case CodeSize.Code16: shortFormOpKind = OpKind.MemoryESDI; break; case CodeSize.Code32: shortFormOpKind = OpKind.MemoryESEDI; break; case CodeSize.Code64: shortFormOpKind = OpKind.MemoryESRDI; break; default: throw new InvalidOperationException(); } bool shortForm = instr.Op0Kind == shortFormOpKind && instr.PrefixSegment == Register.None; if (!shortForm) { info = new InstrOpInfo(mnemonic_args, ref instr, flags); } else { info = default; info.Flags = flags; info.Mnemonic = mnemonic_no_args; } }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { var flags = this.flags; int instrCodeSize = GetCodeSize(instr.CodeSize); if (instrCodeSize != 0 && instrCodeSize != codeSize) { if (codeSize == 16) { flags |= InstrOpInfoFlags.AddrSize16; } else if (codeSize == 32) { flags |= InstrOpInfoFlags.AddrSize32; } else { flags |= InstrOpInfoFlags.AddrSize64; } } info = new InstrOpInfo(mnemonic, ref instr, flags); }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { var flags = InstrOpInfoFlags.None; int instrCodeSize = GetCodeSize(instr.CodeSize); var opKind = instr.GetOpKind(memOpNumber); int memSize; if (opKind == OpKind.Memory64) { memSize = 64; } else { Debug.Assert(opKind == OpKind.Memory); int displSize = instr.MemoryDisplSize; memSize = displSize == 2 ? 16 : 32; } if (instrCodeSize == 0) { instrCodeSize = memSize; } if (instrCodeSize != memSize) { if (memSize == 16) { flags |= InstrOpInfoFlags.AddrSize16; } else if (memSize == 32) { flags |= InstrOpInfoFlags.AddrSize32; } else { flags |= InstrOpInfoFlags.AddrSize64; } } info = new InstrOpInfo(mnemonic, ref instr, flags); }
public override void GetOpInfo(MasmFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { Register baseReg; switch (instr.CodeSize) { case CodeSize.Unknown: baseReg = instr.MemoryBase; break; case CodeSize.Code16: baseReg = Register.BX; break; case CodeSize.Code32: baseReg = Register.EBX; break; case CodeSize.Code64: baseReg = Register.RBX; break; default: throw new InvalidOperationException(); } bool shortForm = instr.MemoryBase == baseReg && instr.PrefixSegment == Register.None; if (!shortForm) { info = new InstrOpInfo(mnemonic_args, ref instr, InstrOpInfoFlags.ShowNoMemSize_ForceSize | InstrOpInfoFlags.IgnoreIndexReg); } else { info = default; info.Mnemonic = mnemonic_no_args; } }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { var flags = InstrOpInfoFlags.None; int instrCodeSize = GetCodeSize(instr.CodeSize); bool hasMemOp = instr.Op0Kind == OpKind.Memory || instr.Op1Kind == OpKind.Memory; if (hasMemOp && !(instrCodeSize == 0 || (instrCodeSize != 64 && instrCodeSize == codeSize) || (instrCodeSize == 64 && codeSize == 32))) { if (codeSize == 16) { flags |= InstrOpInfoFlags.OpSize16; } else if (codeSize == 32) { flags |= InstrOpInfoFlags.OpSize32; } else { flags |= InstrOpInfoFlags.OpSize64; } } info = new InstrOpInfo(mnemonic, ref instr, flags); }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { var flags = this.flags; int instrCodeSize = GetCodeSize(instr.CodeSize); if (instrCodeSize != 0 && instrCodeSize != codeSize) { if (codeSize == 16) { flags |= InstrOpInfoFlags.OpSize16; } else if (codeSize == 32) { flags |= InstrOpInfoFlags.OpSize32; } else { flags |= InstrOpInfoFlags.OpSize64; } } var prefixSeg = instr.SegmentPrefix; if (prefixSeg == Register.CS) { flags |= InstrOpInfoFlags.IgnoreSegmentPrefix | InstrOpInfoFlags.JccNotTaken; } else if (prefixSeg == Register.DS) { flags |= InstrOpInfoFlags.IgnoreSegmentPrefix | InstrOpInfoFlags.JccTaken; } if (instr.HasRepnePrefix) { flags |= InstrOpInfoFlags.BndPrefix; } info = new InstrOpInfo(mnemonic, ref instr, flags); }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { info = new InstrOpInfo(mnemonic, ref instr, InstrOpInfoFlags.None); if (options.UsePseudoOps) { int index; int imm = instr.Immediate8; if (imm == 0) { index = 0; } else if (imm == 1) { index = 1; } else if (imm == 0x10) { index = 2; } else if (imm == 0x11) { index = 3; } else { index = -1; } if (index >= 0) { info.Mnemonic = pseudo_ops[index]; SimpleInstrInfo_pops.RemoveLastOp(ref info); } } }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { var flags = InstrOpInfoFlags.None; int instrCodeSize = GetCodeSize(instr.CodeSize); Register expectedReg; switch (instrCodeSize) { case 0: expectedReg = reg; break; case 16: expectedReg = Register.CX; break; case 32: expectedReg = Register.ECX; break; case 64: expectedReg = Register.RCX; break; default: throw new InvalidOperationException(); } if (instrCodeSize != 0 && instrCodeSize != codeSize) { if (codeSize == 16) { flags |= InstrOpInfoFlags.OpSize16; } else if (codeSize == 32) { flags |= InstrOpInfoFlags.OpSize32; } else { flags |= InstrOpInfoFlags.OpSize64; } } if (expectedReg != reg) { if (reg == Register.CX) { flags |= InstrOpInfoFlags.AddrSize16; } else if (reg == Register.ECX) { flags |= InstrOpInfoFlags.AddrSize32; } else { flags |= InstrOpInfoFlags.AddrSize64; } } info = new InstrOpInfo(mnemonic, ref instr, flags); }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { info = new InstrOpInfo(mnemonic, ref instr, flags); Debug.Assert(instr.OpCount == 1); info.OpCount = 2; info.Op1Kind = InstrOpKind.Register; Debug.Assert(InstrOpInfo.TEST_RegisterBits == 8); info.Op1Register = (byte)Registers.Register_ST; info.Op1Index = OpAccess_Read; }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { int instrCodeSize = GetCodeSize(instr.CodeSize); var flags = instrCodeSize == 0 || (instrCodeSize & codeSize) != 0 ? InstrOpInfoFlags.MemSize_Nothing : InstrOpInfoFlags.ShowNoMemSize_ForceSize; info = new InstrOpInfo(mnemonic, ref instr, flags); }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { info = new InstrOpInfo(mnemonic, ref instr, flags); Debug.Assert(instr.OpCount == 0); info.OpCount = 1; info.Op0Kind = InstrOpKind.Register; Debug.Assert(InstrOpInfo.TEST_RegisterBits == 8); info.Op0Register = (byte)register; if (instr.Code == Code.Skinit) { info.Op0Index = OpAccess_ReadWrite; } else { info.Op0Index = OpAccess_Read; } }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { info = new InstrOpInfo(mnemonic, ref instr, InstrOpInfoFlags.MnemonicIsDirective); info.OpCount = (byte)instr.DeclareDataCount; info.Op0Kind = opKind; info.Op1Kind = opKind; info.Op2Kind = opKind; info.Op3Kind = opKind; info.Op4Kind = opKind; info.Op0Index = OpAccess_Read; info.Op1Index = OpAccess_Read; info.Op2Index = OpAccess_Read; info.Op3Index = OpAccess_Read; info.Op4Index = OpAccess_Read; }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { var flags = InstrOpInfoFlags.None; int instrCodeSize = GetCodeSize(instr.CodeSize); if (instrCodeSize == 0) { // Nothing } else if (instrCodeSize == 64) { if ((codeSize & 16) != 0) { flags |= InstrOpInfoFlags.OpSize16; } } else if ((instrCodeSize & codeSize) == 0) { if ((codeSize & 16) != 0) { flags |= InstrOpInfoFlags.OpSize16; } else if ((codeSize & 32) != 0) { flags |= InstrOpInfoFlags.OpSize32; } } info = new InstrOpInfo(mnemonic, ref instr, flags); }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { info = new InstrOpInfo(mnemonic, ref instr, flags); info.OpCount = 1; info.Op0Kind = InstrOpKind.Register; Debug.Assert(InstrOpInfo.TEST_RegisterBits == 8); info.Op0Register = (byte)register; }
public override void GetOpInfo(MasmFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { Debug.Assert(instr.OpCount == 3); OpKind shortFormOpKind; switch (instr.CodeSize) { case CodeSize.Unknown: shortFormOpKind = instr.Op0Kind; break; case CodeSize.Code16: shortFormOpKind = OpKind.MemorySegDI; break; case CodeSize.Code32: shortFormOpKind = OpKind.MemorySegEDI; break; case CodeSize.Code64: shortFormOpKind = OpKind.MemorySegRDI; break; default: throw new InvalidOperationException(); } bool shortForm = instr.Op0Kind == shortFormOpKind && instr.PrefixSegment == Register.None; if (!shortForm) { info = new InstrOpInfo(mnemonic, ref instr, flags); } else { info = default; info.Flags = flags; info.Mnemonic = mnemonic; info.OpCount = 2; info.Op0Kind = (InstrOpKind)instr.Op1Kind; Debug.Assert(InstrOpInfo.TEST_RegisterBits == 8); info.Op0Register = (byte)instr.Op1Register; info.Op1Kind = (InstrOpKind)instr.Op2Kind; Debug.Assert(InstrOpInfo.TEST_RegisterBits == 8); info.Op1Register = (byte)instr.Op2Register; } }
public override void GetOpInfo(MasmFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { info = default; info.Mnemonic = mnemonic; info.OpCount = 3; info.Op0Kind = InstrOpKind.Register; Debug.Assert(InstrOpInfo.TEST_RegisterBits == 8); info.Op0Register = (byte)reg1; info.Op1Kind = InstrOpKind.Register; Debug.Assert(InstrOpInfo.TEST_RegisterBits == 8); info.Op1Register = (byte)reg2; info.Op2Kind = InstrOpKind.Register; Debug.Assert(InstrOpInfo.TEST_RegisterBits == 8); info.Op2Register = (byte)reg3; }
public override void GetOpInfo(MasmFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { info = default; info.Mnemonic = mnemonic; Debug.Assert(instr.OpCount == 2); Debug.Assert(instr.Op0Kind == OpKind.Register && instr.Op0Register == Register.ST0); if (!pseudoOp || !(options.UsePseudoOps && instr.Op1Register == Register.ST1)) { info.OpCount = 1; Debug.Assert(InstrOpKind.Register == 0); //info.Op0Kind = InstrOpKind.Register; Debug.Assert(InstrOpInfo.TEST_RegisterBits == 8); info.Op0Register = (byte)instr.Op1Register; } }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { info = new InstrOpInfo(mnemonic, ref instr, flags); Debug.Assert(info.OpCount == 3); if (options.UsePseudoOps && info.Op0Kind == InstrOpKind.Register && info.Op1Kind == InstrOpKind.Register && info.Op0Register == info.Op1Register) { info.OpCount--; info.Op1Kind = info.Op2Kind; info.Op1Index = 2; info.Op2Index = OpAccess_INVALID; } }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { const InstrOpInfoFlags flags = InstrOpInfoFlags.None; info = new InstrOpInfo(mnemonic, ref instr, flags); if (Register.EAX <= (Register)info.Op0Register && (Register)info.Op0Register <= Register.R15D) { Debug.Assert(InstrOpInfo.TEST_RegisterBits == 8); info.Op0Register = (byte)((Register)info.Op0Register - Register.EAX + Register.AX); } if (Register.EAX <= (Register)info.Op1Register && (Register)info.Op1Register <= Register.R15D) { Debug.Assert(InstrOpInfo.TEST_RegisterBits == 8); info.Op1Register = (byte)((Register)info.Op1Register - Register.EAX + Register.AX); } }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { Debug.Assert(instr.OpCount == 1, "Instruction is fixed, remove this class"); info = new InstrOpInfo(mnemonic, ref instr, flags); info.OpCount++; info.Op1Kind = InstrOpKind.Register; Debug.Assert(InstrOpInfo.TEST_RegisterBits == 8); info.Op1Register = (byte)reg; info.Op1Index = OpAccess_None; }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) => info = new InstrOpInfo(mnemonic, ref instr, flags);
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { info = new InstrOpInfo(mnemonic, ref instr, flags); Debug.Assert(instr.OpCount == 2); var kreg = instr.OpMask; if (kreg != Register.None) { info.OpCount++; info.Op2Kind = info.Op1Kind; info.Op2Register = info.Op1Register; info.Op2Index = 1; info.Op1Kind = InstrOpKind.Register; Debug.Assert(InstrOpInfo.TEST_RegisterBits == 8); info.Op1Register = (byte)kreg; info.Op1Index = OpAccess_Read; info.Flags |= InstrOpInfoFlags.IgnoreOpMask; } }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { int instrCodeSize = GetCodeSize(instr.CodeSize); if (instrCodeSize == 0 || (instrCodeSize & codeSize) != 0) { info = new InstrOpInfo(mnemonic, ref instr, InstrOpInfoFlags.None); } else { info = default; info.Mnemonic = "xchg"; info.OpCount = 2; info.Op0Kind = InstrOpKind.Register; info.Op1Kind = InstrOpKind.Register; Debug.Assert(InstrOpInfo.TEST_RegisterBits == 8); info.Op0Register = (byte)register; Debug.Assert(InstrOpInfo.TEST_RegisterBits == 8); info.Op1Register = (byte)register; if (instr.Op0Register == instr.Op1Register) { info.Op0Index = OpAccess_None; info.Op1Index = OpAccess_None; } else { info.Op0Index = OpAccess_ReadWrite; info.Op1Index = OpAccess_ReadWrite; } } }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { var flags = this.flags; if (instr.HasRepnePrefix) { flags |= InstrOpInfoFlags.BndPrefix; } info = new InstrOpInfo(mnemonic, ref instr, flags); }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { Debug.Assert(instr.OpCount == 3); var opKind = instr.Op0Kind; OpKind shortFormOpKind; switch (instr.CodeSize) { case CodeSize.Unknown: shortFormOpKind = opKind; break; case CodeSize.Code16: shortFormOpKind = OpKind.MemorySegDI; break; case CodeSize.Code32: shortFormOpKind = OpKind.MemorySegEDI; break; case CodeSize.Code64: shortFormOpKind = OpKind.MemorySegRDI; break; default: throw new InvalidOperationException(); } var flags = this.flags; if (opKind != shortFormOpKind) { if (opKind == OpKind.MemorySegDI) { flags |= InstrOpInfoFlags.AddrSize16; } else if (opKind == OpKind.MemorySegEDI) { flags |= InstrOpInfoFlags.AddrSize32; } else if (opKind == OpKind.MemorySegRDI) { flags |= InstrOpInfoFlags.AddrSize64; } } info = default; info.Flags = flags; info.Mnemonic = mnemonic; info.OpCount = 2; info.Op0Kind = (InstrOpKind)instr.Op1Kind; info.Op0Index = 1; Debug.Assert(InstrOpInfo.TEST_RegisterBits == 8); info.Op0Register = (byte)instr.Op1Register; info.Op1Kind = (InstrOpKind)instr.Op2Kind; info.Op1Index = 2; Debug.Assert(InstrOpInfo.TEST_RegisterBits == 8); info.Op1Register = (byte)instr.Op2Register; var segReg = instr.SegmentPrefix; if (segReg != Register.None) { info.OpCount = 3; info.Op2Kind = InstrOpKind.Register; Debug.Assert(InstrOpInfo.TEST_RegisterBits == 8); info.Op2Register = (byte)segReg; info.Op2Index = OpAccess_Read; } }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { const InstrOpInfoFlags flags = 0; if (options.UsePseudoOps && (instr.Op0Register == Register.ST1 || instr.Op1Register == Register.ST1)) { info = default; info.Mnemonic = mnemonic; } else { info = new InstrOpInfo(mnemonic, ref instr, flags); Debug.Assert(info.Op1Register == (int)Register.ST0); Debug.Assert(InstrOpInfo.TEST_RegisterBits == 8); info.Op1Register = (byte)Registers.Register_ST; } }
public override void GetOpInfo(MasmFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { var flags = InstrOpInfoFlags.None; string mnemonic; if (instr.CodeSize == codeSize || instr.CodeSize == CodeSize.Unknown) { mnemonic = this.mnemonic; } else { mnemonic = mnemonic2; } if (!forceNoMemSize) { flags |= InstrOpInfoFlags.ShowNoMemSize_ForceSize; } info = new InstrOpInfo(mnemonic, ref instr, flags); }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { info = new InstrOpInfo(mnemonic, ref instr, flags); int imm = instr.Immediate8; if (options.UsePseudoOps && (uint)imm < (uint)pseudo_ops.Length) { info.Mnemonic = pseudo_ops[imm]; RemoveLastOp(ref info); } }
public override void GetOpInfo(IntelFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { info = new InstrOpInfo(mnemonic, ref instr, flags); Debug.Assert(info.Op1Register == (int)Register.ST0); Debug.Assert(InstrOpInfo.TEST_RegisterBits == 8); info.Op1Register = (byte)Registers.Register_ST; }
public override void GetOpInfo(MasmFormatterOptions options, ref Instruction instr, out InstrOpInfo info) { info = new InstrOpInfo(mnemonic, ref instr, InstrOpInfoFlags.None); if (options.UsePseudoOps) { int index; int imm = instr.Immediate8; if (imm == 0) { index = 0; } else if (imm == 1) { index = 1; } else if (imm == 0x10) { index = 2; } else if (imm == 0x11) { index = 3; } else { index = -1; } if (index >= 0) { info.Mnemonic = pseudo_ops[index]; info.OpCount--; } } }