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))
Randomizer.do_randomize([obj])
for f in arr.field_l:
print("" + f.name + ": " + str(int(f.get_val())))
def test_smoke(self):
obj = FieldCompositeModel("obj")
arr = obj.add_field(
FieldArrayModel(
"arr",
None, # type_t
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))
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 test_smoke(self):
obj = FieldCompositeModel("obj")
a = obj.add_field(FieldScalarModel("a", 8, False, True))
b = obj.add_field(FieldScalarModel("a", 8, False, True))
obj.add_constraint(
ConstraintBlockModel("c", [
ConstraintExprModel(
ExprBinModel(a.expr(), BinExprType.Lt, b.expr()))
]))
rand = Randomizer(RandState(0))
randstate = RandState(0)
rand.do_randomize(randstate, SourceInfo("", -1), [obj])
self.assertLess(a.val, b.val)
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_wide_var(self):
obj = FieldCompositeModel("obj")
a = obj.add_field(FieldScalarModel("a", 1024, False, True))
obj.add_constraint(
ConstraintBlockModel("c", [
ConstraintExprModel(
ExprBinModel(
a.expr(), BinExprType.Gt,
ExprLiteralModel(0x80000000000000000, False, 72)))
]))
randstate = RandState(0)
rand = Randomizer(randstate)
rand.do_randomize(randstate, SourceInfo("", -1), [obj])
print("a=" + hex(int(a.val)))
self.assertGreater(a.val, ValueScalar(0x80000000000000000))
def pop_constraint_scope():
for e in pop_exprs():
constraint_scope_stack[-1].constraint_l.append(ConstraintExprModel(e))
return constraint_scope_stack.pop()
def push_constraint_stmt(s):
for e in pop_exprs():
constraint_scope_stack[-1].constraint_l.append(ConstraintExprModel(e))
constraint_scope_stack[-1].constraint_l.append(s)
def visit_constraint_expr(self, c: ConstraintExprModel):
if self.do_copy_level > 0:
ret = ConstraintExprModel(self.expr(c.e))
self.constraints.append(ret)
else:
super().visit_constraint_expr(c)
def pop_constraint_scope():
for e in pop_exprs():
c = ConstraintExprModel(e)
c.srcinfo = e.srcinfo
constraint_scope_stack[-1].constraint_l.append(c)
return constraint_scope_stack.pop()
def push_constraint_stmt(s):
for e in pop_exprs():
c = ConstraintExprModel(e)
c.srcinfo = e.srcinfo
constraint_scope_stack[-1].constraint_l.append(c)
constraint_scope_stack[-1].constraint_l.append(s)
def visit_constraint_dist(self, c):
# We replace the dist constraint with an equivalent
# set of hard and soft constraints
scope = ConstraintDistScopeModel(c)
ranges = ExprRangelistModel()
for w in c.weights:
if w.rng_rhs is not None:
# two-value range
ranges.add_range(ExprRangeModel(w.rng_lhs, w.rng_rhs))
else:
# single value
ranges.add_range(w.rng_lhs)
# First, create an 'in' constraint to restrict
# values to the appropriate value set
in_c = ConstraintExprModel(ExprInModel(c.lhs, ranges))
scope.addConstraint(in_c)
# Now, we need to add exclusion constraints for any
# zero weights
# (!w) -> (lhs != [val])
# (!w) -> (lns not in [rng])
for w in c.weights:
if w.rng_rhs is not None:
scope.addConstraint(
ConstraintImpliesModel(
ExprBinModel(w.weight, BinExprType.Eq,
ExprLiteralModel(0, False, 8)),
[
ConstraintExprModel(
ExprUnaryModel(
UnaryExprType.Not,
ExprBinModel(
ExprBinModel(c.lhs, BinExprType.Ge,
w.rng_lhs),
BinExprType.And,
ExprBinModel(c.lhs, BinExprType.Le,
w.rng_rhs))))
]))
else:
scope.addConstraint(
ConstraintImpliesModel(
ExprBinModel(w.weight, BinExprType.Eq,
ExprLiteralModel(0, False, 8)),
[
ExprUnaryModel(
UnaryExprType.Not,
ExprBinModel(c.lhs, BinExprType.Eq, w.rng_lhs))
]))
# Form a list of non-zero weighted tuples of weight/range
# Sort in ascending order
weight_l = []
total_w = 0
for i, w in enumerate(c.weights):
weight = int(w.weight.val())
total_w += weight
if weight > 0:
weight_l.append((weight, i))
weight_l.sort(key=lambda w: w[0])
seed_v = self.rng.randint(1, total_w)
# Find the first range
i = 0
while i < len(weight_l):
seed_v -= weight_l[i][0]
if seed_v <= 0:
break
i += 1
if i >= len(weight_l):
i = len(weight_l) - 1
scope.target_range = weight_l[i][1]
target_w = c.weights[weight_l[i][1]]
dist_soft_c = None
if target_w.rng_rhs is not None:
dist_soft_c = ConstraintSoftModel(
ExprBinModel(
ExprBinModel(c.lhs, BinExprType.Ge, target_w.rng_lhs),
BinExprType.And,
ExprBinModel(c.lhs, BinExprType.Le, target_w.rng_rhs)))
else:
dist_soft_c = ConstraintSoftModel(
ExprBinModel(c.lhs, BinExprType.Eq, target_w.rng_lhs))
# Give dist constraints a high priority to allow
# them to override all user-defined soft constraints
dist_soft_c.priority = 1000000
scope.set_dist_soft_c(dist_soft_c)
self.override_constraint(scope)