private Expression RewriteCondition(ConditionOperand c)
{
switch (c.Code)
{
case CondCode.F: return(Constant.False());
case CondCode.LT: return(m.Test(ConditionCode.LT, binder.EnsureFlagGroup(arch.GetFlagGroup("SV"))));
case CondCode.LE: return(m.Test(ConditionCode.LE, binder.EnsureFlagGroup(arch.GetFlagGroup("SZV"))));
case CondCode.ULE: return(m.Test(ConditionCode.ULE, binder.EnsureFlagGroup(arch.GetFlagGroup("ZC"))));
case CondCode.OV: return(m.Test(ConditionCode.OV, binder.EnsureFlagGroup(arch.GetFlagGroup("V"))));
case CondCode.M: return(m.Test(ConditionCode.LT, binder.EnsureFlagGroup(arch.GetFlagGroup("S"))));
case CondCode.Z: return(m.Test(ConditionCode.EQ, binder.EnsureFlagGroup(arch.GetFlagGroup("Z"))));
case CondCode.C: return(m.Test(ConditionCode.ULT, binder.EnsureFlagGroup(arch.GetFlagGroup("C"))));
case CondCode.T: return(Constant.True());
case CondCode.GE: return(m.Test(ConditionCode.GE, binder.EnsureFlagGroup(arch.GetFlagGroup("SV"))));
case CondCode.GT: return(m.Test(ConditionCode.GT, binder.EnsureFlagGroup(arch.GetFlagGroup("SZV"))));
case CondCode.UGT: return(m.Test(ConditionCode.UGT, binder.EnsureFlagGroup(arch.GetFlagGroup("ZC"))));
case CondCode.NV: return(m.Test(ConditionCode.NO, binder.EnsureFlagGroup(arch.GetFlagGroup("V"))));
case CondCode.P: return(m.Test(ConditionCode.GE, binder.EnsureFlagGroup(arch.GetFlagGroup("S"))));
case CondCode.NZ: return(m.Test(ConditionCode.NE, binder.EnsureFlagGroup(arch.GetFlagGroup("Z"))));
case CondCode.NC: return(m.Test(ConditionCode.UGE, binder.EnsureFlagGroup(arch.GetFlagGroup("C"))));
}
throw new ArgumentException();
}
private Tlcs90Instruction DecodeOperands(byte b, Opcode opcode, string format)
{
int op = 0;
var ops = new MachineOperand[2];
Constant c;
PrimitiveType size;
for (int i = 0; i < format.Length; ++i)
{
switch (format[i])
{
case ',':
continue;
case 'a':
this.dataWidth = PrimitiveType.Byte;
ops[op] = new RegisterOperand(Registers.a);
break;
case '@':
this.dataWidth = PrimitiveType.Word16;
ops[op] = new RegisterOperand(Registers.af_);
break;
case 'A':
this.dataWidth = PrimitiveType.Word16;
ops[op] = new RegisterOperand(Registers.af);
break;
case 'B':
this.dataWidth = PrimitiveType.Word16;
ops[op] = new RegisterOperand(Registers.bc);
break;
case 'c':
ops[op] = new ConditionOperand((CondCode)(b & 0xF));
break;
case 'D':
this.dataWidth = PrimitiveType.Word16;
ops[op] = new RegisterOperand(Registers.de);
break;
case 'I':
// Immediate value
this.dataWidth = GetSize(format[++i]);
if (!rdr.TryReadLe(this.dataWidth, out c))
{
return(null);
}
ops[op] = new ImmediateOperand(c);
break;
case 'i': // immediate value from opcode bits
ops[op] = ImmediateOperand.Byte((byte)(b & 0x7));
break;
case 'g':
Debug.Assert(byteReg != null);
ops[op] = this.byteReg;
break;
case 'G':
Debug.Assert(wordReg != null);
ops[op] = this.wordReg;
break;
case 'H':
ops[op] = new RegisterOperand(Registers.hl);
break;
case 'J':
// Absolute jump.
size = GetSize(format[++i]);
if (!rdr.TryReadLe(size, out c))
{
return(null);
}
ops[op] = AddressOperand.Ptr16(c.ToUInt16());
break;
case 'j':
// relative jump
size = GetSize(format[++i]);
Address dest;
if (size.Size == 1)
{
if (!rdr.TryReadByte(out b))
{
return(null);
}
dest = rdr.Address + (sbyte)b;
}
else
{
if (!rdr.TryReadLeInt16(out short off))
{
return(null);
}
dest = rdr.Address + off;
}
ops[op] = AddressOperand.Create(dest);
break;
case 'M':
this.dataWidth = GetSize(format[++i]);
ushort absAddr;
if (!rdr.TryReadLeUInt16(out absAddr))
{
return(null);
}
ops[op] = MemoryOperand.Absolute(this.dataWidth, absAddr);
break;
case 'm':
size = GetSize(format[++i]);
byte pageAddr;
if (!rdr.TryReadByte(out pageAddr))
{
return(null);
}
ops[op] = MemoryOperand.Absolute(size, (ushort)(0xFF00 | pageAddr));
break;
case 'S':
this.dataWidth = PrimitiveType.Word16;
ops[op] = new RegisterOperand(Registers.sp);
break;
case 'X':
this.dataWidth = PrimitiveType.Word16;
ops[op] = new RegisterOperand(Registers.ix);
break;
case 'Y':
this.dataWidth = PrimitiveType.Word16;
ops[op] = new RegisterOperand(Registers.iy);
break;
case 'r':
// Register encoded in low 3 bits of b.
ops[op] = new RegisterOperand(Registers.byteRegs[b & 7]);
dataWidth = PrimitiveType.Byte;
break;
case 'x':
this.backPatchOp = op;
break;
default: throw new NotImplementedException(string.Format("Encoding '{0}' not implemented yet.", format[i]));
}
++op;
}
return(new Tlcs90Instruction
{
Opcode = opcode,
op1 = op > 0 ? ops[0] : null,
op2 = op > 1 ? ops[1] : null,
});
}
public ConditionalJumpCommand(string sourceText, ConditionOperand conditionOperand, Operand addressOperand) : base(sourceText, conditionOperand, addressOperand)
{
}
/// <exception cref="OverflowException"><paramref name="operand" /> Enum Names should be equivalent</exception>
/// <exception cref="ArgumentNullException"><paramref name="operand" /> or <paramref name="operand" /> is null. </exception>
/// <exception cref="ArgumentException">
/// <paramref name="operand" /> is not an <see cref="ExpressionType" />.-or- <paramref name="operand" />
/// <para />
/// is either an empty string or only contains white space.-or- <paramref name="operand" /> is a name, but not one of
/// the named constants defined for the enumeration.
/// </exception>
public static ExpressionType GetByConditionOperand(ConditionOperand operand)
{
var result = (ExpressionType)Enum.Parse(typeof(ExpressionType), operand.ToString());
return(result);
}
public ConditionPart(string op, ConditionOperand type, ConditionOperator oper = ConditionOperator.EQUALS)
{
Operand = op;
OperandType = type;
OperatorType = oper;
}
public ConditionalRelativeJumpCommand(string sourceText, ConditionOperand conditionOperand, Operand destinationOperand) : base(sourceText, conditionOperand, destinationOperand)
{
}
