protected internal override void VisitBinaryOp(BinaryOp node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessBinOp(GetOpType(node.Op, node.Unsigned, node.Overflow ),stack);
AddTask(node.Next,stack);
}
private static Verifier.OpType GetOpType(BinaryOp.ArithOp op, bool un, bool ovf)
{
if(op == BinaryOp.ArithOp.SHL || op == BinaryOp.ArithOp.SHR)
return(Verifier.OpType.Shift);
if(op == BinaryOp.ArithOp.CEQ || op == BinaryOp.ArithOp.CLT || op == BinaryOp.ArithOp.CGT)
return(Verifier.OpType.Compare);
if(Verifier.IsFloatOperation(Converter.CodeFromBinaryOp(op), un, ovf))
return(Verifier.OpType.FloatOrInt);
return(Verifier.OpType.Int);
}
protected internal virtual void VisitBinaryOp(BinaryOp node, object data)
{
throw new NodeNotSupportedException(node);
}
protected override void VisitBinaryOp(BinaryOp upNode, object o)
{
State state = o as State;
BTValue val2 = state.Stack.Pop() as BTValue;
BTValue val1 = state.Stack.Pop() as BTValue;
if (val1.BTType == val2.BTType)
{
BTValue val3 = new PrimitiveBTValue(val1.BTType);
state.Stack.Push(val3);
Annotation.SetNodeBTType(upNode, val3.BTType);
}
else if (val1.BTType == BTType.Static)
throw new LiftException(val1);
else if (val2.BTType == BTType.Static)
throw new LiftException(val2);
else
throw new InternalException();
}
protected override void VisitBinaryOp(BinaryOp upNode, object o)
{
DepthContainer cnt = o as DepthContainer;
cnt.Depth += 1;
}
protected internal override void VisitBinaryOp(BinaryOp node, object data)
{
switch(node.Op)
{
case BinaryOp.ArithOp.ADD:
{
if(node.Overflow)
if(node.Unsigned)
generator.Emit(OpCodes.Add_Ovf_Un);
else
generator.Emit(OpCodes.Add_Ovf);
else
generator.Emit(OpCodes.Add);
} break;
case BinaryOp.ArithOp.AND:
{
generator.Emit(OpCodes.And);
} break;
case BinaryOp.ArithOp.CEQ:
{
if(node.Next is Branch && node.Next.PrevArray.Count == 1)
{
Branch br = node.Next as Branch;
generator.Emit(OpCodes.Beq, GetLabel(br.Alt));
AddTask(br.Alt,null);
AddTask(br.Next,null);
return;
}
generator.Emit(OpCodes.Ceq);
} break;
case BinaryOp.ArithOp.CGT:
{
if(node.Next is Branch && node.Next.PrevArray.Count == 1)
{
Branch br = node.Next as Branch;
if(node.Unsigned)
generator.Emit(OpCodes.Bgt_Un, GetLabel(br.Alt));
else
generator.Emit(OpCodes.Bgt, GetLabel(br.Alt));
AddTask(br.Alt,null);
AddTask(br.Next,null);
return;
}
if(node.Unsigned)
generator.Emit(OpCodes.Cgt_Un);
else
generator.Emit(OpCodes.Cgt);
} break;
case BinaryOp.ArithOp.CLT:
{
if(node.Next is Branch && node.Next.PrevArray.Count == 1)
{
Branch br = node.Next as Branch;
if(node.Unsigned)
generator.Emit(OpCodes.Blt_Un, GetLabel(br.Alt));
else
generator.Emit(OpCodes.Blt, GetLabel(br.Alt));
AddTask(br.Alt,null);
AddTask(br.Next,null);
return;
}
if(node.Unsigned)
generator.Emit(OpCodes.Clt_Un);
else
generator.Emit(OpCodes.Clt);
} break;
case BinaryOp.ArithOp.DIV:
{
if(node.Unsigned)
generator.Emit(OpCodes.Div_Un);
else
generator.Emit(OpCodes.Div);
} break;
case BinaryOp.ArithOp.MUL:
{
if(node.Overflow)
if(node.Unsigned)
generator.Emit(OpCodes.Mul_Ovf_Un);
else
generator.Emit(OpCodes.Mul_Ovf);
else
generator.Emit(OpCodes.Mul);
} break;
case BinaryOp.ArithOp.OR:
{
generator.Emit(OpCodes.Or);
} break;
case BinaryOp.ArithOp.REM:
{
if(node.Unsigned)
generator.Emit(OpCodes.Rem_Un);
else
generator.Emit(OpCodes.Rem);
} break;
case BinaryOp.ArithOp.SHL:
{
generator.Emit(OpCodes.Shl);
} break;
case BinaryOp.ArithOp.SHR:
{
generator.Emit(OpCodes.Shr);
} break;
case BinaryOp.ArithOp.SUB:
{
if(node.Overflow)
if(node.Unsigned)
generator.Emit(OpCodes.Sub_Ovf_Un);
else
generator.Emit(OpCodes.Sub_Ovf);
else
generator.Emit(OpCodes.Sub);
} break;
case BinaryOp.ArithOp.XOR:
{
generator.Emit(OpCodes.Xor);
} break;
default: throw new EmissionException();
}
AddTask(node.Next,null);
}
