Refine data dependency across function calls

Author: zhixing-xu

regression/goto-analyzer/dependence-graph13/main.c

@@ -0,0 +1,15 @@
+#include <assert.h>
+
+void bar(int a, int b)
+{
+   int result = b;
+}
+
+void main()
+{
+    int a = 1;
+    int b = 2;
+    int c = 3;
+    bar(a, b + c);
+}
+

regression/goto-analyzer/dependence-graph13/test.desc

@@ -0,0 +1,28 @@
+CORE
+main.c
+--dependence-graph --show
+activate-multi-line-match
+^EXIT=0$
+^SIGNAL=0$
+// Assignment has a data dependency on the assignment of b
+\/\/ ([0-9]+).*\n.*b = 2;(.*\n)*Data dependencies: (([0-9]+,\1)|(\1,[0-9]+))\n(.*\n){2,3}.*result = b
+// Assignment has a data dependency on the assignment of c
+\/\/ ([0-9]+).*\n.*c = 3;(.*\n)*Data dependencies: (([0-9]+,\1)|(\1,[0-9]+))\n(.*\n){2,3}.*result = b
+--
+^warning: ignoring
+--
+
+The two regex above matches output portions like shown below (with <N> being a
+location number). The intention is to check whether an function parameter in the 
+callee correctly depends on the caller provided argument.
+
+      // 3 file main.c line 11 function main
+        b = 2;
+...
+**** 12 file main.c line 5 function bar
+Data dependencies: (<N>,...)|(...,<N>)
+
+        // 12 file main.c line 5 function bar
+        result = b;
+
+The second regex matches for c.

src/analyses/dependence_graph.cpp

@@ -20,6 +20,7 @@ Date: August 2013
 #include <util/json_irep.h>
 
 #include "goto_rw.h"
