cfgt: use dense_integer_mapt to provide instruction -> cfg node mapping

This saves a lot of allocations, memory, and time when the cfg is frequently queried.

Author: smowton

Diff for: src/analyses/cfg_dominators.h

@@ -248,17 +248,17 @@ 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.entries())
+  for(const auto &n : cfg.keys())
   {
-    auto n=node.first;
+    const auto &node = cfg.get_node(n);
 
     dominators_pretty_print_node(n, 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[node].dominators)
     {
       if(!first)
         out << ", ";

Diff for: src/goto-analyzer/unreachable_instructions.cpp

@@ -32,15 +32,11 @@ static void unreachable_instructions(
   cfg_dominatorst dominators;
   dominators(goto_program);
 
-  for(cfg_dominatorst::cfgt::entry_mapt::const_iterator
-      it=dominators.cfg.entry_map.begin();
-      it!=dominators.cfg.entry_map.end();
-      ++it)
+  for(const auto instruction : dominators.cfg.keys())
   {
-    const cfg_dominatorst::cfgt::nodet &n=dominators.cfg[it->second];
+    const cfg_dominatorst::cfgt::nodet &n = dominators.get_node(instruction);
     if(n.dominators.empty())
-      dest.insert(std::make_pair(it->first->location_number,
-                                 it->first));
+      dest.insert(std::make_pair(instruction->location_number, instruction));
   }
 }
 

Diff for: src/goto-instrument/dump_c.cpp

@@ -663,6 +663,9 @@ void dump_ct::cleanup_decl(
 
   tmp.add(goto_programt::make_end_function());
 
+  // goto_program2codet requires valid location numbers:
+  tmp.update();
+
   std::unordered_set<irep_idt> typedef_names;
   for(const auto &td : typedef_map)
     typedef_names.insert(td.first);

Diff for: src/goto-instrument/full_slicer.cpp

@@ -271,10 +271,9 @@ void full_slicert::operator()(
   // declarations or dead instructions may be necessary as well
   decl_deadt decl_dead;
 
-  for(const auto &instruction_and_index : cfg.entries())
+  for(const auto &instruction : cfg.keys())
   {
-    const auto &instruction = instruction_and_index.first;
-    const auto instruction_node_index = instruction_and_index.second;
+    const auto instruction_node_index = cfg.get_node_index(instruction);
     if(criterion(cfg[instruction_node_index].function_id, instruction))
       add_to_queue(queue, instruction_node_index, instruction);
     else if(implicit(instruction))

Diff for: src/goto-instrument/goto_instrument_parse_options.cpp

@@ -669,6 +669,10 @@ int goto_instrument_parse_optionst::doit()
       // applied
       restore_returns(goto_model);
 
+      // dump_c (actually goto_program2code) requires valid instruction
+      // location numbers:
+      goto_model.goto_functions.update();
+
       if(cmdline.args.size()==2)
       {
         #ifdef _MSC_VER
@@ -1497,6 +1501,10 @@ void goto_instrument_parse_optionst::instrument_goto_program()
     do_indirect_call_and_rtti_removal();
 
     log.status() << "Performing a reachability slice" << messaget::eom;
+
+    // reachability_slicer requires that the model has unique location numbers:
+    goto_model.goto_functions.update();
+
     if(cmdline.isset("property"))
       reachability_slicer(goto_model, cmdline.get_values("property"));
     else
@@ -1523,7 +1531,11 @@ void goto_instrument_parse_optionst::instrument_goto_program()
     if(cmdline.isset("property"))
       property_slicer(goto_model, cmdline.get_values("property"));
     else
+    {
+      // full_slicer requires that the model has unique location numbers:
+      goto_model.goto_functions.update();
       full_slicer(goto_model);
+    }
   }
 
   // splice option
@@ -1544,6 +1556,9 @@ void goto_instrument_parse_optionst::instrument_goto_program()
   {
     do_indirect_call_and_rtti_removal();
 
+    // reachability_slicer requires that the model has unique location numbers:
+    goto_model.goto_functions.update();
+
     log.status() << "Slicing away initializations of unused global variables"
                  << messaget::eom;
     slice_global_inits(goto_model);
@@ -1572,6 +1587,8 @@ void goto_instrument_parse_optionst::instrument_goto_program()
 
     aggressive_slicer.doit();
 
+    goto_model.goto_functions.update();
+
     log.status() << "Performing a reachability slice" << messaget::eom;
     if(cmdline.isset("property"))
       reachability_slicer(goto_model, cmdline.get_values("property"));

Diff for: src/goto-instrument/points_to.cpp

@@ -21,9 +21,9 @@ void points_tot::fixedpoint()
   {
     added=false;
 
-    for(const auto &instruction_and_entry : cfg.entries())
+    for(const auto &key : cfg.keys())
     {
-      if(transform(cfg[instruction_and_entry.second]))
+      if(transform(cfg.get_node(key)))
         added=true;
     }
   }

Diff for: src/goto-instrument/reachability_slicer.cpp

@@ -39,12 +39,13 @@ reachability_slicert::get_sources(
   const slicing_criteriont &criterion)
 {
   std::vector<cfgt::node_indext> sources;
-  for(const auto &e_it : cfg.entries())
+  for(const auto &instruction : cfg.keys())
   {
+    const auto cfg_node_index = cfg.get_node_index(instruction);
     if(
-      criterion(cfg[e_it.second].function_id, e_it.first) ||
-      is_threaded(e_it.first))
-      sources.push_back(e_it.second);
+      criterion(cfg[cfg_node_index].function_id, instruction) ||
+      is_threaded(instruction))
+      sources.push_back(cfg_node_index);
   }
 
   if(sources.empty())

Diff for: src/goto-programs/cfg.h

@@ -12,8 +12,9 @@ Author: Daniel Kroening, [email protected]
 #ifndef CPROVER_GOTO_PROGRAMS_CFG_H
 #define CPROVER_GOTO_PROGRAMS_CFG_H
 
-#include <util/std_expr.h>
+#include <util/dense_integer_map.h>
 #include <util/graph.h>
+#include <util/std_expr.h>
 
 #include "goto_functions.h"
 
@@ -31,6 +32,29 @@ struct cfg_base_nodet:public graph_nodet<empty_edget>, public T
   I PC;
 };
 
+/// Functor to convert cfg nodes into dense integers, used by \ref cfg_baset.
+/// Default implementation: the identity function.
+template <class T>
+class cfg_instruction_to_dense_integert
+{
+public:
+  std::size_t operator()(T &&t) const
+  {
+    return std::forward<T>(identity_functort<T>{}(t));
+  }
+};
+
+/// GOTO-instruction to location number functor.
+template <>
+class cfg_instruction_to_dense_integert<goto_programt::const_targett>
+{
+public:
+  std::size_t operator()(const goto_programt::const_targett &t) const
+  {
+    return t->location_number;
+  }
+};
+
 /// A multi-procedural control flow graph (CFG) whose nodes store references to
 /// instructions in a GOTO program.
 ///
@@ -69,28 +93,16 @@ class cfg_baset:public grapht< cfg_base_nodet<T, I> >
 
   class entry_mapt final
   {
-    typedef std::map<goto_programt::const_targett, entryt> data_typet;
+    typedef dense_integer_mapt<
+      goto_programt::const_targett,
+      entryt,
+      cfg_instruction_to_dense_integert<goto_programt::const_targett>>
+      data_typet;
     data_typet data;
 
   public:
     grapht< cfg_base_nodet<T, I> > &container;
 
-    // NOLINTNEXTLINE(readability/identifiers)
-    typedef typename data_typet::iterator iterator;
-    // NOLINTNEXTLINE(readability/identifiers)
-    typedef typename data_typet::const_iterator const_iterator;
-
-    template <typename U>
-    const_iterator find(U &&u) const { return data.find(std::forward<U>(u)); }
-
-    iterator begin() { return data.begin(); }
-    const_iterator begin() const { return data.begin(); }
-    const_iterator cbegin() const { return data.cbegin(); }
-
-    iterator end() { return data.end(); }
-    const_iterator end() const { return data.end(); }
-    const_iterator cend() const { return data.cend(); }
-
     explicit entry_mapt(grapht< cfg_base_nodet<T, I> > &_container):
       container(_container)
     {
@@ -100,10 +112,10 @@ class cfg_baset:public grapht< cfg_base_nodet<T, I> >
     {
       auto e=data.insert(std::make_pair(t, 0));
 
-      if(e.second)
-        e.first->second=container.add_node();
+      if(e)
+        data.at(t) = container.add_node();
 
-      return e.first->second;
+      return data.at(t);
     }
 
     entryt &at(const goto_programt::const_targett &t)
@@ -114,6 +126,25 @@ class cfg_baset:public grapht< cfg_base_nodet<T, I> >
     {
       return data.at(t);
     }
+
+    std::size_t count(const goto_programt::const_targett &t) const
+    {
+      return data.count(t);
+    }
+
+    typedef typename data_typet::possible_keyst keyst;
+    const keyst &keys() const
+    {
+      // We always define exactly the keys the entry map was set up for, so
+      // data's possible key set is exactly our key set
+      return data.possible_keys();
+    }
+
+    template <class Iter>
+    void setup_for_keys(Iter begin, Iter end)
+    {
+      data.setup_for_keys(begin, end);
+    }
   };
   entry_mapt entry_map;
 
@@ -173,12 +204,30 @@ class cfg_baset:public grapht< cfg_base_nodet<T, I> >
   void operator()(
     const goto_functionst &goto_functions)
   {
+    std::vector<goto_programt::const_targett> possible_keys;
+    for(const auto &id_and_function : goto_functions.function_map)
+    {
+      const auto &instructions = id_and_function.second.body.instructions;
+      possible_keys.reserve(
+        possible_keys.size() +
+        std::distance(instructions.begin(), instructions.end()));
+      for(auto it = instructions.begin(); it != instructions.end(); ++it)
+        possible_keys.push_back(it);
+    }
+    entry_map.setup_for_keys(possible_keys.begin(), possible_keys.end());
     compute_edges(goto_functions);
   }
 
   void operator()(P &goto_program)
   {
     goto_functionst goto_functions;
+    std::vector<goto_programt::const_targett> possible_keys;
+    const auto &instructions = goto_program.instructions;
+    possible_keys.reserve(
+      std::distance(instructions.begin(), instructions.end()));
+    for(auto it = instructions.begin(); it != instructions.end(); ++it)
+      possible_keys.push_back(it);
+    entry_map.setup_for_keys(possible_keys.begin(), possible_keys.end());
     compute_edges(goto_functions, goto_program);
   }
 
@@ -204,12 +253,11 @@ class cfg_baset:public grapht< cfg_base_nodet<T, I> >
     return (*this)[get_node_index(program_point)];
   }
 
-  /// Get a map from program points to their corresponding node indices. Use
-  /// the indices with `operator[]` similar to those returned by
-  /// \ref get_node_index.
-  const entry_mapt &entries() const
+  /// Get a vector of keys present in this cfg. Use these with \ref get_node or
+  /// \ref get_node_index to get the corresponding CFG nodes.
+  const typename entry_mapt::keyst &keys() const
   {
-    return entry_map;
+    return entry_map.keys();
   }
 
   static I get_first_node(P &program)