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; }