From fd443712710a7160d9835eda9721156b823e1909 Mon Sep 17 00:00:00 2001
From: David Malcolm <dmalcolm@redhat.com>
Date: Tue, 4 Aug 2020 15:07:13 -0400
Subject: [PATCH 13/18] FIXME: rename store2 to store

---
 gcc/Makefile.in                            |   2 +-
 gcc/analyzer/analyzer-selftests.cc         |   3 +-
 gcc/analyzer/analyzer-selftests.h          |   2 +-
 gcc/analyzer/analyzer.h                    |   4 +-
 gcc/analyzer/region-model.cc               |  38 +++---
 gcc/analyzer/region-model.h                |  12 +-
 gcc/analyzer/region-model2-reachability.cc |   4 +-
 gcc/analyzer/region-model2-reachability.h  |   6 +-
 gcc/analyzer/{store2.cc => store.cc}       | 136 ++++++++++-----------
 gcc/analyzer/{store2.h => store.h}         |  92 +++++++-------
 10 files changed, 149 insertions(+), 150 deletions(-)
 rename gcc/analyzer/{store2.cc => store.cc} (94%)
 rename gcc/analyzer/{store2.h => store.h} (87%)

diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index 9f736dbeee8..93fca01830e 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -1249,7 +1249,7 @@ ANALYZER_OBJS = \
 	analyzer/sm-signal.o \
 	analyzer/sm-taint.o \
 	analyzer/state-purge.o \
-	analyzer/store2.o \
+	analyzer/store.o \
 	analyzer/supergraph.o \
 	analyzer/uniq-manager.o
 
diff --git a/gcc/analyzer/analyzer-selftests.cc b/gcc/analyzer/analyzer-selftests.cc
index c93f894b788..338402da151 100644
--- a/gcc/analyzer/analyzer-selftests.cc
+++ b/gcc/analyzer/analyzer-selftests.cc
@@ -51,7 +51,6 @@ void
 run_analyzer_selftests ()
 {
 #if ENABLE_ANALYZER
-  analyzer_store2_cc_tests (); // FIXME: keep alphabetized? or by dependency
   analyzer_constraint_manager_cc_tests ();
   analyzer_function_set_cc_tests ();
   analyzer_immutable_hash_map_cc_tests ();
@@ -60,7 +59,7 @@ run_analyzer_selftests ()
   analyzer_region_model_cc_tests ();
   analyzer_sm_file_cc_tests ();
   analyzer_sm_signal_cc_tests ();
-  //analyzer_store2_cc_tests ();
+  analyzer_store_cc_tests ();
   analyzer_uniq_manager_cc_tests ();
 #endif /* #if ENABLE_ANALYZER */
 }
diff --git a/gcc/analyzer/analyzer-selftests.h b/gcc/analyzer/analyzer-selftests.h
index 5a8363ce031..dfd6317ccd3 100644
--- a/gcc/analyzer/analyzer-selftests.h
+++ b/gcc/analyzer/analyzer-selftests.h
@@ -42,7 +42,7 @@ extern void analyzer_program_state_cc_tests ();
 extern void analyzer_region_model_cc_tests ();
 extern void analyzer_sm_file_cc_tests ();
 extern void analyzer_sm_signal_cc_tests ();
-extern void analyzer_store2_cc_tests ();
+extern void analyzer_store_cc_tests ();
 extern void analyzer_uniq_manager_cc_tests ();
 
 } /* end of namespace ana::selftest.  */
diff --git a/gcc/analyzer/analyzer.h b/gcc/analyzer/analyzer.h
index ce95819fcdc..9e2bdc95c4e 100644
--- a/gcc/analyzer/analyzer.h
+++ b/gcc/analyzer/analyzer.h
@@ -69,8 +69,8 @@ class region2;
   class string_region2;
 class region_model2_manager;
 struct model2_merger;
-class store2_manager;
-class store2;
+class store_manager;
+class store;
 class region_model2;
 class region_model2_context;
   class impl_region_model2_context;
diff --git a/gcc/analyzer/region-model.cc b/gcc/analyzer/region-model.cc
index 1bbafdee7a5..8acaee89dba 100644
--- a/gcc/analyzer/region-model.cc
+++ b/gcc/analyzer/region-model.cc
@@ -3548,7 +3548,7 @@ region_model2_manager::region_model2_manager ()
   m_fndecls_map (), m_labels_map (),
   m_globals_region (alloc_region_id (), &m_root_region),
   m_globals_map (),
-  m_store2_mgr (this)
+  m_store_mgr (this)
 {
   // TODO
 }
@@ -4487,14 +4487,14 @@ region_model2_manager::log_stats (logger *logger, bool show_objs) const
   log_uniq_map (logger, show_objs, "string_region2", m_string_map);
   logger->log ("  # managed dynamic regions: %i",
 	       m_managed_dynamic_regions.length ());
-  m_store2_mgr.log_stats (logger, show_objs);
+  m_store_mgr.log_stats (logger, show_objs);
 }
 
 /* FIXME.  */
 // FIXME: this is here so it can use log_uniq_manager
 
 void
