/* C pointer support: C interface to support C memory arrays in CVCL */
Expr vc_bvCreateMemoryArray(VC vc, char * arrayName) {
Type bv8 = vc_bvType(vc,8);
Type bv32 = vc_bvType(vc,32);
Type malloced_mem0 = vc_arrayType(vc,bv32,bv8);
return vc_varExpr(vc, arrayName, malloced_mem0);
}
TEST(push_pop, two)
{
VC vc = vc_createValidityChecker();
//vc_setFlags(vc, 'n');
vc_setFlags(vc, 'd');
//vc_setFlags(vc, 'p');
//vc_setFlags(vc, 'v');
//vc_setFlags(vc, 's');
vc_setFlags(vc, 'c');
vc_push(vc);
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_varExpr(vc, "a", bv8);
Expr ct_0 = vc_bvConstExprFromInt(vc, 8, 0);
Expr a_eq_0 = vc_eqExpr(vc, a, ct_0);
vc_assertFormula(vc, a_eq_0);
vc_printAsserts(vc);
vc_push(vc);
Expr queryexp = vc_eqExpr(vc, a, vc_bvConstExprFromInt(vc, 8, 0));
//vc_printExpr(vc, queryexp);
int query;
query = vc_query(vc, queryexp);
vc_printCounterExample(vc);
vc_pop(vc);
vc_pop(vc);
ASSERT_TRUE(query);
}
TEST(getbv, INT64)
{
ASSERT_EQ(64, sizeof(uint64_t) * 8);
for (uint64_t j = 1; j < UINT64_MAX; j |= (j << 1))
{
VC vc = vc_createValidityChecker();
ASSERT_NE(vc, (void*)0);
vc_setFlags(vc, 'n');
vc_setFlags(vc, 'd');
vc_setFlags(vc, 'p');
vc_setFlags(vc, 'x');
Type bv8 = vc_bvType(vc, 8); // Why do we need this?
ASSERT_NE(bv8, (void*)0);
Expr a = vc_bvCreateMemoryArray(vc, "a"); // Why do we need this?
ASSERT_NE(a, (void*)0);
Expr index_3 = vc_bvConstExprFromLL(vc, 64, j);
ASSERT_NE(index_3, (void*)0);
uint64_t print_index = getBVUnsignedLongLong(index_3);
ASSERT_EQ(print_index, j);
vc_DeleteExpr(a);
vc_DeleteExpr(index_3);
vc_Destroy(vc);
}
}
int main() {
VC vc = vc_createValidityChecker();
vc_setFlags('n');
vc_setFlags('d');
//vc_setFlags('p');
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_bvCreateMemoryArray(vc, "a");
Expr index_3 = vc_bvConstExprFromInt(vc, 32, 3);
Expr a_of_0 = vc_readExpr(vc, a, index_3);
int i;
for (i = 2; i >= 0; i--)
a_of_0 = vc_bvConcatExpr(vc,
a_of_0,
vc_readExpr(vc, a,
vc_bvConstExprFromInt(vc, 32, i)));
Expr ct_5 = vc_bvConstExprFromInt(vc, 32, 5);
Expr a_of_0_div_5 = vc_bvDivExpr(vc, 32, a_of_0, ct_5);
Expr a_of_0_div_5_eq_5 = vc_eqExpr(vc, a_of_0_div_5, ct_5);
vc_printExpr(vc, a_of_0_div_5_eq_5); printf("\n");
/* Query 1 */
vc_push(vc);
int query = vc_query(vc, a_of_0_div_5_eq_5);
vc_pop(vc);
printf("query = %d\n", query);
vc_assertFormula(vc, a_of_0_div_5_eq_5);
vc_printExpr(vc, a_of_0_div_5_eq_5);
/* query(false) */
vc_push(vc);
query = vc_query(vc, vc_falseExpr(vc));
vc_pop(vc);
printf("query = %d\n", query);
assert(!query);
assert(vc_counterexample_size(vc));
int* a_val = (int*) malloc(sizeof *a_val);
char *p = (char*) a_val;
//a_of_1 = vc_simplify(vc, a_of_1); // BUG here
for (i=0; i<=3; i++) {
Expr elem = vc_readExpr(vc, a, vc_bvConstExprFromInt(vc, 32, i));
Expr ce = vc_getCounterExample(vc, elem);
unsigned long long v = getBVUnsigned(ce);
fprintf(stderr, "a[%d] = %ld\n", i, v);
*p = v; p++;
}
printf("a = %d\n", *a_val);
assert((*a_val)/5 == 5);
vc_Destroy(vc);
}
TEST(push_pop, one)
{
VC vc = vc_createValidityChecker();
//vc_setFlags(vc, 'n');
vc_setFlags(vc, 'd');
//vc_setFlags(vc, 'p');
// vc_setFlags(vc,'v');
// vc_setFlags(vc,'s');
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_varExpr(vc, "a", bv8);
Expr ct_0 = vc_bvConstExprFromInt(vc, 8, 0);
Expr a_eq_0 = vc_eqExpr(vc, a, ct_0);
int query = vc_query(vc, a_eq_0);
ASSERT_FALSE(query);
vc_push(vc);
query = vc_query(vc, a_eq_0);
ASSERT_FALSE(query);
vc_pop(vc);
vc_DeleteExpr(a_eq_0);
vc_DeleteExpr(a);
vc_Destroy(vc);
}
TEST(getbv, INT32)
{
ASSERT_EQ(32, sizeof(int32_t) * 8);
for (uint32_t j = 1; j < UINT32_MAX; j |= (j << 1))
{
VC vc = vc_createValidityChecker();
ASSERT_NE(vc, (void*)0);
vc_setFlags(vc, 'n');
vc_setFlags(vc, 'd');
vc_setFlags(vc, 'p');
vc_setFlags(vc, 'x');
Type bv8 = vc_bvType(vc, 8);
ASSERT_NE(bv8, (void*)0);
Expr a = vc_bvCreateMemoryArray(vc, "a"); // Why do we need this?
ASSERT_NE(a, (void*)0);
Expr index_3 = vc_bvConstExprFromInt(vc, 32, j);
ASSERT_NE(index_3, (void*)0);
uint32_t print_index = getBVUnsignedLongLong(index_3);
ASSERT_EQ(print_index, j);
vc_DeleteExpr(a);
// vc_DeleteExpr(index_3); - Urgh... STP's C API is inconsistent regarding
// what we should delete ourselves and what vc_Destroy() will do for us.
vc_Destroy(vc);
}
}
int main() {
for(int j=0;j < 3; j++) {
VC vc = vc_createValidityChecker();
vc_setFlags(vc,'n');
vc_setFlags(vc,'d');
vc_setFlags(vc,'p');
vc_setFlags(vc,'x');
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_bvCreateMemoryArray(vc, "a");
Expr index_3 = vc_bvConstExprFromLL(vc, 32, 3);
Expr a_of_0 = vc_readExpr(vc, a, index_3);
int i;
for (i = 2; i >= 0; i--)
a_of_0 = vc_bvConcatExpr(vc,
a_of_0,
vc_readExpr(vc, a,
vc_bvConstExprFromInt(vc, 32, i)));
Expr cast_32_to_8 = vc_bvExtract(vc, a_of_0, 7, 0);
Expr cast_8_to_32 = vc_bvSignExtend(vc, cast_32_to_8, 32);
vc_printExpr(vc, cast_8_to_32);
cast_8_to_32 = vc_simplify(vc, cast_8_to_32);
vc_Destroy(vc);
}
}
int main() {
VC vc = vc_createValidityChecker();
vc_setFlags(vc,'n');
vc_setFlags(vc,'c');
vc_setFlags(vc,'d');
vc_setFlags(vc,'p');
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_varExpr(vc, "a", bv8);
Expr ct_0 = vc_bvConstExprFromInt(vc, 8, 0);
Expr a_eq_0 = vc_eqExpr(vc, a, ct_0);
/* Query 1 */
vc_push(vc);
int query = vc_query(vc, a_eq_0);
vc_pop(vc);
printf("query = %d\n", query);
/* Query 2 */
Expr a_neq_0 = vc_notExpr(vc, a_eq_0);
vc_push(vc);
query = vc_query(vc, a_neq_0);
vc_pop(vc);
printf("query = %d\n", query);
vc_Destroy(vc);
return 0;
}
TEST(push_pop, one)
{
VC vc = vc_createValidityChecker();
vc_setFlags(vc, 'n');
vc_setFlags(vc, 'd');
vc_setFlags(vc, 'p');
// vc_setFlags(vc,'v');
// vc_setFlags(vc,'s');
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_varExpr(vc, "a", bv8);
Expr ct_0 = vc_bvConstExprFromInt(vc, 8, 0);
Expr a_eq_0 = vc_eqExpr(vc, a, ct_0);
int query = vc_query(vc, a_eq_0);
printf("query = %d\n", query);
vc_push(vc);
query = vc_query(vc, a_eq_0);
vc_pop(vc);
printf("query = %d\n", query);
vc_DeleteExpr(a_eq_0);
vc_DeleteExpr(a);
vc_Destroy(vc);
// FIXME: Actually test something
// ASSERT_TRUE(false && "FIXME: Actually test something");
}
TEST(multiple_queries,one) {
VC vc = vc_createValidityChecker();
vc_setFlags(vc,'n');
vc_setFlags(vc,'c');
vc_setFlags(vc,'d');
vc_setFlags(vc,'p');
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_varExpr(vc, "a", bv8);
Expr ct_0 = vc_bvConstExprFromInt(vc, 8, 0);
Expr a_eq_0 = vc_eqExpr(vc, a, ct_0);
/* Query 1 */
vc_push(vc);
int query = vc_query(vc, a_eq_0);
vc_pop(vc);
printf("query = %d\n", query);
/* Query 2 */
Expr a_neq_0 = vc_notExpr(vc, a_eq_0);
vc_push(vc);
query = vc_query(vc, a_neq_0);
vc_pop(vc);
printf("query = %d\n", query);
vc_Destroy(vc);
ASSERT_TRUE(false && "FIXME: Actually test something");
}
int main() {
VC vc = vc_createValidityChecker();
vc_setFlags('n');
vc_setFlags('d');
//vc_setFlags('p');
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_bvCreateMemoryArray(vc, "a");
Expr index_1 = vc_bvConstExprFromInt(vc, 32, 1);
Expr a_of_1 = vc_readExpr(vc, a, index_1);
Expr ct_100 = vc_bvConstExprFromInt(vc, 8, 100);
Expr a_of_1_eq_100 = vc_eqExpr(vc, a_of_1, ct_100);
/* Query 1 */
vc_push(vc);
int query = vc_query(vc, a_of_1_eq_100);
vc_pop(vc);
printf("query = %d\n", query);
vc_assertFormula(vc, a_of_1_eq_100);
/* query(false) */
vc_push(vc);
query = vc_query(vc, vc_falseExpr(vc));
vc_pop(vc);
printf("query = %d\n", query);
if (vc_counterexample_size(vc) == 0) {
printf("Counterexample size is 0\n");
exit(1);
}
a_of_1 = vc_simplify(vc, a_of_1);
//vc_printExpr(vc, a_of_1);
Expr ce = vc_getCounterExample(vc, a_of_1);
unsigned long long v = getBVUnsigned(ce);
fprintf(stderr, "a[1] = %ld\n", v);
vc_Destroy(vc);
}
int main() {
for(int j=0;j < 3; j++) {
VC vc = vc_createValidityChecker();
vc_setFlags(vc,'n');
vc_setFlags(vc,'d');
vc_setFlags(vc,'p');
vc_setFlags(vc,'x');
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_bvCreateMemoryArray(vc, "a");
Expr index_3 = vc_bvConstExprFromLL(vc, 64, 0xf0000000effff000LL);
unsigned long long int print_index = getBVUnsignedLongLong(index_3);
printf("testing getBVUnsignedLongLong function: %llx \n", print_index);
printf("\n");
vc_DeleteExpr(a);
vc_DeleteExpr(index_3);
vc_Destroy(vc);
}
}
TEST(stp_counterex,one) {
VC vc = vc_createValidityChecker();
vc_setFlags(vc,'n');
vc_setFlags(vc,'d');
//vc_setFlags(vc,'p');
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_bvCreateMemoryArray(vc, "a");
Expr index_1 = vc_bvConstExprFromInt(vc, 32, 1);
Expr a_of_1 = vc_readExpr(vc, a, index_1);
Expr ct_100 = vc_bvConstExprFromInt(vc, 8, 100);
Expr a_of_1_eq_100 = vc_eqExpr(vc, a_of_1, ct_100);
/* Query 1 */
vc_push(vc);
int query = vc_query(vc, a_of_1_eq_100);
vc_pop(vc);
printf("query = %d\n", query);
vc_assertFormula(vc, a_of_1_eq_100);
/* query(false) */
vc_push(vc);
query = vc_query(vc, vc_falseExpr(vc));
vc_pop(vc);
printf("query = %d\n", query);
ASSERT_FALSE(vc_counterexample_size(vc) == 0);
a_of_1 = vc_simplify(vc, a_of_1);
//vc_printExpr(vc, a_of_1);
Expr ce = vc_getCounterExample(vc, a_of_1);
unsigned long long v = getBVUnsigned(ce);
fprintf(stderr, "a[1] = %llu\n", v);
vc_Destroy(vc);
// FIXME: we should test more things!
}
void test9 (void)
{
VC vc = vc_createValidityChecker (((void *) 0));
Type bv32 = vc_bvType (vc, 32);
Expr zero = vc_bvConstExprFromInt (vc, 32, 0);
Expr one = vc_bvConstExprFromInt (vc, 32, 1);
Expr a = vc_varExpr (vc, "a", bv32);
Expr three = vc_bvConstExprFromInt (vc, 32, 3);
Expr three64 = vc_bvSignExtend (vc, three, 64);
Expr a64 = vc_bvSignExtend (vc, a, 64);
Expr prod64 = vc_bvMultExpr (vc, 64, a64, three64);
Expr min = vc_bvConstExprFromInt (vc, 32, (-2147483647 - 1));
Expr max = vc_bvConstExprFromInt (vc, 32, 2147483647);
Expr prod64_sge_min = vc_bvSGeExpr (vc, prod64, min);
Expr prod64_sle_max = vc_bvSLeExpr (vc, prod64, max);
Expr prod64_sge_min_and_sle_max =
vc_andExpr (vc, prod64_sge_min, prod64_sle_max);
vc_assertFormula (vc, prod64_sge_min_and_sle_max);
Expr D3 = vc_varExpr (vc, "D3", bv32);
Expr prod = vc_bvMultExpr (vc, 32, a, three);
Expr D3_eq_prod = vc_eqExpr (vc, D3, prod);
vc_assertFormula (vc, D3_eq_prod);
Expr D4 = vc_varExpr (vc, "D4", bv32);
Expr D3_sle_a_cond = vc_bvSLeExpr (vc, D3, a);
Expr D3_sle_a_expr = vc_iteExpr (vc, D3_sle_a_cond, one, zero);
Expr D4_eq_D3_sle_a_expr = vc_eqExpr (vc, D4, D3_sle_a_expr);
vc_assertFormula (vc, D4_eq_D3_sle_a_expr);
Expr D6 = vc_varExpr (vc, "D6", bv32);
Expr D3_slt_a_cond = vc_bvSLtExpr (vc, D3, a);
Expr D3_slt_a_expr = vc_iteExpr (vc, D3_slt_a_cond, one, zero);
Expr D6_eq_D3_slt_a_expr = vc_eqExpr (vc, D6, D3_slt_a_expr);
vc_assertFormula (vc, D6_eq_D3_slt_a_expr);
Expr zero_lt_a = vc_bvSLtExpr (vc, zero, a);
vc_assertFormula (vc, zero_lt_a);
Expr D4_eq_one = vc_eqExpr (vc, D4, one);
Expr not_D4_eq_one = vc_notExpr (vc, D4_eq_one);
vc_query (vc, not_D4_eq_one);
Expr D6_eq_one = vc_eqExpr (vc, D6, one);
Expr not_D6_eq_one = vc_notExpr (vc, D6_eq_one);
vc_query (vc, not_D6_eq_one);
vc_destroyValidityChecker(vc);
}
void go (enum ifaceflag_t f)
{
VC vc;
vc = vc_createValidityChecker ();
vc_setInterfaceFlags(vc, f, 0);
//vc_setFlags(vc,'s',0);
// CVC_FILE is a macro that expands to a file path
vc_parseExpr(vc, CVC_FILE);
Expr a = vc_varExpr(vc, "a", vc_bvType(vc, 8));
Expr ct_0 = vc_bvConstExprFromInt(vc, 8, 0);
Expr a_eq_0 = vc_eqExpr(vc, a, ct_0);
int query = vc_query(vc, a_eq_0);
vc_Destroy (vc);
ASSERT_TRUE(false && "FIXME: Actually test something");
}
int main(int argc, char** argv)
{
int width=8;
VC handle = vc_createValidityChecker();
// Create variable "x"
Expr x = vc_varExpr(handle, "x", vc_bvType(handle, width));
// Create bitvector x + x
Expr xPlusx = vc_bvPlusExpr(handle, width, x, x);
// Create bitvector constant 2
Expr two = vc_bvConstExprFromInt(handle, width, 2);
// Create bitvector 2*x
Expr xTimes2 = vc_bvMultExpr(handle, width, two, x);
// Create bool expression x + x = 2*x
Expr equality = vc_eqExpr(handle, xPlusx , xTimes2);
vc_assertFormula(handle, vc_trueExpr(handle) );
// We are asking STP: ∀ x. true → ( x + x = 2*x )
// This should be VALID.
printf("######First Query\n");
handleQuery(handle, equality);
// We are asking STP: ∀ x. true → ( x + x = 2 )
// This should be INVALID.
printf("######Second Query\n");
// Create bool expression x + x = 2
Expr badEquality = vc_eqExpr(handle, xPlusx , two);
handleQuery(handle, badEquality);
// Clean up
vc_Destroy(handle);
return 0;
}
TEST(push_pop, two)
{
VC vc = vc_createValidityChecker();
vc_setFlags(vc, 'n');
vc_setFlags(vc, 'd');
vc_setFlags(vc, 'p');
vc_setFlags(vc, 'v');
vc_setFlags(vc, 's');
vc_setFlags(vc, 'c');
vc_push(vc);
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_varExpr(vc, "a", bv8);
Expr ct_0 = vc_bvConstExprFromInt(vc, 8, 0);
Expr a_eq_0 = vc_eqExpr(vc, a, ct_0);
int query;
// query = vc_query(vc, a_eq_0);
// printf("query = %d\n", query);
Expr a_neq_0 = vc_notExpr(vc, a_eq_0);
vc_assertFormula(vc, a_eq_0);
vc_printAsserts(vc);
vc_push(vc);
Expr queryexp = vc_eqExpr(vc, a, vc_bvConstExprFromInt(vc, 8, 0));
vc_printExpr(vc, queryexp);
query = vc_query(vc, queryexp);
vc_printCounterExample(vc);
vc_pop(vc);
vc_pop(vc);
printf("query = %d\n", query);
// FIXME: Actually test something
// ASSERT_TRUE(false && "FIXME: Actually test something");
}
TEST(extend_adder_notexpr, one)
{
VC vc = vc_createValidityChecker();
vc_setFlags(vc, 'n');
vc_setFlags(vc, 'd');
// 8-bit variable 'x'
Expr x = vc_varExpr(vc, "x", vc_bvType(vc, 8));
// 32 bit constant value 1
Expr one = vc_bvConstExprFromInt(vc, 32, 1);
// 24 bit constant value 0
Expr bit24_zero = vc_bvConstExprFromInt(vc, 24, 0);
// 32 bit constant value 0
Expr bit32_zero = vc_bvConstExprFromInt(vc, 32, 0);
// Extending 8-bit variable to 32-bit value
Expr zero_concat_x = vc_bvConcatExpr(vc, bit24_zero, x);
Expr xp1 = vc_bvPlusExpr(vc, 32, zero_concat_x, one);
// Insteading of concat operation, I also tried with SignExtend
// Expr signextend_x=vc_bvSignExtend(vc,x,32);
// Expr xp1=vc_bvPlusExpr(vc,32,signextend_x,one);
// x+1=0
Expr eq = vc_eqExpr(vc, xp1, bit32_zero);
// x+1!=0
eq = vc_notExpr(vc, eq);
vc_query(vc, eq);
vc_printCounterExample(vc);
// FIXME: Actually test something
// ASSERT_TRUE(false && "FIXME: Actually test something");
}
value caml_vc_bvType(value vc, value no_bits)
{
CAMLparam2(vc,no_bits);
CAMLreturn(alloc_Type(vc_bvType(VC_val(vc),Int_val(no_bits))));
}
TEST(reported_issue_120, one)
{
VC vc = vc_createValidityChecker();
// Numbers will be non-negatives integers bounded at 2^32
Type bv32 = vc_bvType(vc, 32);
// Determine whether the following equations are satisfiable:
// v + 4 = n
// 4 = n
// Construct variable n
Expr n = vc_varExpr(vc, "n", bv32);
// Construct v + 4
Expr v = vc_varExpr(vc, "v", bv32);
Expr ct_4 = vc_bvConstExprFromInt(vc, 32, 4);
Expr add_v_4 = vc_bvPlusExpr(vc, 32, v, ct_4);
// Because numbers are represented as bit vectors,
// addition can roll over. So construct a constraint
// expresses that v+4 does not overflow the bounds:
// v + 4 >= v
//
Expr ge = vc_bvGeExpr(vc, add_v_4, v);
// Push a new context
printf("Push\n");
vc_push(vc);
// Assert v + 4 = n
printf("Assert v + 4 = n\n");
Expr f_add = vc_eqExpr(vc, add_v_4, n);
vc_assertFormula(vc, f_add);
vc_printExpr(vc, f_add);
printf("\n------\n");
// Assert the bounds constraint
printf("Assert v + 4 >= v\n");
vc_assertFormula(vc, ge);
vc_printExpr(vc, ge);
printf("\n------\n");
// Assert 4 = n
printf("Assert 4 = n\n");
Expr f_numeq = vc_eqExpr(vc, ct_4, n);
vc_assertFormula(vc, f_numeq);
vc_printExpr(vc, f_numeq);
printf("\n------\n");
// Check for satisfiability
printf("Check\n");
vc_printAsserts(vc);
printf("\n------\n");
int query = vc_query(vc, vc_falseExpr(vc));
ASSERT_EQ(query, 0);
// Pop context
printf("Pop\n");
vc_pop(vc);
printf("query = %d\n", query);
}
Type vc_bv32Type(VC vc) {
return vc_bvType(vc,32);
}
void test8 (void)
{
Flags flags = vc_createFlags();
/* vc_setStrSeqFlag(flags, "trace", "pushpop", 1); */
/* vc_setStrSeqFlag(flags, "trace", "assertLit", 1); */
/* vc_setStrSeqFlag(flags, "trace", "assertFactCore", 1); */
/* vc_setStrSeqFlag(flags, "trace", "assertFormula", 1); */
VC vc = vc_createValidityChecker (flags);
Type bv32 = vc_bvType (vc, 32);
Expr zero = vc_bvConstExprFromInt (vc, 32, 0);
Expr one = vc_bvConstExprFromInt (vc, 32, 1);
Expr a = vc_varExpr (vc, "a", bv32);
Expr three = vc_bvConstExprFromInt (vc, 32, 3);
Expr prod = vc_bvMultExpr (vc, 32, a, three);
{
Expr a64 = vc_bvSignExtend (vc, a, 64);
Expr three64 = vc_bvSignExtend (vc, three, 64);
Expr prod64 = vc_bvMultExpr (vc, 64, a64, three64);
Expr max = vc_bvConstExprFromInt (vc, 32, 2147483647);
Expr min = vc_bvConstExprFromInt (vc, 32, (-2147483647 - 1));
Expr prod64_sge_min = vc_bvSGeExpr (vc, prod64, min);
Expr prod64_sle_max = vc_bvSLeExpr (vc, prod64, max);
Expr prod64_sge_min_and_sle_max =
vc_andExpr (vc, prod64_sge_min, prod64_sle_max);
vc_assertFormula (vc, prod64_sge_min_and_sle_max);
}
Expr D4 = vc_varExpr (vc, "D4", bv32);
{
Expr cond = vc_bvSLtExpr (vc, a, prod);
Expr test = vc_iteExpr (vc, cond, one, zero);
Expr D4_eq_test = vc_eqExpr (vc, D4, test);
vc_assertFormula (vc, D4_eq_test);
}
Expr D6 = vc_varExpr (vc, "D6", bv32);
{
Expr cond = vc_bvSLeExpr (vc, a, prod);
Expr test = vc_iteExpr (vc, cond, one, zero);
Expr D6_eq_test = vc_eqExpr (vc, D6, test);
vc_assertFormula (vc, D6_eq_test);
}
vc_push (vc);
vc_pop (vc);
vc_push (vc);
{
Expr cond = vc_bvSLtExpr (vc, a, zero);
Expr test = vc_iteExpr (vc, cond, one, zero);
Expr test_eq_one = vc_eqExpr (vc, test, one);
vc_assertFormula (vc, test_eq_one);
vc_push (vc);
{
Expr D4_eq_one = vc_eqExpr (vc, D4, one);
vc_query (vc, D4_eq_one);
}
vc_pop (vc);
vc_push (vc);
vc_pop (vc);
vc_push (vc);
vc_pop (vc);
}
vc_pop (vc);
{
Expr cond = vc_eqExpr (vc, a, zero);
Expr test = vc_iteExpr (vc, cond, one, zero);
Expr test_eq_one = vc_eqExpr (vc, test, one);
vc_assertFormula (vc, test_eq_one);
vc_push (vc);
vc_pop (vc);
{
Expr zero_eq_one = vc_eqExpr (vc, zero, one);
vc_query (vc, zero_eq_one);
}
}
vc_destroyValidityChecker(vc);
}
