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