def __getitem__(self, k):
model = self._int_field_info.model
if get_expr_mode():
# TODO: must determine whether we're within a foreach or just on our own
if is_foreach_arr(self):
to_expr(k)
idx_e = pop_expr()
return expr(ExprArraySubscriptModel(
ExprFieldRefModel(self.get_model()),
idx_e))
else:
to_expr(k)
idx_e = pop_expr()
return expr(ExprArraySubscriptModel(
ExprFieldRefModel(self.get_model()),
idx_e))
else:
if self.is_enum:
ei : EnumInfo = self.t.enum_i
return ei.v2e(model.field_l[k].get_val())
elif self.is_scalar:
return int(model.field_l[k].get_val())
else:
return self.backing_arr[k]
def create_single_var_domain_constraint(
self, f: FieldScalarModel,
bound_m: VariableBoundModel) -> ExprModel:
range_l = bound_m.domain.range_l
if len(range_l) == 1:
val = self.randint(range_l[0][0], range_l[0][1])
e = ExprBinModel(ExprFieldRefModel(f), BinExprType.Eq,
ExprLiteralModel(val, f.is_signed, f.width))
return e
else:
# domain_bin_ratio = int(len(bound_m.domain.range_l)/len(bound_m.domain_offsets))
domain_bin_ratio = 1
if domain_bin_ratio <= 1:
# Just pick a single value
off_val = self.randint(0, bound_m.domain_sz - 1)
target_val = bound_m.offset2value(off_val)
e = ExprBinModel(
ExprFieldRefModel(f), BinExprType.Eq,
ExprLiteralModel(target_val, f.is_signed, f.width))
return e
else:
# TODO: For a variable with a small number of bins
# relative to the domain the cover, it likely makes
# sense to try to place a range within the bin instead
# of selecting a single value
#
print("domain_bin_ratio=" + str(domain_bin_ratio))
pass
return None
def __getitem__(self, rng):
if is_expr_mode():
if isinstance(rng, slice):
# slice
to_expr(rng.start)
upper = pop_expr()
to_expr(rng.stop)
lower = pop_expr()
return expr(
ExprPartselectModel(
ExprFieldRefModel(self._int_field_info.model), upper,
lower))
else:
# single value
to_expr(rng)
e = pop_expr()
return expr(
ExprPartselectModel(
ExprFieldRefModel(self._int_field_info.model), e))
else:
curr = int(self.get_model().get_val())
if isinstance(rng, slice):
msk = ((1 << (rng.start - rng.stop + 1)) - 1) << rng.stop
curr = (curr & msk) >> rng.stop
else:
curr = (curr & (1 << rng)) >> rng
return curr
def __enter__(self):
push_constraint_stmt(self.stmt)
push_constraint_scope(self.stmt)
model = self.arr_model
# return expr(ExprArraySubscriptModel())
push_foreach_arr(self.arr)
idx_term = foreach.idx_term_c(self.stmt.index)
if self.arr_model.is_scalar:
it_term = foreach.it_term_c(
ExprArraySubscriptModel(ExprFieldRefModel(model),
ExprFieldRefModel(self.stmt.index)))
else:
self.arr.t._int_field_info.root_e = ExprArraySubscriptModel(
ExprFieldRefModel(model), ExprFieldRefModel(self.stmt.index))
it_term = self.arr.t
if self.idx and self.it:
return (idx_term, it_term)
else:
if self.it:
return it_term
else:
return idx_term
def __getitem__(self, k):
model = self._int_field_info.model
if get_expr_mode():
# TODO: must determine whether we're within a foreach or just on our own
if is_foreach_arr(self):
to_expr(k)
idx_e = pop_expr()
return expr_subscript(
ExprArraySubscriptModel(
ExprFieldRefModel(self.get_model()), idx_e))
else:
to_expr(k)
idx_e = pop_expr()
return expr_subscript(
ExprArraySubscriptModel(
ExprFieldRefModel(self.get_model()), idx_e))
else:
if self.is_enum:
ei: EnumInfo = self.t.enum_i
return ei.v2e(model.field_l[k].get_val())
elif self.is_scalar:
# The model's view is always masked 2's complement
v = int(model.field_l[k].get_val())
if self.t.is_signed:
if (v & (1 << (self.t.width - 1))) != 0:
v = -((~v & self.mask) + 1)
return v
else:
return self.backing_arr[k]
def test_smoke(self):
obj = FieldCompositeModel("obj")
arr = obj.add_field(FieldArrayModel(
"arr",
True,
None, # not an enum-type
32,
False,
True,
True))
# for i in range(10):
# arr.add_field()
obj.add_constraint(ConstraintBlockModel("XX", [
ConstraintExprModel(
ExprBinModel(
ExprFieldRefModel(arr.size),
BinExprType.Eq,
ExprLiteralModel(10, False, 32)))
]))
foreach = ConstraintForeachModel(ExprFieldRefModel(arr))
foreach.addConstraint(
ConstraintExprModel(
ExprBinModel(
ExprArraySubscriptModel(
ExprFieldRefModel(arr),
ExprFieldRefModel(foreach.index)),
BinExprType.Lt,
ExprLiteralModel(10, False, 32)
)
)
)
obj.add_constraint(ConstraintBlockModel("c", [
foreach
]))
# print("Object: " + ModelPrettyPrinter.print(obj))
#
# constraints = ArrayConstraintBuilder.build(obj)
# for c in constraints:
# print("Constraint: " + ModelPrettyPrinter.print(c))
# print("Object(1): " + ModelPrettyPrinter.print(obj))
#
# ConstraintOverrideRollbackVisitor.rollback(obj)
# print("Object(2): " + ModelPrettyPrinter.print(obj))
Randomizer.do_randomize([obj])
for f in arr.field_l:
print("" + f.name + ": " + str(int(f.get_val())))
def test_cross(self):
stim = FieldCompositeModel("stim", True)
f = FieldScalarModel("a", 16, False, True)
stim.add_field(f)
f2 = FieldScalarModel("b", 16, False, True)
stim.add_field(f2)
cg = CovergroupModel("cg")
cp = CoverpointModel(ExprFieldRefModel(f), "cp1",
CoverageOptionsModel())
cg.add_coverpoint(cp)
bn = CoverpointBinArrayModel("cp", 0, 1, 16)
cp.add_bin_model(bn)
cp2 = CoverpointModel(ExprFieldRefModel(f2), "cp2",
CoverageOptionsModel())
cg.add_coverpoint(cp2)
bn = CoverpointBinArrayModel("cp", 0, 1, 16)
cp2.add_bin_model(bn)
cr = CoverpointCrossModel("aXb",
CoverageOptionsModel())
cr.add_coverpoint(cp)
cr.add_coverpoint(cp2)
cg.add_coverpoint(cr)
gen = GeneratorModel("top")
gen.add_field(stim)
gen.add_covergroup(cg)
gen.finalize()
# Need a special randomizer to deal with generators
r = Randomizer()
count = 0
for i in range(1000):
r.do_randomize([gen])
cg.sample()
count += 1
cov = cg.get_coverage()
print("Coverage: (" + str(i) + ") " + str(cov))
if cov == 100:
break
self.assertEqual(cg.get_coverage(), 100)
# Ensure that we converge relatively quickly
self.assertLessEqual(count, (256+16+16))
def get_sum_expr(self):
if self.sum_expr is None:
# Build
# Compute clog2 of overflow term to
# ensure that we properly size the result
# to avoid overflow
result_bits = self.type_t.width
overflow_val = int(self.size.get_val())-1
while overflow_val > 0:
result_bits += 1
overflow_val >>= 1
# Force the result to be 32-bit, in order to
# match user expectation
ret = ExprLiteralModel(0, self.is_signed, result_bits)
for i in range(int(self.size.get_val())):
f = self.field_l[i]
ret = ExprBinModel(
ret,
BinExprType.Add,
ExprFieldRefModel(f))
self.sum_expr = ret
return self.sum_expr
def get_sum_expr(self):
if self.sum_expr is None:
# Build
ret = None
for f in self.field_l:
if ret is None:
ret = ExprFieldRefModel(f)
else:
ret = ExprBinModel(ret, BinExprType.Add,
ExprFieldRefModel(f))
if ret is None:
ret = ExprLiteralModel(0, False, 32)
self.sum_expr = ret
return self.sum_expr
def visit_expr_indexed_fieldref(self, e):
from .model_pretty_printer import ModelPrettyPrinter
if isinstance(e.root, ExprArraySubscriptModel) and e.root.rhs.fm in self.index_set:
actual_root = e.root.lhs.fm.field_l[int(e.root.rhs.fm.get_val())]
self._expr = ExprFieldRefModel(e.get_target(actual_root))
else:
ConstraintCopyBuilder.visit_expr_indexed_fieldref(self, e)
def expand(self, e: ExprModel) -> ExprModel:
if ForeachRefExpander.EN_DEBUG > 0:
print("--> ForeachRefExpander::expand")
self._field = None
self._expr = None
# Tracks whether a foreach index is used anywhere in the expression
self._refs_index_var = False
e.accept(self)
if self._refs_index_var:
if self._expr is not None:
ret = self._expr
elif self._field is not None:
ret = ExprFieldRefModel(self._field)
else:
raise Exception(
"references index vars, but failed to resolve field")
else:
ret = None
if ForeachRefExpander.EN_DEBUG > 0:
print("<-- ForeachRefExpander::expand ret=%s" % str(ret))
return ret
def __init__(self, *args):
if len(args) == 0:
raise Exception("Empty rangelist specified")
self.range_l = ExprRangelistModel()
for i in range(-1, -(len(args) + 1), -1):
a = args[i]
if isinstance(a, tuple):
# This needs to be a two-element array
if len(a) != 2:
raise Exception(
"Range specified with " + str(len(a)) +
" elements is invalid. Two elements required")
to_expr(a[0])
to_expr(a[1])
e1 = pop_expr()
e0 = pop_expr()
self.range_l.add_range(ExprRangeModel(e0, e1))
elif isinstance(a, rng):
to_expr(a.low)
to_expr(a.high)
e1 = pop_expr()
e0 = pop_expr()
self.range_l.add_range(ExprRangeModel(e0, e1))
elif isinstance(a, list):
list_f = FieldConstArrayModel("<<anonymous>>", a)
self.range_l.add_range(ExprFieldRefModel(list_f))
else:
to_expr(a)
e = pop_expr()
self.range_l.add_range(e)
def swizzle_field(self, f, rs, bound_m) -> ExprModel:
ret = None
if self.debug > 0:
print("Swizzling field %s" % f.name)
if f in rs.dist_field_m.keys():
if self.debug > 0:
print("Note: field %s is in dist map" % f.name)
for d in rs.dist_field_m[f]:
print(" Target interval %d" % d.target_range)
if len(rs.dist_field_m[f]) > 1:
target_d = self.randstate.randint(0,
len(rs.dist_field_m[f]) - 1)
dist_scope_c = rs.dist_field_m[f][target_d]
else:
dist_scope_c = rs.dist_field_m[f][0]
target_w = dist_scope_c.dist_c.weights[dist_scope_c.target_range]
if target_w.rng_rhs is not None:
# Dual-bound range
val_l = target_w.rng_lhs.val()
val_r = target_w.rng_rhs.val()
val = self.randstate.randint(val_l, val_r)
if self.debug > 0:
print(
"Select dist-weight range: %d..%d ; specific value %d"
% (int(val_l), int(val_r), int(val)))
ret = [
ExprBinModel(ExprFieldRefModel(f), BinExprType.Eq,
ExprLiteralModel(val, f.is_signed, f.width))
]
else:
# Single value
val = target_w.rng_lhs.val()
ret = [
ExprBinModel(
ExprFieldRefModel(f), BinExprType.Eq,
ExprLiteralModel(int(val), f.is_signed, f.width))
]
else:
if f in bound_m.keys():
f_bound = bound_m[f]
if not f_bound.isEmpty():
ret = self.create_rand_domain_constraint(f, f_bound)
return ret
def __getitem__(self, val):
if isinstance(val, slice):
# slice
to_expr(val.start)
to_expr(val.stop)
e0 = pop_expr()
e1 = pop_expr()
return expr(
ExprPartselectModel(
ExprFieldRefModel(self._int_field_info.model), e0, e1))
else:
# single value
to_expr(val)
e = pop_expr()
return expr(
ExprPartselectModel(
ExprFieldRefModel(self._int_field_info.model), e))
def test_coverpoint_bins(self):
stim = FieldCompositeModel("stim", True)
f = FieldScalarModel("a", 16, False, True)
stim.add_field(f)
f2 = FieldScalarModel("b", 16, False, True)
stim.add_field(f2)
cg = CovergroupModel("cg")
cp = CoverpointModel(ExprFieldRefModel(f), "cp1",
CoverageOptionsModel())
cg.add_coverpoint(cp)
cp.add_bin_model(CoverpointBinArrayModel("bn1", 0, 1, 16))
cp.add_bin_model(CoverpointBinCollectionModel.mk_collection("bn2", RangelistModel([
[17,65535-16-1]
]), 16))
cp.add_bin_model(CoverpointBinArrayModel("bn3", 0, 65535-16, 65535))
cp2 = CoverpointModel(ExprFieldRefModel(f2), "cp2",
CoverageOptionsModel())
cg.add_coverpoint(cp2)
bn = CoverpointBinArrayModel("cp", 0, 1, 16)
cp2.add_bin_model(bn)
gen = GeneratorModel("top")
gen.add_field(stim)
gen.add_covergroup(cg)
gen.finalize()
# Need a special randomizer to deal with generators
r = Randomizer()
count = 0
for i in range(1000):
r.do_randomize([gen])
cg.sample()
count += 1
cov = cg.get_coverage()
if cov == 100:
break
self.assertEqual(cg.get_coverage(), 100)
# Ensure that we converge relatively quickly
self.assertLessEqual(count, 64)
def test_simple(self):
a = FieldScalarModel("a", 16, False, True)
b = FieldScalarModel("b", 16, False, True)
c = FieldScalarModel("c", 16, False, True)
l = ExprLiteralModel(10, False, 8)
ab_c = ConstraintBlockModel("ab_c", [
ConstraintImpliesModel(
ExprBinModel(ExprFieldRefModel(a), BinExprType.Lt,
ExprFieldRefModel(b)),
[
ConstraintExprModel(
ExprBinModel(ExprFieldRefModel(c), BinExprType.Eq, l))
])
])
copy = ConstraintCopyBuilder.copy(ab_c)
self.assertEquals(1, len(copy))
self.assertIsNot(ab_c, copy[0])
def test_incr(self):
obj = FieldCompositeModel("obj")
arr = obj.add_field(
FieldArrayModel(
"arr",
None, # type_t
True, # is_scalar
None, # not an enum-type list
32,
False,
True,
False))
for i in range(10):
arr.add_field()
obj.add_constraint(
ConstraintBlockModel("XX", [
ConstraintExprModel(
ExprBinModel(ExprFieldRefModel(arr.size), BinExprType.Eq,
ExprLiteralModel(10, False, 32)))
]))
foreach = ConstraintForeachModel(ExprFieldRefModel(arr))
foreach.addConstraint(
ConstraintImpliesModel(
ExprBinModel(ExprFieldRefModel(foreach.index), BinExprType.Gt,
ExprLiteralModel(0, False, 32)),
[
ConstraintExprModel(
ExprBinModel(
ExprArraySubscriptModel(
ExprFieldRefModel(arr),
ExprFieldRefModel(foreach.index)),
BinExprType.Eq,
ExprBinModel(
ExprArraySubscriptModel(
ExprFieldRefModel(arr),
ExprBinModel(
ExprFieldRefModel(foreach.index),
BinExprType.Sub,
ExprLiteralModel(1, False, 32))),
BinExprType.Add, ExprLiteralModel(
1, False, 32))))
]))
obj.add_constraint(ConstraintBlockModel("c", [foreach]))
# print("Object: " + ModelPrettyPrinter.print(obj))
#
# constraints = ArrayConstraintBuilder.build(obj)
# for c in constraints:
# print("Constraint: " + ModelPrettyPrinter.print(c))
# print("Object(1): " + ModelPrettyPrinter.print(obj))
#
# ConstraintOverrideRollbackVisitor.rollback(obj)
# print("Object(2): " + ModelPrettyPrinter.print(obj))
randstate = RandState(0)
Randomizer.do_randomize(randstate, SourceInfo("", -1), [obj])
for f in arr.field_l:
print("" + f.name + ": " + str(int(f.get_val())))
def visit_expr_array_subscript(self, s : ExprArraySubscriptModel):
if self.phase != 1:
return
if isinstance(s.rhs, ExprFieldRefModel) and s.rhs.fm in self.index_set:
# Convert this index into a direct reference
self._expr = ExprFieldRefModel(
s.lhs.fm.field_l[int(s.rhs.fm.get_val())])
else:
ConstraintCopyBuilder.visit_expr_array_subscript(self, s)
def test_smoke(self):
stim = FieldCompositeModel("stim", True)
f = FieldScalarModel("a", 16, False, True)
stim.add_field(f)
f2 = FieldScalarModel("b", 16, False, True)
stim.add_field(f2)
cg = CovergroupModel("cg")
cp = CoverpointModel(ExprFieldRefModel(f), "cp1",
CoverageOptionsModel())
cg.add_coverpoint(cp)
bn = CoverpointBinArrayModel("cp", 1, 16)
cp.add_bin_model(bn)
cp2 = CoverpointModel(ExprFieldRefModel(f2), "cp2",
CoverageOptionsModel())
cg.add_coverpoint(cp2)
bn = CoverpointBinArrayModel("cp", 1, 16)
cp2.add_bin_model(bn)
gen = GeneratorModel("top")
gen.add_field(stim)
gen.add_covergroup(cg)
gen.finalize()
# Need a special randomizer to deal with generators
r = Randomizer(RandState(0))
randstate = RandState(0)
count = 0
for i in range(1000):
r.do_randomize(randstate, SourceInfo("", -1), [gen])
cg.sample()
count += 1
cov = cg.get_coverage()
if cov == 100:
break
self.assertEqual(cg.get_coverage(), 100)
# Ensure that we converge relatively quickly
self.assertLessEqual(count, 32)
def mkCompositeEq(lhs, rhs):
ret = None
if isinstance(lhs, FieldCompositeModel):
# Keep recursing
for i in range(len(lhs.field_l)):
lhs_f = lhs.field_l[i]
rhs_f = rhs.field_l[i]
sub = ExprBinModel.mkCompositeEq(lhs_f, rhs_f)
if ret is None:
ret = sub
elif sub is not None:
ret = ExprBinModel(sub, BinExprType.And, ret)
elif isinstance(lhs, FieldScalarModel):
ret = ExprBinModel(ExprFieldRefModel(lhs), BinExprType.Eq,
ExprFieldRefModel(rhs))
return ret
def get_sum_expr(self):
if self.sum_expr is None:
# Build
# Force the result to be 32-bit, in order to
# match user expectation
ret = ExprLiteralModel(0, self.is_signed, 32)
for i in range(int(self.size.get_val())):
f = self.field_l[i]
if ret is None:
ret = ExprFieldRefModel(f)
else:
ret = ExprBinModel(ret, BinExprType.Add,
ExprFieldRefModel(f))
if ret is None:
ret = ExprLiteralModel(0, self.is_signed, 32)
self.sum_expr = ret
return self.sum_expr
def inside(self, rhs):
lhs_e = pop_expr()
if isinstance(rhs, rangelist):
return expr(ExprInModel(lhs_e, rhs.range_l))
elif isinstance(rhs, list_t):
return expr(ExprInModel(
lhs_e,
ExprRangelistModel(
[ExprFieldRefModel(rhs.get_model())])))
else:
raise Exception("Unsupported 'inside' argument of type " + str(type(rhs)))
def to_expr(self):
if self._int_field_info.id != -1:
# Need something like an indirect reference
# - root reference
# - leaf reference
id_l = []
fi = self._int_field_info
while fi.parent is not None:
id_l.insert(0, fi.id)
fi = fi.parent
return expr(ExprIndexedFieldRefModel(fi.root_e, id_l))
else:
return expr(ExprFieldRefModel(self._int_field_info.model))
def to_expr(self):
if self._int_field_info.id != -1:
# A non-negative id means that this field
# should be referenced indirectly. Follow the
# parent/child relationships up to construct an
# index list back to this field
id_l = []
fi = self._int_field_info
while fi.parent is not None:
id_l.insert(0, fi.id)
fi = fi.parent
return expr(ExprIndexedFieldRefModel(fi.root_e, id_l))
else:
return expr(ExprFieldRefModel(self._int_field_info.model))
def __enter__(self):
push_constraint_stmt(self.stmt)
push_constraint_scope(self.stmt)
idx_term = foreach.idx_term_c(self.stmt.index)
it_term = foreach.it_term_c(
ExprArraySubscriptModel(self.arr_ref_e,
ExprFieldRefModel(self.stmt.index)))
if self.idx and self.it:
return (idx_term, it_term)
else:
if self.it:
return it_term
else:
return idx_term
def get_product_expr(self):
if self.product_expr is None:
# Build
# Force the result to be 32-bit, in order to
# match user expectation
if int(self.size.get_val()) == 0:
ret = ExprLiteralModel(0, self.is_signed, 64)
else:
ret = ExprLiteralModel(1, self.is_signed, 64)
for i in range(int(self.size.get_val())):
f = self.field_l[i]
ret = ExprBinModel(ret, BinExprType.Mul, ExprFieldRefModel(f))
self.product_expr = ret
return self.product_expr
def build(self, btor, ctx_width=-1):
t = None
expr = None
for r in self.rhs.rl:
if isinstance(r, ExprRangeModel):
t = ExprBinModel(ExprBinModel(self.lhs, BinExprType.Ge, r.lhs),
BinExprType.And,
ExprBinModel(self.lhs, BinExprType.Le, r.rhs))
elif isinstance(r, ExprFieldRefModel):
if isinstance(r.fm, FieldArrayModel):
# Need to build out for each element
# TODO: must handle case where size is random
arr: FieldArrayModel = r.fm
if arr.is_rand_sz:
pass
else:
for i in range(int(arr.size.get_val())):
t = ExprBinModel(self.lhs, BinExprType.Eq,
ExprFieldRefModel(arr.field_l[i]))
if expr is None:
expr = t
else:
expr = ExprBinModel(expr, BinExprType.Or, t)
# Clear the temporary term, so the combination code
# below doesn't use it.
t = None
else:
t = ExprBinModel(self.lhs, BinExprType.Eq, r)
else:
t = ExprBinModel(self.lhs, BinExprType.Eq, r)
if t is not None:
if expr is None:
expr = t
else:
expr = ExprBinModel(expr, BinExprType.Or, t)
if expr is None:
expr = ExprLiteralModel(1, False, 1)
from vsc.visitors.model_pretty_printer import ModelPrettyPrinter
return expr.build(btor) if expr is not None else None
def not_inside(self, rhs):
self.to_expr()
lhs_e = pop_expr()
if isinstance(rhs, rangelist):
return expr(
ExprUnaryModel(UnaryExprType.Not,
ExprInModel(lhs_e, rhs.range_l)))
elif isinstance(rhs, list_t):
return expr(
ExprUnaryModel(
UnaryExprType.Not,
ExprInModel(
lhs_e,
ExprRangelistModel(
[ExprFieldRefModel(rhs.get_model())]))))
else:
raise Exception("Unsupported 'not_inside' argument of type " +
str(type(rhs)) + " expect rangelist or list_t")
def __contains__(self, lhs):
if get_expr_mode():
to_expr(lhs)
return expr(
ExprInModel(
pop_expr(),
ExprRangelistModel([ExprFieldRefModel(self.get_model())])))
else:
model = self.get_model()
if self.is_enum:
ei: EnumInfo = self.t.enum_i
val = ei.e2v(lhs)
for f in model.field_l:
if int(f.get_val()) == val:
return True
elif self.is_scalar:
for f in model.field_l:
if int(f.get_val()) == int(lhs):
return True
else:
return lhs in self.backing_arr
return False
def create_rand_domain_constraint(
self, f: FieldScalarModel,
bound_m: VariableBoundModel) -> ExprModel:
e = None
range_l = bound_m.domain.range_l
# print("create_rand_domain_constraint: " + f.name + " " + str(range_l))
if len(range_l) == 1:
domain = range_l[0][1] - range_l[0][0]
if domain > 64:
r_type = self.randint(0, 3)
single_val = self.randint(range_l[0][0], range_l[0][1])
if r_type >= 0 and r_type <= 2: # range
# Pretty simple. Partition and randomize
bin_sz_h = 1 if int(domain / 128) == 0 else int(domain /
128)
if r_type == 0:
# Center value in bin
if single_val + bin_sz_h > range_l[0][1]:
max = range_l[0][1]
min = range_l[0][1] - 2 * bin_sz_h
elif single_val - bin_sz_h < range_l[0][0]:
max = range_l[0][0] + 2 * bin_sz_h
min = range_l[0][0]
else:
max = single_val + bin_sz_h
min = single_val - bin_sz_h
elif r_type == 1:
# Bin starts at value
if single_val + 2 * bin_sz_h > range_l[0][1]:
max = range_l[0][1]
min = range_l[0][1] - 2 * bin_sz_h
elif single_val - 2 * bin_sz_h < range_l[0][0]:
max = range_l[0][0] + 2 * bin_sz_h
min = range_l[0][0]
else:
max = single_val + 2 * bin_sz_h
min = single_val
elif r_type == 2:
# Bin ends at value
if single_val + 2 * bin_sz_h > range_l[0][1]:
max = range_l[0][1]
min = range_l[0][1] - 2 * bin_sz_h
elif single_val - 2 * bin_sz_h < range_l[0][0]:
max = range_l[0][0] + 2 * bin_sz_h
min = range_l[0][0]
else:
max = single_val
min = single_val - 2 * bin_sz_h
e = ExprBinModel(
ExprBinModel(
ExprFieldRefModel(f), BinExprType.Ge,
ExprLiteralModel(min, f.is_signed, f.width)),
BinExprType.And,
ExprBinModel(
ExprFieldRefModel(f), BinExprType.Le,
ExprLiteralModel(max, f.is_signed, f.width)))
elif r_type == 3: # Single value
e = ExprBinModel(
ExprFieldRefModel(f), BinExprType.Eq,
ExprLiteralModel(single_val, f.is_signed, f.width))
else:
val = self.randint(0, domain - 1)
e = ExprBinModel(ExprFieldRefModel(f), BinExprType.Eq,
ExprLiteralModel(val, f.is_signed, f.width))
else:
# domain_bin_ratio = int(len(bound_m.domain.range_l)/len(bound_m.domain_offsets))
#
# if domain_bin_ratio <= 1:
# # Just pick a single value
# print("Should pick single value")
# else:
# #
# print("domain_bin_ratio=" + str(domain_bin_ratio))
# pass
# # Multi-range domain
pass
return e