Move all the various id_sett typedefs into irep.h

src/analyses/call_graph_helpers.cpp

@@ -15,26 +15,26 @@ Author: Chris Smowton, [email protected]
 /// \param graph: call graph
 /// \param function: function to query
 /// \param forwards: if true, get callees; otherwise get callers.
-static std::set<irep_idt> get_neighbours(
+static id_sett get_neighbours(
   const call_grapht::directed_grapht &graph,
   const irep_idt &function,
   bool forwards)
 {
-  std::set<irep_idt> result;
+  id_sett result;
   const auto &fnode = graph[*(graph.get_node_index(function))];
   const auto &neighbours = forwards ? fnode.out : fnode.in;
   for(const auto &succ_edge : neighbours)
     result.insert(graph[succ_edge.first].function);
   return result;
 }
 
-std::set<irep_idt> get_callees(
+id_sett get_callees(
   const call_grapht::directed_grapht &graph, const irep_idt &function)
 {
   return get_neighbours(graph, function, true);
 }
 
-std::set<irep_idt> get_callers(
+id_sett get_callers(
   const call_grapht::directed_grapht &graph, const irep_idt &function)
 {
   return get_neighbours(graph, function, false);
@@ -46,27 +46,29 @@ std::set<irep_idt> get_callers(
 /// \param function: function to query
 /// \param forwards: if true, get reachable functions; otherwise get functions
 ///   that can reach the given function.
-static std::set<irep_idt> get_connected_functions(
+static id_sett get_connected_functions(
   const call_grapht::directed_grapht &graph,
   const irep_idt &function,
   bool forwards)
 {
   std::vector<call_grapht::directed_grapht::node_indext> connected_nodes =
     graph.get_reachable(*(graph.get_node_index(function)), forwards);
-  std::set<irep_idt> result;
+  id_sett result;
   for(const auto i : connected_nodes)
     result.insert(graph[i].function);
   return result;
 }
 
-std::set<irep_idt> get_reachable_functions(
-  const call_grapht::directed_grapht &graph, const irep_idt &function)
+id_sett get_reachable_functions(
+  const call_grapht::directed_grapht &graph,
+  const irep_idt &function)
 {
   return get_connected_functions(graph, function, true);
 }
 
-std::set<irep_idt> get_reaching_functions(
-  const call_grapht::directed_grapht &graph, const irep_idt &function)
+id_sett get_reaching_functions(
+  const call_grapht::directed_grapht &graph,
+  const irep_idt &function)
 {
   return get_connected_functions(graph, function, false);
 }

src/analyses/call_graph_helpers.h

@@ -25,28 +25,32 @@ Author: Chris Smowton, [email protected]
 /// \param graph: call graph
 /// \param function: function to query
 /// \return set of called functions
-std::set<irep_idt> get_callees(
-  const call_grapht::directed_grapht &graph, const irep_idt &function);
+id_sett get_callees(
+  const call_grapht::directed_grapht &graph,
+  const irep_idt &function);
 
 /// Get functions that call a given function
 /// \param graph: call graph
 /// \param function: function to query
 /// \return set of caller functions
-std::set<irep_idt> get_callers(
-  const call_grapht::directed_grapht &graph, const irep_idt &function);
+id_sett get_callers(
+  const call_grapht::directed_grapht &graph,
+  const irep_idt &function);
 
 /// Get functions reachable from a given function
 /// \param graph: call graph
 /// \param function: function to query
 /// \return set of reachable functions, including `function`
-std::set<irep_idt> get_reachable_functions(
-  const call_grapht::directed_grapht &graph, const irep_idt &function);
+id_sett get_reachable_functions(
+  const call_grapht::directed_grapht &graph,
+  const irep_idt &function);
 
 /// Get functions that can reach a given function
 /// \param graph: call graph
 /// \param function: function to query
 /// \return set of functions that can reach the target, including `function`
-std::set<irep_idt> get_reaching_functions(
-  const call_grapht::directed_grapht &graph, const irep_idt &function);
+id_sett get_reaching_functions(
+  const call_grapht::directed_grapht &graph,
+  const irep_idt &function);
 
 #endif

src/analyses/dirty.h

@@ -34,7 +34,6 @@ class dirtyt
 
 public:
   bool initialized;
-  typedef std::unordered_set<irep_idt, irep_id_hash> id_sett;
   typedef goto_functionst::goto_functiont goto_functiont;
 
   /// \post dirtyt objects that are created through this constructor are not
@@ -72,7 +71,7 @@ class dirtyt
     return operator()(expr.get_identifier());
   }
 
-  const id_sett &get_dirty_ids() const
+  const unordered_id_sett &get_dirty_ids() const
   {
     die_if_uninitialized();
     return dirty;
@@ -97,7 +96,7 @@ class dirtyt
   void build(const goto_functiont &goto_function);
 
   // variables whose address is taken
-  id_sett dirty;
+  unordered_id_sett dirty;
 
   void find_dirty(const exprt &expr);
   void find_dirty_address_of(const exprt &expr);
@@ -131,7 +130,7 @@ class incremental_dirtyt
 
 private:
   dirtyt dirty;
-  std::unordered_set<irep_idt, irep_id_hash> dirty_processed_functions;
+  unordered_id_sett dirty_processed_functions;
 };
 
 #endif // CPROVER_ANALYSES_DIRTY_H

src/analyses/escape_analysis.cpp

@@ -42,7 +42,7 @@ irep_idt escape_domaint::get_function(const exprt &lhs)
 
 void escape_domaint::assign_lhs_cleanup(
   const exprt &lhs,
-  const std::set<irep_idt> &cleanup_functions)
+  const id_sett &cleanup_functions)
 {
   if(lhs.id()==ID_symbol)
   {
@@ -61,7 +61,7 @@ void escape_domaint::assign_lhs_cleanup(
 
 void escape_domaint::assign_lhs_aliases(
   const exprt &lhs,
-  const std::set<irep_idt> &alias_set)
+  const id_sett &alias_set)
 {
   if(lhs.id()==ID_symbol)
   {
@@ -82,7 +82,7 @@ void escape_domaint::assign_lhs_aliases(
 
 void escape_domaint::get_rhs_cleanup(
   const exprt &rhs,
-  std::set<irep_idt> &cleanup_functions)
+  id_sett &cleanup_functions)
 {
   if(rhs.id()==ID_symbol)
   {
@@ -110,9 +110,7 @@ void escape_domaint::get_rhs_cleanup(
   }
 }
 
-void escape_domaint::get_rhs_aliases(
-  const exprt &rhs,
-  std::set<irep_idt> &alias_set)
+void escape_domaint::get_rhs_aliases(const exprt &rhs, id_sett &alias_set)
 {
   if(rhs.id()==ID_symbol)
   {
@@ -144,7 +142,7 @@ void escape_domaint::get_rhs_aliases(
 
 void escape_domaint::get_rhs_aliases_address_of(
   const exprt &rhs,
-  std::set<irep_idt> &alias_set)
+  id_sett &alias_set)
 {
   if(rhs.id()==ID_symbol)
   {
@@ -182,11 +180,11 @@ void escape_domaint::transform(
     {
       const code_assignt &code_assign=to_code_assign(instruction.code);
 
-      std::set<irep_idt> cleanup_functions;
+      id_sett cleanup_functions;
       get_rhs_cleanup(code_assign.rhs(), cleanup_functions);
       assign_lhs_cleanup(code_assign.lhs(), cleanup_functions);
 
-      std::set<irep_idt> aliases;
+      id_sett aliases;
       get_rhs_aliases(code_assign.rhs(), aliases);
       assign_lhs_aliases(code_assign.lhs(), aliases);
     }
@@ -196,15 +194,15 @@ void escape_domaint::transform(
     {
       const code_declt &code_decl=to_code_decl(instruction.code);
       aliases.isolate(code_decl.get_identifier());
-      assign_lhs_cleanup(code_decl.symbol(), std::set<irep_idt>());
+      assign_lhs_cleanup(code_decl.symbol(), id_sett());
     }
     break;
 
   case DEAD:
     {
       const code_deadt &code_dead=to_code_dead(instruction.code);
       aliases.isolate(code_dead.get_identifier());
-      assign_lhs_cleanup(code_dead.symbol(), std::set<irep_idt>());
+      assign_lhs_cleanup(code_dead.symbol(), id_sett());
     }
     break;
 
@@ -229,7 +227,7 @@ void escape_domaint::transform(
             if(!cleanup_function.empty())
             {
               // may alias other stuff
-              std::set<irep_idt> lhs_set;
+              id_sett lhs_set;
               get_rhs_aliases(lhs, lhs_set);
 
               for(const auto &lhs : lhs_set)
@@ -309,8 +307,8 @@ bool escape_domaint::merge(
 
   for(const auto &cleanup : b.cleanup_map)
   {
-    const std::set<irep_idt> &b_cleanup=cleanup.second.cleanup_functions;
-    std::set<irep_idt> &a_cleanup=cleanup_map[cleanup.first].cleanup_functions;
+    const id_sett &b_cleanup = cleanup.second.cleanup_functions;
+    id_sett &a_cleanup = cleanup_map[cleanup.first].cleanup_functions;
     auto old_size=a_cleanup.size();
     a_cleanup.insert(b_cleanup.begin(), b_cleanup.end());
     if(a_cleanup.size()!=old_size)
@@ -355,9 +353,7 @@ bool escape_domaint::merge(
   return changed;
 }
 
-void escape_domaint::check_lhs(
-  const exprt &lhs,
-  std::set<irep_idt> &cleanup_functions)
+void escape_domaint::check_lhs(const exprt &lhs, id_sett &cleanup_functions)
 {
   if(lhs.id()==ID_symbol)
   {
@@ -394,7 +390,7 @@ void escape_analysist::insert_cleanup(
   goto_functionst::goto_functiont &goto_function,
   goto_programt::targett location,
   const exprt &lhs,
-  const std::set<irep_idt> &cleanup_functions,
+  const id_sett &cleanup_functions,
   bool is_object,
   const namespacet &ns)
 {
@@ -446,7 +442,7 @@ void escape_analysist::instrument(
         {
           const code_assignt &code_assign=to_code_assign(instruction.code);
 
-          std::set<irep_idt> cleanup_functions;
+          id_sett cleanup_functions;
           operator[](i_it).check_lhs(code_assign.lhs(), cleanup_functions);
           insert_cleanup(
             f_it->second,
@@ -462,7 +458,7 @@ void escape_analysist::instrument(
         {
           const code_deadt &code_dead=to_code_dead(instruction.code);
 
-          std::set<irep_idt> cleanup_functions1;
+          id_sett cleanup_functions1;
 
           escape_domaint &d=operator[](i_it);
 
@@ -477,7 +473,7 @@ void escape_analysist::instrument(
               m_it->second.cleanup_functions.end());
           }
 
-          std::set<irep_idt> cleanup_functions2;
+          id_sett cleanup_functions2;
 
           d.check_lhs(code_dead.symbol(), cleanup_functions2);
 

src/analyses/escape_analysis.h

@@ -82,7 +82,7 @@ class escape_domaint:public ai_domain_baset
 
   struct cleanupt
   {
-    std::set<irep_idt> cleanup_functions;
+    id_sett cleanup_functions;
   };
 
   // We track a set of 'cleanup functions' for specific
@@ -93,13 +93,13 @@ class escape_domaint:public ai_domain_baset
 
 private:
   tvt has_values;
-  void assign_lhs_cleanup(const exprt &, const std::set<irep_idt> &);
-  void get_rhs_cleanup(const exprt &, std::set<irep_idt> &);
-  void assign_lhs_aliases(const exprt &, const std::set<irep_idt> &);
-  void get_rhs_aliases(const exprt &, std::set<irep_idt> &);
-  void get_rhs_aliases_address_of(const exprt &, std::set<irep_idt> &);
+  void assign_lhs_cleanup(const exprt &, const id_sett &);
+  void get_rhs_cleanup(const exprt &, id_sett &);
+  void assign_lhs_aliases(const exprt &, const id_sett &);
+  void get_rhs_aliases(const exprt &, id_sett &);
+  void get_rhs_aliases_address_of(const exprt &, id_sett &);
   irep_idt get_function(const exprt &);
-  void check_lhs(const exprt &, std::set<irep_idt> &);
+  void check_lhs(const exprt &, id_sett &);
 
   friend class escape_analysist;
 
@@ -122,7 +122,7 @@ class escape_analysist:public ait<escape_domaint>
     goto_functionst::goto_functiont &,
     goto_programt::targett,
     const exprt &,
-    const std::set<irep_idt> &,
+    const id_sett &,
     bool is_object,
     const namespacet &);
 };

src/analyses/flow_insensitive_analysis.h

@@ -187,10 +187,10 @@ class flow_insensitive_analysis_baset
     return l;
   }
 
-  typedef std::set<irep_idt> functions_donet;
+  typedef id_sett functions_donet;
   functions_donet functions_done;
 
-  typedef std::set<irep_idt> recursion_sett;
+  typedef id_sett recursion_sett;
   recursion_sett recursion_set;
 
   bool initialized;

src/analyses/global_may_alias.cpp

@@ -13,7 +13,7 @@ Author: Daniel Kroening, [email protected]
 
 void global_may_alias_domaint::assign_lhs_aliases(
   const exprt &lhs,
-  const std::set<irep_idt> &alias_set)
+  const id_sett &alias_set)
 {
   if(lhs.id()==ID_symbol)
   {
@@ -30,7 +30,7 @@ void global_may_alias_domaint::assign_lhs_aliases(
 
 void global_may_alias_domaint::get_rhs_aliases(
   const exprt &rhs,
-  std::set<irep_idt> &alias_set)
+  id_sett &alias_set)
 {
   if(rhs.id()==ID_symbol)
   {
@@ -58,7 +58,7 @@ void global_may_alias_domaint::get_rhs_aliases(
 
 void global_may_alias_domaint::get_rhs_aliases_address_of(
   const exprt &rhs,
-  std::set<irep_idt> &alias_set)
+  id_sett &alias_set)
 {
   if(rhs.id()==ID_symbol)
   {
@@ -92,7 +92,7 @@ void global_may_alias_domaint::transform(
     {
       const code_assignt &code_assign=to_code_assign(instruction.code);
 
-      std::set<irep_idt> aliases;
+      id_sett aliases;
       get_rhs_aliases(code_assign.rhs(), aliases);
       assign_lhs_aliases(code_assign.lhs(), aliases);
     }

src/analyses/global_may_alias.h

@@ -79,9 +79,9 @@ class global_may_alias_domaint:public ai_domain_baset
 private:
   tvt has_values;
 
-  void assign_lhs_aliases(const exprt &, const std::set<irep_idt> &);
-  void get_rhs_aliases(const exprt &, std::set<irep_idt> &);
-  void get_rhs_aliases_address_of(const exprt &, std::set<irep_idt> &);
+  void assign_lhs_aliases(const exprt &, const id_sett &);
+  void get_rhs_aliases(const exprt &, id_sett &);
+  void get_rhs_aliases_address_of(const exprt &, id_sett &);
 };
 
 class global_may_alias_analysist:public ait<global_may_alias_domaint>

src/analyses/invariant_propagation.cpp

@@ -127,7 +127,7 @@ void invariant_propagationt::add_objects(
   forall_goto_functions(f_it, goto_functions)
   {
     // get the locals
-    std::set<irep_idt> locals;
+    id_sett locals;
     get_local_identifiers(f_it->second, locals);
 
     const goto_programt &goto_program=f_it->second.body;