introduce instructiont::set_X

Daniel Kroening · Daniel Kroening · commit e70816eba41a · 2019-02-20T14:41:03.000Z
This avoids accidental disruption of sharing.
diff --git a/src/analyses/constant_propagator.cpp b/src/analyses/constant_propagator.cpp
@@ -761,37 +761,50 @@ void constant_propagator_ait::replace(
     {
       exprt c = it->get_condition();
       replace_types_rec(d.values.replace_const, c);
-      constant_propagator_domaint::partial_evaluate(d.values, c, ns);
-      it->set_condition(c);
+      if(!constant_propagator_domaint::partial_evaluate(d.values, c, ns))
+        it->set_condition(c);
     }
     else if(it->is_assign())
     {
-      exprt &rhs=to_code_assign(it->code).rhs();
-      constant_propagator_domaint::partial_evaluate(d.values, rhs, ns);
+      auto assign = it->get_assign();
+      exprt &rhs = assign.rhs();
 
-      if(rhs.id()==ID_constant)
-        rhs.add_source_location() =
-          to_code_assign(it->code).lhs().source_location();
+      if(!constant_propagator_domaint::partial_evaluate(d.values, rhs, ns))
+      {
+        if(rhs.id() == ID_constant)
+          rhs.add_source_location() = assign.lhs().source_location();
+        it->set_assign(assign);
+      }
     }
     else if(it->is_function_call())
     {
-      exprt &function = to_code_function_call(it->code).function();
-      constant_propagator_domaint::partial_evaluate(d.values, function, ns);
+      auto call = it->get_function_call();
 
-      exprt::operandst &args=
-        to_code_function_call(it->code).arguments();
+      bool call_changed = false;
 
-      for(auto &arg : args)
+      if(!constant_propagator_domaint::partial_evaluate(
+           d.values, call.function(), ns))
       {
-        constant_propagator_domaint::partial_evaluate(d.values, arg, ns);
+        call_changed = true;
       }
+
+      for(auto &arg : call.arguments())
+        if(!constant_propagator_domaint::partial_evaluate(d.values, arg, ns))
+          call_changed = true;
+
+      if(call_changed)
+        it->set_function_call(call);
     }
     else if(it->is_other())
     {
       if(it->get_other().get_statement() == ID_expression)
       {
-        constant_propagator_domaint::partial_evaluate(
-          d.values, it->get_other(), ns);
+        auto c = to_code_expression(it->get_other());
+        if(!constant_propagator_domaint::partial_evaluate(
+             d.values, c.expression(), ns))
+        {
+          it->set_other(c);
+        }
       }
     }
   }
diff --git a/src/goto-analyzer/static_simplifier.cpp b/src/goto-analyzer/static_simplifier.cpp
@@ -95,7 +95,7 @@ bool static_simplifier(
       }
       else if(i_it->is_assign())
       {
-        code_assignt &assign = i_it->get_assign();
+        auto assign = i_it->get_assign();
 
         // Simplification needs to be aware of which side of the
         // expression it is handling as:
@@ -111,11 +111,14 @@ bool static_simplifier(
         if(unchanged_lhs && unchanged_rhs)
           unmodified.assigns++;
         else
+        {
           simplified.assigns++;
+          i_it->set_assign(assign);
+        }
       }
       else if(i_it->is_function_call())
       {
-        code_function_callt &fcall = i_it->get_function_call();
+        auto fcall = i_it->get_function_call();
 
         bool unchanged =
           ai.abstract_state_before(i_it)->ai_simplify(fcall.function(), ns);
@@ -128,7 +131,10 @@ bool static_simplifier(
         if(unchanged)
           unmodified.function_calls++;
         else
+        {
           simplified.function_calls++;
+          i_it->set_function_call(fcall);
+        }
       }
     }
   }
diff --git a/src/goto-programs/goto_program.h b/src/goto-programs/goto_program.h
@@ -188,11 +188,11 @@ class goto_programt
       return to_code_assign(code);
     }
 
