private Expr MakeBinaryIntFunctionCall(string functionName, BinaryOperator.Opcode infixOp, Type resultType, Expr lhs, Expr rhs)
{
Function f = verifier.GetOrCreateIntFunction(functionName, infixOp, resultType, lhs.Type, rhs.Type);
var e = new NAryExpr(Token.NoToken, new FunctionCall(f), new List <Expr> {
lhs, rhs
});
e.Type = resultType;
return(e);
}
private IAppliable GetBinaryFunction(BinaryOperator.Opcode oc)
{
BinaryOperator function = null;
try
{
function = BinaryOperatorCache[oc];
}
catch (KeyNotFoundException)
{
function = new BinaryOperator(Token.NoToken, oc);
BinaryOperatorCache[oc] = function;
}
return(function);
}
static void NormalizeOperator(BinaryOperator op, Expr arg1, Expr arg2, out NAryExpr expr, out bool applyNeg)
{
expr = null;
applyNeg = false;
BinaryOperator.Opcode newop = op.Op;
if (op.Op == BinaryOperator.Opcode.Lt)
{
newop = BinaryOperator.Opcode.Ge;
}
else if (op.Op == BinaryOperator.Opcode.Le)
{
newop = BinaryOperator.Opcode.Gt;
}
else if (op.Op == BinaryOperator.Opcode.Neq)
{
newop = BinaryOperator.Opcode.Eq;
}
var comp = new Comparison <Expr>((e1, e2) => (e1.ToString().CompareTo(e2.ToString())));
var constructExpr = new Func <BinaryOperator, Expr, Expr, NAryExpr>((o, e1, e2) =>
{
if (o.Op == BinaryOperator.Opcode.Eq && comp(e1, e2) > 0)
{
return(new NAryExpr(Token.NoToken, o, new List <Expr> {
e2, e1
}));
}
return(new NAryExpr(Token.NoToken, o, new List <Expr> {
e1, e2
}));
});
if (newop == op.Op)
{
expr = constructExpr(op, arg1, arg2);
applyNeg = false;
}
else
{
expr = constructExpr(new BinaryOperator(Token.NoToken, newop), arg1, arg2);
applyNeg = true;
}
}
// Return the set of conjuncts of the expr
public static List <Expr> GetSubExprs(Expr expr, BinaryOperator.Opcode op)
{
var conjuncts = new List <Expr>();
if (expr is NAryExpr && (expr as NAryExpr).Fun is BinaryOperator &&
((expr as NAryExpr).Fun as BinaryOperator).Op == op)
{
var c0 = GetSubExprs((expr as NAryExpr).Args[0], op);
var c1 = GetSubExprs((expr as NAryExpr).Args[1], op);
conjuncts.AddRange(c0);
conjuncts.AddRange(c1);
}
else
{
conjuncts.Add(expr);
}
return(conjuncts);
}
private static NAryExpr GetBinaryOperator(Expr e, BinaryOperator.Opcode opcode)
{
var nary = e as NAryExpr;
if (nary == null)
{
return(null);
}
var fun = nary.Fun;
if (fun is BinaryOperator)
{
var binary = fun as BinaryOperator;
if (binary.Op == opcode)
{
return(nary);
}
}
return(null);
}
public static Term Binop(BinaryOperator.Opcode opcode, Term arg1, Term arg2)
{
string bopIsa;
switch (opcode)
{
case BinaryOperator.Opcode.Eq:
bopIsa = "Eq";
break;
case BinaryOperator.Opcode.Neq:
bopIsa = "Neq";
break;
case BinaryOperator.Opcode.Add:
bopIsa = "Add";
break;
case BinaryOperator.Opcode.Sub:
bopIsa = "Sub";
break;
case BinaryOperator.Opcode.Mul:
bopIsa = "Mul";
break;
case BinaryOperator.Opcode.Div:
bopIsa = "Div";
break;
case BinaryOperator.Opcode.Mod:
bopIsa = "Mod";
break;
case BinaryOperator.Opcode.Lt:
bopIsa = "Lt";
break;
case BinaryOperator.Opcode.Le:
bopIsa = "Le";
break;
case BinaryOperator.Opcode.Gt:
bopIsa = "Gt";
break;
case BinaryOperator.Opcode.Ge:
bopIsa = "Ge";
break;
case BinaryOperator.Opcode.And:
bopIsa = "And";
break;
case BinaryOperator.Opcode.Or:
bopIsa = "Or";
break;
case BinaryOperator.Opcode.Imp:
bopIsa = "Imp";
break;
case BinaryOperator.Opcode.Iff:
bopIsa = "Iff";
break;
default:
throw new NotImplementedException();
}
var list = new List <Term> {
arg1, IsaCommonTerms.TermIdentFromName(bopIsa), arg2
};
return(new TermApp(IsaCommonTerms.TermIdentFromName("BinOp"), list));
}
private Expr MakeIntBinaryBool(string suffix, BinaryOperator.Opcode infixOp, Expr lhs, Expr rhs)
{
return(MakeBinaryIntFunctionCall("BV32_" + suffix, infixOp, Type.Bool, lhs, rhs));
}
