Merge pull request diffblue#132 from diffblue/marek/irept_instrumenter_PR

SEC-19: Introducing irept_instrumenter.

Author: marek-trtik

src/taint-slicer/Makefile

@@ -4,6 +4,7 @@ SRC = slicer.cpp \
       instrumentation_props.cpp \
       instrumenter.cpp \
       slicing_tasks_builder.cpp \
+      irept_instrument.cpp \
       # end of SRC
 
 INCLUDES= -I .. -I ../../cbmc/src -I ../../boost

src/taint-slicer/irept_instrument.cpp

@@ -0,0 +1,135 @@
+/*******************************************************************\
+
+Module: irept_instrument
+
+Author: Marek Trtik
+
+Date: May 2017
+
+
+@ Copyright Diffblue, Ltd.
+
+\*******************************************************************/
+
+#include <taint-slicer/irept_instrument.h>
+
+// WARNING: 'irept' does not support equality check and its explicit use
+// in functions below was not appreciated (see PR #132). Equivalence
+// checks are thus used. And so, in case of performance issues in the
+// instrumenter focus your attention also to profiling of these checks.
+
+irept instrument(const irept irep, const instrumenter_fnt &instrumenter)
+{
+  bool modified=false;
+
+  irept::subt new_sub;
+  for(const irept &sub : irep.get_sub())
+  {
+    new_sub.push_back(instrument(sub, instrumenter));
+    if(new_sub.back()!=sub)
+      modified=true;
+  }
+
+  irept::named_subt new_named_sub;
+  for(const irept::named_subt::value_type &name_sub : irep.get_named_sub())
+  {
+    const auto it_bool=
+      new_named_sub.insert(
+        {
+          name_sub.first,
+          instrument(name_sub.second, instrumenter)
+        });
+    assert(it_bool.second);
+    if(it_bool.first->second!=name_sub.second)
+      modified=true;
+  }
+
+  irept::named_subt new_comments;
+  for(const irept::named_subt::value_type &name_sub : irep.get_comments())
+  {
+    const auto it_bool=
+      new_comments.insert(
+        {
+          name_sub.first,
+          instrument(name_sub.second, instrumenter)
+        });
+    assert(it_bool.second);
+    if(it_bool.first->second!=name_sub.second)
+      modified=true;
+  }
+
+  if(modified)
+  {
+    irept result(irep.id());
+    result.get_sub()=new_sub;
+    result.get_named_sub()=new_named_sub;
+    result.get_comments()=new_comments;
+    return instrumenter(result);
+  }
+  return instrumenter(irep);
+}
+
+irept instrument_using_guide(
+  const irept pivot,
+  const irept irep,
+  const guide_instrumenter_fnt &instrumenter)
+{
+  bool modified=false;
+
+  irept::subt new_sub;
+  for(auto pit=pivot.get_sub().cbegin(), iit=irep.get_sub().cbegin();
+      pit!=pivot.get_sub().cend() && iit!=irep.get_sub().cend(); ++pit, ++iit)
+  {
+    new_sub.push_back(instrument_using_guide(*pit, *iit, instrumenter));
+    if(new_sub.back()!=*iit)
+      modified=true;
+  }
+
+  irept::named_subt new_named_sub;
+  for(auto iit=irep.get_named_sub().cbegin();
+      iit!=irep.get_named_sub().cend();
+      ++iit)
+  {
+    const auto pit=pivot.get_named_sub().find(iit->first);
+    const auto it_bool=
+      new_named_sub.insert(
+        {
+          iit->first,
+          pit!=pivot.get_named_sub().cend() ?
+            instrument_using_guide(pit->second, iit->second, instrumenter):
+            iit->second
+        });
+    assert(it_bool.second);
+    if(it_bool.first->second!=iit->second)
+      modified=true;
+  }
+
+  irept::named_subt new_comments;
+  for(auto iit=irep.get_comments().cbegin();
+      iit!=irep.get_comments().cend();
+      ++iit)
+  {
+    auto pit=pivot.get_comments().find(iit->first);
+    const auto it_bool=
+      new_comments.insert(
+        {
+          iit->first,
+          pit!=pivot.get_comments().cend() ?
+            instrument_using_guide(pit->second, iit->second, instrumenter):
+            iit->second
+        });
+    assert(it_bool.second);
+    if(it_bool.first->second!=iit->second)
+      modified=true;
+  }
+
+  if(modified)
+  {
+    irept result(irep.id());
+    result.get_sub()=new_sub;
+    result.get_named_sub()=new_named_sub;
+    result.get_comments()=new_comments;
+    return instrumenter(pivot, result);
+  }
+  return instrumenter(pivot, irep);
+}

src/taint-slicer/irept_instrument.h

@@ -0,0 +1,78 @@
+/*******************************************************************\
+
+Module: irept_instrument
+
+Author: Marek Trtik
+
+Date: May 2017
+
+The module provides utility functuions simplifying the instrumentation
+proces of "irept" hierarchical and shared data structures.
+
+@ Copyright Diffblue, Ltd.
+
+\*******************************************************************/
+
+#ifndef CPROVER_TAINT_SLICER_IREPT_INSTRUMENT_H
+#define CPROVER_TAINT_SLICER_IREPT_INSTRUMENT_H
+
+#include <util/irep.h>
+#include <functional>
+
+/// An instrumenter is any function returning from a passed instance of
+/// 'irept' its instrumented version. If the passed instance does not
+/// match the king of 'irept' to be instrumented, the function must return
+/// the same instance to indicate no instrumentation was performed.
+/// Due to performance reasons it is recomended to write instrumenter
+/// functions looking only into the passed instance (i.e. not into
+/// 'irept' hierarchy below the passed instance).
+typedef std::function<irept(irept)> instrumenter_fnt;
+typedef std::function<irept(irept, irept)> guide_instrumenter_fnt;
+
+/*******************************************************************\
+
+Function:
+
+  Inputs:
+
+ Outputs:
+
+ Purpose:
+  The function accepts a hierarchy of 'irept's and for each node in
+  the hierarchy it calls the passed instrumenter. The result of the
+  function is a new 'irept' hierarchy constructed from the original
+  one by traversing it bottom-up and by applying the instrumenter on
+  each visited node.
+
+\*******************************************************************/
+irept instrument(const irept irep, const instrumenter_fnt &instrumenter);
+
+/*******************************************************************\
+
+Function:
+
+  Inputs:
+
+ Outputs:
+
+ Purpose:
+  Builds an instrumented copy of a passed hierarchy of
+  'irept's in the same way as the function 'instrument' above. However,
+  this version allows the user to also specify a 'guide' hierarchy of
+  'irept's providing more refined instrumentation.
+  The instrumenter is called only on that topological part of the hierarchy
+  matching the topology of the guide. Positional and named operands not present
+  in the guide irep are left unaltered. Also, the instrumenter called for
+  some node may use the corresponding guide node to decide how the
+  instrumentation will be performed. For example, imagine two nodes of
+  the exactly the same kind of the instrumenter passed with the different
+  kinds of guide nodes. The intrumenter may then return nodes of different
+  kinds (according to kinds of guide nodes).
+
+\*******************************************************************/
+irept instrument_using_guide(
+  const irept guide,
+  const irept irep,
+  const guide_instrumenter_fnt &instrumenter);
+
+#endif