-    /// Get the assignment for ASSIGN
-    code_assignt &get_assign()
+    /// Set the assignment for ASSIGN
+    void set_assign(code_assignt c)
     {
       PRECONDITION(is_assign());
-      return to_code_assign(code);
+      code = std::move(c);
     }
 
     /// Get the declaration for DECL
@@ -202,11 +202,11 @@ class goto_programt
       return to_code_decl(code);
     }
 
-    /// Get the declaration for DECL
-    code_declt &get_decl()
+    /// Set the declaration for DECL
+    void set_decl(code_declt c)
     {
       PRECONDITION(is_decl());
-      return to_code_decl(code);
+      code = std::move(c);
     }
 
     /// Get the dead statement for DEAD
@@ -216,11 +216,11 @@ class goto_programt
       return to_code_dead(code);
     }
 
-    /// Get the dead statement for DEAD
-    code_deadt &get_dead()
+    /// Set the dead statement for DEAD
+    void set_dead(code_deadt c)
     {
       PRECONDITION(is_dead());
-      return to_code_dead(code);
+      code = std::move(c);
     }
 
     /// Get the return statement for READ
@@ -230,11 +230,11 @@ class goto_programt
       return to_code_return(code);
     }
 
-    /// Get the return statement for READ
-    code_returnt &get_return()
+    /// Set the return statement for READ
+    void set_return(code_returnt c)
     {
       PRECONDITION(is_return());
-      return to_code_return(code);
+      code = std::move(c);
     }
 
     /// Get the function call for FUNCTION_CALL
@@ -244,11 +244,11 @@ class goto_programt
       return to_code_function_call(code);
     }
 
-    /// Get the function call for FUNCTION_CALL
-    code_function_callt &get_function_call()
+    /// Set the function call for FUNCTION_CALL
+    void set_function_call(code_function_callt c)
     {
       PRECONDITION(is_function_call());
-      return to_code_function_call(code);
+      code = std::move(c);
     }
 
     /// Get the statement for OTHER
@@ -258,11 +258,11 @@ class goto_programt
       return code;
     }
 
-    /// Get the statement for OTHER
-    codet &get_other()
+    /// Set the statement for OTHER
+    void set_other(codet &c)
     {
       PRECONDITION(is_other());
-      return code;
+      code = std::move(c);
     }
 
     /// The location of the instruction in the source file
