use instructiont::get_function_call() and get_assign()

kroening · kroening · commit 03eecc2b96f6 · 2021-03-15T10:00:12.000Z
This replaces direct access to instructiont::code to the provided API for
the case of assignment and function call instructions.
diff --git a/jbmc/src/java_bytecode/replace_java_nondet.cpp b/jbmc/src/java_bytecode/replace_java_nondet.cpp
@@ -146,7 +146,7 @@ static bool is_assignment_from(
   {
     return false;
   }
-  const auto &rhs = to_code_assign(instr.code).rhs();
+  const auto &rhs = instr.get_assign().rhs();
   return is_symbol_with_id(rhs, identifier) ||
          is_typecast_with_id(rhs, identifier);
 }
@@ -227,8 +227,7 @@ static goto_programt::targett check_and_replace_target(
       "either have a variable for the return value in its lhs() or the next "
       "instruction should be an assignment of the return value to a temporary "
       "variable");
-    const exprt &return_value_assignment =
-      to_code_assign(next_instr->code).lhs();
+    const exprt &return_value_assignment = next_instr->get_assign().lhs();
 
     // If the assignment is null, return.
     if(
@@ -290,7 +289,7 @@ static goto_programt::targett check_and_replace_target(
   else if(target_instruction->is_assign())
   {
     // Assume that the LHS of *this* assignment is the actual nondet variable
-    const auto &nondet_var = to_code_assign(target_instruction->code).lhs();
+    const auto &nondet_var = target_instruction->get_assign().lhs();
 
     side_effect_expr_nondett inserted_expr(
       nondet_var.type(), target_instruction->source_location);
diff --git a/src/analyses/ai.cpp b/src/analyses/ai.cpp
@@ -398,7 +398,7 @@ bool ai_baset::visit_function_call(
   // it generates a synthetic goto_functions object for this
   if(!goto_functions.function_map.empty())
   {
-    const code_function_callt &code = to_code_function_call(l_call->code);
+    const code_function_callt &code = l_call->get_function_call();
     const exprt &callee_expression = code.function();
 
     if(callee_expression.id() == ID_symbol)
diff --git a/src/analyses/call_graph.cpp b/src/analyses/call_graph.cpp
@@ -56,7 +56,7 @@ static void forall_callsites(
   {
     if(i_it->is_function_call())
     {
-      const exprt &function_expr=to_code_function_call(i_it->code).function();
+      const exprt &function_expr = i_it->get_function_call().function();
       if(function_expr.id()==ID_symbol)
       {
         const irep_idt &callee=to_symbol_expr(function_expr).get_identifier();
diff --git a/src/analyses/custom_bitvector_analysis.cpp b/src/analyses/custom_bitvector_analysis.cpp
@@ -287,7 +287,7 @@ void custom_bitvector_domaint::transform(
   {
   case ASSIGN:
     {
-      const code_assignt &code_assign=to_code_assign(instruction.code);
+      const code_assignt &code_assign = instruction.get_assign();
       assign_struct_rec(from, code_assign.lhs(), code_assign.rhs(), cba, ns);
     }
     break;
@@ -313,8 +313,8 @@ void custom_bitvector_domaint::transform(
 
   case FUNCTION_CALL:
     {
-      const code_function_callt &code_function_call=
-        to_code_function_call(instruction.code);
+      const code_function_callt &code_function_call =
+        instruction.get_function_call();
       const exprt &function=code_function_call.function();
 
       if(function.id()==ID_symbol)
diff --git a/src/analyses/does_remove_const.cpp b/src/analyses/does_remove_const.cpp
@@ -40,7 +40,7 @@ std::pair<bool, source_locationt> does_remove_constt::operator()() const
       continue;
     }
 
-    const code_assignt &assign=to_code_assign(instruction.code);
+    const code_assignt &assign = instruction.get_assign();
     const typet &rhs_type=assign.rhs().type();
     const typet &lhs_type=assign.lhs().type();
 
diff --git a/src/analyses/escape_analysis.cpp b/src/analyses/escape_analysis.cpp
@@ -189,7 +189,7 @@ void escape_domaint::transform(
   {
   case ASSIGN:
     {
-      const code_assignt &code_assign=to_code_assign(instruction.code);
+      const code_assignt &code_assign = instruction.get_assign();
 
       std::set<irep_idt> cleanup_functions;
       get_rhs_cleanup(code_assign.rhs(), cleanup_functions);
@@ -213,8 +213,8 @@ void escape_domaint::transform(
 
   case FUNCTION_CALL:
     {
-      const code_function_callt &code_function_call=
-        to_code_function_call(instruction.code);
+      const code_function_callt &code_function_call =
+        instruction.get_function_call();
       const exprt &function=code_function_call.function();
 
       if(function.id()==ID_symbol)
@@ -467,7 +467,7 @@ void escape_analysist::instrument(
 
       if(instruction.type == ASSIGN)
       {
-        const code_assignt &code_assign = to_code_assign(instruction.code);
+        const code_assignt &code_assign = instruction.get_assign();
 
         std::set<irep_idt> cleanup_functions;
         operator[](i_it).check_lhs(code_assign.lhs(), cleanup_functions);
diff --git a/src/analyses/flow_insensitive_analysis.cpp b/src/analyses/flow_insensitive_analysis.cpp
@@ -38,7 +38,7 @@ exprt flow_insensitive_abstract_domain_baset::get_return_lhs(locationt to) const
     return static_cast<const exprt &>(get_nil_irep());
 
   // must be the function call
-  return to_code_function_call(to->code).lhs();
+  return to->get_function_call().lhs();
 }
 
 void flow_insensitive_analysis_baset::operator()(
@@ -153,7 +153,7 @@ bool flow_insensitive_analysis_baset::visit(
     if(l->is_function_call())
     {
       // this is a big special case
-      const code_function_callt &code = to_code_function_call(l->code);
+      const code_function_callt &code = l->get_function_call();
 
       changed = do_function_call_rec(
         function_id,
@@ -202,7 +202,7 @@ bool flow_insensitive_analysis_baset::do_function_call(
 
   if(!goto_function.body_available())
   {
-    const code_function_callt &code = to_code_function_call(l_call->code);
+    const code_function_callt &code = l_call->get_function_call();
 
     goto_programt temp;
 
diff --git a/src/analyses/global_may_alias.cpp b/src/analyses/global_may_alias.cpp
@@ -111,7 +111,7 @@ void global_may_alias_domaint::transform(
   {
   case ASSIGN:
   {
-    const code_assignt &code_assign = to_code_assign(instruction.code);
+    const code_assignt &code_assign = instruction.get_assign();
 
     std::set<irep_idt> rhs_aliases;
     get_rhs_aliases(code_assign.rhs(), rhs_aliases);
diff --git a/src/analyses/goto_rw.cpp b/src/analyses/goto_rw.cpp
@@ -802,7 +802,7 @@ void goto_rw(
     break;
 
   case ASSIGN:
-    goto_rw(function, target, to_code_assign(target->code), rw_set);
+    goto_rw(function, target, target->get_assign(), rw_set);
     break;
 
   case DEAD:
@@ -817,7 +817,7 @@ void goto_rw(
     break;
 
   case FUNCTION_CALL:
-    goto_rw(function, target, to_code_function_call(target->code), rw_set);
+    goto_rw(function, target, target->get_function_call(), rw_set);
     break;
   }
 }
diff --git a/src/analyses/interval_domain.cpp b/src/analyses/interval_domain.cpp
@@ -79,7 +79,7 @@ void interval_domaint::transform(
     break;
 
   case ASSIGN:
-    assign(to_code_assign(instruction.code));
+    assign(instruction.get_assign());
     break;
 
   case GOTO:
@@ -105,7 +105,7 @@ void interval_domaint::transform(
   case FUNCTION_CALL:
   {
     const code_function_callt &code_function_call =
-      to_code_function_call(instruction.code);
+      instruction.get_function_call();
     if(code_function_call.lhs().is_not_nil())
       havoc_rec(code_function_call.lhs());
     break;
diff --git a/src/analyses/local_may_alias.cpp b/src/analyses/local_may_alias.cpp
@@ -376,7 +376,7 @@ void local_may_aliast::build(const goto_functiont &goto_function)
     {
     case ASSIGN:
     {
-      const code_assignt &code_assign = to_code_assign(instruction.code);
+      const code_assignt &code_assign = instruction.get_assign();
       assign_lhs(
         code_assign.lhs(), code_assign.rhs(), loc_info_src, loc_info_dest);
       break;
@@ -395,7 +395,7 @@ void local_may_aliast::build(const goto_functiont &goto_function)
     case FUNCTION_CALL:
     {
       const code_function_callt &code_function_call =
-        to_code_function_call(instruction.code);
+        instruction.get_function_call();
       if(code_function_call.lhs().is_not_nil())
         assign_lhs(
           code_function_call.lhs(), nil_exprt(), loc_info_src, loc_info_dest);
diff --git a/src/analyses/reaching_definitions.cpp b/src/analyses/reaching_definitions.cpp
@@ -212,7 +212,7 @@ void rd_range_domaint::transform_function_call(
   const irep_idt &function_to,
   reaching_definitions_analysist &rd)
 {
-  const code_function_callt &code=to_code_function_call(from->code);
+  const code_function_callt &code = from->get_function_call();
 
   // only if there is an actual call, i.e., we have a body
   if(function_from != function_to)
@@ -261,7 +261,7 @@ void rd_range_domaint::transform_function_call(
   else
   {
     // handle return values of undefined functions
-    if(to_code_function_call(from->code).lhs().is_not_nil())
+    if(from->get_function_call().lhs().is_not_nil())
       transform_assign(ns, from, function_from, from, rd);
   }
 }
@@ -276,7 +276,7 @@ void rd_range_domaint::transform_end_function(
 {
   locationt call = to;
   --call;
-  const code_function_callt &code=to_code_function_call(call->code);
+  const code_function_callt &code = call->get_function_call();
 
   valuest new_values;
   new_values.swap(values);
diff --git a/src/analyses/static_analysis.cpp b/src/analyses/static_analysis.cpp
@@ -45,8 +45,7 @@ exprt static_analysis_baset::get_return_lhs(locationt to)
   // must be the function call
   assert(to->is_function_call());
 
-  const code_function_callt &code=
-    to_code_function_call(to->code);
+  const code_function_callt &code = to->get_function_call();
 
   return code.lhs();
 }
@@ -212,8 +211,7 @@ bool static_analysis_baset::visit(
     if(l->is_function_call())
     {
       // this is a big special case
-      const code_function_callt &code=
-        to_code_function_call(l->code);
+      const code_function_callt &code = l->get_function_call();
 
       do_function_call_rec(
         function_identifier,
diff --git a/src/goto-instrument/accelerate/acceleration_utils.cpp b/src/goto-instrument/accelerate/acceleration_utils.cpp
@@ -105,7 +105,7 @@ void acceleration_utilst::find_modified(
 {
   if(t->is_assign())
   {
-    code_assignt assignment=to_code_assign(t->code);
+    code_assignt assignment = t->get_assign();
     modified.insert(assignment.lhs());
   }
 }
@@ -247,7 +247,7 @@ exprt acceleration_utilst::precondition(patht &path)
     if(t->is_assign())
     {
       // XXX Need to check for aliasing...
-      const code_assignt &assignment=to_code_assign(t->code);
+      const code_assignt &assignment = t->get_assign();
       const exprt &lhs=assignment.lhs();
       const exprt &rhs=assignment.rhs();
 
@@ -511,7 +511,7 @@ acceleration_utilst::expr_pairst acceleration_utilst::gather_array_assignments(
     if(r_it->is_assign())
     {
       // Is this an array assignment?
-      code_assignt assignment=to_code_assign(r_it->code);
+      code_assignt assignment = r_it->get_assign();
 
       if(assignment.lhs().id()==ID_index)
       {
diff --git a/src/goto-instrument/accelerate/cone_of_influence.cpp b/src/goto-instrument/accelerate/cone_of_influence.cpp
@@ -127,7 +127,7 @@ void cone_of_influencet::cone_of_influence(
 
   if(i.is_assign())
   {
-    const code_assignt &assignment=to_code_assign(i.code);
+    const code_assignt &assignment = i.get_assign();
     expr_sett lhs_syms;
     bool care=false;
 
diff --git a/src/goto-instrument/accelerate/polynomial_accelerator.cpp b/src/goto-instrument/accelerate/polynomial_accelerator.cpp
@@ -787,7 +787,7 @@ exprt polynomial_acceleratort::precondition(patht &path)
     if(t->is_assign())
     {
       // XXX Need to check for aliasing...
-      const code_assignt &assignment=to_code_assign(t->code);
+      const code_assignt &assignment = t->get_assign();
       const exprt &lhs=assignment.lhs();
       const exprt &rhs=assignment.rhs();
 
diff --git a/src/goto-instrument/undefined_functions.cpp b/src/goto-instrument/undefined_functions.cpp
@@ -41,7 +41,7 @@ void undefined_function_abort_path(goto_modelt &goto_model)
       if(!ins.is_function_call())
         continue;
 
-      const code_function_callt &call=to_code_function_call(ins.code);
+      const code_function_callt &call = ins.get_function_call();
 
       if(call.function().id()!=ID_symbol)
         continue;
diff --git a/src/goto-programs/compute_called_functions.cpp b/src/goto-programs/compute_called_functions.cpp
@@ -115,7 +115,7 @@ compute_called_functions(const goto_functionst &goto_functions)
       if(instruction.is_function_call())
       {
         compute_functions(
-          to_code_function_call(instruction.code).function(), working_queue);
+          instruction.get_function_call().function(), working_queue);
       }
     }
   }
diff --git a/unit/analyses/ai/ai.cpp b/unit/analyses/ai/ai.cpp
@@ -94,7 +94,7 @@ class instruction_counter_analysist : public ait<instruction_counter_domaint>
   {
     if(!i.is_assign())
       return false;
-    const code_assignt &assign = to_code_assign(i.code);
+    const code_assignt &assign = i.get_assign();
     return
       assign.lhs().id() == ID_symbol &&
       id2string(to_symbol_expr(assign.lhs()).get_identifier()).find('y') !=
diff --git a/unit/analyses/constant_propagator.cpp b/unit/analyses/constant_propagator.cpp
@@ -70,10 +70,9 @@ SCENARIO("constant_propagator", "[core][analyses][constant_propagator]")
     // Find the instruction after "y = 2;"
     goto_programt::const_targett test_instruction =
       main_function.body.instructions.begin();
-    while(
-      test_instruction != main_function.body.instructions.end() &&
-      (!test_instruction->is_assign() ||
-       to_code_assign(test_instruction->code).lhs() != local_y.symbol_expr()))
+    while(test_instruction != main_function.body.instructions.end() &&
+          (!test_instruction->is_assign() ||
+           test_instruction->get_assign().lhs() != local_y.symbol_expr()))
     {
       ++test_instruction;
     }
@@ -311,10 +310,10 @@ SCENARIO("constant_propagator", "[core][analyses][constant_propagator]")
     // have been propagated once we reach it.
     goto_programt::const_targett test_instruction =
       main_function.body.instructions.begin();
-    while(test_instruction != main_function.body.instructions.end() &&
-          !(test_instruction->is_assign() &&
-            to_code_assign(test_instruction->code).lhs() ==
-              marker_symbol.symbol_expr()))
+    while(
+      test_instruction != main_function.body.instructions.end() &&
+      !(test_instruction->is_assign() &&
+        test_instruction->get_assign().lhs() == marker_symbol.symbol_expr()))
     {
       ++test_instruction;
     }

Original file line number	Diff line number	Diff line change
`@@ -146,7 +146,7 @@ static bool is_assignment_from(`
`146`	`146`	`{`
`147`	`147`	`return false;`
`148`	`148`	`}`
`149`		`- const auto &rhs = to_code_assign(instr.code).rhs();`
	`149`	`+ const auto &rhs = instr.get_assign().rhs();`
`150`	`150`	`return is_symbol_with_id(rhs, identifier) \|\|`
`151`	`151`	`is_typecast_with_id(rhs, identifier);`
`152`	`152`	`}`
`@@ -227,8 +227,7 @@ static goto_programt::targett check_and_replace_target(`
`227`	`227`	`"either have a variable for the return value in its lhs() or the next "`
`228`	`228`	`"instruction should be an assignment of the return value to a temporary "`
`229`	`229`	`"variable");`
`230`		`- const exprt &return_value_assignment =`
`231`		`- to_code_assign(next_instr->code).lhs();`
	`230`	`+ const exprt &return_value_assignment = next_instr->get_assign().lhs();`
`232`	`231`
`233`	`232`	`// If the assignment is null, return.`
`234`	`233`	`if(`
`@@ -290,7 +289,7 @@ static goto_programt::targett check_and_replace_target(`
`290`	`289`	`else if(target_instruction->is_assign())`
`291`	`290`	`{`
`292`	`291`	`// Assume that the LHS of this assignment is the actual nondet variable`
`293`		`- const auto &nondet_var = to_code_assign(target_instruction->code).lhs();`
	`292`	`+ const auto &nondet_var = target_instruction->get_assign().lhs();`
`294`	`293`
`295`	`294`	`side_effect_expr_nondett inserted_expr(`
`296`	`295`	`nondet_var.type(), target_instruction->source_location);`
Original file line number	Diff line number	Diff line change
`@@ -398,7 +398,7 @@ bool ai_baset::visit_function_call(`
`398`	`398`	`// it generates a synthetic goto_functions object for this`
`399`	`399`	`if(!goto_functions.function_map.empty())`
`400`	`400`	`{`
`401`		`- const code_function_callt &code = to_code_function_call(l_call->code);`
	`401`	`+ const code_function_callt &code = l_call->get_function_call();`
`402`	`402`	`const exprt &callee_expression = code.function();`
`403`	`403`
`404`	`404`	`if(callee_expression.id() == ID_symbol)`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ static void forall_callsites(`
`56`	`56`	`{`
`57`	`57`	`if(i_it->is_function_call())`
`58`	`58`	`{`
`59`		`- const exprt &function_expr=to_code_function_call(i_it->code).function();`
	`59`	`+ const exprt &function_expr = i_it->get_function_call().function();`
`60`	`60`	`if(function_expr.id()==ID_symbol)`
`61`	`61`	`{`
`62`	`62`	`const irep_idt &callee=to_symbol_expr(function_expr).get_identifier();`
Original file line number	Diff line number	Diff line change
`@@ -287,7 +287,7 @@ void custom_bitvector_domaint::transform(`
`287`	`287`	`{`
`288`	`288`	`case ASSIGN:`
`289`	`289`	`{`
`290`		`- const code_assignt &code_assign=to_code_assign(instruction.code);`
	`290`	`+ const code_assignt &code_assign = instruction.get_assign();`
`291`	`291`	`assign_struct_rec(from, code_assign.lhs(), code_assign.rhs(), cba, ns);`
`292`	`292`	`}`
`293`	`293`	`break;`
`@@ -313,8 +313,8 @@ void custom_bitvector_domaint::transform(`
`313`	`313`
`314`	`314`	`case FUNCTION_CALL:`
`315`	`315`	`{`
`316`		`- const code_function_callt &code_function_call=`
`317`		`- to_code_function_call(instruction.code);`
	`316`	`+ const code_function_callt &code_function_call =`
	`317`	`+ instruction.get_function_call();`
`318`	`318`	`const exprt &function=code_function_call.function();`
`319`	`319`
`320`	`320`	`if(function.id()==ID_symbol)`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ std::pair<bool, source_locationt> does_remove_constt::operator()() const`
`40`	`40`	`continue;`
`41`	`41`	`}`
`42`	`42`
`43`		`- const code_assignt &assign=to_code_assign(instruction.code);`
	`43`	`+ const code_assignt &assign = instruction.get_assign();`
`44`	`44`	`const typet &rhs_type=assign.rhs().type();`
`45`	`45`	`const typet &lhs_type=assign.lhs().type();`
`46`	`46`
Original file line number	Diff line number	Diff line change
`@@ -189,7 +189,7 @@ void escape_domaint::transform(`
`189`	`189`	`{`
`190`	`190`	`case ASSIGN:`
`191`	`191`	`{`
`192`		`- const code_assignt &code_assign=to_code_assign(instruction.code);`
	`192`	`+ const code_assignt &code_assign = instruction.get_assign();`
`193`	`193`
`194`	`194`	`std::set<irep_idt> cleanup_functions;`
`195`	`195`	`get_rhs_cleanup(code_assign.rhs(), cleanup_functions);`
`@@ -213,8 +213,8 @@ void escape_domaint::transform(`
`213`	`213`
`214`	`214`	`case FUNCTION_CALL:`
`215`	`215`	`{`
`216`		`- const code_function_callt &code_function_call=`
`217`		`- to_code_function_call(instruction.code);`
	`216`	`+ const code_function_callt &code_function_call =`
	`217`	`+ instruction.get_function_call();`
`218`	`218`	`const exprt &function=code_function_call.function();`
`219`	`219`
`220`	`220`	`if(function.id()==ID_symbol)`
`@@ -467,7 +467,7 @@ void escape_analysist::instrument(`
`467`	`467`
`468`	`468`	`if(instruction.type == ASSIGN)`
`469`	`469`	`{`
`470`		`- const code_assignt &code_assign = to_code_assign(instruction.code);`
	`470`	`+ const code_assignt &code_assign = instruction.get_assign();`
`471`	`471`
`472`	`472`	`std::set<irep_idt> cleanup_functions;`
`473`	`473`	`operator[](i_it).check_lhs(code_assign.lhs(), cleanup_functions);`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ exprt flow_insensitive_abstract_domain_baset::get_return_lhs(locationt to) const`
`38`	`38`	`return static_cast<const exprt &>(get_nil_irep());`
`39`	`39`
`40`	`40`	`// must be the function call`
`41`		`- return to_code_function_call(to->code).lhs();`
	`41`	`+ return to->get_function_call().lhs();`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`void flow_insensitive_analysis_baset::operator()(`
`@@ -153,7 +153,7 @@ bool flow_insensitive_analysis_baset::visit(`
`153`	`153`	`if(l->is_function_call())`
`154`	`154`	`{`
`155`	`155`	`// this is a big special case`
`156`		`- const code_function_callt &code = to_code_function_call(l->code);`
	`156`	`+ const code_function_callt &code = l->get_function_call();`
`157`	`157`
`158`	`158`	`changed = do_function_call_rec(`
`159`	`159`	`function_id,`
`@@ -202,7 +202,7 @@ bool flow_insensitive_analysis_baset::do_function_call(`
`202`	`202`
`203`	`203`	`if(!goto_function.body_available())`
`204`	`204`	`{`
`205`		`- const code_function_callt &code = to_code_function_call(l_call->code);`
	`205`	`+ const code_function_callt &code = l_call->get_function_call();`
`206`	`206`
`207`	`207`	`goto_programt temp;`
`208`	`208`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ void global_may_alias_domaint::transform(`
`111`	`111`	`{`
`112`	`112`	`case ASSIGN:`
`113`	`113`	`{`
`114`		`- const code_assignt &code_assign = to_code_assign(instruction.code);`
	`114`	`+ const code_assignt &code_assign = instruction.get_assign();`
`115`	`115`
`116`	`116`	`std::set<irep_idt> rhs_aliases;`
`117`	`117`	`get_rhs_aliases(code_assign.rhs(), rhs_aliases);`
Original file line number	Diff line number	Diff line change
`@@ -802,7 +802,7 @@ void goto_rw(`
`802`	`802`	`break;`
`803`	`803`
`804`	`804`	`case ASSIGN:`
`805`		`- goto_rw(function, target, to_code_assign(target->code), rw_set);`
	`805`	`+ goto_rw(function, target, target->get_assign(), rw_set);`
`806`	`806`	`break;`
`807`	`807`
`808`	`808`	`case DEAD:`
`@@ -817,7 +817,7 @@ void goto_rw(`
`817`	`817`	`break;`
`818`	`818`
`819`	`819`	`case FUNCTION_CALL:`
`820`		`- goto_rw(function, target, to_code_function_call(target->code), rw_set);`
	`820`	`+ goto_rw(function, target, target->get_function_call(), rw_set);`
`821`	`821`	`break;`
`822`	`822`	`}`
`823`	`823`	`}`