const irep_idt &get_affected_variable(const goto_programt::instructiont &instr)
{
switch (instr.type)
{
case goto_program_instruction_typet::DECL:
return to_code_decl(instr.code).get_identifier();
case goto_program_instruction_typet::ASSIGN:
return to_symbol_expr(to_code_assign(instr.code).lhs()).get_identifier();
case goto_program_instruction_typet::DEAD:
return to_code_dead(instr.code).get_identifier();
default:
assert(!"Only DECL, ASSIGN, DEAD allowed.");
}
}
void interval_domaint::transform(
locationt from,
locationt to,
ai_baset &ai,
const namespacet &ns)
{
const goto_programt::instructiont &instruction=*from;
switch(instruction.type)
{
case DECL:
havoc_rec(to_code_decl(instruction.code).symbol());
break;
case DEAD:
havoc_rec(to_code_dead(instruction.code).symbol());
break;
case ASSIGN:
assign(to_code_assign(instruction.code));
break;
case GOTO:
{
locationt next=from;
next++;
if(next==to)
assume(not_exprt(instruction.guard), ns);
else
assume(instruction.guard, ns);
}
break;
case ASSUME:
assume(instruction.guard, ns);
break;
case FUNCTION_CALL:
{
const code_function_callt &code_function_call=
to_code_function_call(instruction.code);
if(code_function_call.lhs().is_not_nil())
havoc_rec(code_function_call.lhs());
}
break;
default:
{
}
}
}
const typet &get_affected_type(const goto_programt::instructiont &instr)
{
switch (instr.type)
{
case goto_program_instruction_typet::DECL:
return to_code_decl(instr.code).symbol().type();
case goto_program_instruction_typet::ASSIGN:
return to_code_assign(instr.code).lhs().type();
case goto_program_instruction_typet::DEAD:
return to_code_dead(instr.code).symbol().type();
default:
assert(!"Only DECL, ASSIGN, DEAD allowed.");
}
}
void rd_range_domaint::transform(
const namespacet &ns,
locationt from,
locationt to)
{
if(from->is_dead())
{
const symbol_exprt &symbol=
to_symbol_expr(to_code_dead(from->code).symbol());
values.erase(symbol.get_identifier());
return;
}
else if(!from->is_assign())
return;
const exprt &lhs=to_code_assign(from->code).lhs();
if(lhs.id()==ID_complex_real ||
lhs.id()==ID_complex_imag)
{
assert(lhs.type().id()==ID_complex);
mp_integer offset=compute_pointer_offset(ns, lhs.op0());
mp_integer sub_size=pointer_offset_size(ns, lhs.type().subtype());
assign(
ns,
from,
lhs.op0(),
offset+((offset==-1 || lhs.id()==ID_complex_real) ? 0 : sub_size),
sub_size);
}
else
{
mp_integer size=pointer_offset_size(ns, lhs.type());
assign(ns, from, lhs, size);
}
}
void ssa_domaint::transform(
locationt from,
locationt to,
ai_baset &ai,
const namespacet &ns)
{
if(from->is_assign() || from->is_decl() || from->is_function_call())
{
const auto &assignments=static_cast<ssa_ait &>(ai).assignments;
const std::set<ssa_objectt> &assigns=assignments.get(from);
for(std::set<ssa_objectt>::const_iterator
o_it=assigns.begin();
o_it!=assigns.end();
o_it++)
{
if(o_it->get_expr().get_bool("#is_rhs_assign") &&
is_pointed(o_it->get_root_object()))
{
// the second part excluded cases
// when a result of malloc is at the right-handed side
const auto object_ai_it=
static_cast<ssa_ait &>(ai)[from].def_map.find(o_it->get_identifier());
if(object_ai_it!=static_cast<ssa_ait &>(ai)[from].def_map.end() &&
object_ai_it->second.def.is_assignment())
{
const exprt pointer=
get_pointer(
o_it->get_root_object(),
pointed_level(o_it->get_root_object())-1);
const auto def_pointer=
static_cast<ssa_ait &>(ai)[from]
.def_map.find(
ssa_objectt(pointer, ns).get_identifier())->second.def;
if(!def_pointer.is_assignment() ||
def_pointer.loc->location_number<
object_ai_it->second.def.loc->location_number)
{
continue;
}
}
}
irep_idt identifier=o_it->get_identifier();
def_entryt &def_entry=def_map[identifier];
def_entry.def.loc=from;
def_entry.source=from;
auto guard_it=assignments.alloc_guards_map.find({from, *o_it});
if(guard_it!=assignments.alloc_guards_map.end())
{
def_entry.def.kind=deft::ALLOCATION;
def_entry.def.guard=guard_it->second;
}
else
def_entry.def.kind=deft::ASSIGNMENT;
}
}
else if(from->is_dead())
{
const code_deadt &code_dead=to_code_dead(from->code);
const irep_idt &id=code_dead.get_identifier();
def_map.erase(id);
}
// update source in all defs
for(def_mapt::iterator
d_it=def_map.begin(); d_it!=def_map.end(); d_it++)
d_it->second.source=from;
}