CFG dominator algorithm change to more closely resemble Coopers

Main change is to make it so that cfg nodes only hold their immediate
dominators index, where previously it used to hold on to all dominators
up the tree. More compact (and faster) but if you need the full
dominator list then you have to walk back up dominator nodes.

Author: JohnDumbell

src/analyses/cfg_dominators.h

@@ -37,11 +37,9 @@ template <class P, class T, bool post_dom>
 class cfg_dominators_templatet
 {
 public:
-  typedef std::set<T> target_sett;
-
   struct nodet
   {
-    target_sett dominators;
+    optionalt<std::size_t> dominator;
   };
 
   typedef procedure_local_cfg_baset<nodet, P, T> cfgt;
@@ -76,7 +74,45 @@ class cfg_dominators_templatet
   /// Note by definition all program points dominate themselves.
   bool dominates(T lhs, const nodet &rhs_node) const
   {
-    return rhs_node.dominators.count(lhs);
+    if (!rhs_node.dominator)
+      return false;
+
+    auto target_index = cfg.get_node_index(lhs);
+    auto current_index = rhs_node.dominator;
+    while (current_index.has_value())
+    {
+      if (*current_index == target_index)
+        return true;
+
+      // As the root dominates itself, we will cancel if we get here and we're
+      // not compared.
+      if (*current_index == 0)
+        return false;
+
+      current_index = cfg[*current_index].dominator;
+    }
+
+    return false;
+  }
+
+  /// Returns a set of T that are the dominators of start_node.
+  std::set<T> dominated_by(T start_node) const
+  {
+    auto current_index = cfg.get_node_index(start_node);
+    std::set<T> results;
+    while (current_index.has_value())
+    {
+      // As the root dominates itself, we will cancel if we get here and we're
+      // not compared.
+      if (*current_index == 0)
+        return false;
+
+      auto &current_node = cfg[*current_index];
+      results.emplace(current_node.PC);
+      current_index = current_node.dominator;
+    }
+
+    return results;
   }
 
   /// Returns true if program point \p lhs dominates \p rhs.
@@ -94,7 +130,7 @@ class cfg_dominators_templatet
     // Dominator analysis walks from the entry point, so a side-effect is to
     // identify unreachable program points (those which don't dominate even
     // themselves).
-    return !program_point_node.dominators.empty();
+    return program_point_node.dominator.has_value();
   }
 
   /// Returns true if the program point for \p program_point_node is reachable
@@ -156,7 +192,7 @@ void cfg_dominators_templatet<P, T, post_dom>::fixedpoint(P &program)
   else
     entry_node = cfgt::get_first_node(program);
   typename cfgt::nodet &n = cfg.get_node(entry_node);
-  n.dominators.insert(entry_node);
+  n.dominator = cfg.get_node_index(entry_node);
 
   for(typename cfgt::edgest::const_iterator
       s_it=(post_dom?n.in:n.out).begin();
@@ -172,58 +208,40 @@ void cfg_dominators_templatet<P, T, post_dom>::fixedpoint(P &program)
 
     bool changed=false;
     typename cfgt::nodet &node = cfg.get_node(current);
-    if(node.dominators.empty())
-    {
-      for(const auto &edge : (post_dom ? node.out : node.in))
-        if(!cfg[edge.first].dominators.empty())
-        {
-          node.dominators=cfg[edge.first].dominators;
-          node.dominators.insert(current);
-          changed=true;
-        }
-    }
+
+    auto potential_dominator = node.dominator;
 
     // compute intersection of predecessors
     for(const auto &edge : (post_dom ? node.out : node.in))
     {
-      const target_sett &other=cfg[edge.first].dominators;
-      if(other.empty())
+      const typename cfgt::nodet &other = cfg[edge.first];
+      if(!other.dominator)
         continue;
 
-      typename target_sett::const_iterator n_it=node.dominators.begin();
-      typename target_sett::const_iterator o_it=other.begin();
+      if (!potential_dominator)
+        potential_dominator = other.dominator;
 
-      // in-place intersection. not safe to use set_intersect
-      while(n_it!=node.dominators.end() && o_it!=other.end())
+      auto edge_index = *other.dominator;
+      while(potential_dominator != edge_index)
       {
-        if(*n_it==current)
-          ++n_it;
-        else if(*n_it<*o_it)
-        {
-          changed=true;
-          node.dominators.erase(n_it++);
-        }
-        else if(*o_it<*n_it)
-          ++o_it;
-        else
+        while(potential_dominator > edge_index)
         {
-          ++n_it;
-          ++o_it;
+          potential_dominator = cfg[*potential_dominator].dominator;
         }
-      }
 
-      while(n_it!=node.dominators.end())
-      {
-        if(*n_it==current)
-          ++n_it;
-        else
+        while(edge_index < potential_dominator)
         {
-          changed=true;
-          node.dominators.erase(n_it++);
+          edge_index = *cfg[edge_index].dominator;
         }
       }
     }
 
+    if (!node.dominator || *potential_dominator != *node.dominator)
+    {
+      node.dominator = potential_dominator;
+      changed = true;
+    }
+
     if(changed) // fixed point for node reached?
     {
       for(const auto &edge : (post_dom ? node.in : node.out))