Add tests for listing potential targets and remove/restore returns

And update the unit makefile.

Also fix sharing_map unit test

Suddenly, the ordering on dstrings became unpredictable: in this commit the
numbers are as follows
i => 796
j => 992
k => 1019
l => 833
I guess the sorting is not the focus of this tests so I made this change; it
should work regardless the ordering.

Author: NlightNFotis

unit/Makefile

@@ -14,6 +14,8 @@ SRC += analyses/ai/ai.cpp \
        analyses/does_remove_const/does_expr_lose_const.cpp \
        analyses/does_remove_const/does_type_preserve_const_correctness.cpp \
        analyses/does_remove_const/is_type_at_least_as_const_as.cpp \
+       analyses/remove_function_pointers.cpp \
+       analyses/remove_returns.cpp \
        big-int/big-int.cpp \
        compound_block_locations.cpp \
        goto-instrument/cover/cover_only.cpp \

unit/analyses/remove_function_pointers.cpp

@@ -0,0 +1,129 @@
+/*******************************************************************\
+ Module: Unit tests for module remove_function_pointers
+
+ Author: Diffblue Ltd.
+
+ Date: Apr 2019
+
+\*******************************************************************/
+
+/// \file
+/// Unit tests for module remove_function_pointers
+
+#include <testing-utils/message.h>
+#include <testing-utils/use_catch.h>
+
+#include <util/arith_tools.h>
+#include <util/c_types.h>
+#include <util/std_code.h>
+
+#include <goto-programs/goto_convert_functions.h>
+#include <goto-programs/goto_model.h>
+#include <goto-programs/remove_function_pointers.h>
+
+SCENARIO(
+  "List potential targets works reliable",
+  "[core][goto-programs][list_potential_targets]")
+{
+  goto_modelt goto_model;
+  // create one instance of the function type, they are all
+  // going to have the same signature
+  typet func_type = code_typet{{}, empty_typet{}};
+  // create an empty code block, to act as the functions' body
+  code_blockt func_body = code_blockt{};
+
+  // void f(){};
+  symbolt f;
+  f.name = "f";
+  f.mode = ID_C;
+  f.type = func_type; // void, takes no params
+  f.value = func_body;
+  goto_model.symbol_table.add(f);
+
+  // void g(){};
+  symbolt g;
+  g.name = "g";
+  g.mode = ID_C;
+  g.type = func_type; // void, takes no params
+  g.value = func_body;
+  goto_model.symbol_table.add(g);
+
+  // void h(){};
+  symbolt h;
+  h.name = "h";
+  h.mode = ID_C;
+  h.type = func_type; // void, takes no params
+  h.value = func_body;
+  goto_model.symbol_table.add(h);
+
+  // void l(){};
+  symbolt l;
+  l.name = "l";
+  l.mode = ID_C;
+  l.type = func_type; // void, takes no params
+  l.value = func_body;
+  goto_model.symbol_table.add(l);
+
+  // create array with function pointer elements
+  array_typet fp_array_type(
+    pointer_typet{func_type, 64}, from_integer(4, signed_int_type()));
+  array_exprt fp_array{{}, fp_array_type};
+
+  fp_array.copy_to_operands(address_of_exprt{f.symbol_expr()});
+  fp_array.copy_to_operands(address_of_exprt{g.symbol_expr()});
+  fp_array.copy_to_operands(address_of_exprt{h.symbol_expr()});
+  fp_array.copy_to_operands(address_of_exprt{l.symbol_expr()});
+
+  // f = fparray {f1, f2, f3, f4};
+  symbolt fpa;
+  fpa.name = "f";
+  fpa.mode = ID_C;
+  fpa.type = fp_array_type;
+  fpa.value = fp_array;
+
+  goto_model.symbol_table.add(fpa);
+
+  // pointer to fn call
+  symbolt fn_ptr;
+  fn_ptr.name = "fn_ptr";
+  fn_ptr.mode = ID_C;
+  fn_ptr.type = pointer_typet{func_type, 64};
+  goto_model.symbol_table.add(fn_ptr);
+
+  // symbol for indexing the array
+  symbolt z;
+  z.name = "z";
+  z.mode = ID_C;
+  z.type = signed_int_type();
+  goto_model.symbol_table.add(z);
+
+  // create function with pointer function call instruction
+
+  // void entry(){z; array; fn_ptr = array[z]; *fn_ptr()};
+  symbolt entry;
+  entry.name = "entry";
+  entry.mode = ID_C;
+  entry.type = func_type; // void, takes no params
+
+  code_blockt entry_body{
+    {// fn_ptr = array[z];
+     code_assignt{
+       fn_ptr.symbol_expr(),
+       index_exprt{fp_array, z.symbol_expr(), pointer_type(func_type)}},
+     // *fn_ptr();
+     code_function_callt{dereference_exprt{fn_ptr.symbol_expr()}}}};
+  entry.value = entry_body;
+  goto_model.symbol_table.add(entry);
+
+  WHEN("list_potential_targets is run")
+  {
+    goto_convert(goto_model, null_message_handler);
+    auto target_map =
+      get_function_pointer_targets(null_message_handler, goto_model);
+    THEN("there should be 4 targets recognised")
+    {
+      REQUIRE(target_map.size() == 1);
+      REQUIRE(target_map.begin()->second.size() == 4);
+    }
+  }
+}