-store2_manager::log_stats (logger *logger, bool show_objs) const
+store_manager::log_stats (logger *logger, bool show_objs) const
 {
   LOG_SCOPE (logger);
   log_uniq_manager (logger, show_objs, "concrete_binding2",
@@ -4737,7 +4737,7 @@ region_model2::dump_to_pp (pretty_printer *pp, bool simple,
   if (!multiline)
     pp_string (pp, ", {");
   m_store.dump_to_pp (pp, simple, multiline,
-		      m_mgr->get_store2_manager ());
+		      m_mgr->get_store_manager ());
   if (!multiline)
     pp_string (pp, "}");
 
@@ -4971,7 +4971,7 @@ region_model2::validate () const
 void
 region_model2::canonicalize ()
 {
-  m_store.canonicalize (m_mgr->get_store2_manager ());
+  m_store.canonicalize (m_mgr->get_store_manager ());
   m_constraints2->canonicalize ();
 }
 
@@ -5280,7 +5280,7 @@ region_model2::on_gassign (const gassign *assign,
 	/* Add a default binding, rather than a direct one, so that array
 	   access will "inherit" the individual chars.  */
 	const svalue2 *rhs_sval = get_rvalue (rhs1, ctxt);
-	m_store.set_value (m_mgr->get_store2_manager(), lhs_reg, rhs_sval,
+	m_store.set_value (m_mgr->get_store_manager(), lhs_reg, rhs_sval,
 			   BK_default);
       }
       break;
@@ -5643,11 +5643,11 @@ region_model2::handle_unrecognized_call (const gcall *call,
     }
 
   /* Mark any clusters that have escaped.  */
-  reachable_regs.mark_escaped_clusters (m_mgr->get_store2_manager ());
+  reachable_regs.mark_escaped_clusters (m_mgr->get_store_manager ());
 
   /* Update bindings for all clusters that have escaped, whether above,
      or previously.  */
-  m_store.on_unknown_fncall (call, m_mgr->get_store2_manager ());
+  m_store.on_unknown_fncall (call, m_mgr->get_store_manager ());
 
 #if 0
   /* Purge sm-state for any remaining svalue2s that point to region2s that
@@ -5732,7 +5732,7 @@ region_model2::get_reachable_svalues (hash_set<const svalue2 *> *out,
     }
 #else
   /* Get regions for locals that have explicitly bound values.  */
-  for (store2::cluster_map_t::iterator iter = m_store.begin ();
+  for (store::cluster_map_t::iterator iter = m_store.begin ();
        iter != m_store.end (); ++iter)
     {
       const region2 *base_reg = (*iter).first;
@@ -6276,7 +6276,7 @@ const svalue2 *
 region_model2::get_store_value (const region2 *reg) const
 {
   const svalue2 *sval
-    = m_store.get_any_binding (m_mgr->get_store2_manager (), reg);
+    = m_store.get_any_binding (m_mgr->get_store_manager (), reg);
   if (sval)
     {
       if (reg->get_type ())
@@ -6647,7 +6647,7 @@ region_model2::set_value (const region2 *lhs_reg, const svalue2 *rhs_sval,
   gcc_assert (lhs_reg);
   gcc_assert (rhs_sval);
 
-  m_store.set_value (m_mgr->get_store2_manager(), lhs_reg, rhs_sval,
+  m_store.set_value (m_mgr->get_store_manager(), lhs_reg, rhs_sval,
 		     BK_direct);
 }
 
@@ -6669,7 +6669,7 @@ region_model2::set_value (tree lhs, tree rhs, region_model2_context *ctxt)
 void
 region_model2::clobber_region (const region2 *reg)
 {
-  m_store.clobber_region (m_mgr->get_store2_manager(), reg);
+  m_store.clobber_region (m_mgr->get_store_manager(), reg);
 }
 
 /* FIXME.  */
@@ -6677,7 +6677,7 @@ region_model2::clobber_region (const region2 *reg)
 void
 region_model2::purge_region (const region2 *reg)
 {
-  m_store.purge_region (m_mgr->get_store2_manager(), reg);
+  m_store.purge_region (m_mgr->get_store_manager(), reg);
 }
 
 /* Zero-fill REG.  */
@@ -6685,7 +6685,7 @@ region_model2::purge_region (const region2 *reg)
 void
 region_model2::zero_fill_region (const region2 *reg)
 {
-  m_store.zero_fill_region (m_mgr->get_store2_manager(), reg);
+  m_store.zero_fill_region (m_mgr->get_store_manager(), reg);
 }
 
 /* Mark REG as having unknown content.  */
@@ -6693,7 +6693,7 @@ region_model2::zero_fill_region (const region2 *reg)
 void
 region_model2::mark_region_as_unknown (const region2 *reg)
 {
-  m_store.mark_region_as_unknown (m_mgr->get_store2_manager(), reg);
+  m_store.mark_region_as_unknown (m_mgr->get_store_manager(), reg);
 }
 
 /* Determine what is known about the condition "LHS_SVAL OP RHS_SVAL" within
@@ -8134,7 +8134,7 @@ region_model2::unbind_region2_and_descendents (const region2 *reg,
 {
   /* Gather a set of base regions to be unbound.  */
   hash_set<const region2 *> base_regs;
-  for (store2::cluster_map_t::iterator iter = m_store.begin ();
+  for (store::cluster_map_t::iterator iter = m_store.begin ();
        iter != m_store.end (); ++iter)
     {
       const region2 *iter_base_reg = (*iter).first;
@@ -8217,9 +8217,9 @@ region_model2::can_merge_with_p (const region_model2 &other_model,
 
   model2_merger m (this, &other_model, point, out_model);
 
-  if (!store2::can_merge_p (&m_store, &other_model.m_store,
-			    &out_model->m_store, m_mgr->get_store2_manager (),
-			    &m))
+  if (!store::can_merge_p (&m_store, &other_model.m_store,
+			   &out_model->m_store, m_mgr->get_store_manager (),
+			   &m))
     return false;
 
   /* Merge constraints.  */
diff --git a/gcc/analyzer/region-model.h b/gcc/analyzer/region-model.h
index c066cb507ae..e5d04b47e0d 100644
--- a/gcc/analyzer/region-model.h
+++ b/gcc/analyzer/region-model.h
@@ -22,7 +22,7 @@ along with GCC; see the file COPYING3.  If not see
 #define GCC_ANALYZER_REGION_MODEL_2_H
 
 #include "analyzer/uniq-manager.h" // FIXME
-#include "analyzer/store2.h" // FIXME
+#include "analyzer/store.h" // FIXME
 #include "analyzer/program-point.h" // FIXME
 
 #define WIDENING 1
@@ -2372,7 +2372,7 @@ public:
 
   unsigned alloc_region_id () { return m_next_region_id++; }
 
-  store2_manager *get_store2_manager () { return &m_store2_mgr; }
+  store_manager *get_store_manager () { return &m_store_mgr; }
 
   /* Dynamically-allocated region2 instances.
      FIXME: for now, the number of these within the analysis can grow
@@ -2483,7 +2483,7 @@ private:
   typedef hash_map<tree, string_region2 *> string_map_t;
   string_map_t m_string_map;
 
-  store2_manager m_store2_mgr;
+  store_manager m_store_mgr;
 
   /* "Dynamically-allocated" region2 instances.
      FIXME: for now, the number of these within the analysis can grow
@@ -2711,8 +2711,8 @@ class region_model2
     return m_constraints2;
   }
 
-  store2 *get_store () { return &m_store; }
-  const store2 *get_store () const { return &m_store; }
+  store *get_store () { return &m_store; }
+  const store *get_store () const { return &m_store; }
 
   region_model2_manager *get_manager () const { return m_mgr; }
 
@@ -2819,7 +2819,7 @@ private:
   /* Storing this here to avoid passing it around everywhere.  */
   region_model2_manager *const m_mgr;
 
-  store2 m_store;
+  store m_store;
 
   constraint_manager2 *m_constraints2; // TODO: embed, rather than dynalloc?
 
diff --git a/gcc/analyzer/region-model2-reachability.cc b/gcc/analyzer/region-model2-reachability.cc
index 6f6a7c4f9a5..95b644efc7f 100644
--- a/gcc/analyzer/region-model2-reachability.cc
+++ b/gcc/analyzer/region-model2-reachability.cc
@@ -71,7 +71,7 @@ along with GCC; see the file COPYING3.  If not see
 
 namespace ana {
 
-reachable_region2s::reachable_region2s (store2 *store,
+reachable_region2s::reachable_region2s (store *store,
 					region_model2_manager *mgr)
 : m_store (store), m_mgr (mgr), m_reachable_regs (), m_mutable_regs ()
 {
@@ -222,7 +222,7 @@ reachable_region2s::handle_parm (const svalue2 *sval, tree param_type)
    as having escaped.  */
 
 void
-reachable_region2s::mark_escaped_clusters (store2_manager *mgr)
+reachable_region2s::mark_escaped_clusters (store_manager *mgr)
 {
   for (hash_set<const region2 *>::iterator iter = m_mutable_regs.begin ();
        iter != m_mutable_regs.end (); ++iter)
diff --git a/gcc/analyzer/region-model2-reachability.h b/gcc/analyzer/region-model2-reachability.h
index 62acded445f..8c49b3f0090 100644
--- a/gcc/analyzer/region-model2-reachability.h
+++ b/gcc/analyzer/region-model2-reachability.h
@@ -31,7 +31,7 @@ namespace ana {
 class reachable_region2s
 {
 public:
-  reachable_region2s (store2 *store, region_model2_manager *mgr);
+  reachable_region2s (store *store, region_model2_manager *mgr);
 
   /* Callback called for each cluster when initializing this object.  */
   static void init_cluster_cb (const region2 *base_reg,
@@ -56,7 +56,7 @@ public:
 
   /* FIXME.  */
 
-  void mark_escaped_clusters (store2_manager *mgr);
+  void mark_escaped_clusters (store_manager *mgr);
 
   /* Iteration over reachable regions.  */
   hash_set<const region2 *>::iterator begin ()
@@ -90,7 +90,7 @@ public:
   DEBUG_FUNCTION void dump () const;
 
 private:
-  store2 *m_store;
+  store *m_store;
   region_model2_manager *m_mgr;
 
   // FIXME: actually, the clusters
diff --git a/gcc/analyzer/store2.cc b/gcc/analyzer/store.cc
similarity index 94%
rename from gcc/analyzer/store2.cc
rename to gcc/analyzer/store.cc
index 490bef4d774..a5f9d1b6006 100644
--- a/gcc/analyzer/store2.cc
+++ b/gcc/analyzer/store.cc
@@ -75,7 +75,7 @@ const char *binding_kind_to_string (enum binding_kind kind)
 /* class binding_key2.  */
 
 const binding_key2 *
-binding_key2::make (store2_manager *mgr, const region2 *r,
+binding_key2::make (store_manager *mgr, const region2 *r,
 		    enum binding_kind kind)
 {
   region_offset offset = r->get_offset ();
@@ -440,7 +440,7 @@ binding_cluster2::dump (bool simple) const
 /* FIXME.  */
 
 void
-binding_cluster2::bind (store2_manager *mgr,
+binding_cluster2::bind (store_manager *mgr,
 			const region2 *reg, const svalue2 *sval,
 			binding_kind kind)
 {
@@ -473,7 +473,7 @@ binding_cluster2::bind_key (const binding_key2 *key, const svalue2 *sval)
    element-wise.  */
 
 void
-binding_cluster2::bind_compound_sval (store2_manager *mgr,
+binding_cluster2::bind_compound_sval (store_manager *mgr,
 				      const region2 *reg,
 				      const compound_svalue2 *compound_sval)
 {
@@ -515,7 +515,7 @@ binding_cluster2::bind_compound_sval (store2_manager *mgr,
 /* Remove all bindings affecting REG within this cluster.  */
 
 void
-binding_cluster2::clobber_region (store2_manager *mgr, const region2 *reg)
+binding_cluster2::clobber_region (store_manager *mgr, const region2 *reg)
 {
   remove_overlapping_bindings (mgr, reg);
 }
@@ -523,7 +523,7 @@ binding_cluster2::clobber_region (store2_manager *mgr, const region2 *reg)
 /* FIXME.  */
 
 void
-binding_cluster2::purge_region (store2_manager *mgr, const region2 *reg)
+binding_cluster2::purge_region (store_manager *mgr, const region2 *reg)
 {
   gcc_assert (reg->get_kind () == region2::RK_DECL);
   const binding_key2 *binding
@@ -537,7 +537,7 @@ binding_cluster2::purge_region (store2_manager *mgr, const region2 *reg)
    TOUCHED flag.  */
 
 void
-binding_cluster2::zero_fill_region (store2_manager *mgr, const region2 *reg)
+binding_cluster2::zero_fill_region (store_manager *mgr, const region2 *reg)
 {
   clobber_region (mgr, reg);
 
@@ -558,7 +558,7 @@ binding_cluster2::zero_fill_region (store2_manager *mgr, const region2 *reg)
 /* FIXME.  */
 
 void
-binding_cluster2::mark_region_as_unknown (store2_manager *mgr,
+binding_cluster2::mark_region_as_unknown (store_manager *mgr,
 					  const region2 *reg)
 {
   remove_overlapping_bindings (mgr, reg);
@@ -573,7 +573,7 @@ binding_cluster2::mark_region_as_unknown (store2_manager *mgr,
 /* FIXME.  */
 
 const svalue2 *
-binding_cluster2::get_binding (store2_manager *mgr,
+binding_cluster2::get_binding (store_manager *mgr,
 			       const region2 *reg,
 			       binding_kind kind) const
 {
@@ -627,7 +627,7 @@ binding_cluster2::get_binding (store2_manager *mgr,
 /* FIXME.  */
 
 const svalue2 *
-binding_cluster2::get_binding_recursive (store2_manager *mgr,
+binding_cluster2::get_binding_recursive (store_manager *mgr,
 					 const region2 *reg,
 					 enum binding_kind kind) const
 {
@@ -649,7 +649,7 @@ binding_cluster2::get_binding_recursive (store2_manager *mgr,
 /* FIXME.  */
 
 const svalue2 *
-binding_cluster2::get_any_binding (store2_manager *mgr,
+binding_cluster2::get_any_binding (store_manager *mgr,
 				   const region2 *reg) const
 {
   /* FIXME:  I'm not quite sure how this should work.
@@ -699,7 +699,7 @@ binding_cluster2::get_any_binding (store2_manager *mgr,
    Return the resulting compound_svalue2, or NULL if there's a problem.  */
 
 const svalue2 *
-binding_cluster2::maybe_get_compound_binding (store2_manager *mgr,
+binding_cluster2::maybe_get_compound_binding (store_manager *mgr,
 					      const region2 *reg) const
 {
   binding_map map;
@@ -755,7 +755,7 @@ binding_cluster2::maybe_get_compound_binding (store2_manager *mgr,
 /* Populate OUT with all bindings within this cluster that overlap REG.  */
 
 void
-binding_cluster2::get_overlapping_bindings (store2_manager *mgr,
+binding_cluster2::get_overlapping_bindings (store_manager *mgr,
 					    const region2 *reg,
 					    auto_vec<const binding_key2 *> *out)
 {
@@ -794,7 +794,7 @@ binding_cluster2::get_overlapping_bindings (store2_manager *mgr,
 /* FIXME.  */
 
 void
-binding_cluster2::remove_overlapping_bindings (store2_manager *mgr,
+binding_cluster2::remove_overlapping_bindings (store_manager *mgr,
 					       const region2 *reg)
 {
   auto_vec<const binding_key2 *> bindings;
@@ -826,7 +826,7 @@ bool
 binding_cluster2::can_merge_p (const binding_cluster2 *cluster_a,
 			       const binding_cluster2 *cluster_b,
 			       binding_cluster2 *out_cluster,
-			       store2_manager *mgr,
+			       store_manager *mgr,
 			       model2_merger *merger)
 {
   gcc_assert (out_cluster);
@@ -922,7 +922,7 @@ binding_cluster2::can_merge_p (const binding_cluster2 *cluster_a,
 
 void
 binding_cluster2::make_unknown_relative_to (const binding_cluster2 *other,
-					    store2_manager *mgr)
+					    store_manager *mgr)
 {
   for (map_t::iterator iter = other->m_map.begin ();
        iter != other->m_map.end (); ++iter)
@@ -957,7 +957,7 @@ binding_cluster2::mark_as_escaped ()
 
 void
 binding_cluster2::on_unknown_fncall (const gcall *call,
-				     store2_manager *mgr)
+				     store_manager *mgr)
 {
   if (m_escaped)
     {
@@ -1051,9 +1051,9 @@ binding_cluster2::get_any_value (const binding_key2 *key) const
    For use in simplifying dumps.  */
 
 const svalue2 *
-binding_cluster2::maybe_get_simple_value (store2_manager *mgr) const
+binding_cluster2::maybe_get_simple_value (store_manager *mgr) const
 {
-  /* Fail gracefully if MGR is NULL to make it easier to dump store2
+  /* Fail gracefully if MGR is NULL to make it easier to dump store
      instances in the debugger.  */
   if (mgr == NULL)
     return NULL;
@@ -1065,14 +1065,14 @@ binding_cluster2::maybe_get_simple_value (store2_manager *mgr) const
   return get_any_value (key);
 }
 
-/* class store2_manager.  */
+/* class store_manager.  */
 
 /* binding consolidation.  */
 
 const concrete_binding2 *
-store2_manager::get_concrete_binding (bit_offset_t start_bit_offset,
-				      bit_offset_t size_in_bits,
-				      enum binding_kind kind)
+store_manager::get_concrete_binding (bit_offset_t start_bit_offset,
+				     bit_offset_t size_in_bits,
+				     enum binding_kind kind)
 {
   concrete_binding2 *b
     = new concrete_binding2 (start_bit_offset, size_in_bits, kind);
@@ -1080,25 +1080,25 @@ store2_manager::get_concrete_binding (bit_offset_t start_bit_offset,
 }
 
 const symbolic_binding2 *
-store2_manager::get_symbolic_binding (const region2 *reg,
-				      enum binding_kind kind)
+store_manager::get_symbolic_binding (const region2 *reg,
+				     enum binding_kind kind)
 {
   symbolic_binding2 *b = new symbolic_binding2 (reg, kind);
   return m_symbolic_binding_key_mgr.consolidate (b);
 }
 
-/* class store2.  */
+/* class store.  */
 
 /* FIXME.  */
 
-store2::store2 ()
+store::store ()
 : m_called_unknown_fn (false)
 {
 }
 
-/* store2's copy ctor.  */
+/* store's copy ctor.  */
 
-store2::store2 (const store2 &other)
+store::store (const store &other)
 : m_called_unknown_fn (other.m_called_unknown_fn)
 {
   /* Deep copy.  TODO: replace with functional approach using immutable_map.  */
@@ -1114,9 +1114,9 @@ store2::store2 (const store2 &other)
     }
 }
 
-/* store2's dtor.  */
+/* store's dtor.  */
 
-store2::~store2 ()
+store::~store ()
 {
   for (cluster_map_t::iterator iter = m_cluster_map.begin ();
        iter != m_cluster_map.end ();
@@ -1124,10 +1124,10 @@ store2::~store2 ()
     delete (*iter).second;
 }
 
-/* store2's assignment operator.  */
+/* store's assignment operator.  */
 
-store2 &
-store2::operator= (const store2 &other)
+store &
+store::operator= (const store &other)
 {
   /* Delete existing cluster map.  */
   for (cluster_map_t::iterator iter = m_cluster_map.begin ();
@@ -1155,7 +1155,7 @@ store2::operator= (const store2 &other)
 /* FIXME.  */
 
 bool
-store2::operator== (const store2 &other) const
+store::operator== (const store &other) const
 {
   if (m_called_unknown_fn != other.m_called_unknown_fn)
     return false;
@@ -1210,8 +1210,8 @@ get_sorted_parent_regions (auto_vec<const region2 *> *out,
    (to make it easier to use from the debugger).  */
 
 void
-store2::dump_to_pp (pretty_printer *pp, bool simple, bool multiline,
-		    store2_manager *mgr) const
+store::dump_to_pp (pretty_printer *pp, bool simple, bool multiline,
+		   store_manager *mgr) const
 {
   /* Sort into some deterministic order.  */
   auto_vec<const region2 *> base_regions;
@@ -1309,10 +1309,10 @@ store2::dump_to_pp (pretty_printer *pp, bool simple, bool multiline,
     pp_newline (pp);
 }
 
-/* Dump a multiline representation of this store2 to stderr.  */
+/* Dump a multiline representation of this store to stderr.  */
 
 DEBUG_FUNCTION void
-store2::dump (bool simple) const
+store::dump (bool simple) const
 {
   pretty_printer pp;
   pp_format_decoder (&pp) = default_tree_printer;
@@ -1326,7 +1326,7 @@ store2::dump (bool simple) const
 /* FIXME.  */
 
 void
-store2::summarize_to_pp (pretty_printer *pp, bool simple) const
+store::summarize_to_pp (pretty_printer *pp, bool simple) const
 {
 #if 1
   // TODO
@@ -1386,7 +1386,7 @@ store2::summarize_to_pp (pretty_printer *pp, bool simple) const
 /* FIXME.  */
 
 const svalue2 *
-store2::get_any_binding (store2_manager *mgr, const region2 *reg) const
+store::get_any_binding (store_manager *mgr, const region2 *reg) const
 {
   const region2 *base_reg = reg->get_base_region ();
   binding_cluster2 **cluster_slot
@@ -1399,8 +1399,8 @@ store2::get_any_binding (store2_manager *mgr, const region2 *reg) const
 /* FIXME.  */
 
 void
-store2::set_value (store2_manager *mgr, const region2 *lhs_reg,
-		   const svalue2 *rhs_sval, enum binding_kind kind)
+store::set_value (store_manager *mgr, const region2 *lhs_reg,
+		  const svalue2 *rhs_sval, enum binding_kind kind)
 {
   remove_overlapping_bindings (mgr, lhs_reg);
 
@@ -1478,8 +1478,8 @@ store2::set_value (store2_manager *mgr, const region2 *lhs_reg,
 /* Determine if BASE_REG_A could be an alias of BASE_REG_B.  */
 
 tristate
-store2::eval_alias (const region2 *base_reg_a,
-		    const region2 *base_reg_b)
+store::eval_alias (const region2 *base_reg_a,
+		   const region2 *base_reg_b)
 {
   /* SSA names can't alias.  */
   tree decl_a = base_reg_a->maybe_get_decl ();
@@ -1525,7 +1525,7 @@ store2::eval_alias (const region2 *base_reg_a,
 /* FIXME.  */
 
 void
-store2::clobber_region (store2_manager *mgr, const region2 *reg)
+store::clobber_region (store_manager *mgr, const region2 *reg)
 {
   const region2 *base_reg = reg->get_base_region ();
   binding_cluster2 **slot = m_cluster_map.get (base_reg);
@@ -1543,7 +1543,7 @@ store2::clobber_region (store2_manager *mgr, const region2 *reg)
 /* FIXME.  */
 
 void
-store2::purge_region (store2_manager *mgr, const region2 *reg)
+store::purge_region (store_manager *mgr, const region2 *reg)
 {
   const region2 *base_reg = reg->get_base_region ();
   binding_cluster2 **slot = m_cluster_map.get (base_reg);
@@ -1561,7 +1561,7 @@ store2::purge_region (store2_manager *mgr, const region2 *reg)
 /* FIXME.  */
 
 void
-store2::zero_fill_region (store2_manager *mgr, const region2 *reg)
+store::zero_fill_region (store_manager *mgr, const region2 *reg)
 {
   const region2 *base_reg = reg->get_base_region ();
   if (base_reg->symbolic_for_unknown_ptr_p ())
@@ -1574,7 +1574,7 @@ store2::zero_fill_region (store2_manager *mgr, const region2 *reg)
 /* FIXME.  */
 
 void
-store2::mark_region_as_unknown (store2_manager *mgr, const region2 *reg)
+store::mark_region_as_unknown (store_manager *mgr, const region2 *reg)
 {
   const region2 *base_reg = reg->get_base_region ();
   if (base_reg->symbolic_for_unknown_ptr_p ())
@@ -1587,7 +1587,7 @@ store2::mark_region_as_unknown (store2_manager *mgr, const region2 *reg)
 /* FIXME.  */
 
 const binding_cluster2 *
-store2::get_cluster (const region2 *base_reg) const
+store::get_cluster (const region2 *base_reg) const
 {
   gcc_assert (base_reg);
   gcc_assert (base_reg->get_base_region () == base_reg);
@@ -1601,7 +1601,7 @@ store2::get_cluster (const region2 *base_reg) const
 /* FIXME.  */
 
 binding_cluster2 *
-store2::get_cluster (const region2 *base_reg)
+store::get_cluster (const region2 *base_reg)
 {
   gcc_assert (base_reg);
   gcc_assert (base_reg->get_base_region () == base_reg);
@@ -1614,7 +1614,7 @@ store2::get_cluster (const region2 *base_reg)
 /* FIXME.  */
 
 binding_cluster2 *
-store2::get_or_create_cluster (const region2 *base_reg)
+store::get_or_create_cluster (const region2 *base_reg)
 {
   gcc_assert (base_reg);
   gcc_assert (base_reg->get_base_region () == base_reg);
@@ -1637,7 +1637,7 @@ store2::get_or_create_cluster (const region2 *base_reg)
    when popping stack frames and handling deleted heap regions.  */
 
 void
-store2::purge_cluster (const region2 *base_reg)
+store::purge_cluster (const region2 *base_reg)
 {
   gcc_assert (base_reg->get_base_region () == base_reg);
   binding_cluster2 **slot = m_cluster_map.get (base_reg);
@@ -1651,9 +1651,9 @@ store2::purge_cluster (const region2 *base_reg)
 /* FIXME.  */
 
 bool
-store2::can_merge_p (const store2 *store_a, const store2 *store_b,
-		     store2 *out_store, store2_manager *mgr,
-		     model2_merger *merger)
+store::can_merge_p (const store *store_a, const store *store_b,
+		    store *out_store, store_manager *mgr,
+		    model2_merger *merger)
 {
   if (store_a->m_called_unknown_fn || store_b->m_called_unknown_fn)
     out_store->m_called_unknown_fn = true;
@@ -1696,7 +1696,7 @@ store2::can_merge_p (const store2 *store_a, const store2 *store_b,
    isn't reachable from args of those calls.  */
 
 void
-store2::mark_as_escaped (const region2 *base_reg)
+store::mark_as_escaped (const region2 *base_reg)
 {
   gcc_assert (base_reg);
   gcc_assert (base_reg->get_base_region () == base_reg);
@@ -1713,7 +1713,7 @@ store2::mark_as_escaped (const region2 *base_reg)
    (either in this fncall, or in a prior one).  */
 
 void
-store2::on_unknown_fncall (const gcall *call, store2_manager *mgr)
+store::on_unknown_fncall (const gcall *call, store_manager *mgr)
 {
   m_called_unknown_fn = true;
 
@@ -1726,7 +1726,7 @@ store2::on_unknown_fncall (const gcall *call, store2_manager *mgr)
    has escaped to code outside of the TU being analyzed.  */
 
 bool
-store2::escaped_p (const region2 *base_reg) const
+store::escaped_p (const region2 *base_reg) const
 {
   gcc_assert (base_reg);
   gcc_assert (base_reg->get_base_region () == base_reg);
@@ -1740,10 +1740,10 @@ store2::escaped_p (const region2 *base_reg) const
 /* FIXME.  */
 
 void
-store2::get_representative_path_vars (const region_model2 *model,
-				      hash_set <const svalue2 *> *visited,
-				      const svalue2 *sval,
-				      auto_vec<path_var> *out_pvs) const
+store::get_representative_path_vars (const region_model2 *model,
+				     hash_set <const svalue2 *> *visited,
+				     const svalue2 *sval,
+				     auto_vec<path_var> *out_pvs) const
 {
   gcc_assert (sval);
 
@@ -1769,7 +1769,7 @@ store2::get_representative_path_vars (const region_model2 *model,
 /* FIXME.  */
 
 void
-store2::remove_overlapping_bindings (store2_manager *mgr, const region2 *reg)
+store::remove_overlapping_bindings (store_manager *mgr, const region2 *reg)
 {
   const region2 *base_reg = reg->get_base_region ();
   if (reg == base_reg && !escaped_p (base_reg))
@@ -1797,7 +1797,7 @@ struct region2_finder : public visitor
 /* FIXME.  */
 
 void
-store2::canonicalize (store2_manager *mgr)
+store::canonicalize (store_manager *mgr)
 {
   /* If we have e.g.:
          cluster for: HEAP_ALLOCATED_REGION(543)
@@ -1875,8 +1875,8 @@ store2::canonicalize (store2_manager *mgr)
    For all that are found, update the binding in this store to UNKNOWN.  */
 
 void
-store2::loop_replay_hack (const store2 *other_store,
-			  region_model2_manager *mgr)
+store::loop_replay_hack (const store *other_store,
+			 region_model2_manager *mgr)
 {
   gcc_assert (other_store);
   for (cluster_map_t::iterator iter = other_store->m_cluster_map.begin ();
@@ -1946,7 +1946,7 @@ assert_disjoint (const location &loc,
 static void
 test_binding_key_overlap ()
 {
-  store2_manager mgr (NULL);
+  store_manager mgr (NULL);
 
   /* Various 8-bit bindings.  */
   const concrete_binding2 *cb_0_7
@@ -2001,7 +2001,7 @@ test_binding_key_overlap ()
 /* Run all of the selftests within this file.  */
 
 void
-analyzer_store2_cc_tests ()
+analyzer_store_cc_tests ()
 {
   test_binding_key_overlap ();
   // TODO: test making keys for regions; verify expected sizes/overlaps etc
diff --git a/gcc/analyzer/store2.h b/gcc/analyzer/store.h
similarity index 87%
rename from gcc/analyzer/store2.h
rename to gcc/analyzer/store.h
index cb39a102d51..aa16a4277b9 100644
--- a/gcc/analyzer/store2.h
+++ b/gcc/analyzer/store.h
@@ -18,8 +18,8 @@ You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING3.  If not see
 <http://www.gnu.org/licenses/>.  */
 
-#ifndef GCC_ANALYZER_STORE2_H
-#define GCC_ANALYZER_STORE2_H
+#ifndef GCC_ANALYZER_STORE_H
+#define GCC_ANALYZER_STORE_H
 
 #include "analyzer/uniq-manager.h" // FIXME
 
@@ -154,7 +154,7 @@ public:
   virtual bool concrete_p () const = 0;
   bool symbolic_p () const { return !concrete_p (); }
 
-  static const binding_key2 *make (store2_manager *mgr, const region2 *r,
+  static const binding_key2 *make (store_manager *mgr, const region2 *r,
 				   enum binding_kind kind);
 
   virtual void dump_to_pp (pretty_printer *pp, bool simple) const;
@@ -315,7 +315,7 @@ private:
 };
 
 /* Concept: BindingVisitor, for use by binding_cluster2::for_each_binding
-   and store2::for_each_binding.
+   and store::for_each_binding.
 
    Should implement:
      void on_binding (const binding_key2 *key, const svalue2 *&sval);
@@ -327,7 +327,7 @@ private:
 class binding_cluster2
 {
 public:
-  friend class store2; // FIXME
+  friend class store; // FIXME
 
   typedef hash_map <const binding_key2 *, const svalue2 *> map_t;
   typedef map_t::iterator iterator_t;
@@ -349,25 +349,25 @@ public:
   void dump_to_pp (pretty_printer *pp, bool simple, bool multiline) const;
   void dump (bool simple) const;
 
-  void bind (store2_manager *mgr, const region2 *, const svalue2 *,
+  void bind (store_manager *mgr, const region2 *, const svalue2 *,
 	     binding_kind kind);
 
-  void clobber_region (store2_manager *mgr, const region2 *reg);
-  void purge_region (store2_manager *mgr, const region2 *reg);
-  void zero_fill_region (store2_manager *mgr, const region2 *reg);
-  void mark_region_as_unknown (store2_manager *mgr, const region2 *reg);
+  void clobber_region (store_manager *mgr, const region2 *reg);
+  void purge_region (store_manager *mgr, const region2 *reg);
+  void zero_fill_region (store_manager *mgr, const region2 *reg);
+  void mark_region_as_unknown (store_manager *mgr, const region2 *reg);
 
-  const svalue2 *get_binding (store2_manager *mgr, const region2 *reg,
+  const svalue2 *get_binding (store_manager *mgr, const region2 *reg,
 			      binding_kind kind) const;
-  const svalue2 *get_binding_recursive (store2_manager *mgr,
+  const svalue2 *get_binding_recursive (store_manager *mgr,
 					const region2 *reg,
 					enum binding_kind kind) const;
-  const svalue2 *get_any_binding (store2_manager *mgr,
+  const svalue2 *get_any_binding (store_manager *mgr,
 				  const region2 *reg) const;
-  const svalue2 *maybe_get_compound_binding (store2_manager *mgr,
+  const svalue2 *maybe_get_compound_binding (store_manager *mgr,
 					     const region2 *reg) const;
 
-  void remove_overlapping_bindings (store2_manager *mgr, const region2 *reg);
+  void remove_overlapping_bindings (store_manager *mgr, const region2 *reg);
 
 #if 1
   template <typename T>
@@ -382,13 +382,13 @@ public:
   static bool can_merge_p (const binding_cluster2 *cluster_a,
 			   const binding_cluster2 *cluster_b,
 			   binding_cluster2 *out_cluster,
-			   store2_manager *mgr,
+			   store_manager *mgr,
 			   model2_merger *merger);
   void make_unknown_relative_to (const binding_cluster2 *other_cluster,
-				 store2_manager *mgr);
+				 store_manager *mgr);
 
   void mark_as_escaped ();
-  void on_unknown_fncall (const gcall *call, store2_manager *mgr);
+  void on_unknown_fncall (const gcall *call, store_manager *mgr);
 
   bool escaped_p () const { return m_escaped; }
   bool touched_p () const { return m_touched; }
@@ -402,7 +402,7 @@ public:
 				     const svalue2 *sval,
 				     auto_vec<path_var> *out_pvs) const;
 
-  const svalue2 *maybe_get_simple_value (store2_manager *mgr) const;
+  const svalue2 *maybe_get_simple_value (store_manager *mgr) const;
 
   template <typename BindingVisitor>
   void for_each_binding (BindingVisitor &v)
@@ -420,9 +420,9 @@ public:
 
 private:
   const svalue2 *get_any_value (const binding_key2 *key) const;
-  void get_overlapping_bindings (store2_manager *mgr, const region2 *reg,
+  void get_overlapping_bindings (store_manager *mgr, const region2 *reg,
 				 auto_vec<const binding_key2 *> *out);
-  void bind_compound_sval (store2_manager *mgr,
+  void bind_compound_sval (store_manager *mgr,
 			   const region2 *reg,
 			   const compound_svalue2 *compound_sval);
   void bind_key (const binding_key2 *key, const svalue2 *sval);
@@ -454,40 +454,40 @@ private:
 /* The mapping from regions to values.
    This is actually expressed by subdividing into clusters.  */
 
-class store2
+class store
 {
 public:
   typedef hash_map <const region2 *, binding_cluster2 *> cluster_map_t;
 
-  store2 ();
-  store2 (const store2 &other);
-  ~store2 ();
+  store ();
+  store (const store &other);
+  ~store ();
 
-  store2 &operator= (const store2 &other);
+  store &operator= (const store &other);
 
-  bool operator== (const store2 &other) const;
-  bool operator!= (const store2 &other) const
+  bool operator== (const store &other) const;
+  bool operator!= (const store &other) const
   {
     return !(*this == other);
   }
 
   void dump_to_pp (pretty_printer *pp, bool summarize, bool multiline,
-		   store2_manager *mgr) const;
+		   store_manager *mgr) const;
   void dump (bool simple) const;
   void summarize_to_pp (pretty_printer *pp, bool simple) const;
 
-  const svalue2 *get_direct_binding (store2_manager *mgr, const region2 *reg);
-  const svalue2 *get_default_binding (store2_manager *mgr, const region2 *reg);
-  const svalue2 *get_any_binding (store2_manager *mgr, const region2 *reg) const;
+  const svalue2 *get_direct_binding (store_manager *mgr, const region2 *reg);
+  const svalue2 *get_default_binding (store_manager *mgr, const region2 *reg);
+  const svalue2 *get_any_binding (store_manager *mgr, const region2 *reg) const;
 
   bool called_unknown_fn_p () const { return m_called_unknown_fn; }
 
-  void set_value (store2_manager *mgr, const region2 *lhs_reg,
+  void set_value (store_manager *mgr, const region2 *lhs_reg,
 		  const svalue2 *rhs_sval, enum binding_kind kind);
-  void clobber_region (store2_manager *mgr, const region2 *reg);
-  void purge_region (store2_manager *mgr, const region2 *reg);
-  void zero_fill_region (store2_manager *mgr, const region2 *reg);
-  void mark_region_as_unknown (store2_manager *mgr, const region2 *reg);
+  void clobber_region (store_manager *mgr, const region2 *reg);
+  void purge_region (store_manager *mgr, const region2 *reg);
+  void zero_fill_region (store_manager *mgr, const region2 *reg);
+  void mark_region_as_unknown (store_manager *mgr, const region2 *reg);
 
   const binding_cluster2 *get_cluster (const region2 *base_reg) const;
   binding_cluster2 *get_cluster (const region2 *base_reg);
@@ -503,12 +503,12 @@ public:
       cb ((*iter).first, user_data);
   }
 
-  static bool can_merge_p (const store2 *store_a, const store2 *store_b,
-			   store2 *out_store, store2_manager *mgr,
+  static bool can_merge_p (const store *store_a, const store *store_b,
+			   store *out_store, store_manager *mgr,
 			   model2_merger *merger);
 
   void mark_as_escaped (const region2 *base_reg);
-  void on_unknown_fncall (const gcall *call, store2_manager *mgr);
+  void on_unknown_fncall (const gcall *call, store_manager *mgr);
   bool escaped_p (const region2 *reg) const;
 
   void get_representative_path_vars (const region_model2 *model,
@@ -530,12 +530,12 @@ public:
       (*iter).second->for_each_binding (v);
   }
 
-  void canonicalize (store2_manager *mgr);
-  void loop_replay_hack (const store2 *other_store,
+  void canonicalize (store_manager *mgr);
+  void loop_replay_hack (const store *other_store,
 			 region_model2_manager *mgr);
 
 private:
-  void remove_overlapping_bindings (store2_manager *mgr, const region2 *reg);
+  void remove_overlapping_bindings (store_manager *mgr, const region2 *reg);
 
   cluster_map_t m_cluster_map; // TODO: deep copy of this!
 
@@ -548,10 +548,10 @@ private:
   bool m_called_unknown_fn;
 };
 
-class store2_manager
+class store_manager
 {
 public:
-  store2_manager (region_model2_manager *mgr) : m_mgr (mgr) {}
+  store_manager (region_model2_manager *mgr) : m_mgr (mgr) {}
 
   /* binding consolidation.  */
   const concrete_binding2 *
@@ -577,4 +577,4 @@ private:
 
 } // namespace ana
 
-#endif /* GCC_ANALYZER_STORE2_H */
+#endif /* GCC_ANALYZER_STORE_H */
-- 
2.26.2

