Dominator analysis: analyse on basic-block granularity

Previously this used instruction granularity, which especially combined with a naive
dominator set (not a dominator tree) can waste a great deal of time and memory computing
and storing the dominator sets.

Now that cfg_dominatorst works on a basic-block granularity, natural_loopst does as well.

Author: smowton

jbmc/src/java_bytecode/java_local_variable_table.cpp

@@ -85,19 +85,19 @@ struct procedure_local_cfg_baset<
     }
   }
 
-  java_bytecode_convert_methodt::method_offsett
-  get_first_node(const method_with_amapt &args) const
+  static java_bytecode_convert_methodt::method_offsett
+  get_first_node(const method_with_amapt &args)
   {
     return args.second.begin()->first;
   }
 
-  java_bytecode_convert_methodt::method_offsett
-  get_last_node(const method_with_amapt &args) const
+  static java_bytecode_convert_methodt::method_offsett
+  get_last_node(const method_with_amapt &args)
   {
     return (--args.second.end())->first;
   }
 
-  bool nodes_empty(const method_with_amapt &args) const
+  static bool nodes_empty(const method_with_amapt &args)
   {
     return args.second.empty();
   }
@@ -442,13 +442,19 @@ static java_bytecode_convert_methodt::method_offsett get_common_dominator(
     candidate_dominators;
   for(auto v : merge_vars)
   {
-    const auto &dominator_nodeidx=
+    const auto &var_start_basic_block =
       dominator_analysis.cfg.entry_map.at(v->var.start_pc);
-    const auto &this_var_doms=
-      dominator_analysis.cfg[dominator_nodeidx].dominators;
-    for(const auto this_var_dom : this_var_doms)
-      if(this_var_dom<=first_pc)
-        candidate_dominators.push_back(this_var_dom);
+    const auto &this_var_dom_blocks =
+      dominator_analysis.cfg[var_start_basic_block].dominators;
+    for(const auto this_var_dom_block_index : this_var_dom_blocks)
+    {
+      const auto &this_var_dom_block =
+        dominator_analysis.cfg[this_var_dom_block_index].block;
+      // Only consider placing variable declarations at the head of
+      // a basic block (which conveniently is always a safe choice, even
+      // for a live range starting midway through a block)
+      candidate_dominators.push_back(this_var_dom_block.front());
+    }
   }
   std::sort(candidate_dominators.begin(), candidate_dominators.end());
 

src/analyses/cfg_dominators.h

@@ -26,20 +26,44 @@ template <class P, class T, bool post_dom>
 class cfg_dominators_templatet
 {
 public:
-  typedef std::set<T> target_sett;
+  typedef std::set<std::size_t> target_sett;
 
   struct nodet
   {
     target_sett dominators;
   };
 
-  typedef procedure_local_cfg_baset<nodet, P, T> cfgt;
+  typedef cfg_basic_blockst<procedure_local_cfg_baset, nodet, P, T> cfgt;
   cfgt cfg;
 
   void operator()(P &program);
 
   T entry_node;
 
+  /// Returns true if basic block \p lhs [post]dominates \p rhs
+  bool basic_block_dominates(std::size_t lhs, std::size_t rhs) const
+  {
+    return cfg[rhs].dominators.count(lhs);
+  }
+
+  /// Returns true if program point \p lhs [post]dominates \p rhs
+  bool dominates(T lhs, T rhs) const;
+
+  const target_sett &basic_block_dominators(std::size_t block) const
+  {
+    return cfg[block].dominators;
+  }
+
+  bool basic_block_reachable(std::size_t block) const
+  {
+    return !cfg[block].dominators.empty();
+  }
+
+  bool instruction_reachable(T instruction) const
+  {
+    return basic_block_reachable(cfg.entry_map.at(instruction));
+  }
+
   void output(std::ostream &) const;
 
 protected:
@@ -76,32 +100,33 @@ void cfg_dominators_templatet<P, T, post_dom>::initialise(P &program)
 template <class P, class T, bool post_dom>
 void cfg_dominators_templatet<P, T, post_dom>::fixedpoint(P &program)
 {
-  std::list<T> worklist;
+  std::list<typename cfgt::node_indext> worklist;
 
   if(cfg.nodes_empty(program))
     return;
 
   if(post_dom)
-    entry_node=cfg.get_last_node(program);
+    entry_node = cfgt::get_last_node(program);
   else
-    entry_node=cfg.get_first_node(program);
-  typename cfgt::nodet &n=cfg[cfg.entry_map[entry_node]];
-  n.dominators.insert(entry_node);
+    entry_node = cfgt::get_first_node(program);
+  const auto entry_node_index = cfg.entry_map[entry_node];
+  typename cfgt::nodet &n = cfg[entry_node_index];
+  n.dominators.insert(entry_node_index);
 
   for(typename cfgt::edgest::const_iterator
       s_it=(post_dom?n.in:n.out).begin();
       s_it!=(post_dom?n.in:n.out).end();
       ++s_it)
-    worklist.push_back(cfg[s_it->first].PC);
+    worklist.push_back(s_it->first);
 
   while(!worklist.empty())
   {
     // get node from worklist
-    T current=worklist.front();
+    const auto current = worklist.front();
     worklist.pop_front();
 
     bool changed=false;
-    typename cfgt::nodet &node=cfg[cfg.entry_map[current]];
+    typename cfgt::nodet &node = cfg[current];
     if(node.dominators.empty())
     {
       for(const auto &edge : (post_dom ? node.out : node.in))
@@ -158,12 +183,39 @@ void cfg_dominators_templatet<P, T, post_dom>::fixedpoint(P &program)
     {
       for(const auto &edge : (post_dom ? node.in : node.out))
       {
-        worklist.push_back(cfg[edge.first].PC);
+        worklist.push_back(edge.first);
       }
     }
   }
 }
 
+template <class P, class T, bool post_dom>
+bool cfg_dominators_templatet<P, T, post_dom>::dominates(T lhs, T rhs) const
+{
+  if(lhs == rhs)
+    return true;
+
+  const auto lhs_block = cfg.entry_map.at(lhs);
+  const auto rhs_block = cfg.entry_map.at(rhs);
+
+  if(lhs_block != rhs_block)
+    return basic_block_dominates(lhs_block, rhs_block);
+
+  // Special case when the program points belong to the same block: lhs
+  // dominates rhs iff it is <= rhs in program order (or the reverse if we're
+  // a postdominator analysis)
+
+  for(const auto &instruction : cfg[lhs_block].block)
+  {
+    if(instruction == lhs)
+      return !post_dom;
+    else if(instruction == rhs)
+      return post_dom;
+  }
+
+  UNREACHABLE; // Entry map is inconsistent with block members?
+}
+
 /// Pretty-print a single node in the dominator tree. Supply a specialisation if
 /// operator<< is not sufficient.
 /// \par parameters: `node` to print and stream `out` to pretty-print it to
@@ -184,22 +236,20 @@ inline void dominators_pretty_print_node(
 template <class P, class T, bool post_dom>
 void cfg_dominators_templatet<P, T, post_dom>::output(std::ostream &out) const
 {
-  for(const auto &node : cfg.entry_map)
+  for(typename cfgt::node_indext i = 0; i < cfg.size(); ++i)
   {
-    auto n=node.first;
-
-    dominators_pretty_print_node(n, out);
+    out << "Block " << dominators_pretty_print_node(cfg[i].block.at(0), out);
     if(post_dom)
       out << " post-dominated by ";
     else
       out << " dominated by ";
     bool first=true;
-    for(const auto &d : cfg[node.second].dominators)
+    for(const auto &d : cfg[i].dominators)
     {
       if(!first)
         out << ", ";
       first=false;
-      dominators_pretty_print_node(d, out);
+      dominators_pretty_print_node(cfg[d].block.at(0), out);
     }
     out << "\n";
   }

src/analyses/dependence_graph.cpp

@@ -97,22 +97,11 @@ void dep_graph_domaint::control_dependencies(
 
     // we could hard-code assume and goto handling here to improve
     // performance
-    cfg_post_dominatorst::cfgt::entry_mapt::const_iterator e =
-      pd.cfg.entry_map.find(control_dep_candidate);
-
-    INVARIANT(
-      e != pd.cfg.entry_map.end(), "cfg must have an entry for every location");
-
-    const cfg_post_dominatorst::cfgt::nodet &m=
-      pd.cfg[e->second];
-
-    // successors of M
-    for(const auto &edge : m.out)
+    for(const auto &candidate_successor :
+        goto_programt::get_well_formed_instruction_successors(
+          control_dep_candidate))
     {
-      const cfg_post_dominatorst::cfgt::nodet &m_s=
-        pd.cfg[edge.first];
-
-      if(m_s.dominators.find(to)!=m_s.dominators.end())
+      if(pd.dominates(to, candidate_successor))
         post_dom_one=true;
       else
         post_dom_all=false;