def __init__(self, bv_size):
super().__init__('bvnor', 2, (exprtypes.BitVectorType(bv_size),
exprtypes.BitVectorType(bv_size)),
exprtypes.BitVectorType(bv_size))
self.smt_function = lambda a, b: ~(a | b)
self.eval_children = lambda a, b: ~(a | b)
self.commutative = True
self.associative = True
def __init__(self, bv_size):
super().__init__('bvcomp', 2, (exprtypes.BitVectorType(bv_size),
exprtypes.BitVectorType(bv_size)),
exprtypes.BitVectorType(1))
self.smt_function = lambda a, b: z3.If(a == b, z3.BitVecVal(1, 1),
z3.BitVecVal(0, 1))
self.eval_children = lambda a, b: a.bvcomp(b)
self.commutative = True
self.associative = True
def preprocess_operators(term_exprs, pred_exprs):
eval_context = evaluation.EvaluationContext()
bitsize = 64
bvlshr = semantics_bv.BVLShR(bitsize)
new_term_exprs = set([])
new_pred_exprs = set([])
for term_expr, f in term_exprs:
subst_pairs = set([])
all_exprs = exprs.get_all_exprs(term_expr)
for e in all_exprs:
if exprs.is_function_expression(e):
if e.function_info.function_name == 'bvudiv':
if exprs.is_constant_expression(e.children[1]):
value = evaluation.evaluate_expression_raw(
e.children[1], eval_context)
new_right_child = exprs.ConstantExpression(
exprs.Value(
BitVector(int(math.log2(value.value)),
bitsize),
exprtypes.BitVectorType(bitsize)))
subst_pairs.add(
(e,
exprs.FunctionExpression(
bvlshr, (e.children[0], new_right_child))))
new_term_expr = term_expr
for (old_term, new_term) in subst_pairs:
new_term_expr = exprs.substitute(new_term_expr, old_term, new_term)
new_term_exprs.add((new_term_expr, f))
for pred_expr, f in pred_exprs:
subst_pairs = set([])
all_exprs = exprs.get_all_exprs(pred_expr)
for e in all_exprs:
if exprs.is_function_expression(e):
if e.function_info.function_name == 'bvudiv':
if exprs.is_constant_expression(e.children[1]):
value = evaluation.evaluate_expression_raw(
e.children[1], eval_context)
new_right_child = exprs.ConstantExpression(
exprs.Value(
BitVector(int(math.log2(value.value)),
bitsize),
exprtypes.BitVectorType(bitsize)))
subst_pairs.add(
(e,
exprs.FunctionExpression(
bvlshr, (e.children[0], new_right_child))))
new_pred_expr = pred_expr
for (old_term, new_term) in subst_pairs:
new_pred_expr = exprs.substitute(new_pred_expr, old_term, new_term)
new_pred_exprs.add((new_pred_expr, f))
return (new_term_exprs, new_pred_exprs)
def __init__(self, bv_size):
super().__init__('bvurem', 2, (exprtypes.BitVectorType(bv_size),
exprtypes.BitVectorType(bv_size)),
exprtypes.BitVectorType(bv_size))
self.smt_function = z3.URem
def eval_c(a, b):
if b.value == 0:
raise basetypes.PartialFunctionError()
return a.urem(b)
self.eval_children = eval_c
def __init__(self, bv_size):
super().__init__('bvsdiv', 2, (exprtypes.BitVectorType(bv_size),
exprtypes.BitVectorType(bv_size)),
exprtypes.BitVectorType(bv_size))
self.smt_function = lambda a, b: a / b
def eval_c(a, b):
if b.value == 0:
raise basetypes.PartialFunctionError()
return a.sdiv(b)
self.eval_children = eval_c
def sexp_to_type(sexp):
if type(sexp) == list and sexp[0] == 'BitVec':
assert type(sexp[1]) == tuple and sexp[1][0] == 'Int'
length = sexp[1][1]
return exprtypes.BitVectorType(length)
elif sexp == 'Int':
return exprtypes.IntType()
elif sexp == 'Bool':
return exprtypes.BoolType()
elif sexp == 'String':
return exprtypes.StringType()
else:
raise Exception("Unknown type: %s" % str(sexp))
def string_to_constant_rewrite(topsymb):
if topsymb.isdigit() or (topsymb.startswith('-') and len(topsymb) >= 2
and topsymb[1:].isdigit):
num = -1 * int(topsymb[1:]) if topsymb.startswith('-') else int(
topsymb)
return grammars.ExpressionRewrite(
exprs.ConstantExpression(exprs.Value(num,
exprtypes.IntType())))
elif topsymb.startswith('#x'): # bitvector
num = int('0' + topsymb[1:], 16)
bitsize = (len(topsymb) - 2) * 4
return grammars.ExpressionRewrite(
exprs.ConstantExpression(
exprs.Value(num, exprtypes.BitVectorType(bitsize))))
else: # boolean
return grammars.ExpressionRewrite(
exprs.ConstantExpression(
exprs.Value(bool(topsymb), exprtypes.BoolType())))
def make_default_grammar(syn_ctx, theory, return_type, args):
int_type = exprtypes.IntType()
bool_type = exprtypes.BoolType()
if theory == 'LIA':
[start, start_bool,
const] = ['Start', 'StartBool', 'ConstantIntegerType']
nts = [start, start_bool, const]
nt_type = {start: int_type, start_bool: bool_type, const: int_type}
rules = {start: [], start_bool: [], const: []}
ntr_start = NTRewrite(start, int_type)
ntr_startbool = NTRewrite(start_bool, bool_type)
ntr_const = NTRewrite(const, int_type)
[ add_func, sub_func, mul_func, div_func, mod_func ] = \
[ syn_ctx.make_function(name, int_type, int_type)
for name in [ 'add', 'sub', 'mul', 'div', 'mod' ] ]
ite_func = syn_ctx.make_function('ite', bool_type, int_type, int_type)
[ and_func, or_func ] = \
[ syn_ctx.make_function(name, bool_type, bool_type)
for name in [ 'and', 'or' ] ]
not_func = syn_ctx.make_function('not', bool_type)
[ eq_func, ne_func, le_func, lt_func, ge_func, gt_func ] = \
[ syn_ctx.make_function(name, int_type, int_type)
for name in [ '=', 'ne', '<=', '<', '>=', '>' ] ]
# Start rules:
# Args
for arg in args:
if exprs.get_expression_type(arg) == int_type:
rules[start].append(ExpressionRewrite(arg))
elif exprs.get_expression_type(arg) == bool_type:
rules[start_bool].append(ExpressionRewrite(arg))
# Constants
rules[start].append(
ExpressionRewrite(
exprs.ConstantExpression(exprs.Value(1, int_type))))
rules[start].append(
ExpressionRewrite(
exprs.ConstantExpression(exprs.Value(0, int_type))))
rules[start].append(ntr_const)
# Start + Start, Start - Start,
rules[start].append(FunctionRewrite(add_func, ntr_start, ntr_start))
rules[start].append(FunctionRewrite(sub_func, ntr_start, ntr_start))
# Start * Constant, Start / Constant, Start mod Constant
rules[start].append(FunctionRewrite(mul_func, ntr_start, ntr_start))
rules[start].append(FunctionRewrite(div_func, ntr_start, ntr_start))
rules[start].append(FunctionRewrite(mod_func, ntr_start, ntr_start))
# ITE
rules[start].append(
FunctionRewrite(ite_func, ntr_startbool, ntr_start, ntr_start))
# Start bool rules
# And, or, not
rules[start_bool].append(
ExpressionRewrite(
exprs.ConstantExpression(exprs.Value(False, bool_type))))
rules[start_bool].append(
ExpressionRewrite(
exprs.ConstantExpression(exprs.Value(True, bool_type))))
rules[start_bool].append(
FunctionRewrite(and_func, ntr_startbool, ntr_startbool))
rules[start_bool].append(
FunctionRewrite(or_func, ntr_startbool, ntr_startbool))
rules[start_bool].append(FunctionRewrite(not_func, ntr_startbool))
# comparison ops
rules[start_bool].append(FunctionRewrite(eq_func, ntr_start,
ntr_start))
rules[start_bool].append(FunctionRewrite(ne_func, ntr_start,
ntr_start))
rules[start_bool].append(FunctionRewrite(le_func, ntr_start,
ntr_start))
rules[start_bool].append(FunctionRewrite(lt_func, ntr_start,
ntr_start))
rules[start_bool].append(FunctionRewrite(ge_func, ntr_start,
ntr_start))
rules[start_bool].append(FunctionRewrite(gt_func, ntr_start,
ntr_start))
# Constant rules
rules[const].append(
ExpressionRewrite(
exprs.ConstantExpression(exprs.Value(1, int_type))))
rules[const].append(
ExpressionRewrite(
exprs.ConstantExpression(exprs.Value(0, int_type))))
rules[const].append(FunctionRewrite(add_func, ntr_const, ntr_const))
rules[const].append(FunctionRewrite(add_func, ntr_const, ntr_const))
rules[const].append(FunctionRewrite(sub_func, ntr_const, ntr_const))
if return_type == int_type:
ret = Grammar(nts, nt_type, rules, start)
elif return_type == bool_type:
ret = Grammar(nts, nt_type, rules, start_bool)
else:
raise NotImplementedError
ret.from_default = True
return ret
elif theory == 'BV':
from semantics import semantics_bv
from semantics import semantics_core
print("ARSAYS: Default bit-vec grammar shouldn't be used!")
(start, start_bool) = ('Start', 'StartBool')
bv_size = 64
nts = [start, start_bool]
(bv_type, bool_type) = (exprtypes.BitVectorType(bv_size),
exprtypes.BoolType())
nt_type = {start: bv_type, start_bool: bool_type}
rules = {start: [], start_bool: []}
ntr_start = NTRewrite(start, bv_type)
ntr_start_bool = NTRewrite(start_bool, bool_type)
rules[start].extend(
map(
lambda x: ExpressionRewrite(
exprs.ConstantExpression(exprs.Value(x, bv_type))),
[0, 1]))
for func in [
semantics_bv.BVNot(bv_size),
semantics_bv.BVAdd(bv_size),
semantics_bv.BVAnd(bv_size),
semantics_bv.BVOr(bv_size),
semantics_bv.BVNeg(bv_size),
semantics_bv.BVAdd(bv_size),
semantics_bv.BVMul(bv_size),
semantics_bv.BVSub(bv_size),
semantics_bv.BVUDiv(bv_size),
semantics_bv.BVSDiv(bv_size),
semantics_bv.BVSRem(bv_size),
semantics_bv.BVURem(bv_size),
semantics_bv.BVShl(bv_size),
semantics_bv.BVLShR(bv_size),
semantics_bv.BVAShR(bv_size),
semantics_bv.BVUlt(bv_size),
semantics_bv.BVUle(bv_size),
semantics_bv.BVUge(bv_size),
semantics_bv.BVUgt(bv_size),
semantics_bv.BVSle(bv_size),
semantics_bv.BVSlt(bv_size),
semantics_bv.BVSge(bv_size),
semantics_bv.BVSgt(bv_size),
semantics_bv.BVXor(bv_size),
semantics_bv.BVXNor(bv_size),
semantics_bv.BVNand(bv_size),
semantics_bv.BVNor(bv_size),
# semantics_bv.BVComp(bv_size)
semantics_core.EqFunction(bv_type)
]:
assert all([t == bv_type for t in func.domain_types])
args = [ntr_start] * len(func.domain_types)
if func.range_type == bv_type:
rules[start].append(FunctionRewrite(func, *args))
elif func.range_type == bool_type:
rules[start_bool].append(FunctionRewrite(func, *args))
else:
assert False
ite_func = semantics_core.IteFunction(bv_type)
rules[start].append(
FunctionRewrite(ite_func, ntr_start_bool, ntr_start, ntr_start))
if return_type == bv_type:
ret = Grammar(nts, nt_type, rules, start)
elif return_type == bool_type:
ret = Grammar(nts, nt_type, rules, start_bool)
else:
raise NotImplementedError
ret.from_default = True
return ret
elif theory == 'SLIA':
raise NotImplementedError
else:
raise NotImplementedError
def __init__(self, bv_size):
super().__init__('bvnot', 1, (exprtypes.BitVectorType(bv_size), ),
exprtypes.BitVectorType(bv_size))
self.smt_function = lambda a: ~a
self.eval_children = lambda a: ~a
def __init__(self, bv_size):
super().__init__('bvsgt', 2, (exprtypes.BitVectorType(bv_size),
exprtypes.BitVectorType(bv_size)),
exprtypes.BoolType())
self.smt_function = lambda a, b: a > b
self.eval_children = lambda a, b: a.sgt(b)
def __init__(self, bv_size):
super().__init__('bvlshr', 2, (exprtypes.BitVectorType(bv_size),
exprtypes.BitVectorType(bv_size)),
exprtypes.BitVectorType(bv_size))
self.smt_function = z3.LShR
self.eval_children = lambda a, b: a.lshr(b)