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('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);
}
// FIXME: Pick a sensible testname that actually means something!
TEST(array_cvcl02,one) {
VC vc = vc_createValidityChecker();
vc_setFlag(vc,'n');
vc_setFlag(vc,'d');
vc_setFlag(vc,'p');
Expr cvcl_array = vc_varExpr1(vc, "a",32,32);
Expr i = vc_varExpr1(vc, "i", 0, 8);
Expr i32 = vc_bvConcatExpr(vc,
vc_bvConstExprFromStr(vc,
"000000000000000000000000"),
i);
Expr no_underflow = vc_bvLeExpr(vc,
vc_bvConstExprFromInt(vc, 32, 0),
i32);
Expr no_overflow = vc_bvLeExpr(vc,
i32,
vc_bvConstExprFromInt(vc, 32, 9));
Expr in_bounds = vc_andExpr(vc, no_underflow, no_overflow);
Expr a_of_i = vc_bvSignExtend(vc,
vc_readExpr(vc,cvcl_array,i32),
32);
Expr a_of_i_eq_11 = vc_eqExpr(vc,
vc_bvConcatExpr(vc,i32,a_of_i),
vc_bvConstExprFromInt(vc, 64, 11));
vc_assertFormula(vc, in_bounds);
vc_assertFormula(vc, a_of_i_eq_11);
vc_query(vc, vc_falseExpr(vc));
long long v;
Expr pre = vc_bvConstExprFromInt(vc,24,0);
int j;
for(j=0;j<10;j++) {
Expr exprj = vc_bvConstExprFromInt(vc,8,j);
Expr index = vc_bvConcatExpr(vc, pre, exprj);
index = vc_simplify(vc,index);
Expr a_of_j = vc_readExpr(vc, cvcl_array, index);
Expr ce = vc_getCounterExample(vc,a_of_j);
}
vc_Destroy(vc);
//vc_printCounterExample(vc);
// FIXME: Actually test something
//ASSERT_TRUE(false && "FIXME: Actually test something");
}
Expr vc_bvReadMemoryArray(VC vc,
Expr array,
Expr byteIndex, int numOfBytes) {
if(!(numOfBytes > 0))
BEEV::FatalError("numOfBytes must be greater than 0");
if(numOfBytes == 1)
return vc_readExpr(vc,array,byteIndex);
else {
int count = 1;
Expr a = vc_readExpr(vc,array,byteIndex);
while(--numOfBytes > 0) {
Expr b = vc_readExpr(vc,array,
/*vc_simplify(vc, */
vc_bvPlusExpr(vc, 32,
byteIndex,
vc_bvConstExprFromInt(vc,32,count)))/*)*/;
a = vc_bvConcatExpr(vc,b,a);
count++;
}
return a;
}
}
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_bvConcatExpr(value vc, value l, value r)
{
CAMLparam3(vc,l,r);
CAMLreturn(alloc_Expr(vc_bvConcatExpr(VC_val(vc),Expr_val(l),Expr_val(r))));
}