bool STPSolverImpl::computeInitialValues(
const Query &query, const std::vector<const Array *> &objects,
std::vector<std::vector<unsigned char> > &values, bool &hasSolution) {
runStatusCode = SOLVER_RUN_STATUS_FAILURE;
TimerStatIncrementer t(stats::queryTime);
vc_push(vc);
for (ConstraintManager::const_iterator it = query.constraints.begin(),
ie = query.constraints.end();
it != ie; ++it)
vc_assertFormula(vc, builder->construct(*it));
++stats::queries;
++stats::queryCounterexamples;
ExprHandle stp_e = builder->construct(query.expr);
if (DebugDumpSTPQueries) {
char *buf;
unsigned long len;
vc_printQueryStateToBuffer(vc, stp_e, &buf, &len, false);
klee_warning("STP query:\n%.*s\n", (unsigned)len, buf);
}
bool success;
if (useForkedSTP) {
runStatusCode = runAndGetCexForked(vc, builder, stp_e, objects, values,
hasSolution, timeout);
success = ((SOLVER_RUN_STATUS_SUCCESS_SOLVABLE == runStatusCode) ||
(SOLVER_RUN_STATUS_SUCCESS_UNSOLVABLE == runStatusCode));
} else {
runStatusCode =
runAndGetCex(vc, builder, stp_e, objects, values, hasSolution);
success = true;
}
if (success) {
if (hasSolution)
++stats::queriesInvalid;
else
++stats::queriesValid;
}
vc_pop(vc);
return success;
}
char *STPSolverImpl::getConstraintLog(const Query &query) {
vc_push(vc);
for (std::vector< ref<Expr> >::const_iterator it = query.constraints.begin(),
ie = query.constraints.end(); it != ie; ++it)
vc_assertFormula(vc, builder->construct(*it));
assert(query.expr == ConstantExpr::alloc(0, Expr::Bool) &&
"Unexpected expression in query!");
char *buffer;
unsigned long length;
vc_printQueryStateToBuffer(vc, builder->getFalse(),
&buffer, &length, false);
vc_pop(vc);
return buffer;
}
bool
STPSolverImpl::computeInitialValues(const Query &query,
const std::vector<const Array*>
&objects,
std::vector< std::vector<unsigned char> >
&values,
bool &hasSolution) {
TimerStatIncrementer t(stats::queryTime);
vc_push(vc);
for (ConstraintManager::const_iterator it = query.constraints.begin(),
ie = query.constraints.end(); it != ie; ++it)
vc_assertFormula(vc, builder->construct(*it));
++stats::queries;
++stats::queryCounterexamples;
ExprHandle stp_e = builder->construct(query.expr);
if (0) {
char *buf;
unsigned long len;
vc_printQueryStateToBuffer(vc, stp_e, &buf, &len, false);
fprintf(stderr, "note: STP query: %.*s\n", (unsigned) len, buf);
}
bool success;
if (useForkedSTP) {
success = runAndGetCexForked(vc, builder, stp_e, objects, values,
hasSolution, timeout);
} else {
runAndGetCex(vc, builder, stp_e, objects, values, hasSolution);
success = true;
}
if (success) {
if (hasSolution)
++stats::queriesInvalid;
else
++stats::queriesValid;
}
vc_pop(vc);
return success;
}
bool
STPSolverImpl::computeInitialValues(const Query &query,
const std::vector<const Array*>
&objects,
std::vector< std::vector<unsigned char> >
&values,
bool &hasSolution) {
TimerStatIncrementer t(stats::queryTime);
reinstantiate();
vc_push(vc);
for (ConstraintManager::const_iterator it = query.constraints.begin(),
ie = query.constraints.end(); it != ie; ++it)
vc_assertFormula(vc, builder->construct(*it));
++stats::queries;
++stats::queryCounterexamples;
ExprHandle stp_e = builder->construct(query.expr);
if (__stp_printstate) {
char *buf;
buf = vc_printSMTLIB(vc, stp_e);
if (g_solverLog) {
*g_solverLog << "==============START=============" << std::endl;
*g_solverLog << buf << std::endl << std::flush;
*g_solverLog << "==============END=============" << std::endl;
}
//fprintf(stderr, "note: STP query: %.*s\n", (unsigned) len, buf);
free(buf);
}
bool success;
if (useForkedSTP) {
success = runAndGetCexForked(vc, builder, stp_e, objects, values,
hasSolution, timeout);
} else {
try {
runAndGetCex(vc, builder, stp_e, objects, values, hasSolution);
success = true;
} catch(std::exception &) {
klee::klee_warning("STP solver threw an exception");
exit(-1);
vc_pop(vc);
reinstantiate();
success = false;
return success;
}
}
if (success) {
if (hasSolution)
++stats::queriesInvalid;
else
++stats::queriesValid;
}
vc_pop(vc);
return success;
}