unit/analyses/remove_returns.cpp

@@ -0,0 +1,93 @@
+/*******************************************************************\
+ Module: Unit tests for module remove_returns
+
+ Author: Diffblue Ltd.
+
+ Date: Apr 2019
+
+\*******************************************************************/
+
+/// \file
+/// Unit tests for module remove_returns
+/// This is testing the top level interfaces for now.
+
+#include <testing-utils/message.h>
+#include <testing-utils/use_catch.h>
+
+#include <util/arith_tools.h>
+#include <util/c_types.h>
+#include <util/std_code.h>
+
+#include <goto-programs/goto_convert_functions.h>
+#include <goto-programs/goto_model.h>
+#include <goto-programs/remove_returns.h>
+
+// scenario for testing remove returns
+
+SCENARIO(
+  "Remove returns is working reliably",
+  "[core][goto-programs][remove_returns]")
+{
+  goto_modelt goto_model;
+
+  // int f() { return 5; }
+  symbolt f;
+  f.name = "f";
+  f.mode = ID_C;
+  f.type = code_typet{{}, signed_int_type()};
+  f.value = code_blockt{{code_returnt(from_integer(5, signed_int_type()))}};
+  goto_model.symbol_table.add(f);
+
+  goto_convert(goto_model, null_message_handler);
+
+  WHEN("remove_returns is invoked")
+  {
+    remove_returns(
+      null_message_handler, goto_model.symbol_table, goto_model.goto_functions);
+    THEN("function f should not contain any return instructions")
+    {
+      const auto &goto_functions = goto_model.goto_functions;
+      for(const auto &function_pair : goto_functions.function_map)
+      {
+        if(function_pair.first == "f")
+        {
+          const auto &instructions = function_pair.second.body.instructions;
+          for(auto target = instructions.begin(); target != instructions.end();
+              target++)
+          {
+            // make sure there are no return instructions.
+            REQUIRE(!target->is_return());
+          }
+        }
+      }
+    }
+  }
+
+  WHEN("restore_returns is invoked")
+  {
+    restore_returns(null_message_handler, goto_model);
+    THEN("function f should have a skip instruction")
+    {
+      int number_of_returns = 0;
+      const auto &goto_functions = goto_model.goto_functions;
+      for(const auto &function_pair : goto_functions.function_map)
+      {
+        if(function_pair.first == "f")
+        {
+          const auto &instructions = function_pair.second.body.instructions;
+          for(auto target = instructions.begin(); target != instructions.end();
+              target++)
+          {
+            if(target->is_return())
+              number_of_returns++;
+          }
+        }
+      }
+
+      // ensure that there were only 1 return instructions in f
+      REQUIRE(number_of_returns == 1);
+    }
+  }
+}
+
+// scenario for testing restore returns

unit/util/sharing_map.cpp

@@ -318,7 +318,19 @@ TEST_CASE("Sharing map views", "[core][util]")
 
     sort_view();
 
-    REQUIRE((pairs[3] == pt("l", "3")));
+    dstringt i("i");
+    dstringt j("j");
+    dstringt k("k");
+    dstringt l("l");
+
+    size_t index = 0;
+    if(i < l)
+      index++;
+    if(j < l)
+      index++;
+    if(k < l)
+      index++;
+    REQUIRE((pairs[index] == pt("l", "3")));
   }
 
   SECTION("Delta view (no sharing, same keys)")