public override void GetOpInfo(MasmFormatterOptions options, ref Instruction instr, out InstrOpInfo info)
{
int instrCodeSize = GetCodeSize(instr.CodeSize);
var flags = instrCodeSize == 0 || (instrCodeSize & codeSize) != 0 ? InstrOpInfoFlags.MemSize_Nothing : InstrOpInfoFlags.MemSize_Normal | InstrOpInfoFlags.ShowNoMemSize_ForceSize;
info = new InstrOpInfo(mnemonic, ref instr, flags);
}
public static MasmFormatterOptions ToMasm(this IMasmDisassemblySettings settings)
{
var options = new MasmFormatterOptions();
CopyBase(options, settings);
return(options);
}
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--;
}
}
}
public override void GetOpInfo(MasmFormatterOptions 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, 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;
}
}
public override void GetOpInfo(MasmFormatterOptions options, ref Instruction instr, out InstrOpInfo info)
{
var flags = this.flags;
if (instr.HasPrefixRepne)
{
flags |= InstrOpInfoFlags.BndPrefix;
}
info = new InstrOpInfo(mnemonic, ref instr, flags);
}
public override void GetOpInfo(MasmFormatterOptions options, ref Instruction instr, out InstrOpInfo info)
{
var flags = InstrOpInfoFlags.None;
if (instr.CodeSize != codeSize && instr.CodeSize != CodeSize.Unknown)
{
flags |= InstrOpInfoFlags.ShowNoMemSize_ForceSize;
}
info = new InstrOpInfo(mnemonic, ref instr, flags);
}
public override void GetOpInfo(MasmFormatterOptions 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.OpCount--;
info.Mnemonic = pseudo_ops[imm];
}
}
public override void GetOpInfo(MasmFormatterOptions options, ref Instruction instr, out InstrOpInfo info)
{
var flags = InstrOpInfoFlags.None;
if (instr.HasPrefixRepne)
{
flags |= InstrOpInfoFlags.BndPrefix;
}
var mnemonic = mnemonics[(int)instr.CodeSize];
info = new InstrOpInfo(mnemonic, ref instr, flags);
}
void Verify_default_formatter_options()
{
var options = new MasmFormatterOptions();
Assert.False(options.UpperCasePrefixes);
Assert.False(options.UpperCaseMnemonics);
Assert.False(options.UpperCaseRegisters);
Assert.False(options.UpperCaseKeywords);
Assert.False(options.UpperCaseDecorators);
Assert.False(options.UpperCaseAll);
Assert.Equal(0, options.FirstOperandCharIndex);
Assert.Equal(0, options.TabSize);
Assert.False(options.SpaceAfterOperandSeparator);
Assert.False(options.SpaceAfterMemoryBracket);
Assert.False(options.SpaceBetweenMemoryAddOperators);
Assert.False(options.SpaceBetweenMemoryMulOperators);
Assert.False(options.ScaleBeforeIndex);
Assert.False(options.AlwaysShowScale);
Assert.False(options.AlwaysShowSegmentRegister);
Assert.False(options.ShowZeroDisplacements);
Assert.Null(options.HexPrefix);
Assert.Equal("h", options.HexSuffix);
Assert.Equal(4, options.HexDigitGroupSize);
Assert.Null(options.DecimalPrefix);
Assert.Null(options.DecimalSuffix);
Assert.Equal(3, options.DecimalDigitGroupSize);
Assert.Null(options.OctalPrefix);
Assert.Equal("o", options.OctalSuffix);
Assert.Equal(4, options.OctalDigitGroupSize);
Assert.Null(options.BinaryPrefix);
Assert.Equal("b", options.BinarySuffix);
Assert.Equal(4, options.BinaryDigitGroupSize);
Assert.Null(options.DigitSeparator);
Assert.False(options.LeadingZeroes);
Assert.True(options.UpperCaseHex);
Assert.True(options.SmallHexNumbersInDecimal);
Assert.True(options.AddLeadingZeroToHexNumbers);
Assert.Equal(NumberBase.Hexadecimal, options.NumberBase);
Assert.True(options.BranchLeadingZeroes);
Assert.False(options.SignedImmediateOperands);
Assert.True(options.SignedMemoryDisplacements);
Assert.False(options.SignExtendMemoryDisplacements);
Assert.Equal(MemorySizeOptions.Default, options.MemorySizeOptions);
Assert.False(options.RipRelativeAddresses);
Assert.True(options.ShowBranchSize);
Assert.True(options.UsePseudoOps);
Assert.False(options.ShowSymbolAddress);
Assert.True(options.AddDsPrefix32);
Assert.True(options.SymbolDisplInBrackets);
Assert.True(options.DisplInBrackets);
}
public override void GetOpInfo(MasmFormatterOptions 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)
{
info.Op0Register = (byte)((Register)info.Op0Register - Register.EAX + Register.AX);
}
if (Register.EAX <= (Register)info.Op1Register && (Register)info.Op1Register <= Register.R15D)
{
info.Op1Register = (byte)((Register)info.Op1Register - Register.EAX + Register.AX);
}
}
public override void GetOpInfo(MasmFormatterOptions options, ref Instruction instr, out InstrOpInfo info)
{
string mnemonic;
if (instr.CodeSize == codeSize)
{
mnemonic = mnemonics[(int)CodeSize.Unknown];
}
else
{
mnemonic = mnemonics[(int)codeSize];
}
info = new InstrOpInfo(mnemonic, ref instr, InstrOpInfoFlags.None);
}
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(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)
{
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)
{
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)
{
OpKind shortFormOpKind;
switch (instr.CodeSize)
{
case CodeSize.Unknown:
shortFormOpKind = instr.Op1Kind;
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.Op1Kind == shortFormOpKind && instr.PrefixSegment == Register.None;
if (!shortForm)
{
info = default;
info.Flags = flags;
info.Mnemonic = mnemonic_args;
info.OpCount = 1;
info.Op0Kind = (InstrOpKind)instr.Op1Kind;
}
else
{
info = default;
info.Flags = flags;
info.Mnemonic = mnemonic_no_args;
}
}
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(MasmFormatterOptions 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;
}
}
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 void TestOptions()
{
var options = new MasmFormatterOptions();
TestOptionsBase(options);
}
public override void GetOpInfo(MasmFormatterOptions options, ref Instruction instr, out InstrOpInfo info) => info = new InstrOpInfo(mnemonic, ref instr, flags);
public override void GetOpInfo(MasmFormatterOptions options, ref Instruction instr, out InstrOpInfo info)
{
var mnemonic = mnemonics[(int)instr.CodeSize];
info = new InstrOpInfo(mnemonic, ref instr, InstrOpInfoFlags.None);
}