+#include <iostream>
 
 bool dep_graph_domaint::merge(
   const dep_graph_domaint &src,
@@ -165,13 +166,14 @@ void dep_graph_domaint::data_dependencies(
     dep_graph.reaching_definitions().get_value_sets();
   rw_range_set_value_sett rw_set(ns, value_sets);
   goto_rw(function_to, to, rw_set);
+  std::cerr << "\ndata_deps from " << from->location_number << " to " << to->location_number << "\n";
 
   forall_rw_range_set_r_objects(it, rw_set)
   {
+    std::cerr << "Checking for symbol : " << it->first << "\n";
     const range_domaint &r_ranges=rw_set.get_ranges(it);
     const rd_range_domaint::ranges_at_loct &w_ranges=
       dep_graph.reaching_definitions()[to].get(it->first);
-
     for(const auto &w_range : w_ranges)
     {
       bool found=false;
@@ -183,6 +185,7 @@ void dep_graph_domaint::data_dependencies(
           {
             // found a def-use pair
             data_deps.insert(w_range.first);
+            std::cerr << " insert data_deps " << w_range.first->location_number << "\n";
             found=true;
           }
     }

src/analyses/goto_rw.cpp

@@ -493,6 +493,22 @@ void rw_range_sett::add(
 
   static_cast<range_domaint&>(*entry->second).push_back(
     {range_start, range_end});
+
+  // add to the single expression read set
+  if(mode==get_modet::READ && is_get_expr_r_set)
+  {
+    objectst::iterator expr_entry=
+         expr_r_range_set.insert(
+           std::pair<const irep_idt &, std::unique_ptr<range_domain_baset>>(
+             identifier, nullptr))
+         .first;
+
+    if(expr_entry->second==nullptr)
+      expr_entry->second=util_make_unique<range_domaint>();
+
+    static_cast<range_domaint&>(*expr_entry->second).push_back(
+      {range_start, range_end});
+  }
 }
 
 void rw_range_sett::get_objects_rec(

src/analyses/goto_rw.h

@@ -124,6 +124,7 @@ class rw_range_sett
   explicit rw_range_sett(const namespacet &_ns):
     ns(_ns)
   {
+    is_get_expr_r_set = false;
   }
 
   const objectst &get_r_set() const
@@ -136,6 +137,18 @@ class rw_range_sett
     return w_range_set;
   }
 
+  objectst &get_expr_r_set()
+  {
+    is_get_expr_r_set = false;
+    return expr_r_range_set;
+  }
+
+  void set_expr_r_set()
+  {
+    is_get_expr_r_set = true;
+    expr_r_range_set.clear();
+  }
+
   const range_domaint &get_ranges(objectst::const_iterator it) const
   {
     PRECONDITION(dynamic_cast<range_domaint*>(it->second.get())!=nullptr);
@@ -167,6 +180,9 @@ class rw_range_sett
   const namespacet &ns;
 
   objectst r_range_set, w_range_set;
+  // the read set for a single expression
+  objectst expr_r_range_set;
+  bool is_get_expr_r_set;
 
   virtual void get_objects_rec(
     get_modet mode,

src/analyses/reaching_definitions.cpp

@@ -20,11 +20,13 @@ Date: February 2013
 #include <util/pointer_offset_size.h>
 #include <util/prefix.h>
 #include <util/make_unique.h>
+#include <util/find_symbols.h>
 
 #include <pointer-analysis/value_set_analysis_fi.h>
 
 #include "is_threaded.h"
 #include "dirty.h"
+#include <iostream>
 
 reaching_definitions_analysist::reaching_definitions_analysist(
   const namespacet &_ns):
@@ -184,6 +186,7 @@ void rd_range_domaint::transform_function_call(
   reaching_definitions_analysist &rd)
 {
   const code_function_callt &code=to_code_function_call(from->code);
+  std::cerr << "\ntransform function call from " << from->location_number << " to " << to->location_number << "\n";
 
   // only if there is an actual call, i.e., we have a body
   if(function_from != function_to)
@@ -215,18 +218,46 @@ void rd_range_domaint::transform_function_call(
     const code_typet &code_type=
       to_code_type(ns.lookup(fn_symbol_expr.get_identifier()).type);
 
-    for(const auto &param : code_type.parameters())
+    std::cerr << "function name :" << fn_symbol_expr.get_identifier() << "\n";
+
+    rw_range_set_value_sett rw_set(ns, rd.get_value_sets());
+    //goto_rw(from, rw_set);
+    rw_set.output(std::cout);
+    //const rw_range_sett::objectst r_objects = rw_set.get_r_set();
+
+    PRECONDITION(code_type.parameters().size() == code.arguments().size());
+    auto param = code_type.parameters().begin();
+    auto arg = code.arguments().begin();
+    // iterate through argument/parameter pairs
+    while(param != code_type.parameters().end() &&
+        arg != code.arguments().end())
     {
-      const irep_idt &identifier=param.get_identifier();
+      const irep_idt &identifier=param->get_identifier();
 
       if(identifier.empty())
         continue;
 
-      auto param_bits = pointer_offset_bits(param.type(), ns);
-      if(param_bits.has_value())
-        gen(from, identifier, 0, to_range_spect(*param_bits));
-      else
-        gen(from, identifier, 0, -1);
+      std::cout << " param name: " << identifier << "\n";
+      // get read set of the argument
+      rw_set.set_expr_r_set();
+      rw_set.get_objects_rec(from, rw_range_sett::get_modet::READ, *arg);
+      std::cout << " argument set: \n";
+      for(rw_range_sett::objectst::const_iterator
+          it=(rw_set).get_expr_r_set().begin();
+          it!=(rw_set).get_expr_r_set().end(); ++it)
+      {
+        std::cout << it->first << ":";
+        const rd_range_domaint::ranges_at_loct &w_ranges = rd[from].get(it->first);
+        for(const auto &w_range : w_ranges)
+        {
+          std::cerr << " further dep on: " << w_range.first->location_number << "\n";
+          for(const auto &wr : w_range.second)
+            gen(w_range.first, identifier, wr.first, wr.second);
+        }
+      }
+      // next argument/parameter pair
+      ++param;
+      ++arg;
     }
   }
   else
@@ -313,8 +344,10 @@ void rd_range_domaint::transform_assign(
   locationt to,
   reaching_definitions_analysist &rd)
 {
+  std::cerr << "\ntransform assign from " << from->location_number << " to " << to->location_number << "\n";
   rw_range_set_value_sett rw_set(ns, rd.get_value_sets());
   goto_rw(function_to, to, rw_set);
+  rw_set.output(std::cerr);
   const bool is_must_alias=rw_set.get_w_set().size()==1;
 
   forall_rw_range_set_w_objects(it, rw_set)