private void ParseData(List <SectionEntry> sectionEntries, OperandSize size, string operandsString)
{
// TODO: handle strings with commas
var result = DatasParser(size).Run(operandsString);
switch (result)
{
case Parser <char, IEnumerable <Data> > .Success success:
foreach (var value in success.Value)
{
sectionEntries.Add(value);
}
break;
case Parser <char, IEnumerable <Data> > .Failure failure:
throw new InvalidOperationException(failure.FailureText);
}
//var operands = operandsString.Split(',').Select(x => x.Trim());
//foreach (var operand in operands)
//{
// sectionEntries.Add(ParseDataOperand(size, operand));
//}
}
private Parser <char, IEnumerable <Data> > DatasParser(OperandSize size)
{
var doubleQuotedString = Satisfy(c => c != '"')
.Many()
.ToStringParser()
.Between(Char('"'), Char('"'))
.Select(str => new Data(str));
var singleQuotedString = Satisfy(c => c != '\'')
.Many()
.ToStringParser()
.Between(Char('\''), Char('\''))
.Select(str => new Data(str));
var hexChars =
from _ in String("0x")
from hex in AnyOf("0123456789abcdefABCDEF").OneOrMore().ToStringParser()
select ParseHexAsData(size, hex);
var intChars =
from intValue in IntParser
select ParseIntAsData(size, intValue.ToString()); // HACK: this could be improved
var dataParser = doubleQuotedString.OrElse(singleQuotedString).OrElse(hexChars).OrElse(intChars);
var sep = Char(',').TakeLeft(SkipWhitespaceChar.ZeroOrMore());
return(dataParser.SepBy1(sep));
}
protected EncoderOpCodeHandler(Code code, uint opCode, int groupIndex, Encodable encodable, OperandSize opSize, AddressSize addrSize, TryConvertToDisp8N tryConvertToDisp8N, Op[] operands)
{
TEST_Code = code;
OpCode = opCode;
GroupIndex = groupIndex;
Encodable = encodable;
OpSize = opSize;
AddrSize = addrSize;
TryConvertToDisp8N = tryConvertToDisp8N;
Operands = operands;
}
protected OpCodeHandler(uint opCode, int groupIndex, OpCodeHandlerFlags flags, Encodable encodable, OperandSize opSize, AddressSize addrSize, TryConvertToDisp8N?tryConvertToDisp8N, Op[] operands)
{
OpCode = opCode;
GroupIndex = groupIndex;
Flags = flags;
Encodable = encodable;
OpSize = opSize;
AddrSize = addrSize;
TryConvertToDisp8N = tryConvertToDisp8N;
Operands = operands;
}
public LegacyOpCodeInfo(EnumValue code, MandatoryPrefix mandatoryPrefix, OpCodeTableKind table, uint opCode, int groupIndex, OperandSize operandSize, AddressSize addressSize, OpCodeFlags flags, LegacyOpKind[] opKinds)
{
Code = code;
MandatoryPrefix = mandatoryPrefix;
Table = table;
OpCode = opCode;
GroupIndex = groupIndex;
Flags = flags;
OperandSize = operandSize;
AddressSize = addressSize;
OpKinds = opKinds;
}
private static int GetOperandSizeMatchLevel(InstructionEncoding encoding, OperandSize size)
{
switch (encoding & InstructionEncoding.OperandSize_Mask)
{
case InstructionEncoding.OperandSize_Ignored: return 0;
case InstructionEncoding.OperandSize_16Or32Or64: return 1;
case InstructionEncoding.OperandSize_16Or32: return 2;
case InstructionEncoding.OperandSize_32Or64: return 2;
case InstructionEncoding.OperandSize_Fixed8: return 3;
case InstructionEncoding.OperandSize_Fixed16: return size == OperandSize.Word ? 3 : -1;
case InstructionEncoding.OperandSize_Fixed32: return size == OperandSize.Dword ? 3 : -1;
case InstructionEncoding.OperandSize_Fixed64: return size == OperandSize.Qword ? 3 : -1;
default: throw new ArgumentException();
}
}
public static int InBytes(this ImmediateSize size, OperandSize operandSize, AddressSize addressSize)
{
Contract.Requires(operandSize >= OperandSize.Word && operandSize <= OperandSize.Qword);
switch (size)
{
case ImmediateSize.Zero: return 0;
case ImmediateSize.Fixed8: return 1;
case ImmediateSize.Fixed16: return 2;
case ImmediateSize.Fixed32: return 4;
case ImmediateSize.Fixed64: return 8;
case ImmediateSize.Operand16Or32: return operandSize == OperandSize.Word ? 2 : 4;
case ImmediateSize.Operand16Or32Or64: return operandSize == OperandSize.Qword ? 8 : 4;
case ImmediateSize.Address16Or32: return addressSize == AddressSize._16 ? 2 : 4;
default: throw new ArgumentException(nameof(size));
}
}
private static Data ParseHexAsData(OperandSize size, string hexValue)
{
switch (size)
{
case OperandSize.Size8 when byte.TryParse(hexValue, NumberStyles.HexNumber, null, out var result):
return(new Data(result));
case OperandSize.Size16 when short.TryParse(hexValue, NumberStyles.HexNumber, null, out var result):
return(new Data(result));
case OperandSize.Size32 when int.TryParse(hexValue, NumberStyles.HexNumber, null, out var result):
return(new Data(result));
case OperandSize.Size64 when long.TryParse(hexValue, NumberStyles.HexNumber, null, out var result):
return(new Data(result));
case OperandSize.None:
default:
throw new InvalidOperationException("Unknown operand data value: " + hexValue);
}
}
//private static Data ParseDataOperand(OperandSize size, string operand)
//{
// if ((operand.StartsWith("'") && operand.EndsWith("'")) ||
// (operand.StartsWith("\"") && operand.EndsWith("\""))) // string
// {
// return new Data(operand.Substring(1, operand.Length - 2));
// }
// if (operand.StartsWith("0x")) //hex
// {
// var hexValue = operand.Substring(2);
// return ParseHexAsData(size, hexValue);
// }
// // assume int
// return ParseIntAsData(size, operand);
//}
private static Data ParseIntAsData(OperandSize size, string operand)
{
switch (size)
{
case OperandSize.Size8 when byte.TryParse(operand, out var result):
return(new Data(result));
case OperandSize.Size16 when short.TryParse(operand, out var result):
return(new Data(result));
case OperandSize.Size32 when int.TryParse(operand, out var result):
return(new Data(result));
case OperandSize.Size64 when long.TryParse(operand, out var result):
return(new Data(result));
case OperandSize.None:
default:
throw new InvalidOperationException("Unknown operand data value: " + operand);
}
}
public RegisterOperand(OperandType type, OperandSize size, int registerIndex = 0)
: base(type, size)
{
Index = registerIndex;
}
public static Opcode WithVectorSize(this Opcode opcode, OperandSize size)
{
Contract.Requires(size >= OperandSize._128 && size <= OperandSize._512);
opcode &= ~Opcode.VexL_Mask;
opcode |= (Opcode)((size - OperandSize._128) << (int)Opcode.VexL_0);
return opcode;
}
public Operand(OperandType type, OperandSize size, EncodingPosition eposition)
{
Type = type;
Size = size;
EncodingPosition = eposition;
}
private Operand(OperandType type, uint value, OperandSize size)
{
_type = type;
_value = value;
_size = size;
}
private Operand GetOperand(string operandString, OperandSize expectedSize = OperandSize.Unknown)
{
var operandHasParens = operandString.StartsWith("(") && operandString.EndsWith(")");
if (!operandHasParens)
{
if (expectedSize != OperandSize.SixteenBit)
{
if (Enum.GetNames(typeof(Register)).Contains(operandString.ToUpper()) && Enum.TryParse <Register>(operandString, true, out var register))
{
return(new RegisterOperand(register));
}
if (_hexParser.TryByteParse(operandString, out var immediateNumber))
{
return(new ImmediateOperand(immediateNumber));
}
}
if (expectedSize != OperandSize.EightBit)
{
if (Enum.GetNames(typeof(ExtendedRegister)).Contains(operandString.ToUpper()) && Enum.TryParse <ExtendedRegister>(operandString, true, out var extendedRegister))
{
return(new RegisterExtendedOperand(extendedRegister));
}
if (_hexParser.TryUShortParse(operandString, out var immediate16BitNumber))
{
return(new ImmediateExtendedOperand(immediate16BitNumber));
}
}
if (IsValidLabel(operandString))
{
return(new LabeledImmediateOperand(operandString));
}
if (new Regex(@"[\+\-\*\/]", RegexOptions.IgnoreCase).IsMatch(operandString))
{
return(new CalculatedImmediateOperand(operandString, _hexParser));
}
}
else
{
var operandWithoutParens = operandString.TrimStart('(').TrimEnd(')');
if (Enum.GetNames(typeof(ExtendedRegister)).Contains(operandWithoutParens.ToUpper()) && Enum.TryParse <ExtendedRegister>(operandWithoutParens, true, out var extendedRegister))
{
return(new IndirectRegisterOperand(extendedRegister));
}
if (Enum.GetNames(typeof(Register)).Contains(operandWithoutParens.ToUpper()) && Enum.TryParse <Register>(operandWithoutParens, true, out var register))
{
return(new IndirectShortRegOperand(register));
}
if (_hexParser.TryUShortParse(operandWithoutParens, out var memoryAddress))
{
return(new ExtendedAddressOperand(memoryAddress));
}
if (TryDisplacementParse(operandWithoutParens, out var displacementRegister, out var displacement))
{
return(new DisplacementOperand(displacementRegister, displacement));
}
if (IsValidLabel(operandWithoutParens))
{
return(new LabeledAddressOperand(operandWithoutParens));
}
if (_hexParser.TryByteParse(operandWithoutParens, out var immediateValue))
{
throw new Exception("need to start parsing in and out commands");
}
}
throw new Exception($"Invalid operand: {operandString}");
}
protected Operand(OperandType type = OperandType.GeneralRegister, OperandSize size = OperandSize.DWord)
{
Type = type;
Size = size;
}
public MemoryOperand(OperandSize size, Operand address)
: base(OperandType.Memory, size)
{
Address = address;
}
public static string GetOpSizeStr(OperandSize Size)
{
return System.Enum.GetName(typeof(OperandSize), Size).ToLower();
}
public OperandInfo(string operand)
{
operand=operand.ToLower();
string[] ss=operand.Split(' ');
if(ss.Length>2) throw new OptimizationException("Operand: More than two parts");
if(ss.Length==2) {
Qualifier=ss[0];
operand=ss[1];
} else { Qualifier=null; }
if(operand.IndexOf('*')!=-1) throw new OptimizationException("Operand: Haven't programmed '*' yet");
Operand=operand;
bool p=false;
if(operand.StartsWith("[")) {
p=true;
operand=operand.Replace("[","").Replace("]","");
}
if(operand.StartsWith("+0x")||operand.StartsWith("-0x")||operand.StartsWith("0x")) {
if(p) { OpType=OperandType.dMemory; } else { OpType=OperandType.Immediate; }
Offset=Program.HexParse(operand);
Register=null;
MultiPart=false;
} else {
if(p) { OpType=OperandType.rMemory; } else { OpType=OperandType.Register; }
ss=operand.Split(':');
if(ss.Length>2) throw new OptimizationException("Operand: Illegal operand");
if(ss.Length==2) {
operand=ss[1];
MultiPart=true;
} else { MultiPart=false; }
if(operand.IndexOf("+")!=-1) {
ss=operand.Split('+');
operand=ss[0];
if(!ss[1].StartsWith("0x")) throw new OptimizationException("Operand: Illegal offset");
Offset=Program.HexParse(ss[1]);
} else if(operand.IndexOf("-")!=-1) {
ss=operand.Split('-');
operand=ss[0];
if(!ss[1].StartsWith("0x")) throw new OptimizationException("Operand: Illegal offset");
Offset=-Program.HexParse(ss[1]);
} else { Offset=0; }
if(Array.IndexOf(Program.Registers,operand)==-1) throw new OptimizationException("Operand: unknown register");
Register=operand;
}
if(OpType==OperandType.Register) {
OpSize=OperandSize.dWord;
} else if(Qualifier!=null) {
switch(Qualifier) {
case ("qword"): OpSize=OperandSize.qWord; break;
case ("dword"): OpSize=OperandSize.dWord; break;
case ("word"): OpSize=OperandSize.Word; break;
case ("byte"): OpSize=OperandSize.Byte; break;
default: throw new OptimizationException("Operand: Unknown prefix");
}
} else {
OpSize=OperandSize.Unknown;
}
}
public ImmediateOperand(OperandSize size, long value)
: base(OperandType.Immediate, size)
{
Value = value;
}
public AddressOperand(OperandSize size, string label)
: base(OperandType.Address, size)
{
Label = label;
}
public static int GetImmediatesSizeInBytes(this InstructionEncoding encoding,
OperandSize operandSize, AddressSize addressSize)
{
Contract.Requires(operandSize >= OperandSize.Word && operandSize <= OperandSize.Qword);
return GetFirstImmediateSize(encoding).InBytes(operandSize, addressSize)
+ GetSecondImmediateSize(encoding).InBytes(operandSize, addressSize);
}
private OperandTypeDefinition(OperandType type, OperandSize size)
{
Type = type;
Size = size;
}
public static string GetOpSizeStr(OperandSize Size)
{
return(System.Enum.GetName(typeof(OperandSize), Size).ToLower());
}
public LegacyOpCodeInfo(EnumValue code, MandatoryPrefix mandatoryPrefix, OpCodeTableKind table, uint opCode, int groupIndex, OperandSize operandSize, AddressSize addressSize, OpCodeFlags flags, LegacyOpKind[] opKinds)
: this(code, mandatoryPrefix, table, opCode, groupIndex, -1, operandSize, addressSize, flags, opKinds)
{
}
public MemoryGetNode(AstNode index, OperandSize size)
{
Index = index;
Size = size;
}
private FixedOperandDefinition(string name, OperandSize size)
{
Name = name;
Size = size;
}
public OperandInfo(string operand)
{
operand = operand.ToLower();
string[] ss = operand.Split(' ');
if (ss.Length > 2)
{
throw new OptimizationException("Operand: More than two parts");
}
if (ss.Length == 2)
{
Qualifier = ss[0];
operand = ss[1];
}
else
{
Qualifier = null;
}
if (operand.IndexOf('*') != -1)
{
throw new OptimizationException("Operand: Haven't programmed '*' yet");
}
Operand = operand;
bool p = false;
if (operand.StartsWith("["))
{
p = true;
operand = operand.Replace("[", "").Replace("]", "");
}
if (operand.StartsWith("+0x") || operand.StartsWith("-0x") || operand.StartsWith("0x"))
{
if (p)
{
OpType = OperandType.dMemory;
}
else
{
OpType = OperandType.Immediate;
}
Offset = Program.HexParse(operand);
Register = null;
MultiPart = false;
}
else
{
if (p)
{
OpType = OperandType.rMemory;
}
else
{
OpType = OperandType.Register;
}
ss = operand.Split(':');
if (ss.Length > 2)
{
throw new OptimizationException("Operand: Illegal operand");
}
if (ss.Length == 2)
{
operand = ss[1];
MultiPart = true;
}
else
{
MultiPart = false;
}
if (operand.IndexOf("+") != -1)
{
ss = operand.Split('+');
operand = ss[0];
if (!ss[1].StartsWith("0x"))
{
throw new OptimizationException("Operand: Illegal offset");
}
Offset = Program.HexParse(ss[1]);
}
else if (operand.IndexOf("-") != -1)
{
ss = operand.Split('-');
operand = ss[0];
if (!ss[1].StartsWith("0x"))
{
throw new OptimizationException("Operand: Illegal offset");
}
Offset = -Program.HexParse(ss[1]);
}
else
{
Offset = 0;
}
if (Array.IndexOf(Program.Registers, operand) == -1)
{
throw new OptimizationException("Operand: unknown register");
}
Register = operand;
}
if (OpType == OperandType.Register)
{
OpSize = OperandSize.dWord;
}
else if (Qualifier != null)
{
switch (Qualifier)
{
case ("qword"): OpSize = OperandSize.qWord; break;
case ("dword"): OpSize = OperandSize.dWord; break;
case ("word"): OpSize = OperandSize.Word; break;
case ("byte"): OpSize = OperandSize.Byte; break;
default: throw new OptimizationException("Operand: Unknown prefix");
}
}
else
{
OpSize = OperandSize.Unknown;
}
}
