void local_SSAt::build_SSA()
{
// perform SSA data-flow analysis
ssa_analysis(goto_function, ns);
// now build phi-nodes
forall_goto_program_instructions(i_it, goto_function.body)
build_phi_nodes(i_it);
// now build transfer functions
forall_goto_program_instructions(i_it, goto_function.body)
build_transfer(i_it);
// now build branching conditions
forall_goto_program_instructions(i_it, goto_function.body)
build_cond(i_it);
// now build guards
forall_goto_program_instructions(i_it, goto_function.body)
build_guard(i_it);
// now build assertions
forall_goto_program_instructions(i_it, goto_function.body)
build_assertions(i_it);
}
void is_threadedt::compute(const goto_functionst &goto_functions)
{
// the analysis doesn't actually use the namespace, fake one
symbol_tablet symbol_table;
const namespacet ns(symbol_table);
ait<is_threaded_domaint> is_threaded_analysis;
is_threaded_analysis(goto_functions, ns);
forall_goto_functions(f_it, goto_functions)
forall_goto_program_instructions(i_it, f_it->second.body)
if(is_threaded_analysis[i_it].is_threaded)
is_threaded_set.insert(i_it);
}
void function_modifiest::get_modifies_function(
const exprt &function,
modifiest &modifies)
{
if(function.id()==ID_symbol)
{
const irep_idt &identifier=to_symbol_expr(function).get_identifier();
function_mapt::const_iterator fm_it=
function_map.find(identifier);
if(fm_it!=function_map.end())
{
// already done
modifies.insert(fm_it->second.begin(), fm_it->second.end());
return;
}
goto_functionst::function_mapt::const_iterator
f_it=goto_functions.function_map.find(identifier);
if(f_it==goto_functions.function_map.end())
return;
local_may_aliast local_may_alias(f_it->second);
const goto_programt &goto_program=f_it->second.body;
forall_goto_program_instructions(i_it, goto_program)
get_modifies(local_may_alias, i_it, modifies);
}
else if(function.id()==ID_if)
{
get_modifies_function(to_if_expr(function).true_case(), modifies);
get_modifies_function(to_if_expr(function).false_case(), modifies);
}
}
void cfg_dominatorst::construct_cfg(const goto_programt &program)
{
forall_goto_program_instructions(it, program)
construct_cfg(program, it);
}
safety_checkert::resultt bmc_all_propertiest::operator()()
{
status() << "Passing problem to " << solver.decision_procedure_text() << eom;
solver.set_message_handler(get_message_handler());
// stop the time
absolute_timet sat_start=current_time();
bmc.do_conversion();
// Collect _all_ goals in `goal_map'.
// This maps property IDs to 'goalt'
forall_goto_functions(f_it, goto_functions)
forall_goto_program_instructions(i_it, f_it->second.body)
if(i_it->is_assert())
goal_map[i_it->source_location.get_property_id()]=goalt(*i_it);
// get the conditions for these goals from formula
// collect all 'instances' of the properties
for(symex_target_equationt::SSA_stepst::iterator
it=bmc.equation.SSA_steps.begin();
it!=bmc.equation.SSA_steps.end();
it++)
{
if(it->is_assert())
{
irep_idt property_id;
if(it->source.pc->is_assert())
property_id=it->source.pc->source_location.get_property_id();
else if(it->source.pc->is_goto())
{
// this is likely an unwinding assertion
property_id=id2string(
it->source.pc->source_location.get_function())+".unwind."+
std::to_string(it->source.pc->loop_number);
goal_map[property_id].description=it->comment;
}
else
continue;
goal_map[property_id].instances.push_back(it);
}
}
do_before_solving();
cover_goalst cover_goals(solver);
cover_goals.set_message_handler(get_message_handler());
cover_goals.register_observer(*this);
for(const auto &g : goal_map)
{
// Our goal is to falsify a property, i.e., we will
// add the negation of the property as goal.
literalt p=!solver.convert(g.second.as_expr());
cover_goals.add(p);
}
status() << "Running " << solver.decision_procedure_text() << eom;
bool error=false;
decision_proceduret::resultt result=cover_goals();
if(result==decision_proceduret::resultt::D_ERROR)
{
error=true;
for(auto &g : goal_map)
if(g.second.status==goalt::statust::UNKNOWN)
g.second.status=goalt::statust::ERROR;
}
else
{
for(auto &g : goal_map)
if(g.second.status==goalt::statust::UNKNOWN)
g.second.status=goalt::statust::SUCCESS;
}
// output runtime
{
absolute_timet sat_stop=current_time();
status() << "Runtime decision procedure: "
<< (sat_stop-sat_start) << "s" << eom;
}
// report
report(cover_goals);
if(error)
return safety_checkert::resultt::ERROR;
bool safe=(cover_goals.number_covered()==0);
if(safe)
bmc.report_success(); // legacy, might go away
else
bmc.report_failure(); // legacy, might go away
return safe?safety_checkert::resultt::SAFE:safety_checkert::resultt::UNSAFE;
}
