Update API calls

Change existing API calls to use the new immediate-dominator version
of dominator analysis.

Author: JohnDumbell

jbmc/src/java_bytecode/java_local_variable_table.cpp

@@ -467,7 +467,7 @@ static java_bytecode_convert_methodt::method_offsett get_common_dominator(
     const auto &dominator_nodeidx=
       dominator_analysis.cfg.entry_map.at(v->var.start_pc);
     const auto &this_var_doms=
-      dominator_analysis.cfg[dominator_nodeidx].dominators;
+      dominator_analysis.dominated_by(dominator_nodeidx);
     for(const auto this_var_dom : this_var_doms)
       if(this_var_dom<=first_pc)
         candidate_dominators.push_back(this_var_dom);

src/analyses/dependence_graph.cpp

@@ -109,7 +109,7 @@ void dep_graph_domaint::control_dependencies(
       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, m_s))
         post_dom_one=true;
       else
         post_dom_all=false;

src/analyses/sese_regions.cpp

@@ -133,44 +133,43 @@ void sese_region_analysist::compute_sese_regions(
       ++it)
   {
     // Only look for regions starting at nontrivial CFG edges:
-
     auto successors = goto_program.get_successors(it);
     if(
       successors.size() == 1 &&
       (*successors.begin())->incoming_edges.size() == 1)
       continue;
 
-    const auto &instruction_postdoms = postdominators.get_node(it).dominators;
-
-    // Ideally we would start with the immediate postdominator and walk down,
-    // but our current dominator analysis doesn't make it easy to determine an
-    // immediate dominator.
+    const auto &instruction_postdom = postdominators.get_node(it).dominator;
+    if (!instruction_postdom)
+      continue;
 
     // Ideally I would use `optionalt<std::size_t>` here, but it triggers a
     // GCC-5 bug.
     std::size_t closest_exit_index = dominators.cfg.size();
-    for(const auto &possible_exit : instruction_postdoms)
+    std::size_t current_index = *instruction_postdom;
+    while(current_index != 0)
     {
-      const auto possible_exit_index = dominators.get_node_index(possible_exit);
-      const auto &possible_exit_node = dominators.cfg[possible_exit_index];
-      const auto possible_exit_dominators =
-        possible_exit_node.dominators.size();
-
+      const auto &possible_exit_node = dominators.cfg[current_index];
+      const auto &possible_exit = possible_exit_node.PC;
       if(
         it != possible_exit && dominators.dominates(it, possible_exit_node) &&
         get_innermost_loop(innermost_loop_ids, it) ==
-          get_innermost_loop(innermost_loop_ids, possible_exit))
+        get_innermost_loop(innermost_loop_ids, possible_exit))
       {
         // If there are several candidate region exit nodes, prefer the one with
         // the least dominators, i.e. the closest to the region entrance.
         if(
           closest_exit_index == dominators.cfg.size() ||
-          dominators.cfg[closest_exit_index].dominators.size() >
-            possible_exit_dominators)
+          current_index < closest_exit_index)
         {
-          closest_exit_index = possible_exit_index;
+          closest_exit_index = current_index;
         }
       }
+
+      if (possible_exit_node.dominator)
+        current_index = *possible_exit_node.dominator;
+      else
+        break;
     }
 
     if(closest_exit_index < dominators.cfg.size())

src/goto-analyzer/unreachable_instructions.cpp

@@ -38,7 +38,7 @@ static void unreachable_instructions(
       ++it)
   {
     const cfg_dominatorst::cfgt::nodet &n=dominators.cfg[it->second];
-    if(n.dominators.empty())
+    if(!n.dominator)
       dest.insert(std::make_pair(it->first->location_number,
                                  it->first));
   }

src/goto-instrument/full_slicer.cpp

@@ -153,30 +153,8 @@ void full_slicert::add_jumps(
     {
       // check whether the nearest post-dominator is different from
       // lex_succ
-      goto_programt::const_targett nearest=lex_succ;
-      std::size_t post_dom_size=0;
-      for(cfg_dominatorst::target_sett::const_iterator d_it =
-            j_PC_node.dominators.begin();
-          d_it != j_PC_node.dominators.end();
-          ++d_it)
-      {
-        const auto &node = cfg.get_node(*d_it);
-        if(node.node_required)
-        {
-          const irep_idt &id2 = node.function_id;
-          INVARIANT(id==id2,
-                    "goto/jump expected to be within a single function");
-
-          const auto &postdom_node = pd.get_node(*d_it);
-
-          if(postdom_node.dominators.size() > post_dom_size)
-          {
-            nearest=*d_it;
-            post_dom_size = postdom_node.dominators.size();
-          }
-        }
-      }
-      if(nearest!=lex_succ)
+      auto nearest=lex_succ;
+      if(j_PC_node.dominator && pd.cfg[*j_PC_node.dominator].PC!=lex_succ)
       {
         add_to_queue(queue, *it, nearest);
         jumps.erase(it);