diff --git a/src/goto-programs/mm_io.cpp b/src/goto-programs/mm_io.cpp
@@ -45,7 +45,7 @@ void mm_io(
 
     if(it->is_assign())
     {
-      auto &a = it->get_assign();
+      auto a = it->get_assign();
       collect_deref_expr(a.rhs(), deref_expr_r);
 
       if(mm_io_r.is_not_nil())
@@ -60,7 +60,8 @@ void mm_io(
           irep_idt r_identifier=id2string(identifier)+RETURN_VALUE_SUFFIX;
           symbol_exprt return_value(r_identifier, ct.return_type());
           if_exprt if_expr(integer_address(d.pointer()), return_value, d);
-          replace_expr(d, if_expr, a.rhs());
+          if(!replace_expr(d, if_expr, a.rhs()))
+            it->set_assign(a);
 
           const typet &pt=ct.parameters()[0].type();
           const typet &st=ct.parameters()[1].type();
diff --git a/src/goto-programs/remove_function_pointers.cpp b/src/goto-programs/remove_function_pointers.cpp
@@ -319,7 +319,9 @@ void remove_function_pointerst::remove_function_pointer(
 
     if(functions.size()==1)
     {
-      target->get_function_call().function() = *functions.cbegin();
+      auto call = target->get_function_call();
+      call.function() = *functions.cbegin();
+      target->set_function_call(call);
       return;
     }
   }
@@ -386,14 +388,18 @@ void remove_function_pointerst::remove_function_pointer(
   for(const auto &fun : functions)
   {
     // call function
-    goto_programt::targett t1 =
-      new_code_calls.add(goto_programt::make_function_call(code));
-    t1->get_function_call().function() = fun;
+    auto new_call = code;
+    new_call.function() = fun;
 
     // the signature of the function might not match precisely
-    fix_argument_types(t1->get_function_call());
+    fix_argument_types(new_call);
+
+    goto_programt tmp;
+    fix_return_type(function_id, new_call, tmp);
+
+    auto call = new_code_calls.add(goto_programt::make_function_call(new_call));
+    new_code_calls.destructive_append(tmp);
 
-    fix_return_type(function_id, t1->get_function_call(), new_code_calls);
     // goto final
     new_code_calls.add(goto_programt::make_goto(t_final, true_exprt()));
 
@@ -404,7 +410,7 @@ void remove_function_pointerst::remove_function_pointer(
       typecast_exprt::conditional_cast(address_of, pointer.type());
 
     new_code_gotos.add(
-      goto_programt::make_goto(t1, equal_exprt(pointer, casted_address)));
+      goto_programt::make_goto(call, equal_exprt(pointer, casted_address)));
   }
 
   // fall-through
diff --git a/src/goto-programs/remove_returns.cpp b/src/goto-programs/remove_returns.cpp
@@ -150,7 +150,7 @@ void remove_returnst::do_function_calls(
   {
     if(i_it->is_function_call())
     {
-      code_function_callt &function_call = i_it->get_function_call();
+      code_function_callt function_call = i_it->get_function_call();
 
       INVARIANT(
         function_call.function().id() == ID_symbol,
@@ -222,6 +222,9 @@ void remove_returnst::do_function_calls(
               goto_programt::make_dead(*return_value, i_it->source_location));
           }
         }
+
+        // update the call
+        i_it->set_function_call(function_call);
       }
     }
   }
@@ -355,7 +358,8 @@ bool remove_returnst::restore_returns(
   {
     if(i_it->is_assign())
     {
-      code_assignt &assign = i_it->get_assign();
+      const auto &assign = i_it->get_assign();
+
       if(assign.lhs().id()!=ID_symbol ||
          to_symbol_expr(assign.lhs()).get_identifier()!=rv_name_id)
         continue;
@@ -384,7 +388,7 @@ void remove_returnst::undo_function_calls(
   {
     if(i_it->is_function_call())
     {
-      code_function_callt &function_call = i_it->get_function_call();
+      code_function_callt function_call = i_it->get_function_call();
 
       // ignore function pointers
       if(function_call.function().id()!=ID_symbol)
@@ -401,8 +405,8 @@ void remove_returnst::undo_function_calls(
 
       // find "f(...); lhs=f#return_value; DEAD f#return_value;"
       // and revert to "lhs=f(...);"
-      goto_programt::instructionst::iterator next=i_it;
-      ++next;
+      goto_programt::instructionst::iterator next = std::next(i_it);
+
       INVARIANT(
         next!=goto_program.instructions.end(),
         "non-void function call must be followed by #return_value read");
@@ -423,6 +427,8 @@ void remove_returnst::undo_function_calls(
       // restore the previous assignment
       function_call.lhs()=assign.lhs();
 
+      i_it->set_function_call(function_call);
+
       // remove the assignment and subsequent dead
       // i_it remains valid
       next=goto_program.instructions.erase(next);
diff --git a/src/goto-programs/remove_virtual_functions.cpp b/src/goto-programs/remove_virtual_functions.cpp
@@ -190,8 +190,9 @@ goto_programt::targett remove_virtual_functionst::remove_virtual_function(
     }
     else
     {
-      create_static_function_call(
-        target->get_function_call(), *functions.front().symbol_expr, ns);
+      auto c = target->get_function_call();
+      create_static_function_call(c, *functions.front().symbol_expr, ns);
+      target->set_function_call(c);
     }
     return next_target;
   }
@@ -250,11 +251,12 @@ goto_programt::targett remove_virtual_functionst::remove_virtual_function(
       if(fun.symbol_expr.has_value())
       {
         // call function
-        goto_programt::targett t1 = new_code_calls.add(
-          goto_programt::make_function_call(code, vcall_source_loc));
+        auto new_call = code;
+
+        create_static_function_call(new_call, *fun.symbol_expr, ns);
 
-        create_static_function_call(
-          t1->get_function_call(), *fun.symbol_expr, ns);
+        goto_programt::targett t1 = new_code_calls.add(
+          goto_programt::make_function_call(new_call, vcall_source_loc));
 
         insertit.first->second = t1;
       }
diff --git a/src/goto-programs/replace_calls.cpp b/src/goto-programs/replace_calls.cpp
@@ -70,7 +70,7 @@ void replace_callst::operator()(
     if(!ins.is_function_call())
       continue;
 
-    code_function_callt &cfc = ins.get_function_call();
+    auto cfc = ins.get_function_call();
     exprt &function = cfc.function();
 
     PRECONDITION(function.id() == ID_symbol);
@@ -114,6 +114,8 @@ void replace_callst::operator()(
     // Finally modify the call
     function.type() = f_it2->second.type;
     se.set_identifier(new_id);
+
+    ins.set_function_call(cfc);
   }
 }
 
diff --git a/src/goto-programs/string_abstraction.cpp b/src/goto-programs/string_abstraction.cpp
diff --git a/src/pointer-analysis/goto_program_dereference.cpp b/src/pointer-analysis/goto_program_dereference.cpp

Original file line number	Diff line number	Diff line change
`@@ -761,37 +761,50 @@ void constant_propagator_ait::replace(`
`761`	`761`	`{`
`762`	`762`	`exprt c = it->get_condition();`
`763`	`763`	`replace_types_rec(d.values.replace_const, c);`
`764`		`- constant_propagator_domaint::partial_evaluate(d.values, c, ns);`
`765`		`- it->set_condition(c);`
	`764`	`+ if(!constant_propagator_domaint::partial_evaluate(d.values, c, ns))`
	`765`	`+ it->set_condition(c);`
`766`	`766`	`}`
`767`	`767`	`else if(it->is_assign())`
`768`	`768`	`{`
`769`		`- exprt &rhs=to_code_assign(it->code).rhs();`
`770`		`- constant_propagator_domaint::partial_evaluate(d.values, rhs, ns);`
	`769`	`+ auto assign = it->get_assign();`
	`770`	`+ exprt &rhs = assign.rhs();`
`771`	`771`
`772`		`- if(rhs.id()==ID_constant)`
`773`		`- rhs.add_source_location() =`
`774`		`- to_code_assign(it->code).lhs().source_location();`
	`772`	`+ if(!constant_propagator_domaint::partial_evaluate(d.values, rhs, ns))`
	`773`	`+ {`
	`774`	`+ if(rhs.id() == ID_constant)`
	`775`	`+ rhs.add_source_location() = assign.lhs().source_location();`
	`776`	`+ it->set_assign(assign);`
	`777`	`+ }`
`775`	`778`	`}`
`776`	`779`	`else if(it->is_function_call())`
`777`	`780`	`{`
`778`		`- exprt &function = to_code_function_call(it->code).function();`
`779`		`- constant_propagator_domaint::partial_evaluate(d.values, function, ns);`
	`781`	`+ auto call = it->get_function_call();`
`780`	`782`
`781`		`- exprt::operandst &args=`
`782`		`- to_code_function_call(it->code).arguments();`
	`783`	`+ bool call_changed = false;`
`783`	`784`
`784`		`- for(auto &arg : args)`
	`785`	`+ if(!constant_propagator_domaint::partial_evaluate(`
	`786`	`+ d.values, call.function(), ns))`
`785`	`787`	`{`
`786`		`- constant_propagator_domaint::partial_evaluate(d.values, arg, ns);`
	`788`	`+ call_changed = true;`
`787`	`789`	`}`
	`790`	`+`
	`791`	`+ for(auto &arg : call.arguments())`
	`792`	`+ if(!constant_propagator_domaint::partial_evaluate(d.values, arg, ns))`
	`793`	`+ call_changed = true;`
	`794`	`+`
	`795`	`+ if(call_changed)`
	`796`	`+ it->set_function_call(call);`
`788`	`797`	`}`
`789`	`798`	`else if(it->is_other())`
`790`	`799`	`{`
`791`	`800`	`if(it->get_other().get_statement() == ID_expression)`
`792`	`801`	`{`
`793`		`- constant_propagator_domaint::partial_evaluate(`
`794`		`- d.values, it->get_other(), ns);`
	`802`	`+ auto c = to_code_expression(it->get_other());`
	`803`	`+ if(!constant_propagator_domaint::partial_evaluate(`
	`804`	`+ d.values, c.expression(), ns))`
	`805`	`+ {`
	`806`	`+ it->set_other(c);`
	`807`	`+ }`
`795`	`808`	`}`
`796`	`809`	`}`
`797`	`810`	`}`
Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ bool static_simplifier(`
`95`	`95`	`}`
`96`	`96`	`else if(i_it->is_assign())`
`97`	`97`	`{`
`98`		`- code_assignt &assign = i_it->get_assign();`
	`98`	`+ auto assign = i_it->get_assign();`
`99`	`99`
`100`	`100`	`// Simplification needs to be aware of which side of the`
`101`	`101`	`// expression it is handling as:`
`@@ -111,11 +111,14 @@ bool static_simplifier(`
`111`	`111`	`if(unchanged_lhs && unchanged_rhs)`
`112`	`112`	`unmodified.assigns++;`
`113`	`113`	`else`
	`114`	`+ {`
`114`	`115`	`simplified.assigns++;`
	`116`	`+ i_it->set_assign(assign);`
	`117`	`+ }`
`115`	`118`	`}`
`116`	`119`	`else if(i_it->is_function_call())`
`117`	`120`	`{`
`118`		`- code_function_callt &fcall = i_it->get_function_call();`
	`121`	`+ auto fcall = i_it->get_function_call();`
`119`	`122`
`120`	`123`	`bool unchanged =`
`121`	`124`	`ai.abstract_state_before(i_it)->ai_simplify(fcall.function(), ns);`
`@@ -128,7 +131,10 @@ bool static_simplifier(`
`128`	`131`	`if(unchanged)`
`129`	`132`	`unmodified.function_calls++;`
`130`	`133`	`else`
	`134`	`+ {`
`131`	`135`	`simplified.function_calls++;`
	`136`	`+ i_it->set_function_call(fcall);`
	`137`	`+ }`
`132`	`138`	`}`
`133`	`139`	`}`
`134`	`140`	`}`
Original file line number	Diff line number	Diff line change
`@@ -188,11 +188,11 @@ class goto_programt`
`188`	`188`	`return to_code_assign(code);`
`189`	`189`	`}`
`190`	`190`
`191`		`- /// Get the assignment for ASSIGN`
`192`		`- code_assignt &get_assign()`
	`191`	`+ /// Set the assignment for ASSIGN`
	`192`	`+ void set_assign(code_assignt c)`
`193`	`193`	`{`
`194`	`194`	`PRECONDITION(is_assign());`
`195`		`- return to_code_assign(code);`
	`195`	`+ code = std::move(c);`
`196`	`196`	`}`
`197`	`197`
`198`	`198`	`/// Get the declaration for DECL`
`@@ -202,11 +202,11 @@ class goto_programt`
`202`	`202`	`return to_code_decl(code);`
`203`	`203`	`}`
`204`	`204`
`205`		`- /// Get the declaration for DECL`
`206`		`- code_declt &get_decl()`
	`205`	`+ /// Set the declaration for DECL`
	`206`	`+ void set_decl(code_declt c)`
`207`	`207`	`{`
`208`	`208`	`PRECONDITION(is_decl());`
`209`		`- return to_code_decl(code);`
	`209`	`+ code = std::move(c);`
`210`	`210`	`}`
`211`	`211`
`212`	`212`	`/// Get the dead statement for DEAD`
`@@ -216,11 +216,11 @@ class goto_programt`
`216`	`216`	`return to_code_dead(code);`
`217`	`217`	`}`
`218`	`218`
`219`		`- /// Get the dead statement for DEAD`
`220`		`- code_deadt &get_dead()`
	`219`	`+ /// Set the dead statement for DEAD`
	`220`	`+ void set_dead(code_deadt c)`
`221`	`221`	`{`
`222`	`222`	`PRECONDITION(is_dead());`
`223`		`- return to_code_dead(code);`
	`223`	`+ code = std::move(c);`
`224`	`224`	`}`
`225`	`225`
`226`	`226`	`/// Get the return statement for READ`
`@@ -230,11 +230,11 @@ class goto_programt`
`230`	`230`	`return to_code_return(code);`
`231`	`231`	`}`
`232`	`232`
`233`		`- /// Get the return statement for READ`
`234`		`- code_returnt &get_return()`
	`233`	`+ /// Set the return statement for READ`
	`234`	`+ void set_return(code_returnt c)`
`235`	`235`	`{`
`236`	`236`	`PRECONDITION(is_return());`
`237`		`- return to_code_return(code);`
	`237`	`+ code = std::move(c);`
`238`	`238`	`}`
`239`	`239`
`240`	`240`	`/// Get the function call for FUNCTION_CALL`
`@@ -244,11 +244,11 @@ class goto_programt`
`244`	`244`	`return to_code_function_call(code);`
`245`	`245`	`}`
`246`	`246`
`247`		`- /// Get the function call for FUNCTION_CALL`
`248`		`- code_function_callt &get_function_call()`
	`247`	`+ /// Set the function call for FUNCTION_CALL`
	`248`	`+ void set_function_call(code_function_callt c)`
`249`	`249`	`{`
`250`	`250`	`PRECONDITION(is_function_call());`
`251`		`- return to_code_function_call(code);`
	`251`	`+ code = std::move(c);`
`252`	`252`	`}`
`253`	`253`
`254`	`254`	`/// Get the statement for OTHER`
`@@ -258,11 +258,11 @@ class goto_programt`
`258`	`258`	`return code;`
`259`	`259`	`}`
`260`	`260`
`261`		`- /// Get the statement for OTHER`
`262`		`- codet &get_other()`
	`261`	`+ /// Set the statement for OTHER`
	`262`	`+ void set_other(codet &c)`
`263`	`263`	`{`
`264`	`264`	`PRECONDITION(is_other());`
`265`		`- return code;`
	`265`	`+ code = std::move(c);`
`266`	`266`	`}`
`267`	`267`
`268`	`268`	`/// The location of the instruction in the source file`
Original file line number	Diff line number	Diff line change
`@@ -150,7 +150,7 @@ void remove_returnst::do_function_calls(`
`150`	`150`	`{`
`151`	`151`	`if(i_it->is_function_call())`
`152`	`152`	`{`
`153`		`- code_function_callt &function_call = i_it->get_function_call();`
	`153`	`+ code_function_callt function_call = i_it->get_function_call();`
`154`	`154`
`155`	`155`	`INVARIANT(`
`156`	`156`	`function_call.function().id() == ID_symbol,`
`@@ -222,6 +222,9 @@ void remove_returnst::do_function_calls(`
`222`	`222`	`goto_programt::make_dead(*return_value, i_it->source_location));`
`223`	`223`	`}`
`224`	`224`	`}`
	`225`	`+`
	`226`	`+ // update the call`
	`227`	`+ i_it->set_function_call(function_call);`
`225`	`228`	`}`
`226`	`229`	`}`
`227`	`230`	`}`
`@@ -355,7 +358,8 @@ bool remove_returnst::restore_returns(`
`355`	`358`	`{`
`356`	`359`	`if(i_it->is_assign())`
`357`	`360`	`{`
`358`		`- code_assignt &assign = i_it->get_assign();`
	`361`	`+ const auto &assign = i_it->get_assign();`
	`362`	`+`
`359`	`363`	`if(assign.lhs().id()!=ID_symbol \|\|`
`360`	`364`	`to_symbol_expr(assign.lhs()).get_identifier()!=rv_name_id)`
`361`	`365`	`continue;`
`@@ -384,7 +388,7 @@ void remove_returnst::undo_function_calls(`
`384`	`388`	`{`
`385`	`389`	`if(i_it->is_function_call())`
`386`	`390`	`{`
`387`		`- code_function_callt &function_call = i_it->get_function_call();`
	`391`	`+ code_function_callt function_call = i_it->get_function_call();`
`388`	`392`
`389`	`393`	`// ignore function pointers`
`390`	`394`	`if(function_call.function().id()!=ID_symbol)`
`@@ -401,8 +405,8 @@ void remove_returnst::undo_function_calls(`
`401`	`405`
`402`	`406`	`// find "f(...); lhs=f#return_value; DEAD f#return_value;"`
`403`	`407`	`// and revert to "lhs=f(...);"`
`404`		`- goto_programt::instructionst::iterator next=i_it;`
`405`		`- ++next;`
	`408`	`+ goto_programt::instructionst::iterator next = std::next(i_it);`
	`409`	`+`
`406`	`410`	`INVARIANT(`
`407`	`411`	`next!=goto_program.instructions.end(),`
`408`	`412`	`"non-void function call must be followed by #return_value read");`
`@@ -423,6 +427,8 @@ void remove_returnst::undo_function_calls(`
`423`	`427`	`// restore the previous assignment`
`424`	`428`	`function_call.lhs()=assign.lhs();`
`425`	`429`
	`430`	`+ i_it->set_function_call(function_call);`
	`431`	`+`
`426`	`432`	`// remove the assignment and subsequent dead`
`427`	`433`	`// i_it remains valid`
`428`	`434`	`next=goto_program.instructions.erase(next);`
Original file line number	Diff line number	Diff line change
`@@ -190,8 +190,9 @@ goto_programt::targett remove_virtual_functionst::remove_virtual_function(`
`190`	`190`	`}`
`191`	`191`	`else`
`192`	`192`	`{`
`193`		`- create_static_function_call(`
`194`		`- target->get_function_call(), *functions.front().symbol_expr, ns);`
	`193`	`+ auto c = target->get_function_call();`
	`194`	`+ create_static_function_call(c, *functions.front().symbol_expr, ns);`
	`195`	`+ target->set_function_call(c);`
`195`	`196`	`}`
`196`	`197`	`return next_target;`
`197`	`198`	`}`
`@@ -250,11 +251,12 @@ goto_programt::targett remove_virtual_functionst::remove_virtual_function(`
`250`	`251`	`if(fun.symbol_expr.has_value())`
`251`	`252`	`{`
`252`	`253`	`// call function`
`253`		`- goto_programt::targett t1 = new_code_calls.add(`
`254`		`- goto_programt::make_function_call(code, vcall_source_loc));`
	`254`	`+ auto new_call = code;`
	`255`	`+`
	`256`	`+ create_static_function_call(new_call, *fun.symbol_expr, ns);`
`255`	`257`
`256`		`- create_static_function_call(`
`257`		`- t1->get_function_call(), *fun.symbol_expr, ns);`
	`258`	`+ goto_programt::targett t1 = new_code_calls.add(`
	`259`	`+ goto_programt::make_function_call(new_call, vcall_source_loc));`
`258`	`260`
`259`	`261`	`insertit.first->second = t1;`
`260`	`262`	`}`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ void replace_callst::operator()(`
`70`	`70`	`if(!ins.is_function_call())`
`71`	`71`	`continue;`
`72`	`72`
`73`		`- code_function_callt &cfc = ins.get_function_call();`
	`73`	`+ auto cfc = ins.get_function_call();`
`74`	`74`	`exprt &function = cfc.function();`
`75`	`75`
`76`	`76`	`PRECONDITION(function.id() == ID_symbol);`
`@@ -114,6 +114,8 @@ void replace_callst::operator()(`
`114`	`114`	`// Finally modify the call`
`115`	`115`	`function.type() = f_it2->second.type;`
`116`	`116`	`se.set_identifier(new_id);`
	`117`	`+`
	`118`	`+ ins.set_function_call(cfc);`
`117`	`119`	`}`
`118`	`120`	`}`
`119`	`121`