def make_linear_term(syn_ctx, v, c, consts, neg, constant_multiplication):
if c == 1:
return v
if c in consts and constant_multiplication:
return syn_ctx.make_function_expr(
'*', v,
exprs.ConstantExpression(exprs.Value(c, exprtypes.IntType())))
if neg and 0 in consts and (-c) in consts and constant_multiplication:
return syn_ctx.make_function_expr(
'-', exprs.ConstantExpression(exprs.Value(0, exprtypes.IntType())),
syn_ctx.make_function_expr(
'*', v,
exprs.ConstantExpression(exprs.Value(-c,
exprtypes.IntType()))))
if neg and c < 0:
return syn_ctx.make_function_expr(
'-', exprs.ConstantExpression(exprs.Value(0, exprtypes.IntType())),
make_linear_term(syn_ctx, v, -c, consts, neg,
constant_multiplication))
if c > 0:
ret = v
for x in range(1, c):
ret = syn_ctx.make_function_expr('+', v, ret)
return ret
return None
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 term_to_expr(var, coeff):
if var == 1:
term = exprs.ConstantExpression(
exprs.Value(coeff, exprtypes.IntType()))
else:
if coeff == 1:
term = var
else:
coeff_expr = exprs.ConstantExpression(
exprs.Value(coeff, exprtypes.IntType()))
term = syn_ctx.make_function_expr('mul', var, coeff_expr)
return term
def simplify_basic(syn_ctx, expr):
if not exprs.is_function_expression(expr):
return expr
func_name = expr.function_info.function_name
if func_name not in ['and', 'or', 'not', 'ite']:
return expr
true = exprs.ConstantExpression(exprs.Value(True, exprtypes.BoolType()))
false = exprs.ConstantExpression(exprs.Value(False, exprtypes.BoolType()))
if func_name == 'and':
cond_children = [simplify_basic(syn_ctx, c) for c in expr.children]
cond_true_children = [c for c in cond_children if c != true]
cond_false_children = [c for c in cond_children if c == false]
if len(cond_false_children) > 0:
return false
elif len(cond_true_children) == 0:
return true
elif len(cond_true_children) == 1:
return cond_true_children[0]
else:
return syn_ctx.make_function_expr('and', *cond_true_children)
elif func_name == 'or':
cond_children = [simplify_basic(syn_ctx, c) for c in expr.children]
cond_true_children = [c for c in cond_children if c == true]
cond_false_children = [c for c in cond_children if c != false]
if len(cond_true_children) > 0:
return true
elif len(cond_false_children) == 0:
return false
elif len(cond_false_children) == 1:
return cond_false_children[0]
else:
return syn_ctx.make_function_expr('or', *cond_false_children)
elif func_name == 'not':
child = simplify_basic(syn_ctx, expr.children[0])
if child == true:
return false
elif child == false:
return true
else:
return expr
else: #ITE
cond = simplify_basic(syn_ctx, expr.children[0])
if cond == true:
return simplify_basic(syn_ctx, expr.children[1])
elif cond == false:
return simplify_basic(syn_ctx, expr.children[2])
else:
return syn_ctx.make_function_expr(
'ite', cond, simplify_basic(syn_ctx, expr.children[1]),
simplify_basic(syn_ctx, expr.children[2]))
def make_constant_rules(constraints):
constants = set()
for constraint in constraints:
constants |= exprs.get_all_constants(constraint)
constants.add(exprs.ConstantExpression(exprs.Value(1, exprtypes.IntType(), -1)))
constants.add(exprs.ConstantExpression(exprs.Value(0, exprtypes.IntType(), -1)))
const_templates = []
for const in constants:
const_template = grammars.ExpressionRewrite(const)
const_templates.append(const_template)
return const_templates
def z3value_to_value(value, var_info):
if (var_info.variable_type == exprtypes.BoolType()):
return exprs.Value(bool(value), exprtypes.BoolType())
elif (var_info.variable_type == exprtypes.IntType()):
# TODO: Why are these int(str(value)) instead of value.as_long()
return exprs.Value(int(str(value)), exprtypes.IntType())
elif (var_info.variable_type.type_code ==
exprtypes.TypeCodes.bit_vector_type):
return exprs.Value(
BitVector(int(str(value)), var_info.variable_type.size),
var_info.variable_type)
else:
raise basetypes.UnhandledCaseError('solvers.In model_to_point')
def to_expr(self, syn_ctx):
def term_to_expr(var, coeff):
if var == 1:
term = exprs.ConstantExpression(
exprs.Value(coeff, exprtypes.IntType()))
else:
if coeff == 1:
term = var
else:
coeff_expr = exprs.ConstantExpression(
exprs.Value(coeff, exprtypes.IntType()))
term = syn_ctx.make_function_expr('mul', var, coeff_expr)
return term
terms = [
term_to_expr(var, coeff) for var, coeff in self.coeffs.items()
if coeff != 0
]
if len(terms) == 0:
return exprs.ConstantExpression(exprs.Value(
0, exprtypes.IntType()))
else:
return reduce(lambda a, b: syn_ctx.make_function_expr('+', a, b),
terms)
def _trivial_solve(self):
ret = exprs.ConstantExpression(exprs.Value(0, exprtypes.IntType()))
if len(self.synth_funs) > 1:
domain_types = tuple([exprtypes.IntType()] * len(self.synth_funs))
ret = exprs.FunctionExpression(semantics_core.CommaFunction(domain_types),
tuple([ret] * len(self.synth_funs)))
self.signature_to_term = {None:ret}
return True
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 solve_inequalities_one_outvar(model, outvar, inequalities, syn_ctx):
if len(inequalities) == 0:
return [exprs.ConstantExpression(exprs.Value(0, exprtypes.IntType()))]
bounds = [ineq.get_bounds(outvar) for ineq in inequalities]
eqs = [(c, eq_exp) for (c, (_, eq_exp, _)) in bounds if eq_exp is not None]
lbs = [(c, lb_exp) for (c, (lb_exp, _, _)) in bounds if lb_exp is not None]
ubs = [(c, ub_exp) for (c, (_, _, ub_exp)) in bounds if ub_exp is not None]
# Equalities
if len(eqs) > 0:
rhs = eqs[0][1].to_expr(syn_ctx)
if eqs[0][0] == 1:
return [rhs]
else:
return [
syn_ctx.make_function_expr(
'div', rhs,
exprs.ConstantExpression(
exprs.Value(eqs[0][0], exprtypes.IntType())))
]
# Upper bounds
if len(ubs) > 0:
tightest_ub = min(ubs, key=lambda a: a[1].eval(model) / a[0])
if tightest_ub is not None:
coeff = tighest_ub[0]
rhs = tightest_ub[1].to_expr(syn_ctx)
if coeff == 1:
return [rhs]
else:
return [
syn_ctx.make_function_expr(
'div', rhs,
exprs.ConstantExpression(
exprs.Value(coeff, exprtypes.IntType())))
]
# Lower bounds
if len(lbs) > 0:
tightest_lb = max(lbs, key=lambda a: a[1].eval(model) / a[0])
if tightest_lb is not None:
coeff = tightest_lb[0]
rhs = tightest_lb[1].to_expr(syn_ctx)
if coeff == 1:
return [rhs]
return [
syn_ctx.make_function_expr(
'div',
syn_ctx.make_function_expr(
'add', rhs,
exprs.ConstantExpression(
exprs.Value(1, exprtypes.IntType()))),
exprs.ConstantExpression(
exprs.Value(coeff, exprtypes.IntType())))
]
return exprs.ConstantExpression(exprs.Value(0, exprtypes.IntType()))
def rewrite_pred(syn_ctx, pred, boolean_combs, comparators, neg, consts,
constant_multiplication):
liaineq = LIAInequality.from_expr(pred).to_positive_form()
if liaineq.is_valid():
if len(consts) > 0:
return exprs.ConstantExpression(
exprs.Value(True, exprtypes.BoolType()))
else:
return None
(left, op, right) = (liaineq.left, liaineq.op, liaineq.right)
negate = {'<': '>=', '>': '<=', '>=': '<', '<=': '>'}
flip = {'<': '>', '>': '<', '>=': '<=', '<=': '>='}
addNot = False
if op not in comparators:
if op in negate and negate[op] in comparators:
(left, op, right) = (left, negate[op], right)
addNot = True
elif op in flip and flip[op] in comparators:
(left, op, right) = (right, flip[op], left)
elif op == '=' and ('<=' in comparators or '>=' in comparators):
new_op = '<=' if '<=' in comparators else '>='
p1 = syn_ctx.make_function_expr(new_op, pred.children[0],
pred.children[1])
p2 = syn_ctx.make_function_expr(new_op, pred.children[1],
pred.children[0])
return syn_ctx.make_function_expr(
'and',
rewrite_pred(syn_ctx, p1, boolean_combs, comparators, neg,
consts, constant_multiplication),
rewrite_pred(syn_ctx, p2, boolean_combs, comparators, neg,
consts, constant_multiplication))
else:
return None
liaineq = LIAInequality(left, op, right).to_positive_form()
left_term = rewrite_lia_term(syn_ctx, liaineq.left, neg, consts,
constant_multiplication)
right_term = rewrite_lia_term(syn_ctx, liaineq.right, neg, consts,
constant_multiplication)
if left_term is None or right_term is None:
return None
ret = syn_ctx.make_function_expr(liaineq.op, left_term, right_term)
if addNot:
ret = syn_ctx.make_function_expr('not', ret)
return ret
def sexp_to_value(sexp):
(type_sexp, value_exp) = sexp
value_type = sexp_to_type(type_sexp)
if value_type.type_code == exprtypes.TypeCodes.integer_type:
value = int(value_exp)
elif value_type.type_code == exprtypes.TypeCodes.boolean_type:
assert value_exp == 'true' or value_exp == 'false'
value = True if value_exp == 'true' else False
elif value_type.type_code == exprtypes.TypeCodes.bit_vector_type:
value = BitVector(int(str(value_exp)), value_type.size)
elif value_type.type_code == exprtypes.TypeCodes.string_type:
value = value_exp
else:
raise Exception('Unknown type: %s' % value_type)
return exprs.Value(value, value_type, -1)
def evaluate(self, expr_object, eval_context_object):
"""The eval_context_object is assumed to have a map called interpretations.
The interpretation will be an expression, except that it will be in terms of
the formal parameters to the function. We substitute the formal parameters
with the values obtained by evaluating the children."""
from exprs.evaluation import evaluate_expression_on_stack
num_children = len(expr_object.children)
self._evaluate_children(expr_object, eval_context_object)
parameter_map = [exprs.Value(eval_context_object.peek(i), self.domain_types[i], -1)
for i in reversed(range(len(self.domain_types)))]
eval_context_object.pop(num_children)
orig_valuation_map = eval_context_object.valuation_map
eval_context_object.set_valuation_map(parameter_map)
interpretation = eval_context_object.interpretation_map[self.unknown_function_id]
evaluate_expression_on_stack(interpretation, eval_context_object)
eval_context_object.set_valuation_map(orig_valuation_map)
def rewrite_lia_term(syn_ctx, lia_term, neg, consts, constant_multiplication):
c = lia_term.get_const()
linear_terms = [
make_linear_term(syn_ctx, v, coeff, consts, neg,
constant_multiplication)
for (v, coeff) in lia_term.get_var_coeff_pairs()
]
if c != 0:
new_term = make_constant(syn_ctx, c, consts, neg)
if new_term is None:
return None
elif len(linear_terms) > 0:
new_term = linear_terms[0]
linear_terms = linear_terms[1:]
else:
if 0 in consts:
return exprs.ConstantExpression(exprs.Value(
0, exprtypes.IntType()))
else:
return None
for nt in linear_terms:
new_term = syn_ctx.make_function_expr('+', nt, new_term)
return new_term
def make_constant(syn_ctx, c, consts, neg):
if c in consts:
return exprs.ConstantExpression(exprs.Value(c, exprtypes.IntType()))
if -c in consts and neg and 0 in consts:
return syn_ctx.make_function_expr(
'-', exprs.ConstantExpression(exprs.Value(0, exprtypes.IntType())),
exprs.ConstantExpression(exprs.Value(-c, exprtypes.IntType())))
if c > 0:
ret = exprs.ConstantExpression(exprs.Value(1, exprtypes.IntType()))
for x in range(1, c):
ret = syn_ctx.make_function_expr(
'+', ret,
exprs.ConstantExpression(exprs.Value(1, exprtypes.IntType())))
return ret
elif c < 0 and neg and 0 in consts:
return syn_ctx.make_function_expr(
'-', exprs.ConstantExpression(exprs.Value(0, exprtypes.IntType())),
make_constant(syn_ctx, -c, consts, neg))
return None
def _generate_test_generators():
from core import synthesis_context
from semantics import semantics_core
from semantics import semantics_lia
syn_ctx = synthesis_context.SynthesisContext(
semantics_core.CoreInstantiator(), semantics_lia.LIAInstantiator())
var_a_info = syn_ctx.make_variable(exprtypes.IntType(), 'varA', 0)
var_b_info = syn_ctx.make_variable(exprtypes.IntType(), 'varB', 1)
var_c_info = syn_ctx.make_variable(exprtypes.IntType(), 'varC', 2)
var_a = exprs.VariableExpression(var_a_info)
var_b = exprs.VariableExpression(var_b_info)
var_c = exprs.VariableExpression(var_c_info)
zero_value = exprs.Value(0, exprtypes.IntType())
one_value = exprs.Value(1, exprtypes.IntType())
zero_exp = exprs.ConstantExpression(zero_value)
one_exp = exprs.ConstantExpression(one_value)
var_generator = LeafGenerator([var_a, var_b, var_c], 'Variable Generator')
const_generator = LeafGenerator([zero_exp, one_exp], 'Constant Generator')
leaf_generator = AlternativesGenerator([var_generator, const_generator],
'Leaf Term Generator')
generator_factory = RecursiveGeneratorFactory()
start_generator_ph = generator_factory.make_placeholder('Start')
start_bool_generator_ph = generator_factory.make_placeholder('StartBool')
add_fun = syn_ctx.make_function('add', exprtypes.IntType(),
exprtypes.IntType())
sub_fun = syn_ctx.make_function('sub', exprtypes.IntType(),
exprtypes.IntType())
ite_fun = syn_ctx.make_function('ite', exprtypes.BoolType(),
exprtypes.IntType(), exprtypes.IntType())
and_fun = syn_ctx.make_function('and', exprtypes.BoolType(),
exprtypes.BoolType())
or_fun = syn_ctx.make_function('or', exprtypes.BoolType(),
exprtypes.BoolType())
not_fun = syn_ctx.make_function('not', exprtypes.BoolType())
le_fun = syn_ctx.make_function('le', exprtypes.IntType(),
exprtypes.IntType())
ge_fun = syn_ctx.make_function('ge', exprtypes.IntType(),
exprtypes.IntType())
eq_fun = syn_ctx.make_function('eq', exprtypes.IntType(),
exprtypes.IntType())
start_generator = \
generator_factory.make_generator('Start',
AlternativesGenerator,
([leaf_generator] +
[FunctionalGenerator(add_fun,
[start_generator_ph,
start_generator_ph]),
FunctionalGenerator(sub_fun,
[start_generator_ph,
start_generator_ph]),
FunctionalGenerator(ite_fun,
[start_bool_generator_ph,
start_generator_ph,
start_generator_ph])],))
generator_factory.make_generator('StartBool', AlternativesGenerator, ([
FunctionalGenerator(
and_fun, [start_bool_generator_ph, start_bool_generator_ph]),
FunctionalGenerator(
or_fun, [start_bool_generator_ph, start_bool_generator_ph]),
FunctionalGenerator(not_fun, [start_bool_generator_ph]),
FunctionalGenerator(le_fun, [start_generator_ph, start_generator_ph]),
FunctionalGenerator(eq_fun, [start_generator_ph, start_generator_ph]),
FunctionalGenerator(ge_fun, [start_generator_ph, start_generator_ph])
], ))
return start_generator
from parsers import parser
from core import synthesis_context
from semantics import semantics_core
from semantics import semantics_types
from core import synthesis_context
import random
import pickle
import itertools
# import numpy as np
# import matplotlib.pyplot as plt
# import networkx as nx
from sphogs.sphog_utils import *
from utils import z3smt
max_score = 9999999.0
original_expr_to_compare = exprs.ConstantExpression(exprs.Value(True, exprtypes.BoolType()))
class PriorityQueue:
def __init__(self):
self.heap = []
self.elements = set([])
self.nelem = 0
def empty(self):
return (self.nelem == 0)
def get(self):
pri, d = heapq.heappop(self.heap)
self.nelem -= 1
self.elements.remove(d)
return pri, d
def make_constant_expr(self, const_type, const_value):
"""Makes a typed constant expression with the given value."""
assert (isinstance(const_type, exprtypes.TypeBase))
return exprs.ConstantExpression(exprs.Value(const_type, const_value))
from core import synthesis_context
from semantics import semantics_core
from semantics import semantics_types
from core import synthesis_context
import random
import pickle
import itertools
# import numpy as np
# import matplotlib.pyplot as plt
# import networkx as nx
from phogs.phog_utils import *
from utils import z3smt
max_score = 9999999.0
original_expr_to_compare = exprs.ConstantExpression(
exprs.Value(True, exprtypes.BoolType()))
class PriorityQueue:
def __init__(self):
self.heap = []
self.elements = set([])
self.nelem = 0
def empty(self):
return (self.nelem == 0)
def get(self):
pri, d = heapq.heappop(self.heap)
self.nelem -= 1
self.elements.remove(d)
#
#
# Code:
from eusolver import BitSet
from semantics import semantics_core
from unifiers.unifiers import UnifierInterface
from exprs import evaluation
from exprs import exprs
from exprs import exprtypes
from utils.lia_utils import LIAInequality
_expr_to_str = exprs.expression_to_string
_true_expr = exprs.ConstantExpression(exprs.Value(True, exprtypes.BoolType()))
_false_expr = exprs.ConstantExpression(exprs.Value(False,
exprtypes.BoolType()))
def simplify_inequality(inequality):
if LIAInequality.from_expr(inequality).is_valid():
return _true_expr
return inequality
def _filter_to_intro_vars(clauses, intro_vars):
only_intro_var_clauses = []
for clause in clauses:
new_clause = []
for disjunct in clause:
def make_true_expr(self):
"""Makes an expression representing the Boolean constant TRUE."""
return exprs.ConstantExpression(exprs.Value(True,
exprtypes.BoolType()))
def make_false_expr(self):
"""Makes an expression representing the boolean constant FALSE."""
return exprs.ConstantExpression(
exprs.Value(False, 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 evaluate_expression(expr_object, eval_context):
retval = evaluate_expression_raw(expr_object, eval_context)
retval = exprs.Value(retval, exprs.get_expression_type(expr_object), -1)
return retval
