void symex_dereference_statet::get_value_set(
const exprt &expr,
value_setst::valuest &value_set)
{
renaming_nst renaming_ns(goto_symex.ns, state);
state.value_set.get_value_set(expr, value_set, renaming_ns);
#if 0
std::cout << "**************************\n";
state.value_set.output(renaming_ns, std::cout);
std::cout << "**************************\n";
#endif
#if 0
std::cout << "E: " << from_expr(renaming_ns, "", expr) << std::endl;
#endif
#if 0
std::cout << "**************************\n";
for(value_setst::valuest::const_iterator it=value_set.begin();
it!=value_set.end();
it++)
std::cout << from_expr(renaming_ns, "", *it) << std::endl;
std::cout << "**************************\n";
#endif
}
void equality_domaint::output_value(
std::ostream &out,
const valuet &value,
const namespacet &ns) const
{
const equ_valuet &_v=static_cast<const equ_valuet &>(value);
equ_valuet v=_v;
for(unsigned index=0; index<templ.size(); index++)
{
const var_pairt &vv=templ[index].var_pair;
if(v.equs.same_set(vv.first, vv.second))
{
out << from_expr(ns, "", vv.first) << "=="
<< from_expr(ns, "", vv.second) << std::endl;
}
}
for(index_sett::const_iterator it=v.disequs.begin();
it!=v.disequs.end(); it++)
{
const var_pairt &vv=templ[*it].var_pair;
out << from_expr(ns, "", vv.first) << "!="
<< from_expr(ns, "", vv.second) << std::endl;
}
}
exprt local_SSAt::read_rhs(const exprt &expr, locationt loc) const
{
exprt tmp1=expr;
adjust_float_expressions(tmp1, ns);
unsigned counter=0;
replace_side_effects_rec(tmp1, loc, counter);
#ifdef DEBUG
std::cout << "read_rhs tmp1: " << from_expr(ns, "", tmp1) << '\n';
#endif
exprt tmp2=dereference(tmp1, loc);
#ifdef DEBUG
std::cout << "read_rhs tmp2: " << from_expr(ns, "", tmp2) << '\n';
#endif
exprt result=read_rhs_rec(tmp2, loc);
#ifdef DEBUG
std::cout << "read_rhs result: " << from_expr(ns, "", result) << '\n';
#endif
return result;
}
void show_properties(
const namespacet &ns,
const irep_idt &identifier,
ui_message_handlert::uit ui,
const goto_programt &goto_program)
{
for(const auto &ins : goto_program.instructions)
{
if(!ins.is_assert())
continue;
const source_locationt &source_location=ins.source_location;
const irep_idt &comment=source_location.get_comment();
const irep_idt &property_class=source_location.get_property_class();
const irep_idt description=
(comment==""?"assertion":comment);
irep_idt property_id=source_location.get_property_id();
switch(ui)
{
case ui_message_handlert::uit::XML_UI:
{
// use me instead
xmlt xml_property("property");
xml_property.set_attribute("name", id2string(property_id));
xml_property.set_attribute("class", id2string(property_class));
xmlt &property_l=xml_property.new_element();
property_l=xml(source_location);
xml_property.new_element("description").data=id2string(description);
xml_property.new_element("expression").data=
from_expr(ns, identifier, ins.guard);
std::cout << xml_property << '\n';
}
break;
case ui_message_handlert::uit::JSON_UI:
UNREACHABLE;
break;
case ui_message_handlert::uit::PLAIN:
std::cout << "Property " << property_id << ":\n";
std::cout << " " << ins.source_location << '\n'
<< " " << description << '\n'
<< " " << from_expr(ns, identifier, ins.guard)
<< '\n';
std::cout << '\n';
break;
default:
UNREACHABLE;
}
}
}
void predabs_domaint::output_value(
std::ostream &out,
const valuet &value,
const namespacet &ns) const
{
const templ_valuet &v=static_cast<const templ_valuet &>(value);
for(std::size_t row=0; row<templ.size(); ++row)
{
const template_rowt &templ_row=templ[row];
switch(templ_row.kind)
{
case LOOP:
out << "(LOOP) [ " << from_expr(ns, "", templ_row.pre_guard) << " | ";
out << from_expr(ns, "", templ_row.post_guard) << " | ";
out << from_expr(ns, "", templ_row.aux_expr)
<< " ]===> " << std::endl << " ";
break;
case IN: out << "(IN) "; break;
case OUT: case OUTL: out << "(OUT) "; break;
default: assert(false);
}
out << "( " << from_expr(ns, "", v[row]) << "==> " <<
from_expr(ns, "", templ_row.expr) << " )" << std::endl;
}
}
void termination_baset::show_loop_trace(
const goto_tracet &goto_trace,
goto_tracet::stepst::const_iterator &loop_begin)
{
if(verbosity<9) return;
std::string output;
output = "--- LOOP TRACE START\n";
for(goto_tracet::stepst::const_iterator step=loop_begin;
step!=goto_trace.steps.end();
step++)
{
switch(step->type)
{
case goto_trace_stept::ASSIGNMENT:
output+=from_expr(ns, "", step->pc->code) + "\n";
break;
case goto_trace_stept::ASSUME:
output+=from_expr(ns, "", step->pc->guard) + " [" +
(step->cond_value?"":"!") + from_expr(ns, "", step->cond_expr) + "]\n";
break;
default:
break;
}
}
output+="--- LOOP TRACE END\n";
debug(output);
}
void path_searcht::do_show_vcc(
statet &state,
const namespacet &ns)
{
// keep statistics
number_of_VCCs++;
const goto_programt::instructiont &instruction=
*state.get_instruction();
mstreamt &out=result();
if(instruction.location.is_not_nil())
out << instruction.location << "\n";
if(instruction.location.get_comment()!="")
out << instruction.location.get_comment() << "\n";
unsigned count=1;
std::vector<path_symex_step_reft> steps;
state.history.build_history(steps);
for(std::vector<path_symex_step_reft>::const_iterator
s_it=steps.begin();
s_it!=steps.end();
s_it++)
{
if((*s_it)->guard.is_not_nil())
{
std::string string_value=from_expr(ns, "", (*s_it)->guard);
out << "{-" << count << "} " << string_value << "\n";
count++;
}
if((*s_it)->ssa_rhs.is_not_nil())
{
equal_exprt equality((*s_it)->ssa_lhs, (*s_it)->ssa_rhs);
std::string string_value=from_expr(ns, "", equality);
out << "{-" << count << "} " << string_value << "\n";
count++;
}
}
out << "|--------------------------" << "\n";
exprt assertion=state.read(instruction.guard);
out << "{" << 1 << "} "
<< from_expr(ns, "", assertion) << "\n";
if(!assertion.is_true())
number_of_VCCs_after_simplification++;
out << eom;
}
std::set<symbol_exprt> concurrency_aware_abstractort::targets_of_lvalue(const exprt& lvalue, goto_programt::const_targett program_location)
{
std::set<symbol_exprt> result;
if(lvalue.id() == ID_index)
{
exprt array_name = lvalue.op0();
if(array_name.id() == ID_symbol)
{
result.insert(to_symbol_expr(array_name));
} else {
return targets_of_lvalue(array_name, program_location);
}
} else if(lvalue.id() == ID_member) {
assert(lvalue.operands().size() == 1);
return targets_of_lvalue(lvalue.op0(), program_location);
} else if(lvalue.id() == ID_symbol) {
result.insert(to_symbol_expr(lvalue));
} else if(lvalue.id() == ID_dereference) {
// We would like to add anything the pointer can point to,
// but not the pointer itself
value_setst::valuest value_set;
pointer_info.get_values(program_location, lvalue.op0(), value_set);
for(value_setst::valuest::iterator it = value_set.begin(); it != value_set.end(); it++)
{
if(it->id() != ID_object_descriptor)
{
// TODO: We may need to deal with this situation more carefully
continue;
}
object_descriptor_exprt& object_descriptor = to_object_descriptor_expr(*it);
if(object_descriptor.offset() != from_integer(0, index_type()))
{
std::cout << "Pointer " << from_expr(lvalue.op0()) << " can point to " << from_expr(*it) << " at line " <<
program_location->location.get_line() << ", we cannot handle this" << std::endl;
exit(1);
}
if(object_descriptor.object().id() != ID_symbol)
{
std::cout << "Pointer " << from_expr(lvalue.op0()) << " can point to " << from_expr(*it) << " at line " <<
program_location->location.get_line() << ", we cannot handle this" << std::endl;
exit(1);
}
result.insert(to_symbol_expr(object_descriptor.object()));
}
} else {
std::cout << "Cannot currently handle lvalue: " << from_expr(lvalue) << std::endl;
assert(false);
}
return result;
}
void symex_target_equationt::SSA_stept::output(
const namespacet &ns,
std::ostream &out) const
{
if(source.is_set)
{
out << "Thread " << source.thread_nr;
if(source.pc->location.is_not_nil())
out << " " << source.pc->location << std::endl;
else
out << std::endl;
}
switch(type)
{
case goto_trace_stept::ASSERT: out << "ASSERT" << std::endl; break;
case goto_trace_stept::ASSUME: out << "ASSUME" << std::endl; break;
case goto_trace_stept::LOCATION: out << "LOCATION" << std::endl; break;
case goto_trace_stept::INPUT: out << "INPUT" << std::endl; break;
case goto_trace_stept::OUTPUT: out << "OUTPUT" << std::endl; break;
case goto_trace_stept::DECL:
out << "DECL" << std::endl;
out << from_expr(ns, "", ssa_lhs) << std::endl;
break;
case goto_trace_stept::ASSIGNMENT:
out << "ASSIGNMENT (";
switch(assignment_type)
{
case HIDDEN: out << "HIDDEN"; break;
case STATE: out << "STATE"; break;
default:;
}
out << ")" << std::endl;
break;
case goto_trace_stept::DEAD: out << "DEAD" << std::endl; break;
case goto_trace_stept::FUNCTION_CALL: out << "FUNCTION_CALL" << std::endl; break;
case goto_trace_stept::FUNCTION_RETURN: out << "FUNCTION_RETURN" << std::endl; break;
default: assert(false);
}
if(is_assert() || is_assume() || is_assignment())
out << from_expr(ns, "", cond_expr) << std::endl;
if(is_assert())
out << comment << std::endl;
out << "Guard: " << from_expr(ns, "", guard_expr) << std::endl;
}
void path_searcht::do_show_vcc(statet &state)
{
// keep statistics
number_of_VCCs++;
const goto_programt::instructiont &instruction=
*state.get_instruction();
mstreamt &out=result();
if(instruction.source_location.is_not_nil())
out << instruction.source_location << '\n';
if(instruction.source_location.get_comment()!="")
out << instruction.source_location.get_comment() << '\n';
unsigned count=1;
std::vector<path_symex_step_reft> steps;
state.history.build_history(steps);
for(const auto &step_ref : steps)
{
if(step_ref->guard.is_not_nil())
{
std::string string_value=from_expr(ns, "", step_ref->guard);
out << "{-" << count << "} " << string_value << '\n';
count++;
}
if(step_ref->ssa_rhs.is_not_nil())
{
equal_exprt equality(step_ref->ssa_lhs, step_ref->ssa_rhs);
std::string string_value=from_expr(ns, "", equality);
out << "{-" << count << "} " << string_value << '\n';
count++;
}
}
out << "|--------------------------" << '\n';
exprt assertion=state.read(instruction.guard);
out << "{" << 1 << "} "
<< from_expr(ns, "", assertion) << '\n';
if(!assertion.is_true())
number_of_VCCs_after_simplification++;
out << eom;
}
void abstractor_wpt::pred_abstract_block(
goto_programt::const_targett target,
const predicatest &predicates,
abstract_transition_relationt &
abstract_transition_relation)
{
std::vector<exprt> predicates_wp;
std::list<exprt> constraints;
build_equation(
concrete_model.ns,
predicates,
target,
constraints,
predicates_wp);
#if 0
std::cout << target->location << std::endl;
std::cout << equation;
#endif
// find unchanged predicates
// find predicates with value
for(unsigned i=0; i<predicates.size(); i++)
{
if(predicates_wp[i]==predicates[i])
{
abstract_transition_relation.values.erase(i);
#if 0
std::cout << "UNCHANGED: P" << i << std::endl;
#endif
}
else
{
#if 0
std::cout << "DIFFERENT: P" << i << std::endl;
std::cout << "WP: " << from_expr(concrete_model.ns, "", predicates_wp[i]) << std::endl;
std::cout << "P: " << from_expr(concrete_model.ns, "", predicates[i]) << std::endl;
#endif
abstract_transition_relation.values[i]=
get_value(i, predicates, predicates_wp[i], concrete_model.ns, target);
// if it changes, it's output
abstract_transition_relation.to_predicates.insert(i);
}
}
}
void ranking_synthesis_satt::show_coefficients(c_valuest &c_values)
{
if(verbosity<9) return;
std::string t("Coefficients: ");
for(c_valuest::const_iterator it=c_values.begin();
it!=c_values.end();
it++)
{
if(it!=c_values.begin()) t+=", ";
t+=from_expr(ns, "", it->first) +"=" +
from_expr(ns, "", from_integer(it->second, it->first.type()));
}
debug(t);
}
void show_properties_json(
json_arrayt &json_properties,
const namespacet &ns,
const irep_idt &identifier,
const goto_programt &goto_program)
{
for(const auto &ins : goto_program.instructions)
{
if(!ins.is_assert())
continue;
const source_locationt &source_location=ins.source_location;
const irep_idt &comment=source_location.get_comment();
// const irep_idt &function=location.get_function();
const irep_idt &property_class=source_location.get_property_class();
const irep_idt description=
(comment==""?"assertion":comment);
irep_idt property_id=source_location.get_property_id();
json_objectt &json_property=
json_properties.push_back(jsont()).make_object();
json_property["name"]=json_stringt(id2string(property_id));
json_property["class"]=json_stringt(id2string(property_class));
json_property["sourceLocation"]=json(source_location);
json_property["description"]=json_stringt(id2string(description));
json_property["expression"]=
json_stringt(from_expr(ns, identifier, ins.guard));
}
}
bool ranking_synthesis_seneschalt::write_constraints(
std::ostream &f,
replace_mapt &rmap,
exprt e)
{
expr2seneschalt expr2seneschal(ns);
f << " \\transition {" << std::endl;
bool first=true;
forall_operands(it, e)
{
exprt t = *it;
replace_expr(rmap, t);
{
if(!first) f << " & " << std::endl;
try {
f << " " << expr2seneschal(t, false, true);
}
catch (const expr2seneschalt::UnhandledException &ex)
{
status("Seneschal unsuitable: " + ex.reason.id_string());
status("In: " + from_expr(ns, "", t));
return false;
}
first=false;
}
}
void predicatet::output(std::ostream &out) const
{
// print equalities in pretty way
out << "State vars:";
for(unsigned v=0; v<state_vars.size(); v++)
out << " " << from_expr(state_vars[v]);
out << "\n";
std::map<unsigned, unsigned> eq_count;
for(unsigned v=0; v<state_vars.size(); v++)
eq_count[uuf.find(v)]++;
for(std::map<unsigned, unsigned>::const_iterator
e_it=eq_count.begin(); e_it!=eq_count.end(); e_it++)
{
if(e_it->second>=2)
{
for(unsigned v=0; v<state_vars.size(); v++)
if(e_it->first==uuf.find(v))
out << "Equal: " << from_expr(state_vars[v]) << "\n";
out << "\n";
}
}
// print intervals
#if 0
for(integer_intervalst::const_iterator
i_it=integer_intervals.begin(); i_it!=integer_intervals.end(); i_it++)
{
if(i_it->lower_is_set || i_it->upper_is_set)
{
if(i_it->lower_is_set)
out << from_expr(i_it->lower) << " <= ";
out << from_expr(vars[i_it-intervals.begin()]);
if(i_it->upper_is_set)
out << " <= " << from_expr(i_it->lower);
out << "\n";
}
}
#endif
}
/*******************************************************************\
Function: acdl_conflict_grapht::print_output
Inputs:
Outputs:
Purpose:
\*******************************************************************/
void acdl_conflict_grapht::dump_dec_trail(const local_SSAt &SSA)
{
std::cout << "Dump the decision trail" << std::endl;
for(unsigned i=0;i<dec_trail.size();i++) {
std::cout << "decision trail element:" << from_expr(SSA.ns, "", dec_trail[i]) << std::endl;
// std::cout << "Val trail:" << from_expr(SSA.ns, "", numbering[val_trail[i]]) << std::endl;
}
}
std::string bv_refinementt::approximationt::as_string() const
{
#if 0
return from_expr(expr);
#else
return i2string(id_nr)+"/"+id2string(expr.id());
#endif
}
std::set<symbol_exprt> locations_of_expression(const predicatet& phi, const goto_programt::const_targett program_location, value_set_analysist& pointer_info, const namespacet& ns)
{
#ifdef DEBUG
std::cout << "Computing locations of " << from_expr(ns, "", phi) << std::endl;
#endif
return locations_of_expression_rec(phi, program_location, pointer_info, ns);
}
void equality_domaint::output_domain(
std::ostream &out,
const namespacet &ns) const
{
for(unsigned index=0; index<templ.size(); index++)
{
const template_rowt &templ_row=templ[index];
switch(templ_row.kind)
{
case LOOP:
out << "(LOOP) [ " << from_expr(ns, "", templ_row.pre_guard) << " | ";
out << from_expr(ns, "", templ_row.post_guard) << " | ";
out << from_expr(ns, "", templ_row.aux_expr)
<< " ]===> " << std::endl << " ";
break;
case IN:
out << "(IN) ";
out << from_expr(ns, "", templ_row.pre_guard) << "===> "
<< std::endl << " ";
break;
case OUT: case OUTL:
out << "(OUT) ";
out << from_expr(ns, "", templ_row.post_guard) << "===> "
<< std::endl << " ";
break;
default: assert(false);
}
const var_pairt &vv=templ_row.var_pair;
out << from_expr(ns, "", vv.first) << "=!= "
<< from_expr(ns, "", vv.second) << std::endl;
}
}
void path_symex_stept::output(std::ostream &out) const
{
out << "PCs:";
/*
for(pc_vectort::const_iterator p_it=s_it->pc_vector.begin();
p_it!=pc_vector.end();
p_it++)
out << " " << *p_it;
*/
out << "\n";
out << "Guard: " << from_expr(guard) << "\n";
out << "Full LHS: " << from_expr(full_lhs) << "\n";
out << "SSA LHS: " << from_expr(ssa_lhs) << "\n";
out << "SSA RHS: " << from_expr(ssa_rhs) << "\n";
out << "\n";
}
void acdl_analyze_conflict_baset::get_conflict_clause
(const local_SSAt &SSA, acdl_conflict_grapht &graph, acdl_domaint::valuet &conf_clause)
{
// PROPOSITIONAL proof
if(last_proof==PROPOSITIONAL) {
assert(conflicting_clause!=-1);
conf_clause=learned_clauses[conflicting_clause];
#ifdef DEBUG
std::cout << "Conflict is purely Propositional" << std::endl;
#endif
}
// conflict is caused by Abstract Interpretation proof
else if(last_proof==ABSINT) {
acdl_domaint::valuet reason;
get_ai_reason(SSA, graph, reason);
// print the reason
#ifdef DEBUG
std::cout << "Reason: " << from_expr(SSA.ns, "", disjunction(reason)) << std::endl;
#endif
for(acdl_domaint::valuet::iterator it=reason.begin();
it!=reason.end(); it++)
{
negate(*it, conf_clause);
}
#ifdef DEBUG
std::cout << "Conflict is purely from Abstract Interpretation Proof" << std::endl;
#endif
}
#ifdef DEBUG
std::cout << "Conflict at decision level is " << graph.current_level <<std::endl;
#endif
if(conf_clause.size()==0)
backtrack_level=-1;
else
find_uip(SSA, graph, conf_clause, graph.current_level);
// print the conflict clause
#ifdef DEBUG
std::cout << "learnt clause: " << from_expr(SSA.ns, "", disjunction(conf_clause)) << std::endl;
#endif
}
std::string inv_object_storet::build_string(const exprt &expr) const
{
// we ignore some casts
if(expr.id()==ID_typecast)
{
assert(expr.operands().size()==1);
if(expr.type().id()==ID_signedbv ||
expr.type().id()==ID_unsignedbv)
{
if(expr.op0().type().id()==ID_signedbv ||
expr.op0().type().id()==ID_unsignedbv)
{
if(to_bitvector_type(expr.type()).get_width()>=
to_bitvector_type(expr.op0().type()).get_width())
return build_string(expr.op0());
}
else if(expr.op0().type().id()==ID_bool)
{
return build_string(expr.op0());
}
}
}
// we always track constants, but make sure they are uniquely
// represented
if(expr.is_constant())
{
// NULL?
if(expr.type().id()==ID_pointer)
if(expr.get(ID_value)==ID_NULL)
return "0";
mp_integer i;
if(!to_integer(expr, i))
return integer2string(i);
}
// we also like "address_of" and "reference_to"
// if the object is constant
if(is_constant_address(expr))
return from_expr(ns, "", expr);
if(expr.id()==ID_member)
{
assert(expr.operands().size()==1);
return build_string(expr.op0())+"."+expr.get_string(ID_component_name);
}
if(expr.id()==ID_symbol)
return expr.get_string(ID_identifier);
return "";
}
void constant_propagator_domaint::assign_rec(
valuest &values,
const exprt &lhs, const exprt &rhs,
const namespacet &ns)
{
const typet & lhs_type = ns.follow(lhs.type());
const typet & rhs_type = ns.follow(rhs.type());
#ifdef DEBUG
std::cout << "assign: " << from_expr(ns, "", lhs)
<< " := " << from_type(ns, "", rhs_type) << '\n';
#endif
if(lhs.id()==ID_symbol && rhs.id()==ID_if)
{
exprt cond=rhs.op0();
assert(cond.operands().size()==2);
if(values.is_constant(cond.op0())
&& values.is_constant(cond.op1()))
{
if(cond.op0().id()==ID_index)
{
exprt index=cond.op0();
exprt new_expr=concatenate_array_id(index.op0(), index.op1(), index.type());
values.replace_const(new_expr);
cond.op0()=new_expr;
cond = simplify_expr(cond,ns);
}
else
assert(0);
assign(values, to_symbol_expr(lhs), cond, ns);
}
}
else if(lhs.id()==ID_symbol && rhs_type.id()!=ID_array
&& rhs_type.id()!=ID_struct
&& rhs_type.id()!=ID_union)
{
if(values.is_constant(rhs))
assign(values, to_symbol_expr(lhs), rhs, ns);
else
values.set_to_top(to_symbol_expr(lhs));
}
else if(lhs.id()==ID_symbol && lhs_type.id()==ID_array
&& rhs_type.id()==ID_array)
{
exprt new_expr;
mp_integer idx=0;
forall_operands(it, rhs)
{
new_expr=concatenate_array_id(lhs, idx, it->type());
assign(values, to_symbol_expr(new_expr), *it, ns);
idx = idx +1;
}
void invariant_sett::strengthen_rec(const exprt &expr)
{
if(expr.type().id()!=ID_bool)
throw "non-Boolean argument to strengthen()";
#if 0
std::cout << "S: " << from_expr(*ns, "", expr) << '\n';
#endif
if(is_false)
{
// we can't get any stronger
return;
}
if(expr.is_true())
{
// do nothing, it's useless
}
else if(expr.is_false())
{
// wow, that's strong
make_false();
}
else if(expr.id()==ID_not)
{
// give up, we expect NNF
}
else if(expr.id()==ID_and)
{
forall_operands(it, expr)
strengthen_rec(*it);
}
else if(expr.id()==ID_le ||
expr.id()==ID_lt)
{
assert(expr.operands().size()==2);
// special rule: x <= (a & b)
// implies: x<=a && x<=b
if(expr.op1().id()==ID_bitand)
{
const exprt &bitand_op=expr.op1();
forall_operands(it, bitand_op)
{
exprt tmp(expr);
tmp.op1()=*it;
strengthen_rec(tmp);
}
return;
}
/*******************************************************************\
Function: abstr_dpll_searcht::chronological_backtrack
Inputs:
Outputs:
Purpose:
\*******************************************************************/
bool acdl_analyze_conflict_baset::chronological_backtrack(const local_SSAt &SSA, acdl_conflict_grapht &graph)
{
#ifdef DEBUG
std::cout << "inside backtrack" << std::endl;
#endif
if(graph.current_level==0) {
backtrack_level=-1; // no further backtrack possible
return false;
}
unsigned first_idx=graph.control_trail.back();
#ifdef DEBUG
std::cout << "val_trail size is: " << graph.val_trail.size() << "control_trail.back is: " << first_idx << std::endl;
#endif
assert(graph.val_trail.size() >= first_idx+1);
exprt dec_exp=graph.prop_trail[first_idx];
// check val_trail and prop_trail are of equal size
assert(graph.prop_trail.size()==graph.val_trail.size());
#ifdef DEBUG
std::cout << "The decision to be flipped is " << from_expr(SSA.ns, "", dec_exp);
std::cout << "The trail before backtracking is" << std::endl;
#endif
graph.dump_trail(SSA);
// backtrack one level
cancel_once(SSA, graph);
// flip the expression
exprt exp=flip(dec_exp);
graph.assign_to_trail(exp);
#ifdef DEBUG
std::cout << "The trail after backtracking and assigning negation of previous decision is" << std::endl;
#endif
graph.dump_trail(SSA);
// check val_trail and prop_trail are of
// equal size after backtracking
assert(graph.prop_trail.size()==graph.val_trail.size());
// update the backtrack level
backtrack_level=graph.current_level;
just_backtracked=true;
graph.check_consistency();
return true;
}
bool ranking_synthesis_satt::generate_functions(void)
{
exprt templ = instantiate();
if(body.variable_map.size()==0 || templ.is_false())
return false;
// some coefficient values
c_valuest c_values;
debug("Template:" + from_expr(ns, "", templ));
satcheckt::resultt result=satcheckt::P_SATISFIABLE;
while(result==satcheckt::P_SATISFIABLE)
{
if(c_values.size()==0)
initialize_coefficients(c_values);
else
{
if(increase_coefficients(c_values))
break;
}
result=check_for_counterexample(templ, c_values,
conversion_time, solver_time);
}
if(result==satcheckt::P_ERROR)
throw ("Solver error.");
else if(result==satcheckt::P_UNSATISFIABLE) // no counter-example
{
debug("Found ranking functions");
// put the coefficient values in the rank relation
replace_mapt replace_map;
for(c_valuest::const_iterator it=c_values.begin();
it!=c_values.end();
it++)
{
replace_map[it->first] = from_integer(it->second, it->first.type());
}
replace_expr(replace_map, rank_relation);
simplify(rank_relation, ns);
return true;
}
else
return false;
}
std::ostream& operator<< (std::ostream& out,
const predicatest &predicates)
{
for(unsigned i=0; i<predicates.size(); i++)
{
contextt context;
namespacet ns(context);
out << "b" << i << " <=> "
<< from_expr(ns, "", predicates[i]) << std::endl;
}
return out;
}
void summarizer_fwt::compute_summary_rec(const function_namet &function_name,
const exprt &precondition,
bool context_sensitive)
{
local_SSAt &SSA = ssa_db.get(function_name); //TODO: make const
// recursively compute summaries for function calls
inline_summaries(function_name,SSA,precondition,context_sensitive);
status() << "Analyzing function " << function_name << eom;
#if 0
{
std::ostringstream out;
out << "Function body for " << function_name <<
" to be analyzed: " << std::endl;
for(local_SSAt::nodest::iterator n = SSA.nodes.begin();
n!=SSA.nodes.end(); n++)
{
if(!n->empty()) n->output(out,SSA.ns);
}
out << "(enable) " << from_expr(SSA.ns, "", SSA.get_enabling_exprs())
<< "\n";
debug() << out.str() << eom;
}
#endif
// create summary
summaryt summary;
summary.params = SSA.params;
summary.globals_in = SSA.globals_in;
summary.globals_out = SSA.globals_out;
summary.fw_precondition = precondition;
if(!options.get_bool_option("havoc"))
{
do_summary(function_name,SSA,summary,true_exprt(),context_sensitive);
}
if(!options.get_bool_option("competition-mode"))
{
std::ostringstream out;
out << std::endl << "Summary for function " << function_name << std::endl;
summary.output(out,SSA.ns);
status() << out.str() << eom;
}
// store summary in db
summary_db.put(function_name,summary);
}
void ranking_synthesis_satt::show_counterexample(boolbvt &converter)
{
if(verbosity<9) return;
std::string output=" ... NO: ";
for(bodyt::variable_mapt::const_iterator it=body.variable_map.begin();
it!=body.variable_map.end();
it++)
{
if(used_variables.find(it->first)==used_variables.end())
continue;
if(it!=body.variable_map.begin()) output += ", ";
exprt postsym=symbol_exprt(it->first, ns.lookup(it->first).type);
exprt presym=symbol_exprt(it->second, ns.lookup(it->second).type);
exprt post=converter.get(postsym);
if(post.id()!="nil")
{
output += from_expr(ns, "", postsym) + "=" + from_expr(ns, "", post) + " (";
}
else
output += "? (";
exprt pre=converter.get(presym);
if(pre.id()!="nil")
output += from_expr(ns, "", pre);
else
output += "?";
output += ")";
}
debug(output);
}
exprt dereference(
const exprt &src,
const ssa_value_domaint &ssa_value_domain,
const std::string &nondet_prefix,
const namespacet &ns)
{
#ifdef DEBUG
std::cout << "dereference src: " << from_expr(ns, "", src) << '\n';
#endif
exprt tmp1=dereference_rec(src, ssa_value_domain, nondet_prefix, ns);
#ifdef DEBUG
std::cout << "dereference tmp1: " << from_expr(ns, "", tmp1) << '\n';
#endif
exprt tmp2=simplify_expr(tmp1, ns);
#ifdef DEBUG
std::cout << "dereference tmp2: " << from_expr(ns, "", tmp2) << '\n';
#endif
return tmp2;
}
