private void EmitBranch(ConditionOperand cOp, Address dst)
{
m.Branch(
GenerateTestExpression(cOp, false),
dst,
InstrClass.ConditionalTransfer);
}
private void RewriteBranch(ConditionCode cc, FlagGroupStorage flags)
{
var grf = binder.EnsureFlagGroup(flags);
var target = (Address)RewriteOp(0);
m.Branch(m.Test(cc, grf), target, InstrClass.ConditionalTransfer);
}
private void RewriteBranch(ConditionCode cc, FlagM grfM)
{
var grf = binder.EnsureFlagGroup(arch.GetFlagGroup(arch.sreg, (uint)grfM));
var target = (Address)RewriteOp(0);
m.Branch(m.Test(cc, grf), target, InstrClass.ConditionalTransfer);
}
private void RewriteBeqz(MipsInstruction instr)
{
var reg = binder.EnsureRegister(((RegisterOperand)instr.Operands[0]).Register);
var dst = ((AddressOperand)instr.Operands[1]).Address;
m.Branch(m.Eq0(reg), dst); // No jump delay slot
}
private void RewriteBf()
{
var cond = RewriteSrc(instr.Operands[0]);
var target = (Address)RewriteSrc(instr.Operands[1]);
m.Branch(m.Not(cond), target, InstrClass.ConditionalTransfer);
}
private void EmitBranch(ConditionOperand cOp, ImmediateOperand dst)
{
emitter.Branch(
GenerateTestExpression(cOp, false),
Address.Ptr16(dst.Value.ToUInt16()),
RtlClass.Transfer);
}
private void RewriteCjne()
{
iclass = InstrClass.ConditionalTransfer;
var a = OpSrc(instr.Operands[0]);
var b = OpSrc(instr.Operands[1]);
var addr = ((AddressOperand)instr.Operands[2]).Address;
m.Branch(m.Ne(a, b), addr, iclass);
}
private void EmitBranch(ConditionOperand cOp, Address dst)
{
rtlc.Class = RtlClass.ConditionalTransfer;
emitter.Branch(
GenerateTestExpression(cOp, false),
dst,
RtlClass.ConditionalTransfer);
}
private void RewriteBranch(ConditionCode cc, FlagM grfM)
{
rtlc.Class = RtlClass.ConditionalTransfer;
var grf = frame.EnsureFlagGroup(arch.GetFlagGroup((uint)grfM));
var target = (Address)RewriteOp(0);
m.Branch(m.Test(cc, grf), target, RtlClass.ConditionalTransfer);
}
private void RewriteCjne()
{
rtlc = InstrClass.ConditionalTransfer;
var a = OpSrc(instr.Operand1);
var b = OpSrc(instr.Operand2);
var addr = ((AddressOperand)instr.Operand3).Address;
m.Branch(m.Ne(a, b), addr, rtlc);
}
private void RewriteBtj(Func <Expression, Expression> fn)
{
this.iclass = InstrClass.ConditionalTransfer;
var opLeft = Operand(instr.Operands[1]);
var opRight = Operand(instr.Operands[0]);
NZ0(m.And(opLeft, fn(opRight)));
var z = binder.EnsureFlagGroup(arch.GetFlagGroup(arch.st, (uint)FlagM.ZF));
m.Branch(
m.Test(ConditionCode.NE, z),
((AddressOperand)instr.Operands[2]).Address,
InstrClass.ConditionalTransfer);
}
protected void ArithCondSkip(Expression dst, Expression src, Expression cond, FSRIndexedMode indMode, Expression memPtr)
{
iclass = InstrClass.ConditionalTransfer;
switch (indMode)
{
case FSRIndexedMode.None:
m.Assign(dst, src);
m.Branch(cond, SkipToAddr(), iclass);
break;
case FSRIndexedMode.INDF:
case FSRIndexedMode.PLUSW:
m.Assign(dst, src);
m.Branch(cond, SkipToAddr(), iclass);
break;
case FSRIndexedMode.POSTDEC:
m.Assign(dst, src);
m.BranchInMiddleOfInstruction(cond, SkipToAddr(), iclass);
m.Assign(memPtr, m.ISub(memPtr, 1));
break;
case FSRIndexedMode.POSTINC:
m.Assign(dst, src);
m.BranchInMiddleOfInstruction(cond, SkipToAddr(), iclass);
m.Assign(memPtr, m.IAdd(memPtr, 1));
break;
case FSRIndexedMode.PREINC:
m.Assign(memPtr, m.IAdd(memPtr, 1));
m.Assign(dst, src);
m.Branch(cond, SkipToAddr(), iclass);
break;
}
}
private void RewriteBtj(Func <Expression, Expression> fn)
{
this.rtlc = RtlClass.ConditionalTransfer;
var opLeft = Operand(instr.op2);
var opRight = Operand(instr.op1);
NZ0(m.And(opLeft, fn(opRight)));
var z = binder.EnsureFlagGroup(arch.GetFlagGroup((uint)FlagM.ZF));
m.Branch(
m.Test(ConditionCode.NE, z),
((AddressOperand)instr.op3).Address,
RtlClass.ConditionalTransfer);
}
private void RewriteIf()
{
var expr = ParseExpr();
if (expr == null)
{
SyntaxError();
}
if (PeekAndDiscard((byte)Token.THEN))
{
if (!EatSpaces())
{
SyntaxError();
}
byte b = line[i];
int lineNumber;
if (IsDigit(b))
{
if (!GetInteger(out lineNumber))
{
SyntaxError();
}
cluster.Class = RtlClass.ConditionalTransfer;
emitter.Branch(expr, Address.Ptr16((ushort)lineNumber), RtlClass.ConditionalTransfer);
return;
}
var cl = cluster;
var em = emitter;
cluster = new RtlInstructionCluster(cl.Address, 1);
emitter = new RtlEmitter(cluster.Instructions);
ParseStatement();
em.If(expr, cluster.Instructions.Last());
cluster = cl;
emitter = em;
return;
}
else if (PeekAndDiscard((byte)Token.GOTO))
{
int lineNumber;
if (!GetInteger(out lineNumber))
{
SyntaxError();
}
cluster.Class = RtlClass.ConditionalTransfer;
emitter.Branch(expr, Address.Ptr16((ushort)lineNumber), RtlClass.ConditionalTransfer);
return;
}
throw new NotImplementedException();
}
private void RewriteIf()
{
var expr = ParseExpr();
if (expr == null)
{
SyntaxError();
}
if (PeekAndDiscard((byte)Token.THEN))
{
if (!EatSpaces())
{
SyntaxError();
}
byte b = line[i];
int lineNumber;
if (IsDigit(b))
{
if (!GetInteger(out lineNumber))
{
SyntaxError();
}
rtlc = InstrClass.ConditionalTransfer;
m.Branch(expr, Address.Ptr16((ushort)lineNumber), InstrClass.ConditionalTransfer);
return;
}
var cl = rtlInstructions;
var em = m;
rtlInstructions = new List <RtlInstruction>();
m = new RtlEmitter(rtlInstructions);
ParseStatement();
em.If(expr, rtlInstructions.Last());
rtlInstructions = cl;
m = em;
return;
}
else if (PeekAndDiscard((byte)Token.GOTO))
{
int lineNumber;
if (!GetInteger(out lineNumber))
{
SyntaxError();
}
rtlc = InstrClass.ConditionalTransfer;
m.Branch(expr, Address.Ptr16((ushort)lineNumber), InstrClass.ConditionalTransfer);
return;
}
throw new NotImplementedException();
}
private void RewriteJmpa()
{
var target = (Address)Src(1);
var c = ((ConditionalOperand)instr.Operands[0]).CondCode;
if (c == CondCode.cc_UC)
{
m.Goto(target);
}
else
{
var condition = TestFromCondition(c);
m.Branch(condition, target);
}
}
private void RewriteB(bool link)
{
Address addr = ((AddressOperand)instr.Dst).Address;
if (link)
{
if (instr.Cond == Condition.al)
{
emitter.Call(addr, 0);
}
else
{
emitter.If(TestCond(instr.Cond), new RtlCall(addr, 0, RtlClass.Transfer));
}
}
else
{
if (instr.Cond == Condition.al)
{
emitter.Goto(addr);
}
else
{
emitter.Branch(TestCond(instr.Cond), addr, RtlClass.ConditionalTransfer);
}
}
}
private void RewriteB(bool link)
{
Address addr = Address.Ptr32((uint)Dst.ImmediateValue.Value);
if (link)
{
ric.Class = RtlClass.Transfer;
if (instr.ArchitectureDetail.CodeCondition == ArmCodeCondition.AL)
{
emitter.Call(addr, 0);
}
else
{
emitter.If(TestCond(instr.ArchitectureDetail.CodeCondition), new RtlCall(addr, 0, RtlClass.Transfer));
}
}
else
{
if (instr.ArchitectureDetail.CodeCondition == ArmCodeCondition.AL)
{
ric.Class = RtlClass.Transfer;
emitter.Goto(addr);
}
else
{
ric.Class = RtlClass.ConditionalTransfer;
emitter.Branch(TestCond(instr.ArchitectureDetail.CodeCondition), addr, RtlClass.ConditionalTransfer);
}
}
}
private void RewriteBranch(ConditionCode cc, FlagM flags)
{
rtlc = InstrClass.ConditionalTransfer;
var grf = binder.EnsureFlagGroup(arch.GetFlagGroup((uint)flags));
m.Branch(m.Test(cc, grf), ((AddressOperand)instr.op1).Address, InstrClass.ConditionalTransfer);
}
private bool MaybeConditionalJump(
InstrClass iclass,
Address addrTaken,
Func <Expression, Expression, Expression> rewriteCondition,
bool invert,
Expression left,
Expression?right = null)
{
if (instr.Condition == null ||
instr.Condition.Type == ConditionType.Never ||
instr.Condition.Type == ConditionType.Never64)
{
return(false);
}
right = right ?? Constant.Word(left.DataType.BitSize, 0);
Expression e = rewriteCondition(left, right);
if (e is Constant c)
{
if (!c.IsZero)
{
m.Goto(addrTaken);
return(true);
}
}
if (invert)
{
e = e.Invert();
}
m.Branch(e, addrTaken, iclass);
return(true);
}
private void RewriteBranch(ConditionCode cc, FlagM flags)
{
iclass = InstrClass.ConditionalTransfer;
var grf = binder.EnsureFlagGroup(arch.GetFlagGroup(Registers.sr, (uint)flags));
m.Branch(m.Test(cc, grf), ((AddressOperand)instr.Operands[0]).Address, InstrClass.ConditionalTransfer);
}
private void RewriteBranch(Func <Expression, Expression, Expression> fn)
{
var src1 = Rewrite(instr.Operands[0]);
var src2 = Rewrite(instr.Operands[1]);
var dst = ((AddressOperand)instr.Operands[2]).Address;
m.Branch(fn(src1, src2), dst);
}
private void Branch(ConditionCode cc, FlagM flags)
{
var f = FlagGroupStorage(flags);
emitter.Branch(
emitter.Test(cc, f),
Address.Ptr16(instrCur.Operand.Offset.ToUInt16()),
RtlClass.ConditionalTransfer);
}
private void Branch(ConditionCode cc, FlagM flags)
{
var f = FlagGroupStorage(flags);
m.Branch(
m.Test(cc, f),
Address.Ptr16(((Operand)instrCur.Operands[0]).Offset.ToUInt16()),
rtlc);
}
private void RewriteBranch(bool v)
{
Expression f = binder.EnsureFlagGroup(Registers.F);
if (v)
{
f = m.Not(f);
}
var target = (AddressOperand)instrCur.Operands[0];
m.Branch(f, target.Address, instrCur.InstructionClass);
}
private void RewriteBranch()
{
var addr = ((AddressOperand)instr.Operands[0]).Address;
if (instr.Condition == Avr32Condition.al)
{
m.Goto(addr);
}
else
{
m.Branch(Condition(), addr);
}
}
private void RewriteBranch(bool takenOnTset, bool delaySlot)
{
this.iclass = delaySlot
? InstrClass.ConditionalTransfer | InstrClass.Delay
: InstrClass.ConditionalTransfer;
Expression cond = binder.EnsureFlagGroup(Registers.T);
var addr = ((AddressOperand)instr.Operands[0]).Address;
if (!takenOnTset)
{
cond = m.Not(cond);
}
m.Branch(cond, addr, this.iclass);
}
private void RewriteBranch0(MipsInstruction instr, BinaryOperator condOp, bool link)
{
if (!link)
{
var reg = RewriteOperand(instr.op1);
var addr = (Address)RewriteOperand(instr.op2);
var cond = new BinaryExpression(condOp, PrimitiveType.Bool, reg, Constant.Zero(reg.DataType));
emitter.Branch(cond, addr, RtlClass.ConditionalTransfer | RtlClass.Delay);
}
else
{
throw new NotImplementedException("Linked branches not implemented yet.");
}
}
private void RewriteB(bool link)
{
Expression dst;
if (Dst.Type == ArmInstructionOperandType.Immediate)
{
dst = Address.Ptr32((uint)Dst.ImmediateValue.Value);
}
else
{
dst = Operand(Dst);
}
if (link)
{
rtlc = RtlClass.Transfer | RtlClass.Call;
if (instr.ArchitectureDetail.CodeCondition != ArmCodeCondition.AL)
{
m.BranchInMiddleOfInstruction(
TestCond(instr.ArchitectureDetail.CodeCondition).Invert(),
Address.Ptr32((uint)(instr.Address + instr.Bytes.Length)),
RtlClass.ConditionalTransfer);
}
m.Call(dst, 0);
}
else
{
if (instr.ArchitectureDetail.CodeCondition == ArmCodeCondition.AL)
{
rtlc = RtlClass.Transfer;
m.Goto(dst);
}
else
{
rtlc = RtlClass.ConditionalTransfer;
var addr = dst as Address;
if (addr != null)
{
m.Branch(TestCond(instr.ArchitectureDetail.CodeCondition), addr, RtlClass.ConditionalTransfer);
}
else
{
m.BranchInMiddleOfInstruction(
TestCond(instr.ArchitectureDetail.CodeCondition).Invert(),
Address.Ptr32((uint)(instr.Address + instr.Bytes.Length)),
RtlClass.ConditionalTransfer);
m.Goto(dst, RtlClass.Transfer);
}
}
}
}
private void RewriteBranch(bool takenOnTset, bool delaySlot)
{
rtlc = delaySlot
? RtlClass.ConditionalTransfer | RtlClass.Delay
: RtlClass.ConditionalTransfer;
Expression cond = binder.EnsureFlagGroup(Registers.T);
var addr = ((AddressOperand)instr.op1).Address;
if (!takenOnTset)
{
cond = m.Not(cond);
}
m.Branch(cond, addr, rtlc);
}
